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/ClangAttrEmitter.cpp

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

4240 lines
150 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
//===- ClangAttrEmitter.cpp - Generate Clang attribute handling =-*- C++ -*--=//
//
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
//
//===----------------------------------------------------------------------===//
//
// These tablegen backends emit Clang attribute processing code
//
//===----------------------------------------------------------------------===//
Use scope qualifiers in Clang's tblgen backends to get useful redeclaration checking. NFC. llvm-svn: 373406
2019-10-02 07:12:57 +08:00
#include "TableGenBackends.h"
[NFC] Rename ClangASTEmitters.h -> ASTTableGen.h
2019-10-26 09:38:07 +08:00
#include "ASTTableGen.h"
Use scope qualifiers in Clang's tblgen backends to get useful redeclaration checking. NFC. llvm-svn: 373406
2019-10-02 07:12:57 +08:00
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
#include "llvm/ADT/ArrayRef.h"
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
#include "llvm/ADT/DenseMap.h"
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
#include "llvm/ADT/DenseSet.h"
Revert r300539 - Add #pragma clang attribute Some tests fail on the Windows buildbots. I will have to investigate more. This commit reverts r300539, r300540 and r300542. llvm-svn: 300543
2017-04-18 18:46:41 +08:00
#include "llvm/ADT/STLExtras.h"
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
#include "llvm/ADT/SmallString.h"
Fixing a use of stringstream to use an LLVM helper function. Drive-by fixing header include order. NFC. llvm-svn: 222151
2014-11-18 02:17:19 +08:00
#include "llvm/ADT/StringExtras.h"
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
#include "llvm/ADT/StringRef.h"
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
#include "llvm/ADT/StringSet.h"
Sort all the #include lines with LLVM's utils/sort_includes.py which encodes the canonical rules for LLVM's style. I noticed this had drifted quite a bit when cleaning up LLVM, so wanted to clean up Clang as well. llvm-svn: 198686
2014-01-07 19:51:46 +08:00
#include "llvm/ADT/StringSwitch.h"
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
#include "llvm/ADT/iterator_range.h"
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
Sort all the #include lines with LLVM's utils/sort_includes.py which encodes the canonical rules for LLVM's style. I noticed this had drifted quite a bit when cleaning up LLVM, so wanted to clean up Clang as well. llvm-svn: 198686
2014-01-07 19:51:46 +08:00
#include "llvm/TableGen/Error.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/TableGen/Record.h"
Replace the StringSwitch in AttributeList::getKind() with a TableGen-generated StringMatcher, for a 1.2% speedup in -fparse-only time in <rdar://problem/11004361>. Thanks to Benjamin for pointing me at StringMatcher! llvm-svn: 156003
2012-05-03 01:33:51 +08:00
#include "llvm/TableGen/StringMatcher.h"
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
#include "llvm/TableGen/TableGenBackend.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 <algorithm>
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
#include <cassert>
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 <cctype>
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
#include <cstddef>
#include <cstdint>
#include <map>
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
#include <memory>
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
#include <set>
Sort all the #include lines with LLVM's utils/sort_includes.py which encodes the canonical rules for LLVM's style. I noticed this had drifted quite a bit when cleaning up LLVM, so wanted to clean up Clang as well. llvm-svn: 198686
2014-01-07 19:51:46 +08:00
#include <sstream>
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
#include <string>
#include <utility>
#include <vector>
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
using namespace llvm;
Make helper functions static. NFC. llvm-svn: 231811
2015-03-11 02:24:01 +08:00
namespace {
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
class FlattenedSpelling {
std::string V, N, NS;
Support GCC [[gnu::attributes]] in C2x mode GCC 10.1 introduced support for the [[]] style spelling of attributes in C mode. Similar to how GCC supports __attribute__((foo)) as [[gnu::foo]] in C++ mode, it now supports the same spelling in C mode as well. This patch makes a change in Clang so that when you use the GCC attribute spelling, the attribute is automatically available in all three spellings by default. However, like Clang, GCC has some attributes it only recognizes in C++ mode (specifically, abi_tag and init_priority), which this patch also honors.
2020-06-01 22:39:38 +08:00
bool K = false;
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
public:
FlattenedSpelling(const std::string &Variety, const std::string &Name,
const std::string &Namespace, bool KnownToGCC) :
V(Variety), N(Name), NS(Namespace), K(KnownToGCC) {}
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
explicit FlattenedSpelling(const Record &Spelling)
: V(std::string(Spelling.getValueAsString("Variety"))),
N(std::string(Spelling.getValueAsString("Name"))) {
Add a new attribute definition spelling, Clang<"attr">, that expands to two attribute spellings: GNU<"attr"> and CXX11<"clang", "attr">. This is similar to how the GCC spelling works and is intended to be used for attributes introduced for Clang. Changes all existing attributes that currently use GNU<"attr"> and CXX11<"clang", "attr> spellings to instead use the Clang<"attr"> spelling. No additional tests are necessary because the existing tests already use both spellings for the attributes converted to the new spelling. No functional changes are expected. llvm-svn: 316658
2017-10-26 20:19:02 +08:00
assert(V != "GCC" && V != "Clang" &&
"Given a GCC spelling, which means this hasn't been flattened!");
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
if (V == "CXX11" || V == "C2x" || V == "Pragma")
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
NS = std::string(Spelling.getValueAsString("Namespace"));
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
}
const std::string &variety() const { return V; }
const std::string &name() const { return N; }
const std::string &nameSpace() const { return NS; }
bool knownToGCC() const { return K; }
};
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
} // end anonymous namespace
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
Make helper functions static. NFC. llvm-svn: 231811
2015-03-11 02:24:01 +08:00
static std::vector<FlattenedSpelling>
GetFlattenedSpellings(const Record &Attr) {
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<Record *> Spellings = Attr.getValueAsListOfDefs("Spellings");
std::vector<FlattenedSpelling> Ret;
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &Spelling : Spellings) {
Add a new attribute definition spelling, Clang<"attr">, that expands to two attribute spellings: GNU<"attr"> and CXX11<"clang", "attr">. This is similar to how the GCC spelling works and is intended to be used for attributes introduced for Clang. Changes all existing attributes that currently use GNU<"attr"> and CXX11<"clang", "attr> spellings to instead use the Clang<"attr"> spelling. No additional tests are necessary because the existing tests already use both spellings for the attributes converted to the new spelling. No functional changes are expected. llvm-svn: 316658
2017-10-26 20:19:02 +08:00
StringRef Variety = Spelling->getValueAsString("Variety");
StringRef Name = Spelling->getValueAsString("Name");
if (Variety == "GCC") {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
Ret.emplace_back("GNU", std::string(Name), "", true);
Ret.emplace_back("CXX11", std::string(Name), "gnu", true);
Support GCC [[gnu::attributes]] in C2x mode GCC 10.1 introduced support for the [[]] style spelling of attributes in C mode. Similar to how GCC supports __attribute__((foo)) as [[gnu::foo]] in C++ mode, it now supports the same spelling in C mode as well. This patch makes a change in Clang so that when you use the GCC attribute spelling, the attribute is automatically available in all three spellings by default. However, like Clang, GCC has some attributes it only recognizes in C++ mode (specifically, abi_tag and init_priority), which this patch also honors.
2020-06-01 22:39:38 +08:00
if (Spelling->getValueAsBit("AllowInC"))
Ret.emplace_back("C2x", std::string(Name), "gnu", true);
Add a new attribute definition spelling, Clang<"attr">, that expands to two attribute spellings: GNU<"attr"> and CXX11<"clang", "attr">. This is similar to how the GCC spelling works and is intended to be used for attributes introduced for Clang. Changes all existing attributes that currently use GNU<"attr"> and CXX11<"clang", "attr> spellings to instead use the Clang<"attr"> spelling. No additional tests are necessary because the existing tests already use both spellings for the attributes converted to the new spelling. No functional changes are expected. llvm-svn: 316658
2017-10-26 20:19:02 +08:00
} else if (Variety == "Clang") {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
Ret.emplace_back("GNU", std::string(Name), "", false);
Ret.emplace_back("CXX11", std::string(Name), "clang", false);
Introduce some infrastructure for adding C attributes with [[]] syntax. This patch adds support to the attribute tablegen for specifying a [[]] attribute is allowed in C mode. This patch also adds the annotate attribute to the list of double square bracket attributes we support in C mode. Eventually, I anticipate that this logic will be reversed (you have to opt out of allowing an attribute in C rather than opting in), but I want to see how the design plays out as more attributes are considered. llvm-svn: 321763
2018-01-04 06:22:48 +08:00
if (Spelling->getValueAsBit("AllowInC"))
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
Ret.emplace_back("C2x", std::string(Name), "clang", false);
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
} else
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
Ret.push_back(FlattenedSpelling(*Spelling));
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
}
return Ret;
}
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
static std::string ReadPCHRecord(StringRef type) {
return StringSwitch<std::string>(type)
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
.EndsWith("Decl *", "Record.GetLocalDeclAs<" +
std::string(type.data(), 0, type.size() - 1) +
">(Record.readInt())")
.Case("TypeSourceInfo *", "Record.readTypeSourceInfo()")
.Case("Expr *", "Record.readExpr()")
.Case("IdentifierInfo *", "Record.readIdentifier()")
.Case("StringRef", "Record.readString()")
.Case("ParamIdx", "ParamIdx::deserialize(Record.readInt())")
[OpenMP][NFC] Minimize memory usage and copying of `OMPTraitInfo`s See rational here: https://reviews.llvm.org/D71830#1922656 Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D76173
2020-03-14 12:42:05 +08:00
.Case("OMPTraitInfo *", "Record.readOMPTraitInfo()")
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
.Default("Record.readInt()");
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
}
Fix use-after-free ASan failures for modules / PCH files that deserialize abi_tag or no_sanitize attributes. llvm-svn: 269869
2016-05-18 08:16:51 +08:00
// Get a type that is suitable for storing an object of the specified type.
static StringRef getStorageType(StringRef type) {
return StringSwitch<StringRef>(type)
.Case("StringRef", "std::string")
.Default(type);
}
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
// Assumes that the way to get the value is SA->getname()
static std::string WritePCHRecord(StringRef type, StringRef name) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
return "Record." +
StringSwitch<std::string>(type)
.EndsWith("Decl *", "AddDeclRef(" + std::string(name) + ");\n")
.Case("TypeSourceInfo *",
"AddTypeSourceInfo(" + std::string(name) + ");\n")
.Case("Expr *", "AddStmt(" + std::string(name) + ");\n")
.Case("IdentifierInfo *",
"AddIdentifierRef(" + std::string(name) + ");\n")
.Case("StringRef", "AddString(" + std::string(name) + ");\n")
.Case("ParamIdx",
"push_back(" + std::string(name) + ".serialize());\n")
[OpenMP][NFC] Minimize memory usage and copying of `OMPTraitInfo`s See rational here: https://reviews.llvm.org/D71830#1922656 Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D76173
2020-03-14 12:42:05 +08:00
.Case("OMPTraitInfo *",
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
"writeOMPTraitInfo(" + std::string(name) + ");\n")
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
.Default("push_back(" + std::string(name) + ");\n");
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
}
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
// Normalize attribute name by removing leading and trailing
// underscores. For example, __foo, foo__, __foo__ would
// become foo.
static StringRef NormalizeAttrName(StringRef AttrName) {
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
AttrName.consume_front("__");
AttrName.consume_back("__");
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
return AttrName;
}
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
// Normalize the name by removing any and all leading and trailing underscores.
// This is different from NormalizeAttrName in that it also handles names like
// _pascal and __pascal.
static StringRef NormalizeNameForSpellingComparison(StringRef Name) {
[tblgen] Use StringRef::trim llvm-svn: 234643
2015-04-11 05:37:21 +08:00
return Name.trim("_");
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
}
[TableGen] Only normalize the spelling of GNU-style attributes. Summary: When Sema looks up an attribute name, it strips off leading and trailing "__" if the attribute is GNU-style. That is, __attribute__((foo)) and __attribute__((__foo__)) are equivalent. This is only true for GNU-style attributes. In particular, __declspec(__foo__) is not equivalent to __declspec(foo), and Sema respects this difference. This patch fixes TableGen to match Sema's behavior. The spelling 'GNU<"__foo__">' should be normalized to 'GNU<"foo">', but 'Declspec<"__foo__">' should not be changed. This is necessary to make CUDA compilation work on Windows, because e.g. the __device__ attribute is spelled __declspec(__device__). Attr.td does not contain any Declspec spellings that start or end with "__", so this change should not affect any other attributes. Reviewers: rnk Subscribers: cfe-commits, tra Differential Revision: https://reviews.llvm.org/D28318 llvm-svn: 291129
2017-01-06 00:51:54 +08:00
// Normalize the spelling of a GNU attribute (i.e. "x" in "__attribute__((x))"),
// removing "__" if it appears at the beginning and end of the attribute's name.
static StringRef NormalizeGNUAttrSpelling(StringRef AttrSpelling) {
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
if (AttrSpelling.startswith("__") && AttrSpelling.endswith("__")) {
AttrSpelling = AttrSpelling.substr(2, AttrSpelling.size() - 4);
}
return AttrSpelling;
}
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
typedef std::vector<std::pair<std::string, const Record *>> ParsedAttrMap;
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
static ParsedAttrMap getParsedAttrList(const RecordKeeper &Records,
[C++11] Use 'nullptr'. llvm-svn: 208163
2014-05-07 14:21:57 +08:00
ParsedAttrMap *Dupes = nullptr) {
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
std::set<std::string> Seen;
ParsedAttrMap R;
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
if (Attr->getValueAsBit("SemaHandler")) {
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
std::string AN;
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
if (Attr->isSubClassOf("TargetSpecificAttr") &&
!Attr->isValueUnset("ParseKind")) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
AN = std::string(Attr->getValueAsString("ParseKind"));
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
// If this attribute has already been handled, it does not need to be
// handled again.
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
if (Seen.find(AN) != Seen.end()) {
if (Dupes)
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
Dupes->push_back(std::make_pair(AN, Attr));
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
continue;
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
}
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
Seen.insert(AN);
} else
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
AN = NormalizeAttrName(Attr->getName()).str();
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
R.push_back(std::make_pair(AN, Attr));
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
}
}
return R;
}
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 {
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +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
class Argument {
std::string lowerName, upperName;
StringRef attrName;
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
bool isOpt;
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
bool Fake;
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
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
Argument(const Record &Arg, StringRef Attr)
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
: lowerName(std::string(Arg.getValueAsString("Name"))),
upperName(lowerName), attrName(Attr), isOpt(false), Fake(false) {
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
if (!lowerName.empty()) {
lowerName[0] = std::tolower(lowerName[0]);
upperName[0] = std::toupper(upperName[0]);
}
Work around MinGW's macro definition of 'interface' to 'struct' Previous attempts to rename the IBOutletCollection argument to something other than "Interface" were undone (r127127 and r139620). Instead of renaming it, work around this in tablegen, so the public facing getter can have the usual name of 'getInterface'. Fixes PR26682 llvm-svn: 271305
2016-06-01 01:42:56 +08:00
// Work around MinGW's macro definition of 'interface' to 'struct'. We
// have an attribute argument called 'Interface', so only the lower case
// name conflicts with the macro definition.
if (lowerName == "interface")
lowerName = "interface_";
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
}
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
virtual ~Argument() = default;
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
StringRef getLowerName() const { return lowerName; }
StringRef getUpperName() const { return upperName; }
StringRef getAttrName() const { return attrName; }
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
bool isOptional() const { return isOpt; }
void setOptional(bool set) { isOpt = set; }
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
bool isFake() const { return Fake; }
void setFake(bool fake) { Fake = fake; }
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
// These functions print the argument contents formatted in different ways.
virtual void writeAccessors(raw_ostream &OS) const = 0;
virtual void writeAccessorDefinitions(raw_ostream &OS) const {}
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
virtual void writeASTVisitorTraversal(raw_ostream &OS) const {}
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
virtual void writeCloneArgs(raw_ostream &OS) const = 0;
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
virtual void writeTemplateInstantiationArgs(raw_ostream &OS) const = 0;
Remove stray semi-colon. llvm-svn: 150231
2012-02-10 14:00:29 +08:00
virtual void writeTemplateInstantiation(raw_ostream &OS) const {}
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
virtual void writeCtorBody(raw_ostream &OS) const {}
virtual void writeCtorInitializers(raw_ostream &OS) const = 0;
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
virtual void writeCtorDefaultInitializers(raw_ostream &OS) const = 0;
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
virtual void writeCtorParameters(raw_ostream &OS) const = 0;
virtual void writeDeclarations(raw_ostream &OS) const = 0;
virtual void writePCHReadArgs(raw_ostream &OS) const = 0;
virtual void writePCHReadDecls(raw_ostream &OS) const = 0;
virtual void writePCHWrite(raw_ostream &OS) const = 0;
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
virtual std::string getIsOmitted() const { return "false"; }
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
virtual void writeValue(raw_ostream &OS) const = 0;
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
virtual void writeDump(raw_ostream &OS) const = 0;
virtual void writeDumpChildren(raw_ostream &OS) const {}
Add indents to AST dumping and removed parenthesis from AST nodes. Indents were given the color blue when outputting with color. AST dumping now looks like this: Node |-Node | `-Node `-Node `-Node Compared to the previous: (Node (Node (Node)) (Node (Node))) llvm-svn: 174022
2013-01-31 09:44:26 +08:00
virtual void writeHasChildren(raw_ostream &OS) const { OS << "false"; }
Tablegen now generates a StringSwitch for attributes containing enumeration arguments to map strings to the proper enumeration value. This makes error checking more consistent and reduces the amount of hand-written code required. llvm-svn: 190545
2013-09-12 03:47:58 +08:00
virtual bool isEnumArg() const { return false; }
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
virtual bool isVariadicEnumArg() const { return false; }
Automate attribute argument count semantic checking when there are variadic or optional arguments present. With this, the only time you should have to manually check attribute argument counts is when HasCustomParsing is set to true, or when you have variadic arguments that aren't really variadic (like ownership_holds and friends). Updating the diagnostics in the launch_bounds test since they have been improved in that case. Adding a test for nonnull since it has little test coverage, but has truly variadic arguments. llvm-svn: 214407
2014-08-01 00:37:04 +08:00
virtual bool isVariadic() const { return false; }
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
virtual void writeImplicitCtorArgs(raw_ostream &OS) const {
OS << getUpperName();
}
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
};
class SimpleArgument : public Argument {
std::string type;
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
SimpleArgument(const Record &Arg, StringRef Attr, std::string T)
Apply clang-tidy's misc-move-constructor-init throughout Clang. No functionality change intended, maybe a tiny performance improvement. llvm-svn: 270996
2016-05-27 22:27:13 +08:00
: Argument(Arg, Attr), type(std::move(T)) {}
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
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
std::string getType() const { return type; }
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
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
OS << " " << type << " get" << getUpperName() << "() const {\n";
OS << " return " << getLowerName() << ";\n";
OS << " }";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCloneArgs(raw_ostream &OS) const override {
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
OS << getLowerName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << "A->get" << getUpperName() << "()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorInitializers(raw_ostream &OS) const override {
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
OS << getLowerName() << "(" << getUpperName() << ")";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorDefaultInitializers(raw_ostream &OS) const override {
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
OS << getLowerName() << "()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorParameters(raw_ostream &OS) const override {
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
OS << type << " " << getUpperName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDeclarations(raw_ostream &OS) const override {
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
OS << type << " " << getLowerName() << ";";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadDecls(raw_ostream &OS) const override {
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
std::string read = ReadPCHRecord(type);
OS << " " << type << " " << getLowerName() << " = " << read << ";\n";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadArgs(raw_ostream &OS) const override {
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
OS << getLowerName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
OS << " "
<< WritePCHRecord(type,
"SA->get" + std::string(getUpperName()) + "()");
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
std::string getIsOmitted() const override {
if (type == "IdentifierInfo *")
return "!get" + getUpperName().str() + "()";
Add lifetime categories attributes Summary: This is the first part of work announced in "[RFC] Adding lifetime analysis to clang" [0], i.e. the addition of the [[gsl::Owner(T)]] and [[gsl::Pointer(T)]] attributes, which will enable user-defined types to participate in the lifetime analysis (which will be part of the next PR). The type `T` here is called "DerefType" in the paper, and denotes the type that an Owner owns and a Pointer points to. E.g. `std::vector<int>` should be annotated with `[[gsl::Owner(int)]]` and a `std::vector<int>::iterator` with `[[gsl::Pointer(int)]]`. [0] http://lists.llvm.org/pipermail/cfe-dev/2018-November/060355.html Reviewers: gribozavr Subscribers: xazax.hun, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63954 llvm-svn: 367040
2019-07-26 01:50:51 +08:00
if (type == "TypeSourceInfo *")
return "!get" + getUpperName().str() + "Loc()";
Reland "[Attr] Fix parameter indexing for several attributes" Relands r326602 (reverted in r326862) with new test and fix for PR36620. Differential Revision: https://reviews.llvm.org/D43248 llvm-svn: 327405
2018-03-13 22:51:22 +08:00
if (type == "ParamIdx")
return "!get" + getUpperName().str() + "().isValid()";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
return "false";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeValue(raw_ostream &OS) const override {
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
if (type == "FunctionDecl *")
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
OS << "\" << get" << getUpperName()
<< "()->getNameInfo().getAsString() << \"";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
else if (type == "IdentifierInfo *")
// Some non-optional (comma required) identifier arguments can be the
// empty string but are then recorded as a nullptr.
OS << "\" << (get" << getUpperName() << "() ? get" << getUpperName()
<< "()->getName() : \"\") << \"";
Introduce ns_error_domain attribute. ns_error_domain can be used by, e.g. NS_ERROR_ENUM, in order to identify a global declaration representing the domain constant. Introduces the attribute, Sema handling, diagnostics, and test case. This is cherry-picked from https://github.com/llvm/llvm-project-staging/commit/a14779f504b02ad0e4dbc39d6d10cadc7ed4cfd0 and adapted to updated Clang APIs. Reviewed By: gribozavr2, aaron.ballman Differential Revision: https://reviews.llvm.org/D84005
2020-08-13 20:54:02 +08:00
else if (type == "VarDecl *")
OS << "\" << get" << getUpperName() << "()->getName() << \"";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
else if (type == "TypeSourceInfo *")
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
OS << "\" << get" << getUpperName() << "().getAsString() << \"";
Reland "[Attr] Fix parameter indexing for several attributes" Relands r326602 (reverted in r326862) with new test and fix for PR36620. Differential Revision: https://reviews.llvm.org/D43248 llvm-svn: 327405
2018-03-13 22:51:22 +08:00
else if (type == "ParamIdx")
OS << "\" << get" << getUpperName() << "().getSourceIndex() << \"";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
else
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
OS << "\" << get" << getUpperName() << "() << \"";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDump(raw_ostream &OS) const override {
Generalize our two different kinds of declaration argument for attributes to support any kind of declaration. In preparation for adding a third kind.
2020-04-15 14:28:33 +08:00
if (StringRef(type).endswith("Decl *")) {
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
OS << " OS << \" \";\n";
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
OS << " dumpBareDeclRef(SA->get" << getUpperName() << "());\n";
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
} else if (type == "IdentifierInfo *") {
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
// Some non-optional (comma required) identifier arguments can be the
// empty string but are then recorded as a nullptr.
OS << " if (SA->get" << getUpperName() << "())\n"
<< " OS << \" \" << SA->get" << getUpperName()
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
<< "()->getName();\n";
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
} else if (type == "TypeSourceInfo *") {
Add lifetime categories attributes Summary: This is the first part of work announced in "[RFC] Adding lifetime analysis to clang" [0], i.e. the addition of the [[gsl::Owner(T)]] and [[gsl::Pointer(T)]] attributes, which will enable user-defined types to participate in the lifetime analysis (which will be part of the next PR). The type `T` here is called "DerefType" in the paper, and denotes the type that an Owner owns and a Pointer points to. E.g. `std::vector<int>` should be annotated with `[[gsl::Owner(int)]]` and a `std::vector<int>::iterator` with `[[gsl::Pointer(int)]]`. [0] http://lists.llvm.org/pipermail/cfe-dev/2018-November/060355.html Reviewers: gribozavr Subscribers: xazax.hun, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63954 llvm-svn: 367040
2019-07-26 01:50:51 +08:00
if (isOptional())
OS << " if (SA->get" << getUpperName() << "Loc())";
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
OS << " OS << \" \" << SA->get" << getUpperName()
<< "().getAsString();\n";
} else if (type == "bool") {
OS << " if (SA->get" << getUpperName() << "()) OS << \" "
<< getUpperName() << "\";\n";
} else if (type == "int" || type == "unsigned") {
OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
Reland "[Attr] Fix parameter indexing for several attributes" Relands r326602 (reverted in r326862) with new test and fix for PR36620. Differential Revision: https://reviews.llvm.org/D43248 llvm-svn: 327405
2018-03-13 22:51:22 +08:00
} else if (type == "ParamIdx") {
if (isOptional())
OS << " if (SA->get" << getUpperName() << "().isValid())\n ";
OS << " OS << \" \" << SA->get" << getUpperName()
<< "().getSourceIndex();\n";
[OpenMP][NFC] Minimize memory usage and copying of `OMPTraitInfo`s See rational here: https://reviews.llvm.org/D71830#1922656 Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D76173
2020-03-14 12:42:05 +08:00
} else if (type == "OMPTraitInfo *") {
[FIX] Remove pointer in attribute to eliminate leaks (see D71830)
2020-02-16 08:07:42 +08:00
OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
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
} else {
llvm_unreachable("Unknown SimpleArgument type!");
}
}
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
};
Implemented DefaultIntArgument in the table generator and start using it in semantic analysis. Removes some magic numbers. llvm-svn: 195287
2013-11-21 08:28:23 +08:00
class DefaultSimpleArgument : public SimpleArgument {
int64_t Default;
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
DefaultSimpleArgument(const Record &Arg, StringRef Attr,
Implemented DefaultIntArgument in the table generator and start using it in semantic analysis. Removes some magic numbers. llvm-svn: 195287
2013-11-21 08:28:23 +08:00
std::string T, int64_t Default)
: SimpleArgument(Arg, Attr, T), Default(Default) {}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
Implemented DefaultIntArgument in the table generator and start using it in semantic analysis. Removes some magic numbers. llvm-svn: 195287
2013-11-21 08:28:23 +08:00
SimpleArgument::writeAccessors(OS);
OS << "\n\n static const " << getType() << " Default" << getUpperName()
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
<< " = ";
if (getType() == "bool")
OS << (Default != 0 ? "true" : "false");
else
OS << Default;
OS << ";";
Implemented DefaultIntArgument in the table generator and start using it in semantic analysis. Removes some magic numbers. llvm-svn: 195287
2013-11-21 08:28:23 +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
class StringArgument : public Argument {
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
StringArgument(const Record &Arg, StringRef Attr)
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
: Argument(Arg, Attr)
{}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
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
OS << " llvm::StringRef get" << getUpperName() << "() const {\n";
OS << " return llvm::StringRef(" << getLowerName() << ", "
<< getLowerName() << "Length);\n";
OS << " }\n";
OS << " unsigned get" << getUpperName() << "Length() const {\n";
OS << " return " << getLowerName() << "Length;\n";
OS << " }\n";
OS << " void set" << getUpperName()
<< "(ASTContext &C, llvm::StringRef S) {\n";
OS << " " << getLowerName() << "Length = S.size();\n";
OS << " this->" << getLowerName() << " = new (C, 1) char ["
<< getLowerName() << "Length];\n";
[UB] Guard two calls to memcpy in generated attribute code to handle null StringRef objects as inputs. Found by UBSan. llvm-svn: 243949
2015-08-04 11:53:01 +08:00
OS << " if (!S.empty())\n";
OS << " std::memcpy(this->" << getLowerName() << ", S.data(), "
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
<< getLowerName() << "Length);\n";
OS << " }";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCloneArgs(raw_ostream &OS) const override {
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
OS << "get" << getUpperName() << "()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << "A->get" << getUpperName() << "()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorBody(raw_ostream &OS) const override {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " if (!" << getUpperName() << ".empty())\n";
OS << " std::memcpy(" << getLowerName() << ", " << getUpperName()
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
<< ".data(), " << getLowerName() << "Length);\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorInitializers(raw_ostream &OS) const override {
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
OS << getLowerName() << "Length(" << getUpperName() << ".size()),"
<< getLowerName() << "(new (Ctx, 1) char[" << getLowerName()
<< "Length])";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorDefaultInitializers(raw_ostream &OS) const override {
Fix Clang-tidy modernize-use-nullptr warnings in headers and generated files; other minor cleanups. By Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13187 llvm-svn: 248828
2015-09-30 04:56:43 +08:00
OS << getLowerName() << "Length(0)," << getLowerName() << "(nullptr)";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorParameters(raw_ostream &OS) const override {
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
OS << "llvm::StringRef " << getUpperName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDeclarations(raw_ostream &OS) const override {
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
OS << "unsigned " << getLowerName() << "Length;\n";
OS << "char *" << getLowerName() << ";";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadDecls(raw_ostream &OS) const override {
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
OS << " std::string " << getLowerName()
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
<< "= Record.readString();\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadArgs(raw_ostream &OS) const override {
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
OS << getLowerName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
OS << " Record.AddString(SA->get" << getUpperName() << "());\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeValue(raw_ostream &OS) const override {
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
OS << "\\\"\" << get" << getUpperName() << "() << \"\\\"";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDump(raw_ostream &OS) const override {
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
OS << " OS << \" \\\"\" << SA->get" << getUpperName()
<< "() << \"\\\"\";\n";
}
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
};
class AlignedArgument : public Argument {
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
AlignedArgument(const Record &Arg, StringRef Attr)
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
: Argument(Arg, Attr)
{}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
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
OS << " bool is" << getUpperName() << "Dependent() const;\n";
[AST] Fix recovery-expr crash on invalid aligned attr. Summary: crash stack: ``` lang: tools/clang/include/clang/AST/AttrImpl.inc:1490: unsigned int clang::AlignedAttr::getAlignment(clang::ASTContext &) const: Assertion `!isAlignmentDependent()' failed. PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script. Stack dump: 0. Program arguments: ./bin/clang -cc1 -std=c++1y -ast-dump -frecovery-ast -fcxx-exceptions /tmp/t4.cpp 1. /tmp/t4.cpp:3:31: current parser token ';' #0 0x0000000002530cff llvm::sys::PrintStackTrace(llvm::raw_ostream&) llvm-project/llvm/lib/Support/Unix/Signals.inc:564:13 #1 0x000000000252ee30 llvm::sys::RunSignalHandlers() llvm-project/llvm/lib/Support/Signals.cpp:69:18 #2 0x000000000253126c SignalHandler(int) llvm-project/llvm/lib/Support/Unix/Signals.inc:396:3 #3 0x00007f86964d0520 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x13520) #4 0x00007f8695f9ff61 raise /build/glibc-oCLvUT/glibc-2.29/signal/../sysdeps/unix/sysv/linux/raise.c:51:1 #5 0x00007f8695f8b535 abort /build/glibc-oCLvUT/glibc-2.29/stdlib/abort.c:81:7 #6 0x00007f8695f8b40f _nl_load_domain /build/glibc-oCLvUT/glibc-2.29/intl/loadmsgcat.c:1177:9 #7 0x00007f8695f98b92 (/lib/x86_64-linux-gnu/libc.so.6+0x32b92) #8 0x0000000004503d9f llvm::APInt::getZExtValue() const llvm-project/llvm/include/llvm/ADT/APInt.h:1623:5 #9 0x0000000004503d9f clang::AlignedAttr::getAlignment(clang::ASTContext&) const llvm-project/build/tools/clang/include/clang/AST/AttrImpl.inc:1492:0 ``` Reviewers: sammccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D78085
2020-04-13 05:06:00 +08:00
OS << " bool is" << getUpperName() << "ErrorDependent() const;\n";
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
OS << " unsigned get" << getUpperName() << "(ASTContext &Ctx) const;\n";
OS << " bool is" << getUpperName() << "Expr() const {\n";
OS << " return is" << getLowerName() << "Expr;\n";
OS << " }\n";
OS << " Expr *get" << getUpperName() << "Expr() const {\n";
OS << " assert(is" << getLowerName() << "Expr);\n";
OS << " return " << getLowerName() << "Expr;\n";
OS << " }\n";
OS << " TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
OS << " assert(!is" << getLowerName() << "Expr);\n";
OS << " return " << getLowerName() << "Type;\n";
OS << " }";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessorDefinitions(raw_ostream &OS) const override {
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
OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
<< "Dependent() const {\n";
OS << " if (is" << getLowerName() << "Expr)\n";
OS << " return " << getLowerName() << "Expr && (" << getLowerName()
<< "Expr->isValueDependent() || " << getLowerName()
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
<< "Expr->isTypeDependent());\n";
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
OS << " else\n";
OS << " return " << getLowerName()
<< "Type->getType()->isDependentType();\n";
OS << "}\n";
[AST] Fix recovery-expr crash on invalid aligned attr. Summary: crash stack: ``` lang: tools/clang/include/clang/AST/AttrImpl.inc:1490: unsigned int clang::AlignedAttr::getAlignment(clang::ASTContext &) const: Assertion `!isAlignmentDependent()' failed. PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script. Stack dump: 0. Program arguments: ./bin/clang -cc1 -std=c++1y -ast-dump -frecovery-ast -fcxx-exceptions /tmp/t4.cpp 1. /tmp/t4.cpp:3:31: current parser token ';' #0 0x0000000002530cff llvm::sys::PrintStackTrace(llvm::raw_ostream&) llvm-project/llvm/lib/Support/Unix/Signals.inc:564:13 #1 0x000000000252ee30 llvm::sys::RunSignalHandlers() llvm-project/llvm/lib/Support/Signals.cpp:69:18 #2 0x000000000253126c SignalHandler(int) llvm-project/llvm/lib/Support/Unix/Signals.inc:396:3 #3 0x00007f86964d0520 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x13520) #4 0x00007f8695f9ff61 raise /build/glibc-oCLvUT/glibc-2.29/signal/../sysdeps/unix/sysv/linux/raise.c:51:1 #5 0x00007f8695f8b535 abort /build/glibc-oCLvUT/glibc-2.29/stdlib/abort.c:81:7 #6 0x00007f8695f8b40f _nl_load_domain /build/glibc-oCLvUT/glibc-2.29/intl/loadmsgcat.c:1177:9 #7 0x00007f8695f98b92 (/lib/x86_64-linux-gnu/libc.so.6+0x32b92) #8 0x0000000004503d9f llvm::APInt::getZExtValue() const llvm-project/llvm/include/llvm/ADT/APInt.h:1623:5 #9 0x0000000004503d9f clang::AlignedAttr::getAlignment(clang::ASTContext&) const llvm-project/build/tools/clang/include/clang/AST/AttrImpl.inc:1492:0 ``` Reviewers: sammccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D78085
2020-04-13 05:06:00 +08:00
OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
<< "ErrorDependent() const {\n";
OS << " if (is" << getLowerName() << "Expr)\n";
OS << " return " << getLowerName() << "Expr && " << getLowerName()
<< "Expr->containsErrors();\n";
OS << " return " << getLowerName()
<< "Type->getType()->containsErrors();\n";
OS << "}\n";
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
// FIXME: Do not do the calculation here
// FIXME: Handle types correctly
// A null pointer means maximum alignment
OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
<< "(ASTContext &Ctx) const {\n";
OS << " assert(!is" << getUpperName() << "Dependent());\n";
OS << " if (is" << getLowerName() << "Expr)\n";
Implement target-specific __attribute__((aligned)) value The GCC construct __attribute__((aligned)) is defined to set alignment to "the default alignment for the target architecture" according to the GCC documentation: The default alignment is sufficient for all scalar types, but may not be enough for all vector types on a target that supports vector operations. The default alignment is fixed for a particular target ABI. clang currently hard-coded an alignment of 16 bytes for that construct, which is correct on some platforms (including X86), but wrong on others (including SystemZ). Since this value is ABI-relevant, it is important to get correct for compatibility purposes. This patch adds a new TargetInfo member "DefaultAlignForAttributeAligned" that targets can set to the appropriate default __attribute__((aligned)) value. Note that I'm deliberately *not* using the existing "SuitableAlign" value, which is used to set the pre-defined macro __BIGGEST_ALIGNMENT__, since those two values may not be the same on all platforms. In fact, on X86, __attribute__((aligned)) always uses 16-byte alignment, while __BIGGEST_ALIGNMENT__ may be larger if AVX-2 or AVX-512 are supported. (This is actually not yet correctly implemented in clang either.) The patch provides a value for DefaultAlignForAttributeAligned only for SystemZ, and leaves the default for all other targets at 16, which means no visible change in behavior on all other targets. (The value is still wrong for some other targets, but I'd prefer to leave it to the target maintainers for those platforms to fix.) llvm-svn: 235397
2015-04-22 01:29:35 +08:00
OS << " return " << getLowerName() << "Expr ? " << getLowerName()
<< "Expr->EvaluateKnownConstInt(Ctx).getZExtValue()"
<< " * Ctx.getCharWidth() : "
<< "Ctx.getTargetDefaultAlignForAttributeAligned();\n";
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
OS << " else\n";
OS << " return 0; // FIXME\n";
OS << "}\n";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Do not look through pack expansions when looking for unexpanded parameter packs. Fixes a selection of rejects-valids when pack-expanding a lambda that itself contains a pack expansion. llvm-svn: 310972
2017-08-16 06:58:45 +08:00
void writeASTVisitorTraversal(raw_ostream &OS) const override {
StringRef Name = getUpperName();
OS << " if (A->is" << Name << "Expr()) {\n"
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
<< " if (!getDerived().TraverseStmt(A->get" << Name << "Expr()))\n"
<< " return false;\n"
Do not look through pack expansions when looking for unexpanded parameter packs. Fixes a selection of rejects-valids when pack-expanding a lambda that itself contains a pack expansion. llvm-svn: 310972
2017-08-16 06:58:45 +08:00
<< " } else if (auto *TSI = A->get" << Name << "Type()) {\n"
<< " if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n"
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
<< " return false;\n"
Do not look through pack expansions when looking for unexpanded parameter packs. Fixes a selection of rejects-valids when pack-expanding a lambda that itself contains a pack expansion. llvm-svn: 310972
2017-08-16 06:58:45 +08:00
<< " }\n";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCloneArgs(raw_ostream &OS) const override {
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
OS << "is" << getLowerName() << "Expr, is" << getLowerName()
<< "Expr ? static_cast<void*>(" << getLowerName()
<< "Expr) : " << getLowerName()
<< "Type";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
// FIXME: move the definition in Sema::InstantiateAttrs to here.
// In the meantime, aligned attributes are cloned.
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorBody(raw_ostream &OS) const override {
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
OS << " if (is" << getLowerName() << "Expr)\n";
OS << " " << getLowerName() << "Expr = reinterpret_cast<Expr *>("
<< getUpperName() << ");\n";
OS << " else\n";
OS << " " << getLowerName()
<< "Type = reinterpret_cast<TypeSourceInfo *>(" << getUpperName()
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
<< ");\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorInitializers(raw_ostream &OS) const override {
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
OS << "is" << getLowerName() << "Expr(Is" << getUpperName() << "Expr)";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorDefaultInitializers(raw_ostream &OS) const override {
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
OS << "is" << getLowerName() << "Expr(false)";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorParameters(raw_ostream &OS) const override {
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
OS << "bool Is" << getUpperName() << "Expr, void *" << getUpperName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeImplicitCtorArgs(raw_ostream &OS) const override {
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
OS << "Is" << getUpperName() << "Expr, " << getUpperName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDeclarations(raw_ostream &OS) const override {
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
OS << "bool is" << getLowerName() << "Expr;\n";
OS << "union {\n";
OS << "Expr *" << getLowerName() << "Expr;\n";
OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
OS << "};";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadArgs(raw_ostream &OS) const override {
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
OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadDecls(raw_ostream &OS) const override {
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
OS << " bool is" << getLowerName() << "Expr = Record.readInt();\n";
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
OS << " void *" << getLowerName() << "Ptr;\n";
OS << " if (is" << getLowerName() << "Expr)\n";
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
OS << " " << getLowerName() << "Ptr = Record.readExpr();\n";
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
OS << " else\n";
OS << " " << getLowerName()
Standardize the reader methods in ASTReader; NFC. There are three significant changes here: - Most of the methods to read various embedded structures (`APInt`, `NestedNameSpecifier`, `DeclarationName`, etc.) have been moved from `ASTReader` to `ASTRecordReader`. This cleans up quite a bit of code which was passing around `(F, Record, Idx)` arguments everywhere or doing explicit indexing, and it nicely parallels how it works on the writer side. It also sets us up to then move most of these methods into the `BasicReader`s that I'm introducing as part of abstract serialization. As part of this, several of the top-level reader methods (e.g. `readTypeRecord`) have been converted to use `ASTRecordReader` internally, which is a nice readability improvement. - I've standardized most of these method names on `readFoo` rather than `ReadFoo` (used in some of the helper structures) or `GetFoo` (used for some specific types for no apparent reason). - I've changed a few of these methods to return their result instead of reading into an argument passed by reference. This is partly for general consistency and partly because it will make the metaprogramming easier with abstract serialization.
2019-12-13 16:37:23 +08:00
<< "Ptr = Record.readTypeSourceInfo();\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
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
OS << " Record.push_back(SA->is" << getUpperName() << "Expr());\n";
OS << " if (SA->is" << getUpperName() << "Expr())\n";
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
OS << " Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
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
OS << " else\n";
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
OS << " Record.AddTypeSourceInfo(SA->get" << getUpperName()
<< "Type());\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
std::string getIsOmitted() const override {
return "!is" + getLowerName().str() + "Expr || !" + getLowerName().str()
+ "Expr";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeValue(raw_ostream &OS) const override {
Removing an "if (this == nullptr)" check from two print methods. The condition will never be true in a well-defined context. The checking for null pointers has been moved into the caller logic so it does not rely on undefined behavior. llvm-svn: 210498
2014-06-10 06:53:25 +08:00
OS << "\";\n";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
OS << " " << getLowerName()
<< "Expr->printPretty(OS, nullptr, Policy);\n";
Removing an "if (this == nullptr)" check from two print methods. The condition will never be true in a well-defined context. The checking for null pointers has been moved into the caller logic so it does not rely on undefined behavior. llvm-svn: 210498
2014-06-10 06:53:25 +08:00
OS << " OS << \"";
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
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
void writeDump(raw_ostream &OS) const override {
OS << " if (!SA->is" << getUpperName() << "Expr())\n";
OS << " dumpType(SA->get" << getUpperName()
<< "Type()->getType());\n";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDumpChildren(raw_ostream &OS) const override {
Refactor tree printing in AST dumping. Instead of manually maintaining a flag indicating whether we're about to print out the last child of the parent node (to determine whether we print "`" or "|"), capture a callable to print that child and defer printing it until we either see a next child or finish the parent. No functionality change intended. llvm-svn: 220930
2014-10-31 05:02:37 +08:00
OS << " if (SA->is" << getUpperName() << "Expr())\n";
[ASTDump] Rename methods which are conceptually Visits This is consistent with the TextNodeDumper, and is the appropriate name for the traverser class which will be extracted. llvm-svn: 352657
2019-01-31 03:49:49 +08:00
OS << " Visit(SA->get" << getUpperName() << "Expr());\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeHasChildren(raw_ostream &OS) const override {
Add indents to AST dumping and removed parenthesis from AST nodes. Indents were given the color blue when outputting with color. AST dumping now looks like this: Node |-Node | `-Node `-Node `-Node Compared to the previous: (Node (Node (Node)) (Node (Node))) llvm-svn: 174022
2013-01-31 09:44:26 +08:00
OS << "SA->is" << getUpperName() << "Expr()";
}
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
};
class VariadicArgument : public Argument {
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
std::string Type, ArgName, ArgSizeName, RangeName;
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
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
protected:
// Assumed to receive a parameter: raw_ostream OS.
virtual void writeValueImpl(raw_ostream &OS) const {
OS << " OS << Val;\n";
}
Reland "[Attr] Fix parameter indexing for several attributes" Relands r326602 (reverted in r326862) with new test and fix for PR36620. Differential Revision: https://reviews.llvm.org/D43248 llvm-svn: 327405
2018-03-13 22:51:22 +08:00
// Assumed to receive a parameter: raw_ostream OS.
virtual void writeDumpImpl(raw_ostream &OS) const {
OS << " OS << \" \" << Val;\n";
}
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +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
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
VariadicArgument(const Record &Arg, StringRef Attr, std::string T)
Apply clang-tidy's misc-move-constructor-init throughout Clang. No functionality change intended, maybe a tiny performance improvement. llvm-svn: 270996
2016-05-27 22:27:13 +08:00
: Argument(Arg, Attr), Type(std::move(T)),
ArgName(getLowerName().str() + "_"), ArgSizeName(ArgName + "Size"),
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
RangeName(std::string(getLowerName())) {}
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
Fix a leak in the generated code for attributes with strings. Storing std::strings in attributes simply doesn't work, we never call the destructor. Use an array of StringRefs instead of std::strings and copy the data into memory taken from the ASTContext. llvm-svn: 260831
2016-02-14 02:11:49 +08:00
const std::string &getType() const { return Type; }
const std::string &getArgName() const { return ArgName; }
const std::string &getArgSizeName() const { return ArgSizeName; }
Automate attribute argument count semantic checking when there are variadic or optional arguments present. With this, the only time you should have to manually check attribute argument counts is when HasCustomParsing is set to true, or when you have variadic arguments that aren't really variadic (like ownership_holds and friends). Updating the diagnostics in the launch_bounds test since they have been improved in that case. Adding a test for nonnull since it has little test coverage, but has truly variadic arguments. llvm-svn: 214407
2014-08-01 00:37:04 +08:00
bool isVariadic() const override { return true; }
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
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
std::string IteratorType = getLowerName().str() + "_iterator";
std::string BeginFn = getLowerName().str() + "_begin()";
std::string EndFn = getLowerName().str() + "_end()";
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
OS << " typedef " << Type << "* " << IteratorType << ";\n";
OS << " " << IteratorType << " " << BeginFn << " const {"
<< " return " << ArgName << "; }\n";
OS << " " << IteratorType << " " << EndFn << " const {"
<< " return " << ArgName << " + " << ArgSizeName << "; }\n";
OS << " unsigned " << getLowerName() << "_size() const {"
<< " return " << ArgSizeName << "; }\n";
OS << " llvm::iterator_range<" << IteratorType << "> " << RangeName
<< "() const { return llvm::make_range(" << BeginFn << ", " << EndFn
<< "); }\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCloneArgs(raw_ostream &OS) const override {
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
OS << ArgName << ", " << ArgSizeName;
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
// This isn't elegant, but we have to go through public methods...
OS << "A->" << getLowerName() << "_begin(), "
<< "A->" << getLowerName() << "_size()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Do not look through pack expansions when looking for unexpanded parameter packs. Fixes a selection of rejects-valids when pack-expanding a lambda that itself contains a pack expansion. llvm-svn: 310972
2017-08-16 06:58:45 +08:00
void writeASTVisitorTraversal(raw_ostream &OS) const override {
// FIXME: Traverse the elements.
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorBody(raw_ostream &OS) const override {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " std::copy(" << getUpperName() << ", " << getUpperName() << " + "
<< ArgSizeName << ", " << ArgName << ");\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorInitializers(raw_ostream &OS) const override {
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
OS << ArgSizeName << "(" << getUpperName() << "Size), "
<< ArgName << "(new (Ctx, 16) " << getType() << "["
<< ArgSizeName << "])";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorDefaultInitializers(raw_ostream &OS) const override {
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
OS << ArgSizeName << "(0), " << ArgName << "(nullptr)";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorParameters(raw_ostream &OS) const override {
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
OS << getType() << " *" << getUpperName() << ", unsigned "
<< getUpperName() << "Size";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeImplicitCtorArgs(raw_ostream &OS) const override {
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
OS << getUpperName() << ", " << getUpperName() << "Size";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDeclarations(raw_ostream &OS) const override {
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
OS << " unsigned " << ArgSizeName << ";\n";
OS << " " << getType() << " *" << ArgName << ";";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadDecls(raw_ostream &OS) const override {
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
Fix use-after-free ASan failures for modules / PCH files that deserialize abi_tag or no_sanitize attributes. llvm-svn: 269869
2016-05-18 08:16:51 +08:00
OS << " SmallVector<" << getType() << ", 4> "
<< getLowerName() << ";\n";
OS << " " << getLowerName() << ".reserve(" << getLowerName()
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
<< "Size);\n";
Fix use-after-free ASan failures for modules / PCH files that deserialize abi_tag or no_sanitize attributes. llvm-svn: 269869
2016-05-18 08:16:51 +08:00
// If we can't store the values in the current type (if it's something
// like StringRef), store them in a different type and convert the
// container afterwards.
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string StorageType = std::string(getStorageType(getType()));
std::string StorageName = std::string(getLowerName());
Fix use-after-free ASan failures for modules / PCH files that deserialize abi_tag or no_sanitize attributes. llvm-svn: 269869
2016-05-18 08:16:51 +08:00
if (StorageType != getType()) {
StorageName += "Storage";
OS << " SmallVector<" << StorageType << ", 4> "
<< StorageName << ";\n";
OS << " " << StorageName << ".reserve(" << getLowerName()
<< "Size);\n";
}
OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
std::string read = ReadPCHRecord(Type);
Fix use-after-free ASan failures for modules / PCH files that deserialize abi_tag or no_sanitize attributes. llvm-svn: 269869
2016-05-18 08:16:51 +08:00
OS << " " << StorageName << ".push_back(" << read << ");\n";
if (StorageType != getType()) {
OS << " for (unsigned i = 0; i != " << getLowerName() << "Size; ++i)\n";
OS << " " << getLowerName() << ".push_back("
<< StorageName << "[i]);\n";
}
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadArgs(raw_ostream &OS) const override {
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
OS << getLowerName() << ".data(), " << getLowerName() << "Size";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
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
OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
OS << " for (auto &Val : SA->" << RangeName << "())\n";
OS << " " << WritePCHRecord(Type, "Val");
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeValue(raw_ostream &OS) const override {
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
OS << "\";\n";
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " for (const auto &Val : " << RangeName << "()) {\n"
<< " DelimitAttributeArgument(OS, IsFirstArgument);\n";
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
writeValueImpl(OS);
OS << " }\n";
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
OS << " OS << \"";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDump(raw_ostream &OS) const override {
Updated the attribute tablegen emitter for variadic arguments to emit a range accessor in addition to the iterators. Updated code using iterators to use range-based for loops. llvm-svn: 207837
2014-05-02 21:35:42 +08:00
OS << " for (const auto &Val : SA->" << RangeName << "())\n";
Reland "[Attr] Fix parameter indexing for several attributes" Relands r326602 (reverted in r326862) with new test and fix for PR36620. Differential Revision: https://reviews.llvm.org/D43248 llvm-svn: 327405
2018-03-13 22:51:22 +08:00
writeDumpImpl(OS);
}
};
class VariadicParamIdxArgument : public VariadicArgument {
public:
VariadicParamIdxArgument(const Record &Arg, StringRef Attr)
: VariadicArgument(Arg, Attr, "ParamIdx") {}
public:
void writeValueImpl(raw_ostream &OS) const override {
OS << " OS << Val.getSourceIndex();\n";
}
void writeDumpImpl(raw_ostream &OS) const override {
OS << " OS << \" \" << Val.getSourceIndex();\n";
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
}
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
};
Emit !callback metadata and introduce the callback attribute With commit r351627, LLVM gained the ability to apply (existing) IPO optimizations on indirections through callbacks, or transitive calls. The general idea is that we use an abstraction to hide the middle man and represent the callback call in the context of the initial caller. It is described in more detail in the commit message of the LLVM patch r351627, the llvm::AbstractCallSite class description, and the language reference section on callback-metadata. This commit enables clang to emit !callback metadata that is understood by LLVM. It does so in three different cases: 1) For known broker functions declarations that are directly generated, e.g., __kmpc_fork_call for the OpenMP pragma parallel. 2) For known broker functions that are identified by their name and source location through the builtin detection, e.g., pthread_create from the POSIX thread API. 3) For user annotated functions that carry the "callback(callee, ...)" attribute. The attribute has to include the name, or index, of the callback callee and how the passed arguments can be identified (as many as the callback callee has). See the callback attribute documentation for detailed information. Differential Revision: https://reviews.llvm.org/D55483 llvm-svn: 351629
2019-01-19 13:36:54 +08:00
struct VariadicParamOrParamIdxArgument : public VariadicArgument {
VariadicParamOrParamIdxArgument(const Record &Arg, StringRef Attr)
: VariadicArgument(Arg, Attr, "int") {}
};
Attributes: Emit enumerators in td file declaration order llvm-svn: 201246
2014-02-13 02:22:18 +08:00
// Unique the enums, but maintain the original declaration ordering.
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
std::vector<StringRef>
uniqueEnumsInOrder(const std::vector<StringRef> &enums) {
std::vector<StringRef> uniques;
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
SmallDenseSet<StringRef, 8> unique_set;
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &i : enums) {
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
if (unique_set.insert(i).second)
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
uniques.push_back(i);
Attributes: Emit enumerators in td file declaration order llvm-svn: 201246
2014-02-13 02:22:18 +08:00
}
return uniques;
}
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
class EnumArgument : public Argument {
std::string type;
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
std::vector<StringRef> values, enums, uniques;
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
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
EnumArgument(const Record &Arg, StringRef Attr)
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
: Argument(Arg, Attr), type(std::string(Arg.getValueAsString("Type"))),
values(Arg.getValueAsListOfStrings("Values")),
enums(Arg.getValueAsListOfStrings("Enums")),
uniques(uniqueEnumsInOrder(enums)) {
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
// FIXME: Emit a proper error
assert(!uniques.empty());
}
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
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
bool isEnumArg() const override { return true; }
Tablegen now generates a StringSwitch for attributes containing enumeration arguments to map strings to the proper enumeration value. This makes error checking more consistent and reduces the amount of hand-written code required. llvm-svn: 190545
2013-09-12 03:47:58 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
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
OS << " " << type << " get" << getUpperName() << "() const {\n";
OS << " return " << getLowerName() << ";\n";
OS << " }";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCloneArgs(raw_ostream &OS) const override {
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
OS << getLowerName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << "A->get" << getUpperName() << "()";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorInitializers(raw_ostream &OS) const override {
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
OS << getLowerName() << "(" << getUpperName() << ")";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorDefaultInitializers(raw_ostream &OS) const override {
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
OS << getLowerName() << "(" << type << "(0))";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorParameters(raw_ostream &OS) const override {
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
OS << type << " " << getUpperName();
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDeclarations(raw_ostream &OS) const override {
Use range loops and autos in utils/TableGen/ClangAttrEmitter.cpp and generated code. Differential revision: http://reviews.llvm.org/D15313 llvm-svn: 255042
2015-12-09 02:49:01 +08:00
auto i = uniques.cbegin(), e = uniques.cend();
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
// The last one needs to not have a comma.
--e;
OS << "public:\n";
OS << " enum " << type << " {\n";
for (; i != e; ++i)
OS << " " << *i << ",\n";
OS << " " << *e << "\n";
OS << " };\n";
OS << "private:\n";
OS << " " << type << " " << getLowerName() << ";";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadDecls(raw_ostream &OS) const override {
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
OS << " " << getAttrName() << "Attr::" << type << " " << getLowerName()
<< "(static_cast<" << getAttrName() << "Attr::" << type
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
<< ">(Record.readInt()));\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadArgs(raw_ostream &OS) const override {
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
OS << getLowerName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
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
OS << "Record.push_back(SA->get" << getUpperName() << "());\n";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeValue(raw_ostream &OS) const override {
Adding some FIXMEs to the attribute emitter code regarding whether pretty printing enumerators should use quoted string literals, or identifiers. NFC. llvm-svn: 217781
2014-09-16 00:16:14 +08:00
// FIXME: this isn't 100% correct -- some enum arguments require printing
// as a string literal, while others require printing as an identifier.
// Tablegen currently does not distinguish between the two forms.
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
OS << "\\\"\" << " << getAttrName() << "Attr::Convert" << type << "ToStr(get"
<< getUpperName() << "()) << \"\\\"";
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDump(raw_ostream &OS) const override {
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
OS << " switch(SA->get" << getUpperName() << "()) {\n";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &I : uniques) {
OS << " case " << getAttrName() << "Attr::" << I << ":\n";
OS << " OS << \" " << I << "\";\n";
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
OS << " break;\n";
}
OS << " }\n";
}
Tablegen now generates a StringSwitch for attributes containing enumeration arguments to map strings to the proper enumeration value. This makes error checking more consistent and reduces the amount of hand-written code required. llvm-svn: 190545
2013-09-12 03:47:58 +08:00
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
void writeConversion(raw_ostream &OS, bool Header) const {
if (Header) {
OS << " static bool ConvertStrTo" << type << "(StringRef Val, " << type
<< " &Out);\n";
OS << " static const char *Convert" << type << "ToStr(" << type
<< " Val);\n";
return;
}
OS << "bool " << getAttrName() << "Attr::ConvertStrTo" << type
<< "(StringRef Val, " << type << " &Out) {\n";
OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
OS << type << ">>(Val)\n";
Tablegen now generates a StringSwitch for attributes containing enumeration arguments to map strings to the proper enumeration value. This makes error checking more consistent and reduces the amount of hand-written code required. llvm-svn: 190545
2013-09-12 03:47:58 +08:00
for (size_t I = 0; I < enums.size(); ++I) {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " .Case(\"" << values[I] << "\", ";
Tablegen now generates a StringSwitch for attributes containing enumeration arguments to map strings to the proper enumeration value. This makes error checking more consistent and reduces the amount of hand-written code required. llvm-svn: 190545
2013-09-12 03:47:58 +08:00
OS << getAttrName() << "Attr::" << enums[I] << ")\n";
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " .Default(Optional<" << type << ">());\n";
OS << " if (R) {\n";
OS << " Out = *R;\n return true;\n }\n";
OS << " return false;\n";
OS << "}\n\n";
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
// Mapping from enumeration values back to enumeration strings isn't
// trivial because some enumeration values have multiple named
// enumerators, such as type_visibility(internal) and
// type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << "const char *" << getAttrName() << "Attr::Convert" << type
<< "ToStr(" << type << " Val) {\n"
<< " switch(Val) {\n";
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
SmallDenseSet<StringRef, 8> Uniques;
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
for (size_t I = 0; I < enums.size(); ++I) {
if (Uniques.insert(enums[I]).second)
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " case " << getAttrName() << "Attr::" << enums[I]
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
<< ": return \"" << values[I] << "\";\n";
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " }\n"
<< " llvm_unreachable(\"No enumerator with that value\");\n"
<< "}\n";
Tablegen now generates a StringSwitch for attributes containing enumeration arguments to map strings to the proper enumeration value. This makes error checking more consistent and reduces the amount of hand-written code required. llvm-svn: 190545
2013-09-12 03:47:58 +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
};
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
class VariadicEnumArgument: public VariadicArgument {
std::string type, QualifiedTypeName;
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
std::vector<StringRef> values, enums, uniques;
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
protected:
void writeValueImpl(raw_ostream &OS) const override {
Adding some FIXMEs to the attribute emitter code regarding whether pretty printing enumerators should use quoted string literals, or identifiers. NFC. llvm-svn: 217781
2014-09-16 00:16:14 +08:00
// FIXME: this isn't 100% correct -- some enum arguments require printing
// as a string literal, while others require printing as an identifier.
// Tablegen currently does not distinguish between the two forms.
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
OS << " OS << \"\\\"\" << " << getAttrName() << "Attr::Convert" << type
<< "ToStr(Val)" << "<< \"\\\"\";\n";
}
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
VariadicEnumArgument(const Record &Arg, StringRef Attr)
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
: VariadicArgument(Arg, Attr,
std::string(Arg.getValueAsString("Type"))),
type(std::string(Arg.getValueAsString("Type"))),
values(Arg.getValueAsListOfStrings("Values")),
enums(Arg.getValueAsListOfStrings("Enums")),
uniques(uniqueEnumsInOrder(enums)) {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
QualifiedTypeName = getAttrName().str() + "Attr::" + type;
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
// FIXME: Emit a proper error
assert(!uniques.empty());
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
bool isVariadicEnumArg() const override { return true; }
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDeclarations(raw_ostream &OS) const override {
Use range loops and autos in utils/TableGen/ClangAttrEmitter.cpp and generated code. Differential revision: http://reviews.llvm.org/D15313 llvm-svn: 255042
2015-12-09 02:49:01 +08:00
auto i = uniques.cbegin(), e = uniques.cend();
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
// The last one needs to not have a comma.
--e;
OS << "public:\n";
OS << " enum " << type << " {\n";
for (; i != e; ++i)
OS << " " << *i << ",\n";
OS << " " << *e << "\n";
OS << " };\n";
OS << "private:\n";
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
VariadicArgument::writeDeclarations(OS);
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDump(raw_ostream &OS) const override {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
OS << " for (" << getAttrName() << "Attr::" << getLowerName()
<< "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
<< getLowerName() << "_end(); I != E; ++I) {\n";
OS << " switch(*I) {\n";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &UI : uniques) {
OS << " case " << getAttrName() << "Attr::" << UI << ":\n";
OS << " OS << \" " << UI << "\";\n";
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
OS << " break;\n";
}
OS << " }\n";
OS << " }\n";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadDecls(raw_ostream &OS) const override {
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
OS << " unsigned " << getLowerName() << "Size = Record.readInt();\n";
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
OS << " SmallVector<" << QualifiedTypeName << ", 4> " << getLowerName()
<< ";\n";
OS << " " << getLowerName() << ".reserve(" << getLowerName()
<< "Size);\n";
OS << " for (unsigned i = " << getLowerName() << "Size; i; --i)\n";
OS << " " << getLowerName() << ".push_back(" << "static_cast<"
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
<< QualifiedTypeName << ">(Record.readInt()));\n";
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
OS << " Record.push_back(SA->" << getLowerName() << "_size());\n";
OS << " for (" << getAttrName() << "Attr::" << getLowerName()
<< "_iterator i = SA->" << getLowerName() << "_begin(), e = SA->"
<< getLowerName() << "_end(); i != e; ++i)\n";
OS << " " << WritePCHRecord(QualifiedTypeName, "(*i)");
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
void writeConversion(raw_ostream &OS, bool Header) const {
if (Header) {
OS << " static bool ConvertStrTo" << type << "(StringRef Val, " << type
<< " &Out);\n";
OS << " static const char *Convert" << type << "ToStr(" << type
<< " Val);\n";
return;
}
OS << "bool " << getAttrName() << "Attr::ConvertStrTo" << type
<< "(StringRef Val, ";
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
OS << type << " &Out) {\n";
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " Optional<" << type << "> R = llvm::StringSwitch<Optional<";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
OS << type << ">>(Val)\n";
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
for (size_t I = 0; I < enums.size(); ++I) {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " .Case(\"" << values[I] << "\", ";
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
OS << getAttrName() << "Attr::" << enums[I] << ")\n";
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " .Default(Optional<" << type << ">());\n";
OS << " if (R) {\n";
OS << " Out = *R;\n return true;\n }\n";
OS << " return false;\n";
OS << "}\n\n";
OS << "const char *" << getAttrName() << "Attr::Convert" << type
<< "ToStr(" << type << " Val) {\n"
<< " switch(Val) {\n";
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
SmallDenseSet<StringRef, 8> Uniques;
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
for (size_t I = 0; I < enums.size(); ++I) {
if (Uniques.insert(enums[I]).second)
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " case " << getAttrName() << "Attr::" << enums[I]
<< ": return \"" << values[I] << "\";\n";
When pretty printing attributes that have enumeration arguments, print the enumerator identifier (as a string literal) instead of the internal enumerator integral value. llvm-svn: 217771
2014-09-15 23:14:13 +08:00
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " }\n"
<< " llvm_unreachable(\"No enumerator with that value\");\n"
<< "}\n";
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +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
class VersionArgument : public Argument {
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
VersionArgument(const Record &Arg, StringRef Attr)
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
: Argument(Arg, Attr)
{}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
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
OS << " VersionTuple get" << getUpperName() << "() const {\n";
OS << " return " << getLowerName() << ";\n";
OS << " }\n";
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
OS << " void set" << getUpperName()
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
<< "(ASTContext &C, VersionTuple V) {\n";
OS << " " << getLowerName() << " = V;\n";
OS << " }";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCloneArgs(raw_ostream &OS) const override {
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
OS << "get" << getUpperName() << "()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << "A->get" << getUpperName() << "()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorInitializers(raw_ostream &OS) const override {
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
OS << getLowerName() << "(" << getUpperName() << ")";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorDefaultInitializers(raw_ostream &OS) const override {
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
OS << getLowerName() << "()";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeCtorParameters(raw_ostream &OS) const override {
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
OS << "VersionTuple " << getUpperName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDeclarations(raw_ostream &OS) const override {
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
OS << "VersionTuple " << getLowerName() << ";\n";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadDecls(raw_ostream &OS) const override {
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
OS << " VersionTuple " << getLowerName()
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
<< "= Record.readVersionTuple();\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHReadArgs(raw_ostream &OS) const override {
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
OS << getLowerName();
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
Re-commit r265518 ("[modules] Continue factoring encoding of AST records out of ASTWriter."), reverted in r265526, with a fix for an iterator invalidation bug (thanks, MSan!). llvm-svn: 265564
2016-04-07 01:06:00 +08:00
OS << " Record.AddVersionTuple(SA->get" << getUpperName() << "());\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeValue(raw_ostream &OS) const override {
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
OS << getLowerName() << "=\" << get" << getUpperName() << "() << \"";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDump(raw_ostream &OS) const override {
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
OS << " OS << \" \" << SA->get" << getUpperName() << "();\n";
}
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
};
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
class ExprArgument : public SimpleArgument {
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
ExprArgument(const Record &Arg, StringRef Attr)
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
: SimpleArgument(Arg, Attr, "Expr *")
{}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeASTVisitorTraversal(raw_ostream &OS) const override {
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
OS << " if (!"
<< "getDerived().TraverseStmt(A->get" << getUpperName() << "()))\n";
OS << " return false;\n";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << "tempInst" << getUpperName();
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiation(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << " " << getType() << " tempInst" << getUpperName() << ";\n";
OS << " {\n";
OS << " EnterExpressionEvaluationContext "
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
<< "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << " ExprResult " << "Result = S.SubstExpr("
<< "A->get" << getUpperName() << "(), TemplateArgs);\n";
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-12 09:12:18 +08:00
OS << " if (Result.isInvalid())\n";
OS << " return nullptr;\n";
OS << " tempInst" << getUpperName() << " = Result.get();\n";
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << " }\n";
}
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
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203537
2014-03-11 11:39:26 +08:00
void writeDump(raw_ostream &OS) const override {}
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
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDumpChildren(raw_ostream &OS) const override {
[ASTDump] Rename methods which are conceptually Visits This is consistent with the TextNodeDumper, and is the appropriate name for the traverser class which will be extracted. llvm-svn: 352657
2019-01-31 03:49:49 +08:00
OS << " Visit(SA->get" << getUpperName() << "());\n";
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
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeHasChildren(raw_ostream &OS) const override { OS << "true"; }
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
};
class VariadicExprArgument : public VariadicArgument {
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
VariadicExprArgument(const Record &Arg, StringRef Attr)
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
: VariadicArgument(Arg, Attr, "Expr *")
{}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeASTVisitorTraversal(raw_ostream &OS) const override {
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
OS << " {\n";
OS << " " << getType() << " *I = A->" << getLowerName()
<< "_begin();\n";
OS << " " << getType() << " *E = A->" << getLowerName()
<< "_end();\n";
OS << " for (; I != E; ++I) {\n";
OS << " if (!getDerived().TraverseStmt(*I))\n";
OS << " return false;\n";
OS << " }\n";
OS << " }\n";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << "tempInst" << getUpperName() << ", "
<< "A->" << getLowerName() << "_size()";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiation(raw_ostream &OS) const override {
Use range loops and autos in utils/TableGen/ClangAttrEmitter.cpp and generated code. Differential revision: http://reviews.llvm.org/D15313 llvm-svn: 255042
2015-12-09 02:49:01 +08:00
OS << " auto *tempInst" << getUpperName()
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
<< " = new (C, 16) " << getType()
<< "[A->" << getLowerName() << "_size()];\n";
OS << " {\n";
OS << " EnterExpressionEvaluationContext "
[NFC, Scoped Enum] Convert Sema::ExpressionEvaluationContext into a scoped Enum - also replace direct equality checks against the ConstantEvaluated enumerator with isConstantEvaluted(), in anticipation of adding finer granularity to the various ConstantEvaluated contexts and reinstating certain restrictions on where lambda expressions can occur in C++17. - update the clang tablegen backend that uses these Enumerators, and add the relevant scope where needed. llvm-svn: 299316
2017-04-02 05:30:49 +08:00
<< "Unevaluated(S, Sema::ExpressionEvaluationContext::Unevaluated);\n";
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << " " << getType() << " *TI = tempInst" << getUpperName()
<< ";\n";
OS << " " << getType() << " *I = A->" << getLowerName()
<< "_begin();\n";
OS << " " << getType() << " *E = A->" << getLowerName()
<< "_end();\n";
OS << " for (; I != E; ++I, ++TI) {\n";
OS << " ExprResult Result = S.SubstExpr(*I, TemplateArgs);\n";
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-12 09:12:18 +08:00
OS << " if (Result.isInvalid())\n";
OS << " return nullptr;\n";
OS << " *TI = Result.get();\n";
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << " }\n";
OS << " }\n";
}
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
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203537
2014-03-11 11:39:26 +08:00
void writeDump(raw_ostream &OS) const override {}
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
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeDumpChildren(raw_ostream &OS) const override {
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
OS << " for (" << getAttrName() << "Attr::" << getLowerName()
<< "_iterator I = SA->" << getLowerName() << "_begin(), E = SA->"
Refactor tree printing in AST dumping. Instead of manually maintaining a flag indicating whether we're about to print out the last child of the parent node (to determine whether we print "`" or "|"), capture a callable to print that child and defer printing it until we either see a next child or finish the parent. No functionality change intended. llvm-svn: 220930
2014-10-31 05:02:37 +08:00
<< getLowerName() << "_end(); I != E; ++I)\n";
[ASTDump] Rename methods which are conceptually Visits This is consistent with the TextNodeDumper, and is the appropriate name for the traverser class which will be extracted. llvm-svn: 352657
2019-01-31 03:49:49 +08:00
OS << " Visit(*I);\n";
Add indents to AST dumping and removed parenthesis from AST nodes. Indents were given the color blue when outputting with color. AST dumping now looks like this: Node |-Node | `-Node `-Node `-Node Compared to the previous: (Node (Node (Node)) (Node (Node))) llvm-svn: 174022
2013-01-31 09:44:26 +08:00
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeHasChildren(raw_ostream &OS) const override {
Add indents to AST dumping and removed parenthesis from AST nodes. Indents were given the color blue when outputting with color. AST dumping now looks like this: Node |-Node | `-Node `-Node `-Node Compared to the previous: (Node (Node (Node)) (Node (Node))) llvm-svn: 174022
2013-01-31 09:44:26 +08:00
OS << "SA->" << getLowerName() << "_begin() != "
<< "SA->" << getLowerName() << "_end()";
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
}
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
};
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
Implement cpu_dispatch/cpu_specific Multiversioning As documented here: https://software.intel.com/en-us/node/682969 and https://software.intel.com/en-us/node/523346. cpu_dispatch multiversioning is an ICC feature that provides for function multiversioning. This feature is implemented with two attributes: First, cpu_specific, which specifies the individual function versions. Second, cpu_dispatch, which specifies the location of the resolver function and the list of resolvable functions. This is valuable since it provides a mechanism where the resolver's TU can be specified in one location, and the individual implementions each in their own translation units. The goal of this patch is to be source-compatible with ICC, so this implementation diverges from the ICC implementation in a few ways: 1- Linux x86/64 only: This implementation uses ifuncs in order to properly dispatch functions. This is is a valuable performance benefit over the ICC implementation. A future patch will be provided to enable this feature on Windows, but it will obviously more closely fit ICC's implementation. 2- CPU Identification functions: ICC uses a set of custom functions to identify the feature list of the host processor. This patch uses the cpu_supports functionality in order to better align with 'target' multiversioning. 1- cpu_dispatch function def/decl: ICC's cpu_dispatch requires that the function marked cpu_dispatch be an empty definition. This patch supports that as well, however declarations are also permitted, since the linker will solve the issue of multiple emissions. Differential Revision: https://reviews.llvm.org/D47474 llvm-svn: 337552
2018-07-20 22:13:28 +08:00
class VariadicIdentifierArgument : public VariadicArgument {
public:
VariadicIdentifierArgument(const Record &Arg, StringRef Attr)
: VariadicArgument(Arg, Attr, "IdentifierInfo *")
{}
};
Implement no_sanitize attribute. Differential Revision: http://reviews.llvm.org/D9631 llvm-svn: 237463
2015-05-16 02:33:32 +08:00
class VariadicStringArgument : public VariadicArgument {
public:
VariadicStringArgument(const Record &Arg, StringRef Attr)
Fix a leak in the generated code for attributes with strings. Storing std::strings in attributes simply doesn't work, we never call the destructor. Use an array of StringRefs instead of std::strings and copy the data into memory taken from the ASTContext. llvm-svn: 260831
2016-02-14 02:11:49 +08:00
: VariadicArgument(Arg, Attr, "StringRef")
Implement no_sanitize attribute. Differential Revision: http://reviews.llvm.org/D9631 llvm-svn: 237463
2015-05-16 02:33:32 +08:00
{}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Fix a leak in the generated code for attributes with strings. Storing std::strings in attributes simply doesn't work, we never call the destructor. Use an array of StringRefs instead of std::strings and copy the data into memory taken from the ASTContext. llvm-svn: 260831
2016-02-14 02:11:49 +08:00
void writeCtorBody(raw_ostream &OS) const override {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " for (size_t I = 0, E = " << getArgSizeName() << "; I != E;\n"
" ++I) {\n"
" StringRef Ref = " << getUpperName() << "[I];\n"
" if (!Ref.empty()) {\n"
" char *Mem = new (Ctx, 1) char[Ref.size()];\n"
" std::memcpy(Mem, Ref.data(), Ref.size());\n"
" " << getArgName() << "[I] = StringRef(Mem, Ref.size());\n"
" }\n"
" }\n";
Fix a leak in the generated code for attributes with strings. Storing std::strings in attributes simply doesn't work, we never call the destructor. Use an array of StringRefs instead of std::strings and copy the data into memory taken from the ASTContext. llvm-svn: 260831
2016-02-14 02:11:49 +08:00
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Implement no_sanitize attribute. Differential Revision: http://reviews.llvm.org/D9631 llvm-svn: 237463
2015-05-16 02:33:32 +08:00
void writeValueImpl(raw_ostream &OS) const override {
OS << " OS << \"\\\"\" << Val << \"\\\"\";\n";
}
};
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
class TypeArgument : public SimpleArgument {
public:
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
TypeArgument(const Record &Arg, StringRef Attr)
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
: SimpleArgument(Arg, Attr, "TypeSourceInfo *")
{}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeAccessors(raw_ostream &OS) const override {
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
OS << " QualType get" << getUpperName() << "() const {\n";
OS << " return " << getLowerName() << "->getType();\n";
OS << " }";
OS << " " << getType() << " get" << getUpperName() << "Loc() const {\n";
OS << " return " << getLowerName() << ";\n";
OS << " }";
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Do not look through pack expansions when looking for unexpanded parameter packs. Fixes a selection of rejects-valids when pack-expanding a lambda that itself contains a pack expansion. llvm-svn: 310972
2017-08-16 06:58:45 +08:00
void writeASTVisitorTraversal(raw_ostream &OS) const override {
OS << " if (auto *TSI = A->get" << getUpperName() << "Loc())\n";
OS << " if (!getDerived().TraverseTypeLoc(TSI->getTypeLoc()))\n";
OS << " return false;\n";
}
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-12 09:12:18 +08:00
void writeTemplateInstantiation(raw_ostream &OS) const override {
OS << " " << getType() << " tempInst" << getUpperName() << " =\n";
OS << " S.SubstType(A->get" << getUpperName() << "Loc(), "
<< "TemplateArgs, A->getLoc(), A->getAttrName());\n";
OS << " if (!tempInst" << getUpperName() << ")\n";
OS << " return nullptr;\n";
}
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writeTemplateInstantiationArgs(raw_ostream &OS) const override {
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-12 09:12:18 +08:00
OS << "tempInst" << getUpperName();
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
}
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
[C++11] Adding override specifiers where appropriate, and removing virtual specifiers where not needed. No functional changes intended. llvm-svn: 203122
2014-03-06 23:09:50 +08:00
void writePCHWrite(raw_ostream &OS) const override {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
OS << " "
<< WritePCHRecord(getType(),
"SA->get" + std::string(getUpperName()) + "Loc()");
Store a TypeArgument on an attribute as a TypeSourceInfo*, rather than as a QualType with a SourceLocation stashed alongside. llvm-svn: 193803
2013-11-01 05:23:20 +08:00
}
};
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
} // end anonymous namespace
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
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
static std::unique_ptr<Argument>
createArgument(const Record &Arg, StringRef Attr,
const Record *Search = nullptr) {
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
if (!Search)
Search = &Arg;
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
std::unique_ptr<Argument> Ptr;
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
llvm::StringRef ArgName = Search->getName();
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
if (ArgName == "AlignedArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<AlignedArgument>(Arg, Attr);
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
else if (ArgName == "EnumArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<EnumArgument>(Arg, Attr);
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
else if (ArgName == "ExprArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<ExprArgument>(Arg, Attr);
Generalize our two different kinds of declaration argument for attributes to support any kind of declaration. In preparation for adding a third kind.
2020-04-15 14:28:33 +08:00
else if (ArgName == "DeclArgument")
Ptr = std::make_unique<SimpleArgument>(
Arg, Attr, (Arg.getValueAsDef("Kind")->getName() + "Decl *").str());
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
else if (ArgName == "IdentifierArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
else if (ArgName == "DefaultBoolArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<DefaultSimpleArgument>(
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
Arg, Attr, "bool", Arg.getValueAsBit("Default"));
else if (ArgName == "BoolArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "bool");
Implemented DefaultIntArgument in the table generator and start using it in semantic analysis. Removes some magic numbers. llvm-svn: 195287
2013-11-21 08:28:23 +08:00
else if (ArgName == "DefaultIntArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<DefaultSimpleArgument>(
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
Arg, Attr, "int", Arg.getValueAsInt("Default"));
else if (ArgName == "IntArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "int");
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
else if (ArgName == "StringArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<StringArgument>(Arg, Attr);
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
else if (ArgName == "TypeArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<TypeArgument>(Arg, Attr);
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
else if (ArgName == "UnsignedArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
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
else if (ArgName == "VariadicUnsignedArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
Implement no_sanitize attribute. Differential Revision: http://reviews.llvm.org/D9631 llvm-svn: 237463
2015-05-16 02:33:32 +08:00
else if (ArgName == "VariadicStringArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VariadicStringArgument>(Arg, Attr);
Consumed Analysis: Change callable_when so that it can take a list of states that a function can be called in. This reduced the total number of annotations needed and makes writing more complicated behaviour less burdensome. Patch by chriswails@gmail.com. llvm-svn: 191983
2013-10-05 05:28:06 +08:00
else if (ArgName == "VariadicEnumArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VariadicEnumArgument>(Arg, Attr);
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
else if (ArgName == "VariadicExprArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VariadicExprArgument>(Arg, Attr);
Reland "[Attr] Fix parameter indexing for several attributes" Relands r326602 (reverted in r326862) with new test and fix for PR36620. Differential Revision: https://reviews.llvm.org/D43248 llvm-svn: 327405
2018-03-13 22:51:22 +08:00
else if (ArgName == "VariadicParamIdxArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VariadicParamIdxArgument>(Arg, Attr);
Emit !callback metadata and introduce the callback attribute With commit r351627, LLVM gained the ability to apply (existing) IPO optimizations on indirections through callbacks, or transitive calls. The general idea is that we use an abstraction to hide the middle man and represent the callback call in the context of the initial caller. It is described in more detail in the commit message of the LLVM patch r351627, the llvm::AbstractCallSite class description, and the language reference section on callback-metadata. This commit enables clang to emit !callback metadata that is understood by LLVM. It does so in three different cases: 1) For known broker functions declarations that are directly generated, e.g., __kmpc_fork_call for the OpenMP pragma parallel. 2) For known broker functions that are identified by their name and source location through the builtin detection, e.g., pthread_create from the POSIX thread API. 3) For user annotated functions that carry the "callback(callee, ...)" attribute. The attribute has to include the name, or index, of the callback callee and how the passed arguments can be identified (as many as the callback callee has). See the callback attribute documentation for detailed information. Differential Revision: https://reviews.llvm.org/D55483 llvm-svn: 351629
2019-01-19 13:36:54 +08:00
else if (ArgName == "VariadicParamOrParamIdxArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VariadicParamOrParamIdxArgument>(Arg, Attr);
Reland "[Attr] Fix parameter indexing for several attributes" Relands r326602 (reverted in r326862) with new test and fix for PR36620. Differential Revision: https://reviews.llvm.org/D43248 llvm-svn: 327405
2018-03-13 22:51:22 +08:00
else if (ArgName == "ParamIdxArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "ParamIdx");
Implement cpu_dispatch/cpu_specific Multiversioning As documented here: https://software.intel.com/en-us/node/682969 and https://software.intel.com/en-us/node/523346. cpu_dispatch multiversioning is an ICC feature that provides for function multiversioning. This feature is implemented with two attributes: First, cpu_specific, which specifies the individual function versions. Second, cpu_dispatch, which specifies the location of the resolver function and the list of resolvable functions. This is valuable since it provides a mechanism where the resolver's TU can be specified in one location, and the individual implementions each in their own translation units. The goal of this patch is to be source-compatible with ICC, so this implementation diverges from the ICC implementation in a few ways: 1- Linux x86/64 only: This implementation uses ifuncs in order to properly dispatch functions. This is is a valuable performance benefit over the ICC implementation. A future patch will be provided to enable this feature on Windows, but it will obviously more closely fit ICC's implementation. 2- CPU Identification functions: ICC uses a set of custom functions to identify the feature list of the host processor. This patch uses the cpu_supports functionality in order to better align with 'target' multiversioning. 1- cpu_dispatch function def/decl: ICC's cpu_dispatch requires that the function marked cpu_dispatch be an empty definition. This patch supports that as well, however declarations are also permitted, since the linker will solve the issue of multiple emissions. Differential Revision: https://reviews.llvm.org/D47474 llvm-svn: 337552
2018-07-20 22:13:28 +08:00
else if (ArgName == "VariadicIdentifierArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VariadicIdentifierArgument>(Arg, Attr);
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
else if (ArgName == "VersionArgument")
[Clang] Migrate llvm::make_unique to std::make_unique Now that we've moved to C++14, we no longer need the llvm::make_unique implementation from STLExtras.h. This patch is a mechanical replacement of (hopefully) all the llvm::make_unique instances across the monorepo. Differential revision: https://reviews.llvm.org/D66259 llvm-svn: 368942
2019-08-15 07:04:18 +08:00
Ptr = std::make_unique<VersionArgument>(Arg, Attr);
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
else if (ArgName == "OMPTraitInfoArgument")
[OpenMP][NFC] Minimize memory usage and copying of `OMPTraitInfo`s See rational here: https://reviews.llvm.org/D71830#1922656 Reviewed By: rnk Differential Revision: https://reviews.llvm.org/D76173
2020-03-14 12:42:05 +08:00
Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "OMPTraitInfo *");
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
if (!Ptr) {
Implemented DefaultIntArgument in the table generator and start using it in semantic analysis. Removes some magic numbers. llvm-svn: 195287
2013-11-21 08:28:23 +08:00
// Search in reverse order so that the most-derived type is handled first.
[TableGen] Merge the SuperClass Record and SMRange vector a single vector. This removes the state needed to manage the extract vector. NFC llvm-svn: 258066
2016-01-19 03:52:54 +08:00
ArrayRef<std::pair<Record*, SMRange>> Bases = Search->getSuperClasses();
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
for (const auto &Base : llvm::reverse(Bases)) {
[TableGen] Merge the SuperClass Record and SMRange vector a single vector. This removes the state needed to manage the extract vector. NFC llvm-svn: 258066
2016-01-19 03:52:54 +08:00
if ((Ptr = createArgument(Arg, Attr, Base.first)))
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
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
if (Ptr && Arg.getValueAsBit("Optional"))
Ptr->setOptional(true);
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
if (Ptr && Arg.getValueAsBit("Fake"))
Ptr->setFake(true);
Remove some transient raw pointer ownership in ClangAttrEmitter::createArgument This function might be a bit easier if it were split in two with a lot of early returns - and that setOptional bit in the outer function, but anyway. llvm-svn: 215263
2014-08-09 07:59:38 +08:00
return Ptr;
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
}
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
static void writeAvailabilityValue(raw_ostream &OS) {
OS << "\" << getPlatform()->getName();\n"
Print strict in Availability attribute when it is on. llvm-svn: 263172
2016-03-11 07:54:12 +08:00
<< " if (getStrict()) OS << \", strict\";\n"
Add support for pretty-printing attributes, from Richard Membarth! llvm-svn: 145002
2011-11-20 03:22:57 +08:00
<< " if (!getIntroduced().empty()) OS << \", introduced=\" << getIntroduced();\n"
<< " if (!getDeprecated().empty()) OS << \", deprecated=\" << getDeprecated();\n"
<< " if (!getObsoleted().empty()) OS << \", obsoleted=\" << getObsoleted();\n"
<< " if (getUnavailable()) OS << \", unavailable\";\n"
<< " OS << \"";
}
Add an optional string argument to DeprecatedAttr for Fix-It. We only add this to __attribute__((deprecated)). Differential Revision: http://reviews.llvm.org/D17865 llvm-svn: 263652
2016-03-17 02:50:49 +08:00
static void writeDeprecatedAttrValue(raw_ostream &OS, std::string &Variety) {
OS << "\\\"\" << getMessage() << \"\\\"\";\n";
// Only GNU deprecated has an optional fixit argument at the second position.
if (Variety == "GNU")
OS << " if (!getReplacement().empty()) OS << \", \\\"\""
" << getReplacement() << \"\\\"\";\n";
OS << " OS << \"";
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
static void writeGetSpellingFunction(const Record &R, raw_ostream &OS) {
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
Teach the diagnostics engine about the Attr type to make reporting on semantic attributes easier (and not require hard-coded strings). This requires a getSpelling() function on the Attr class, which is table-driven. Updates a handful of cases where a hard-coded string was being used to test the functionality out. Updating associated test cases for the improved quoting. llvm-svn: 198055
2013-12-27 02:30:57 +08:00
OS << "const char *" << R.getName() << "Attr::getSpelling() const {\n";
if (Spellings.empty()) {
OS << " return \"(No spelling)\";\n}\n\n";
return;
}
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << " switch (getAttributeSpellingListIndex()) {\n"
Teach the diagnostics engine about the Attr type to make reporting on semantic attributes easier (and not require hard-coded strings). This requires a getSpelling() function on the Attr class, which is table-driven. Updates a handful of cases where a hard-coded string was being used to test the functionality out. Updating associated test cases for the improved quoting. llvm-svn: 198055
2013-12-27 02:30:57 +08:00
" default:\n"
" llvm_unreachable(\"Unknown attribute spelling!\");\n"
" return \"(No spelling)\";\n";
for (unsigned I = 0; I < Spellings.size(); ++I)
OS << " case " << I << ":\n"
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
" return \"" << Spellings[I].name() << "\";\n";
Teach the diagnostics engine about the Attr type to make reporting on semantic attributes easier (and not require hard-coded strings). This requires a getSpelling() function on the Attr class, which is table-driven. Updates a handful of cases where a hard-coded string was being used to test the functionality out. Updating associated test cases for the improved quoting. llvm-svn: 198055
2013-12-27 02:30:57 +08:00
// End of the switch statement.
OS << " }\n";
// End of the getSpelling function.
OS << "}\n\n";
}
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
static void
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
writePrettyPrintFunction(const Record &R,
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
const std::vector<std::unique_ptr<Argument>> &Args,
raw_ostream &OS) {
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
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
OS << "void " << R.getName() << "Attr::printPretty("
<< "raw_ostream &OS, const PrintingPolicy &Policy) const {\n";
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
if (Spellings.empty()) {
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
OS << "}\n\n";
return;
}
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " bool IsFirstArgument = true; (void)IsFirstArgument;\n"
<< " unsigned TrailingOmittedArgs = 0; (void)TrailingOmittedArgs;\n"
<< " switch (getAttributeSpellingListIndex()) {\n"
<< " default:\n"
<< " llvm_unreachable(\"Unknown attribute spelling!\");\n"
<< " break;\n";
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
for (unsigned I = 0; I < Spellings.size(); ++ I) {
llvm::SmallString<16> Prefix;
llvm::SmallString<8> Suffix;
// The actual spelling of the name and namespace (if applicable)
// of an attribute without considering prefix and suffix.
llvm::SmallString<64> Spelling;
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::string Name = Spellings[I].name();
std::string Variety = Spellings[I].variety();
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
if (Variety == "GNU") {
Prefix = " __attribute__((";
Suffix = "))";
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
} else if (Variety == "CXX11" || Variety == "C2x") {
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
Prefix = " [[";
Suffix = "]]";
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::string Namespace = Spellings[I].nameSpace();
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
if (!Namespace.empty()) {
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
Spelling += Namespace;
Spelling += "::";
}
} else if (Variety == "Declspec") {
Prefix = " __declspec(";
Suffix = ")";
Add plumbing for new attribute type "Microsoft". This is for attributes in []-delimited lists preceding a class, like e.g. `[uuid("...")] class Foo {};` Not used by anything yet, so no behavior change. Part of https://reviews.llvm.org/D23895 llvm-svn: 280575
2016-09-03 10:55:10 +08:00
} else if (Variety == "Microsoft") {
Prefix = "[";
Suffix = "]";
Replace AS_MSTypespec with AS_Keyword, for representing any attribute spelled as a keyword. Rationalize existing attributes to use it as appropriate, and to not lie about some __declspec attributes being GNU attributes. In passing, remove a gross hack which was discarding attributes which we could handle. This results in us actually respecting the __pascal keyword again. llvm-svn: 173746
2013-01-29 09:24:26 +08:00
} else if (Variety == "Keyword") {
Prefix = " ";
Suffix = "";
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
} else if (Variety == "Pragma") {
Prefix = "#pragma ";
Suffix = "\n";
std::string Namespace = Spellings[I].nameSpace();
if (!Namespace.empty()) {
Spelling += Namespace;
Spelling += " ";
}
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
} else {
Replace AS_MSTypespec with AS_Keyword, for representing any attribute spelled as a keyword. Rationalize existing attributes to use it as appropriate, and to not lie about some __declspec attributes being GNU attributes. In passing, remove a gross hack which was discarding attributes which we could handle. This results in us actually respecting the __pascal keyword again. llvm-svn: 173746
2013-01-29 09:24:26 +08:00
llvm_unreachable("Unknown attribute syntax variety!");
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
}
Spelling += Name;
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " case " << I << " : {\n"
<< " OS << \"" << Prefix << Spelling << "\";\n";
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
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
if (Variety == "Pragma") {
OS << " printPrettyPragma(OS, Policy);\n";
[ATTR] Automatic line feed after pragma-like attribute. Automatically insert line feed after pretty printing of all pragma-like attributes + fix printing of pragma-like pragmas on declarations. Differential Revision: http://reviews.llvm.org/D13546 llvm-svn: 250017
2015-10-12 14:59:48 +08:00
OS << " OS << \"\\n\";";
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
OS << " break;\n";
OS << " }\n";
continue;
}
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
if (Spelling == "availability") {
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " OS << \"(";
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
writeAvailabilityValue(OS);
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << ")\";\n";
Add an optional string argument to DeprecatedAttr for Fix-It. We only add this to __attribute__((deprecated)). Differential Revision: http://reviews.llvm.org/D17865 llvm-svn: 263652
2016-03-17 02:50:49 +08:00
} else if (Spelling == "deprecated" || Spelling == "gnu::deprecated") {
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " OS << \"(";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
writeDeprecatedAttrValue(OS, Variety);
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << ")\";\n";
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
} else {
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
// To avoid printing parentheses around an empty argument list or
// printing spurious commas at the end of an argument list, we need to
// determine where the last provided non-fake argument is.
unsigned NonFakeArgs = 0;
bool FoundNonOptArg = false;
for (const auto &arg : llvm::reverse(Args)) {
if (arg->isFake())
continue;
++NonFakeArgs;
if (FoundNonOptArg)
continue;
// FIXME: arg->getIsOmitted() == "false" means we haven't implemented
// any way to detect whether the argument was omitted.
if (!arg->isOptional() || arg->getIsOmitted() == "false") {
FoundNonOptArg = true;
continue;
}
OS << " if (" << arg->getIsOmitted() << ")\n"
<< " ++TrailingOmittedArgs;\n";
}
unsigned ArgIndex = 0;
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
for (const auto &arg : Args) {
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
if (arg->isFake())
continue;
std::string IsOmitted = arg->getIsOmitted();
if (arg->isOptional() && IsOmitted != "false")
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " if (!(" << IsOmitted << ")) {\n";
// Variadic arguments print their own leading comma.
if (!arg->isVariadic())
OS << " DelimitAttributeArgument(OS, IsFirstArgument);\n";
OS << " OS << \"";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
arg->writeValue(OS);
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << "\";\n";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
if (arg->isOptional() && IsOmitted != "false")
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " }\n";
Improve the way attribute argument printing happens for omitted optional arguments when pretty printing. Patch by Joel Denny. llvm-svn: 326266
2018-02-28 07:49:28 +08:00
++ArgIndex;
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
}
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
if (ArgIndex != 0)
OS << " if (!IsFirstArgument)\n"
<< " OS << \")\";\n";
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
}
[clang-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
OS << " OS << \"" << Suffix << "\";\n"
<< " break;\n"
<< " }\n";
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
}
// End of the switch statement.
OS << "}\n";
// End of the print function.
OS << "}\n\n";
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Return the index of a spelling in a spelling list.
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
static unsigned
getSpellingListIndex(const std::vector<FlattenedSpelling> &SpellingList,
const FlattenedSpelling &Spelling) {
Replace size() calls on containers with empty() calls where appropriate. NFC http://reviews.llvm.org/D7090 Patch by Gábor Horváth! llvm-svn: 226914
2015-01-23 23:36:10 +08:00
assert(!SpellingList.empty() && "Spelling list is empty!");
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
for (unsigned Index = 0; Index < SpellingList.size(); ++Index) {
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
const FlattenedSpelling &S = SpellingList[Index];
if (S.variety() != Spelling.variety())
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
continue;
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
if (S.nameSpace() != Spelling.nameSpace())
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
continue;
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
if (S.name() != Spelling.name())
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
continue;
return Index;
}
llvm_unreachable("Unknown spelling!");
}
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
static void writeAttrAccessorDefinition(const Record &R, raw_ostream &OS) {
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
std::vector<Record*> Accessors = R.getValueAsListOfDefs("Accessors");
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
if (Accessors.empty())
return;
const std::vector<FlattenedSpelling> SpellingList = GetFlattenedSpellings(R);
assert(!SpellingList.empty() &&
"Attribute with empty spelling list can't have accessors!");
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Accessor : Accessors) {
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef Name = Accessor->getValueAsString("Name");
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Accessor);
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << " bool " << Name
<< "() const { return getAttributeSpellingListIndex() == ";
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
for (unsigned Index = 0; Index < Spellings.size(); ++Index) {
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
OS << getSpellingListIndex(SpellingList, Spellings[Index]);
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
if (Index != Spellings.size() - 1)
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << " ||\n getAttributeSpellingListIndex() == ";
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
else
OS << "; }\n";
}
}
}
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
static bool
SpellingNamesAreCommon(const std::vector<FlattenedSpelling>& Spellings) {
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
assert(!Spellings.empty() && "An empty list of spellings was provided");
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string FirstName =
std::string(NormalizeNameForSpellingComparison(Spellings.front().name()));
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto &Spelling :
llvm::make_range(std::next(Spellings.begin()), Spellings.end())) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string Name =
std::string(NormalizeNameForSpellingComparison(Spelling.name()));
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
if (Name != FirstName)
return false;
}
return true;
}
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
typedef std::map<unsigned, std::string> SemanticSpellingMap;
static std::string
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
CreateSemanticSpellings(const std::vector<FlattenedSpelling> &Spellings,
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
SemanticSpellingMap &Map) {
// The enumerants are automatically generated based on the variety,
// namespace (if present) and name for each attribute spelling. However,
// care is taken to avoid trampling on the reserved namespace due to
// underscores.
std::string Ret(" enum Spelling {\n");
std::set<std::string> Uniques;
unsigned Idx = 0;
Add SpellingNotCalculated to Attribute Enums to suppress UBSan warnings UBSan downstreams noticed that the assignment of SpellingNotCalculated to the spellings caused warnings. llvm-svn: 372124
2019-09-17 22:11:51 +08:00
// If we have a need to have this many spellings we likely need to add an
// extra bit to the SpellingIndex in AttributeCommonInfo, then increase the
// value of SpellingNotCalculated there and here.
assert(Spellings.size() < 15 &&
"Too many spellings, would step on SpellingNotCalculated in "
"AttributeCommonInfo");
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (auto I = Spellings.begin(), E = Spellings.end(); I != E; ++I, ++Idx) {
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
const FlattenedSpelling &S = *I;
Turn copies into references as suggested by clang-tidy's performance-unnecessary-copy-initialization. llvm-svn: 270994
2016-05-27 21:36:58 +08:00
const std::string &Variety = S.variety();
const std::string &Spelling = S.name();
const std::string &Namespace = S.nameSpace();
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
std::string EnumName;
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
EnumName += (Variety + "_");
if (!Namespace.empty())
EnumName += (NormalizeNameForSpellingComparison(Namespace).str() +
"_");
EnumName += NormalizeNameForSpellingComparison(Spelling);
// Even if the name is not unique, this spelling index corresponds to a
// particular enumerant name that we've calculated.
Map[Idx] = EnumName;
// Since we have been stripping underscores to avoid trampling on the
// reserved namespace, we may have inadvertently created duplicate
// enumerant names. These duplicates are not considered part of the
// semantic spelling, and can be elided.
if (Uniques.find(EnumName) != Uniques.end())
continue;
Uniques.insert(EnumName);
if (I != Spellings.begin())
Ret += ",\n";
The semantic spelling enumeration should retain values to the spelling list indexes used by the attribute. The only attribute affected by this in practice is the OpenCLImageAccessAttr, which has duplicate semantic spellings that are automatically stripped. We do not implicitly create an OpenCLImageAccessAttr, so this change only affects out of tree users. There is no way to test this behavior specifically that I can see, since this only affects implicit creation of attributes. Fixes PR22403. llvm-svn: 231803
2015-03-11 01:19:18 +08:00
// Duplicate spellings are not considered part of the semantic spelling
// enumeration, but the spelling index and semantic spelling values are
// meant to be equivalent, so we must specify a concrete value for each
// enumerator.
Ret += " " + EnumName + " = " + llvm::utostr(Idx);
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
}
Add SpellingNotCalculated to Attribute Enums to suppress UBSan warnings UBSan downstreams noticed that the assignment of SpellingNotCalculated to the spellings caused warnings. llvm-svn: 372124
2019-09-17 22:11:51 +08:00
Ret += ",\n SpellingNotCalculated = 15\n";
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
Ret += "\n };\n\n";
return Ret;
}
void WriteSemanticSpellingSwitch(const std::string &VarName,
const SemanticSpellingMap &Map,
raw_ostream &OS) {
OS << " switch (" << VarName << ") {\n default: "
<< "llvm_unreachable(\"Unknown spelling list index\");\n";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &I : Map)
OS << " case " << I.first << ": return " << I.second << ";\n";
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
OS << " }\n";
}
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
// Emits the LateParsed property for attributes.
static void emitClangAttrLateParsedList(RecordKeeper &Records, raw_ostream &OS) {
OS << "#if defined(CLANG_ATTR_LATE_PARSED_LIST)\n";
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
bool LateParsed = Attr->getValueAsBit("LateParsed");
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
if (LateParsed) {
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
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
// FIXME: Handle non-GNU attributes
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &I : Spellings) {
if (I.variety() != "GNU")
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
continue;
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
OS << ".Case(\"" << I.name() << "\", " << LateParsed << ")\n";
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
}
}
}
OS << "#endif // CLANG_ATTR_LATE_PARSED_LIST\n\n";
}
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
static bool hasGNUorCXX11Spelling(const Record &Attribute) {
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
for (const auto &I : Spellings) {
if (I.variety() == "GNU" || I.variety() == "CXX11")
return true;
}
return false;
}
namespace {
struct AttributeSubjectMatchRule {
const Record *MetaSubject;
const Record *Constraint;
AttributeSubjectMatchRule(const Record *MetaSubject, const Record *Constraint)
: MetaSubject(MetaSubject), Constraint(Constraint) {
assert(MetaSubject && "Missing subject");
}
bool isSubRule() const { return Constraint != nullptr; }
std::vector<Record *> getSubjects() const {
return (Constraint ? Constraint : MetaSubject)
->getValueAsListOfDefs("Subjects");
}
std::vector<Record *> getLangOpts() const {
if (Constraint) {
// Lookup the options in the sub-rule first, in case the sub-rule
// overrides the rules options.
std::vector<Record *> Opts = Constraint->getValueAsListOfDefs("LangOpts");
if (!Opts.empty())
return Opts;
}
return MetaSubject->getValueAsListOfDefs("LangOpts");
}
// Abstract rules are used only for sub-rules
bool isAbstractRule() const { return getSubjects().empty(); }
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
StringRef getName() const {
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
return (Constraint ? Constraint : MetaSubject)->getValueAsString("Name");
}
bool isNegatedSubRule() const {
assert(isSubRule() && "Not a sub-rule");
return Constraint->getValueAsBit("Negated");
}
std::string getSpelling() const {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string Result = std::string(MetaSubject->getValueAsString("Name"));
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
if (isSubRule()) {
Result += '(';
if (isNegatedSubRule())
Result += "unless(";
Result += getName();
if (isNegatedSubRule())
Result += ')';
Result += ')';
}
return Result;
}
std::string getEnumValueName() const {
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
SmallString<128> Result;
Result += "SubjectMatchRule_";
Result += MetaSubject->getValueAsString("Name");
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
if (isSubRule()) {
Result += "_";
if (isNegatedSubRule())
Result += "not_";
Result += Constraint->getValueAsString("Name");
}
if (isAbstractRule())
Result += "_abstract";
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
return std::string(Result.str());
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
}
std::string getEnumValue() const { return "attr::" + getEnumValueName(); }
static const char *EnumName;
};
const char *AttributeSubjectMatchRule::EnumName = "attr::SubjectMatchRule";
struct PragmaClangAttributeSupport {
std::vector<AttributeSubjectMatchRule> Rules;
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
class RuleOrAggregateRuleSet {
std::vector<AttributeSubjectMatchRule> Rules;
bool IsRule;
RuleOrAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules,
bool IsRule)
: Rules(Rules), IsRule(IsRule) {}
public:
bool isRule() const { return IsRule; }
const AttributeSubjectMatchRule &getRule() const {
assert(IsRule && "not a rule!");
return Rules[0];
}
ArrayRef<AttributeSubjectMatchRule> getAggregateRuleSet() const {
return Rules;
}
static RuleOrAggregateRuleSet
getRule(const AttributeSubjectMatchRule &Rule) {
return RuleOrAggregateRuleSet(Rule, /*IsRule=*/true);
}
static RuleOrAggregateRuleSet
getAggregateRuleSet(ArrayRef<AttributeSubjectMatchRule> Rules) {
return RuleOrAggregateRuleSet(Rules, /*IsRule=*/false);
}
};
llvm::DenseMap<const Record *, RuleOrAggregateRuleSet> SubjectsToRules;
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
PragmaClangAttributeSupport(RecordKeeper &Records);
bool isAttributedSupported(const Record &Attribute);
void emitMatchRuleList(raw_ostream &OS);
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
void generateStrictConformsTo(const Record &Attr, raw_ostream &OS);
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
void generateParsingHelpers(raw_ostream &OS);
};
} // end anonymous namespace
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
static bool doesDeclDeriveFrom(const Record *D, const Record *Base) {
[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
const Record *CurrentBase = D->getValueAsOptionalDef(BaseFieldName);
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
if (!CurrentBase)
return false;
if (CurrentBase == Base)
return true;
return doesDeclDeriveFrom(CurrentBase, Base);
}
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
PragmaClangAttributeSupport::PragmaClangAttributeSupport(
RecordKeeper &Records) {
std::vector<Record *> MetaSubjects =
Records.getAllDerivedDefinitions("AttrSubjectMatcherRule");
auto MapFromSubjectsToRules = [this](const Record *SubjectContainer,
const Record *MetaSubject,
utils: Silence -Wpedantic warning llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp:1673:67: warning: default argument specified for lambda parameter [-Wpedantic] const Record *Constraint = nullptr) { ^~~~~~~ Found by gcc 5.4.0. llvm-svn: 301783
2017-05-01 08:26:59 +08:00
const Record *Constraint) {
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
Rules.emplace_back(MetaSubject, Constraint);
std::vector<Record *> ApplicableSubjects =
SubjectContainer->getValueAsListOfDefs("Subjects");
for (const auto *Subject : ApplicableSubjects) {
bool Inserted =
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
SubjectsToRules
.try_emplace(Subject, RuleOrAggregateRuleSet::getRule(
AttributeSubjectMatchRule(MetaSubject,
Constraint)))
.second;
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
if (!Inserted) {
PrintFatalError("Attribute subject match rules should not represent"
"same attribute subjects.");
}
}
};
for (const auto *MetaSubject : MetaSubjects) {
utils: Silence -Wpedantic warning llvm/tools/clang/utils/TableGen/ClangAttrEmitter.cpp:1673:67: warning: default argument specified for lambda parameter [-Wpedantic] const Record *Constraint = nullptr) { ^~~~~~~ Found by gcc 5.4.0. llvm-svn: 301783
2017-05-01 08:26:59 +08:00
MapFromSubjectsToRules(MetaSubject, MetaSubject, /*Constraints=*/nullptr);
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
std::vector<Record *> Constraints =
MetaSubject->getValueAsListOfDefs("Constraints");
for (const auto *Constraint : Constraints)
MapFromSubjectsToRules(Constraint, MetaSubject, Constraint);
}
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
std::vector<Record *> Aggregates =
Records.getAllDerivedDefinitions("AttrSubjectMatcherAggregateRule");
[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
std::vector<Record *> DeclNodes =
Records.getAllDerivedDefinitions(DeclNodeClassName);
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
for (const auto *Aggregate : Aggregates) {
Record *SubjectDecl = Aggregate->getValueAsDef("Subject");
// Gather sub-classes of the aggregate subject that act as attribute
// subject rules.
std::vector<AttributeSubjectMatchRule> Rules;
for (const auto *D : DeclNodes) {
if (doesDeclDeriveFrom(D, SubjectDecl)) {
auto It = SubjectsToRules.find(D);
if (It == SubjectsToRules.end())
continue;
if (!It->second.isRule() || It->second.getRule().isSubRule())
continue; // Assume that the rule will be included as well.
Rules.push_back(It->second.getRule());
}
}
bool Inserted =
SubjectsToRules
.try_emplace(SubjectDecl,
RuleOrAggregateRuleSet::getAggregateRuleSet(Rules))
.second;
if (!Inserted) {
PrintFatalError("Attribute subject match rules should not represent"
"same attribute subjects.");
}
}
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
}
static PragmaClangAttributeSupport &
getPragmaAttributeSupport(RecordKeeper &Records) {
static PragmaClangAttributeSupport Instance(Records);
return Instance;
}
void PragmaClangAttributeSupport::emitMatchRuleList(raw_ostream &OS) {
OS << "#ifndef ATTR_MATCH_SUB_RULE\n";
OS << "#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, "
"IsNegated) "
<< "ATTR_MATCH_RULE(Value, Spelling, IsAbstract)\n";
OS << "#endif\n";
for (const auto &Rule : Rules) {
OS << (Rule.isSubRule() ? "ATTR_MATCH_SUB_RULE" : "ATTR_MATCH_RULE") << '(';
OS << Rule.getEnumValueName() << ", \"" << Rule.getSpelling() << "\", "
<< Rule.isAbstractRule();
if (Rule.isSubRule())
OS << ", "
<< AttributeSubjectMatchRule(Rule.MetaSubject, nullptr).getEnumValue()
<< ", " << Rule.isNegatedSubRule();
OS << ")\n";
}
OS << "#undef ATTR_MATCH_SUB_RULE\n";
}
bool PragmaClangAttributeSupport::isAttributedSupported(
const Record &Attribute) {
Adjust Attr representation so that changes to documentation don't affect how we parse source code. Instead of implicitly opting all undocumented attributes out of '#pragma clang attribute' support, explicitly opt them all out and remove the documentation check from TableGen. (No new attributes should be added without documentation, so this has little chance of backsliding. We already support the pragma on one undocumented attribute, so we don't even want to enforce our old "rule".) No functionality change intended. llvm-svn: 341009
2018-08-30 09:01:07 +08:00
// If the attribute explicitly specified whether to support #pragma clang
// attribute, use that setting.
bool Unset;
bool SpecifiedResult =
Attribute.getValueAsBitOrUnset("PragmaAttributeSupport", Unset);
if (!Unset)
return SpecifiedResult;
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
// Opt-out rules:
// An attribute requires delayed parsing (LateParsed is on)
if (Attribute.getValueAsBit("LateParsed"))
return false;
// An attribute has no GNU/CXX11 spelling
if (!hasGNUorCXX11Spelling(Attribute))
return false;
// An attribute subject list has a subject that isn't covered by one of the
// subject match rules or has no subjects at all.
if (Attribute.isValueUnset("Subjects"))
return false;
const Record *SubjectObj = Attribute.getValueAsDef("Subjects");
std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
if (Subjects.empty())
return false;
for (const auto *Subject : Subjects) {
if (SubjectsToRules.find(Subject) == SubjectsToRules.end())
return false;
}
return true;
}
Add the `objc_class_stub` attribute. Swift requires certain classes to be not just initialized lazily on first use, but actually allocated lazily using information that is only available at runtime. This is incompatible with ObjC class initialization, or at least not efficiently compatible, because there is no meaningful class symbol that can be put in a class-ref variable at load time. This leaves ObjC code unable to access such classes, which is undesirable. objc_class_stub says that class references should be resolved by calling a new ObjC runtime function with a pointer to a new "class stub" structure. Non-ObjC compilers (like Swift) can simply emit this structure when ObjC interop is required for a class that cannot be statically allocated, then apply this attribute to the `@interface` in the generated ObjC header for the class. This attribute can be thought of as a generalization of the existing `objc_runtime_visible` attribute which permits more efficient class resolution as well as supporting the additon of categories to the class. Subclassing these classes from ObjC is currently not allowed. Patch by Slava Pestov! llvm-svn: 362054
2019-05-30 12:09:01 +08:00
static std::string GenerateTestExpression(ArrayRef<Record *> LangOpts) {
std::string Test;
for (auto *E : LangOpts) {
if (!Test.empty())
Test += " || ";
const StringRef Code = E->getValueAsString("CustomCode");
if (!Code.empty()) {
Test += "(";
Test += Code;
Test += ")";
Improve the attribute language option interface somewhat; NFCi. The name field is optional if the custom code is supplied, so this updates the documentation for LangOpt and introduces a tablegen warning if both custom code and a language option name are supplied.
2020-03-15 03:57:28 +08:00
if (!E->getValueAsString("Name").empty()) {
PrintWarning(
E->getLoc(),
"non-empty 'Name' field ignored because 'CustomCode' was supplied");
}
Add the `objc_class_stub` attribute. Swift requires certain classes to be not just initialized lazily on first use, but actually allocated lazily using information that is only available at runtime. This is incompatible with ObjC class initialization, or at least not efficiently compatible, because there is no meaningful class symbol that can be put in a class-ref variable at load time. This leaves ObjC code unable to access such classes, which is undesirable. objc_class_stub says that class references should be resolved by calling a new ObjC runtime function with a pointer to a new "class stub" structure. Non-ObjC compilers (like Swift) can simply emit this structure when ObjC interop is required for a class that cannot be statically allocated, then apply this attribute to the `@interface` in the generated ObjC header for the class. This attribute can be thought of as a generalization of the existing `objc_runtime_visible` attribute which permits more efficient class resolution as well as supporting the additon of categories to the class. Subclassing these classes from ObjC is currently not allowed. Patch by Slava Pestov! llvm-svn: 362054
2019-05-30 12:09:01 +08:00
} else {
Test += "LangOpts.";
Test += E->getValueAsString("Name");
}
}
if (Test.empty())
return "true";
return Test;
}
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
void
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
PragmaClangAttributeSupport::generateStrictConformsTo(const Record &Attr,
raw_ostream &OS) {
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
if (!isAttributedSupported(Attr) || Attr.isValueUnset("Subjects"))
return;
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
// Generate a function that constructs a set of matching rules that describe
// to which declarations the attribute should apply to.
[clang] Add 'override' to virtual function overrides generated by ClangAttrEmitter ClangAttrEmitter.cpp generates ParsedAttr derived classes with virtual overrides in them (which end up in AttrParsedAttrImpl.inc); this patch ensures these generated functions are marked override, and not (redundantly) virtual. I hesitate to say NFC since this does of course affect the behavior of the generator code, but the generated code behaves the same as it did before, so it's NFC in that sense. Differential Revision: https://reviews.llvm.org/D83616
2020-07-15 00:36:43 +08:00
OS << "void getPragmaAttributeMatchRules("
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
<< "llvm::SmallVectorImpl<std::pair<"
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
<< AttributeSubjectMatchRule::EnumName
[clang] Add 'override' to virtual function overrides generated by ClangAttrEmitter ClangAttrEmitter.cpp generates ParsedAttr derived classes with virtual overrides in them (which end up in AttrParsedAttrImpl.inc); this patch ensures these generated functions are marked override, and not (redundantly) virtual. I hesitate to say NFC since this does of course affect the behavior of the generator code, but the generated code behaves the same as it did before, so it's NFC in that sense. Differential Revision: https://reviews.llvm.org/D83616
2020-07-15 00:36:43 +08:00
<< ", bool>> &MatchRules, const LangOptions &LangOpts) const override {\n";
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
const Record *SubjectObj = Attr.getValueAsDef("Subjects");
std::vector<Record *> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
for (const auto *Subject : Subjects) {
auto It = SubjectsToRules.find(Subject);
assert(It != SubjectsToRules.end() &&
"This attribute is unsupported by #pragma clang attribute");
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
for (const auto &Rule : It->getSecond().getAggregateRuleSet()) {
// The rule might be language specific, so only subtract it from the given
// rules if the specific language options are specified.
std::vector<Record *> LangOpts = Rule.getLangOpts();
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
OS << " MatchRules.push_back(std::make_pair(" << Rule.getEnumValue()
Add the `objc_class_stub` attribute. Swift requires certain classes to be not just initialized lazily on first use, but actually allocated lazily using information that is only available at runtime. This is incompatible with ObjC class initialization, or at least not efficiently compatible, because there is no meaningful class symbol that can be put in a class-ref variable at load time. This leaves ObjC code unable to access such classes, which is undesirable. objc_class_stub says that class references should be resolved by calling a new ObjC runtime function with a pointer to a new "class stub" structure. Non-ObjC compilers (like Swift) can simply emit this structure when ObjC interop is required for a class that cannot be statically allocated, then apply this attribute to the `@interface` in the generated ObjC header for the class. This attribute can be thought of as a generalization of the existing `objc_runtime_visible` attribute which permits more efficient class resolution as well as supporting the additon of categories to the class. Subclassing these classes from ObjC is currently not allowed. Patch by Slava Pestov! llvm-svn: 362054
2019-05-30 12:09:01 +08:00
<< ", /*IsSupported=*/" << GenerateTestExpression(LangOpts)
<< "));\n";
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
}
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
}
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
OS << "}\n\n";
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
}
void PragmaClangAttributeSupport::generateParsingHelpers(raw_ostream &OS) {
// Generate routines that check the names of sub-rules.
OS << "Optional<attr::SubjectMatchRule> "
"defaultIsAttributeSubjectMatchSubRuleFor(StringRef, bool) {\n";
OS << " return None;\n";
OS << "}\n\n";
std::map<const Record *, std::vector<AttributeSubjectMatchRule>>
SubMatchRules;
for (const auto &Rule : Rules) {
if (!Rule.isSubRule())
continue;
SubMatchRules[Rule.MetaSubject].push_back(Rule);
}
for (const auto &SubMatchRule : SubMatchRules) {
OS << "Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_"
<< SubMatchRule.first->getValueAsString("Name")
<< "(StringRef Name, bool IsUnless) {\n";
OS << " if (IsUnless)\n";
OS << " return "
"llvm::StringSwitch<Optional<attr::SubjectMatchRule>>(Name).\n";
for (const auto &Rule : SubMatchRule.second) {
if (Rule.isNegatedSubRule())
OS << " Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
<< ").\n";
}
OS << " Default(None);\n";
OS << " return "
"llvm::StringSwitch<Optional<attr::SubjectMatchRule>>(Name).\n";
for (const auto &Rule : SubMatchRule.second) {
if (!Rule.isNegatedSubRule())
OS << " Case(\"" << Rule.getName() << "\", " << Rule.getEnumValue()
<< ").\n";
}
OS << " Default(None);\n";
OS << "}\n\n";
}
// Generate the function that checks for the top-level rules.
OS << "std::pair<Optional<attr::SubjectMatchRule>, "
"Optional<attr::SubjectMatchRule> (*)(StringRef, "
"bool)> isAttributeSubjectMatchRule(StringRef Name) {\n";
OS << " return "
"llvm::StringSwitch<std::pair<Optional<attr::SubjectMatchRule>, "
"Optional<attr::SubjectMatchRule> (*) (StringRef, "
"bool)>>(Name).\n";
for (const auto &Rule : Rules) {
if (Rule.isSubRule())
continue;
std::string SubRuleFunction;
if (SubMatchRules.count(Rule.MetaSubject))
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
SubRuleFunction =
("isAttributeSubjectMatchSubRuleFor_" + Rule.getName()).str();
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
else
SubRuleFunction = "defaultIsAttributeSubjectMatchSubRuleFor";
OS << " Case(\"" << Rule.getName() << "\", std::make_pair("
<< Rule.getEnumValue() << ", " << SubRuleFunction << ")).\n";
}
OS << " Default(std::make_pair(None, "
"defaultIsAttributeSubjectMatchSubRuleFor));\n";
OS << "}\n\n";
// Generate the function that checks for the submatch rules.
OS << "const char *validAttributeSubjectMatchSubRules("
<< AttributeSubjectMatchRule::EnumName << " Rule) {\n";
OS << " switch (Rule) {\n";
for (const auto &SubMatchRule : SubMatchRules) {
OS << " case "
<< AttributeSubjectMatchRule(SubMatchRule.first, nullptr).getEnumValue()
<< ":\n";
OS << " return \"'";
bool IsFirst = true;
for (const auto &Rule : SubMatchRule.second) {
if (!IsFirst)
OS << ", '";
IsFirst = false;
if (Rule.isNegatedSubRule())
OS << "unless(";
OS << Rule.getName();
if (Rule.isNegatedSubRule())
OS << ')';
OS << "'";
}
OS << "\";\n";
}
OS << " default: return nullptr;\n";
OS << " }\n";
OS << "}\n\n";
}
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
template <typename Fn>
static void forEachUniqueSpelling(const Record &Attr, Fn &&F) {
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
SmallDenseSet<StringRef, 8> Seen;
for (const FlattenedSpelling &S : Spellings) {
if (Seen.insert(S.name()).second)
F(S);
}
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Emits the first-argument-is-type property for attributes.
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
static void emitClangAttrTypeArgList(RecordKeeper &Records, raw_ostream &OS) {
OS << "#if defined(CLANG_ATTR_TYPE_ARG_LIST)\n";
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
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
// Determine whether the first argument is a type.
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
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
if (Args.empty())
continue;
[TableGen] Merge the SuperClass Record and SMRange vector a single vector. This removes the state needed to manage the extract vector. NFC llvm-svn: 258066
2016-01-19 03:52:54 +08:00
if (Args[0]->getSuperClasses().back().first->getName() != "TypeArgument")
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
continue;
// All these spellings take a single type argument.
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
});
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
}
OS << "#endif // CLANG_ATTR_TYPE_ARG_LIST\n\n";
}
Remove \brief commands from doxygen comments. This is similar to the LLVM change https://reviews.llvm.org/D46290. We've been running doxygen with the autobrief option for a couple of years now. This makes the \brief markers into our comments redundant. Since they are a visual distraction and we don't want to encourage more \brief markers in new code either, this patch removes them all. Patch produced by for i in $(git grep -l '\@brief'); do perl -pi -e 's/\@brief //g' $i & done for i in $(git grep -l '\\brief'); do perl -pi -e 's/\\brief //g' $i & done Differential Revision: https://reviews.llvm.org/D46320 llvm-svn: 331834
2018-05-09 09:00:01 +08:00
/// Emits the parse-arguments-in-unevaluated-context property for
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
/// attributes.
static void emitClangAttrArgContextList(RecordKeeper &Records, raw_ostream &OS) {
OS << "#if defined(CLANG_ATTR_ARG_CONTEXT_LIST)\n";
ParsedAttrMap Attrs = getParsedAttrList(Records);
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &I : Attrs) {
const Record &Attr = *I.second;
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
if (!Attr.getValueAsBit("ParseArgumentsAsUnevaluated"))
continue;
// All these spellings take are parsed unevaluated.
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
forEachUniqueSpelling(Attr, [&](const FlattenedSpelling &S) {
OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
});
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
}
OS << "#endif // CLANG_ATTR_ARG_CONTEXT_LIST\n\n";
}
static bool isIdentifierArgument(Record *Arg) {
return !Arg->getSuperClasses().empty() &&
[TableGen] Merge the SuperClass Record and SMRange vector a single vector. This removes the state needed to manage the extract vector. NFC llvm-svn: 258066
2016-01-19 03:52:54 +08:00
llvm::StringSwitch<bool>(Arg->getSuperClasses().back().first->getName())
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("IdentifierArgument", true)
.Case("EnumArgument", true)
Attributes accepting an EnumArgument are allowed to pass a string literal, or an identifier. VariadicEnumArguments now behave consistently instead of only accepting a string literal. This change affects the only attribute accepting a variadic enumeration: callable_when. llvm-svn: 224582
2014-12-20 00:42:04 +08:00
.Case("VariadicEnumArgument", true)
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
.Default(false);
}
Implement cpu_dispatch/cpu_specific Multiversioning As documented here: https://software.intel.com/en-us/node/682969 and https://software.intel.com/en-us/node/523346. cpu_dispatch multiversioning is an ICC feature that provides for function multiversioning. This feature is implemented with two attributes: First, cpu_specific, which specifies the individual function versions. Second, cpu_dispatch, which specifies the location of the resolver function and the list of resolvable functions. This is valuable since it provides a mechanism where the resolver's TU can be specified in one location, and the individual implementions each in their own translation units. The goal of this patch is to be source-compatible with ICC, so this implementation diverges from the ICC implementation in a few ways: 1- Linux x86/64 only: This implementation uses ifuncs in order to properly dispatch functions. This is is a valuable performance benefit over the ICC implementation. A future patch will be provided to enable this feature on Windows, but it will obviously more closely fit ICC's implementation. 2- CPU Identification functions: ICC uses a set of custom functions to identify the feature list of the host processor. This patch uses the cpu_supports functionality in order to better align with 'target' multiversioning. 1- cpu_dispatch function def/decl: ICC's cpu_dispatch requires that the function marked cpu_dispatch be an empty definition. This patch supports that as well, however declarations are also permitted, since the linker will solve the issue of multiple emissions. Differential Revision: https://reviews.llvm.org/D47474 llvm-svn: 337552
2018-07-20 22:13:28 +08:00
static bool isVariadicIdentifierArgument(Record *Arg) {
return !Arg->getSuperClasses().empty() &&
llvm::StringSwitch<bool>(
Arg->getSuperClasses().back().first->getName())
.Case("VariadicIdentifierArgument", true)
Emit !callback metadata and introduce the callback attribute With commit r351627, LLVM gained the ability to apply (existing) IPO optimizations on indirections through callbacks, or transitive calls. The general idea is that we use an abstraction to hide the middle man and represent the callback call in the context of the initial caller. It is described in more detail in the commit message of the LLVM patch r351627, the llvm::AbstractCallSite class description, and the language reference section on callback-metadata. This commit enables clang to emit !callback metadata that is understood by LLVM. It does so in three different cases: 1) For known broker functions declarations that are directly generated, e.g., __kmpc_fork_call for the OpenMP pragma parallel. 2) For known broker functions that are identified by their name and source location through the builtin detection, e.g., pthread_create from the POSIX thread API. 3) For user annotated functions that carry the "callback(callee, ...)" attribute. The attribute has to include the name, or index, of the callback callee and how the passed arguments can be identified (as many as the callback callee has). See the callback attribute documentation for detailed information. Differential Revision: https://reviews.llvm.org/D55483 llvm-svn: 351629
2019-01-19 13:36:54 +08:00
.Case("VariadicParamOrParamIdxArgument", true)
Implement cpu_dispatch/cpu_specific Multiversioning As documented here: https://software.intel.com/en-us/node/682969 and https://software.intel.com/en-us/node/523346. cpu_dispatch multiversioning is an ICC feature that provides for function multiversioning. This feature is implemented with two attributes: First, cpu_specific, which specifies the individual function versions. Second, cpu_dispatch, which specifies the location of the resolver function and the list of resolvable functions. This is valuable since it provides a mechanism where the resolver's TU can be specified in one location, and the individual implementions each in their own translation units. The goal of this patch is to be source-compatible with ICC, so this implementation diverges from the ICC implementation in a few ways: 1- Linux x86/64 only: This implementation uses ifuncs in order to properly dispatch functions. This is is a valuable performance benefit over the ICC implementation. A future patch will be provided to enable this feature on Windows, but it will obviously more closely fit ICC's implementation. 2- CPU Identification functions: ICC uses a set of custom functions to identify the feature list of the host processor. This patch uses the cpu_supports functionality in order to better align with 'target' multiversioning. 1- cpu_dispatch function def/decl: ICC's cpu_dispatch requires that the function marked cpu_dispatch be an empty definition. This patch supports that as well, however declarations are also permitted, since the linker will solve the issue of multiple emissions. Differential Revision: https://reviews.llvm.org/D47474 llvm-svn: 337552
2018-07-20 22:13:28 +08:00
.Default(false);
}
static void emitClangAttrVariadicIdentifierArgList(RecordKeeper &Records,
raw_ostream &OS) {
OS << "#if defined(CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST)\n";
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
for (const auto *A : Attrs) {
// Determine whether the first argument is a variadic identifier.
std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
if (Args.empty() || !isVariadicIdentifierArgument(Args[0]))
continue;
// All these spellings take an identifier argument.
forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
OS << ".Case(\"" << S.name() << "\", "
<< "true"
<< ")\n";
});
}
OS << "#endif // CLANG_ATTR_VARIADIC_IDENTIFIER_ARG_LIST\n\n";
}
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
// Emits the first-argument-is-identifier property for attributes.
static void emitClangAttrIdentifierArgList(RecordKeeper &Records, raw_ostream &OS) {
OS << "#if defined(CLANG_ATTR_IDENTIFIER_ARG_LIST)\n";
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
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
// Determine whether the first argument is an identifier.
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
std::vector<Record *> Args = Attr->getValueAsListOfDefs("Args");
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
if (Args.empty() || !isIdentifierArgument(Args[0]))
continue;
// All these spellings take an identifier argument.
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
forEachUniqueSpelling(*Attr, [&](const FlattenedSpelling &S) {
OS << ".Case(\"" << S.name() << "\", " << "true" << ")\n";
});
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
}
OS << "#endif // CLANG_ATTR_IDENTIFIER_ARG_LIST\n\n";
}
Emit !callback metadata and introduce the callback attribute With commit r351627, LLVM gained the ability to apply (existing) IPO optimizations on indirections through callbacks, or transitive calls. The general idea is that we use an abstraction to hide the middle man and represent the callback call in the context of the initial caller. It is described in more detail in the commit message of the LLVM patch r351627, the llvm::AbstractCallSite class description, and the language reference section on callback-metadata. This commit enables clang to emit !callback metadata that is understood by LLVM. It does so in three different cases: 1) For known broker functions declarations that are directly generated, e.g., __kmpc_fork_call for the OpenMP pragma parallel. 2) For known broker functions that are identified by their name and source location through the builtin detection, e.g., pthread_create from the POSIX thread API. 3) For user annotated functions that carry the "callback(callee, ...)" attribute. The attribute has to include the name, or index, of the callback callee and how the passed arguments can be identified (as many as the callback callee has). See the callback attribute documentation for detailed information. Differential Revision: https://reviews.llvm.org/D55483 llvm-svn: 351629
2019-01-19 13:36:54 +08:00
static bool keywordThisIsaIdentifierInArgument(const Record *Arg) {
return !Arg->getSuperClasses().empty() &&
llvm::StringSwitch<bool>(
Arg->getSuperClasses().back().first->getName())
.Case("VariadicParamOrParamIdxArgument", true)
.Default(false);
}
static void emitClangAttrThisIsaIdentifierArgList(RecordKeeper &Records,
raw_ostream &OS) {
OS << "#if defined(CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST)\n";
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
for (const auto *A : Attrs) {
// Determine whether the first argument is a variadic identifier.
std::vector<Record *> Args = A->getValueAsListOfDefs("Args");
if (Args.empty() || !keywordThisIsaIdentifierInArgument(Args[0]))
continue;
// All these spellings take an identifier argument.
forEachUniqueSpelling(*A, [&](const FlattenedSpelling &S) {
OS << ".Case(\"" << S.name() << "\", "
<< "true"
<< ")\n";
});
}
OS << "#endif // CLANG_ATTR_THIS_ISA_IDENTIFIER_ARG_LIST\n\n";
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
static void emitAttributes(RecordKeeper &Records, raw_ostream &OS,
bool Header) {
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
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
ParsedAttrMap AttrMap = getParsedAttrList(Records);
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-tblgen] AnnotateAttr::printPretty has spurious comma when no variadic argument is specified rdar://73742471 Differential Revision: https://reviews.llvm.org/D95695
2021-02-03 06:20:20 +08:00
// Helper to print the starting character of an attribute argument. If there
// hasn't been an argument yet, it prints an opening parenthese; otherwise it
// prints a comma.
OS << "static inline void DelimitAttributeArgument("
<< "raw_ostream& OS, bool& IsFirst) {\n"
<< " if (IsFirst) {\n"
<< " IsFirst = false;\n"
<< " OS << \"(\";\n"
<< " } else\n"
<< " OS << \", \";\n"
<< "}\n";
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
Forcing it to be an error when there is no Documentation list specified for an attribute. This is a bit of a (harmless) hack, but the FIXME explains why and when this hack can be removed. It's a justified hack because this prevents attribute authors from forgetting to add documentation when they add a new attribute. llvm-svn: 201524
2014-02-18 02:23:02 +08:00
// FIXME: Currently, documentation is generated as-needed due to the fact
// that there is no way to allow a generated project "reach into" the docs
// directory (for instance, it may be an out-of-tree build). However, we want
// to ensure that every attribute has a Documentation field, and produce an
// error if it has been neglected. Otherwise, the on-demand generation which
// happens server-side will fail. This code is ensuring that functionality,
// even though this Emitter doesn't technically need the documentation.
// When attribute documentation can be generated as part of the build
// itself, this code can be removed.
(void)R.getValueAsListOfDefs("Documentation");
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
Introduce the notion of an attribute that has no direct representation as an AST node, and fold a number of such attributes into Attr.td. llvm-svn: 155995
2012-05-02 23:56:52 +08:00
if (!R.getValueAsBit("ASTNode"))
continue;
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
[TableGen] Merge the SuperClass Record and SMRange vector a single vector. This removes the state needed to manage the extract vector. NFC llvm-svn: 258066
2016-01-19 03:52:54 +08:00
ArrayRef<std::pair<Record *, SMRange>> Supers = R.getSuperClasses();
Added the notion of Type and TargetSpecific attributes to the clang tablegen. In turn, this fixes a mistake with Ptr32, Ptr64, UPtr and SPtr attribtues generating AST nodes that are never actually used. llvm-svn: 187401
2013-07-30 09:44:15 +08:00
assert(!Supers.empty() && "Forgot to specify a superclass for the attr");
std::string SuperName;
Make attribute instantiation instantiate all attributes, not just the first of each kind. Attribute instantiation would previously default to instantiating each kind of attribute only once. This was overridden by a flag whose intended purpose was to permit attributes from a prior declaration to be inherited onto a new declaration even if that new declaration had its own copy of the attribute. This is the wrong behavior: when instantiating attributes from a template, we should always instantiate all the attributes that were written on that template. This patch renames the flag in the Attr class (and TableGen sources) to more clearly identify what it's actually for, and removes the usage of the flag from template instantiation. I also removed the flag from AlignedAttr, which was only added to work around the incorrect suppression of duplicate attribute instantiation. llvm-svn: 321834
2018-01-05 07:42:29 +08:00
bool Inheritable = false;
Use ranges to concisely express iteration No functional change is intended, this should just clean things up a little. llvm-svn: 273522
2016-06-23 08:15:04 +08:00
for (const auto &Super : llvm::reverse(Supers)) {
[TableGen] Merge the SuperClass Record and SMRange vector a single vector. This removes the state needed to manage the extract vector. NFC llvm-svn: 258066
2016-01-19 03:52:54 +08:00
const Record *R = Super.first;
Allow writing calling convention attributes on function types. Calling convention attributes notionally appertain to the function type -- they modify the mangling of the function, change the behavior of assignment operations, etc. This commit allows the calling convention attributes to be written in the type position as well as the declaration position. llvm-svn: 331459
2018-05-03 23:33:50 +08:00
if (R->getName() != "TargetSpecificAttr" &&
R->getName() != "DeclOrTypeAttr" && SuperName.empty())
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
SuperName = std::string(R->getName());
Make attribute instantiation instantiate all attributes, not just the first of each kind. Attribute instantiation would previously default to instantiating each kind of attribute only once. This was overridden by a flag whose intended purpose was to permit attributes from a prior declaration to be inherited onto a new declaration even if that new declaration had its own copy of the attribute. This is the wrong behavior: when instantiating attributes from a template, we should always instantiate all the attributes that were written on that template. This patch renames the flag in the Attr class (and TableGen sources) to more clearly identify what it's actually for, and removes the usage of the flag from template instantiation. I also removed the flag from AlignedAttr, which was only added to work around the incorrect suppression of duplicate attribute instantiation. llvm-svn: 321834
2018-01-05 07:42:29 +08:00
if (R->getName() == "InheritableAttr")
Inheritable = true;
Added the notion of Type and TargetSpecific attributes to the clang tablegen. In turn, this fixes a mistake with Ptr32, Ptr64, UPtr and SPtr attribtues generating AST nodes that are never actually used. llvm-svn: 187401
2013-07-30 09:44:15 +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
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << "class " << R.getName() << "Attr : public " << SuperName << " {\n";
else
OS << "\n// " << R.getName() << "Attr implementation\n\n";
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
std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
std::vector<std::unique_ptr<Argument>> Args;
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
Args.reserve(ArgRecords.size());
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
bool HasOptArg = false;
bool HasFakeArg = false;
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *ArgRecord : ArgRecords) {
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
Args.emplace_back(createArgument(*ArgRecord, R.getName()));
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header) {
Args.back()->writeDeclarations(OS);
OS << "\n\n";
}
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// For these purposes, fake takes priority over optional.
if (Args.back()->isFake()) {
HasFakeArg = true;
} else if (Args.back()->isOptional()) {
HasOptArg = true;
}
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] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << "public:\n";
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
// If there are zero or one spellings, all spelling-related functionality
// can be elided. If all of the spellings share the same name, the spelling
// functionality can also be elided.
bool ElideSpelling = (Spellings.size() <= 1) ||
SpellingNamesAreCommon(Spellings);
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
// This maps spelling index values to semantic Spelling enumerants.
SemanticSpellingMap SemanticToSyntacticMap;
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
std::string SpellingEnum;
[NFC][Attr TableGen] Emit Spelling Enum for Attr types if there >1 Discovered in a downstream, it is often useful to have slightly different semantics for an attribute based on its namespace, however our spelling infrastructure doesn't consider namespace when deciding to elide the enum list. The result is that the solution for a case where an attribute has slightly different semantics based on a namespace requires checking against the integer value, which is fragile. This patch makes us always emit the spelling enum if there is more than 1 and we're generating the header. Differential Revision: https://reviews.llvm.org/D76289
2020-03-17 23:23:45 +08:00
if (Spellings.size() > 1)
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
SpellingEnum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
if (Header)
OS << SpellingEnum;
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
const auto &ParsedAttrSpellingItr = llvm::find_if(
AttrMap, [R](const std::pair<std::string, const Record *> &P) {
return &R == P.second;
});
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// Emit CreateImplicit factory methods.
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
auto emitCreate = [&](bool Implicit, bool emitFake) {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << " static ";
OS << R.getName() << "Attr *";
if (!Header)
OS << R.getName() << "Attr::";
OS << "Create";
if (Implicit)
OS << "Implicit";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << "(";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
OS << "ASTContext &Ctx";
for (auto const &ai : Args) {
if (ai->isFake() && !emitFake) continue;
OS << ", ";
ai->writeCtorParameters(OS);
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << ", const AttributeCommonInfo &CommonInfo";
Non-implicit attribute creation requires a source range; NFC There are two factory functions used to create a semantic attribute, Create() and CreateImplicit(). CreateImplicit() does not need to specify the source range of the attribute since it's an implicitly- generated attribute. The same logic does not apply to Create(), so this removes the default argument from those declarations to avoid accidentally creating a semantic attribute without source location information.
2020-11-13 02:06:30 +08:00
if (Header && Implicit)
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " = {SourceRange{}}";
OS << ")";
if (Header) {
OS << ";\n";
return;
}
OS << " {\n";
OS << " auto *A = new (Ctx) " << R.getName();
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << "Attr(Ctx, CommonInfo";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
for (auto const &ai : Args) {
if (ai->isFake() && !emitFake) continue;
OS << ", ";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
ai->writeImplicitCtorArgs(OS);
}
OS << ");\n";
if (Implicit) {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " A->setImplicit(true);\n";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
}
if (Implicit || ElideSpelling) {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " if (!A->isAttributeSpellingListCalculated() && "
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
"!A->getAttrName())\n";
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " A->setAttributeSpellingListIndex(0);\n";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " return A;\n}\n\n";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
};
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
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
auto emitCreateNoCI = [&](bool Implicit, bool emitFake) {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << " static ";
OS << R.getName() << "Attr *";
if (!Header)
OS << R.getName() << "Attr::";
OS << "Create";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
if (Implicit)
OS << "Implicit";
OS << "(";
OS << "ASTContext &Ctx";
for (auto const &ai : Args) {
if (ai->isFake() && !emitFake) continue;
OS << ", ";
ai->writeCtorParameters(OS);
}
OS << ", SourceRange Range, AttributeCommonInfo::Syntax Syntax";
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (!ElideSpelling) {
OS << ", " << R.getName() << "Attr::Spelling S";
if (Header)
OS << " = static_cast<Spelling>(SpellingNotCalculated)";
}
OS << ")";
if (Header) {
OS << ";\n";
return;
}
OS << " {\n";
OS << " AttributeCommonInfo I(Range, ";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
if (ParsedAttrSpellingItr != std::end(AttrMap))
OS << "AT_" << ParsedAttrSpellingItr->first;
else
OS << "NoSemaHandlerAttribute";
OS << ", Syntax";
if (!ElideSpelling)
Fix build error in 371875 Apparently Clang complains about the name hiding here in a way that my GCC build does not, so a shocking number of buildbots decided to tell me about it. Change the name of the variable to prevent the name hiding and hope we don't have to fix this again. llvm-svn: 371876
2019-09-14 01:56:38 +08:00
OS << ", S";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << ");\n";
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " return Create";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
if (Implicit)
OS << "Implicit";
OS << "(Ctx";
for (auto const &ai : Args) {
if (ai->isFake() && !emitFake) continue;
OS << ", ";
ai->writeImplicitCtorArgs(OS);
}
OS << ", I);\n";
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << "}\n\n";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
};
auto emitCreates = [&](bool emitFake) {
emitCreate(true, emitFake);
emitCreate(false, emitFake);
emitCreateNoCI(true, emitFake);
emitCreateNoCI(false, emitFake);
};
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << " // Factory methods\n";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// Emit a CreateImplicit that takes all the arguments.
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
emitCreates(true);
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
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// Emit a CreateImplicit that takes all the non-fake arguments.
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
if (HasFakeArg)
emitCreates(false);
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
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// Emit constructors.
auto emitCtor = [&](bool emitOpt, bool emitFake) {
auto shouldEmitArg = [=](const std::unique_ptr<Argument> &arg) {
if (arg->isFake()) return emitFake;
if (arg->isOptional()) return emitOpt;
return true;
};
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << " ";
else
OS << R.getName() << "Attr::";
OS << R.getName()
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
<< "Attr(ASTContext &Ctx, const AttributeCommonInfo &CommonInfo";
OS << '\n';
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
for (auto const &ai : Args) {
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
if (!shouldEmitArg(ai)) continue;
OS << " , ";
ai->writeCtorParameters(OS);
OS << "\n";
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
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << " )";
if (Header) {
OS << ";\n";
return;
}
OS << "\n : " << SuperName << "(Ctx, CommonInfo, ";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << "attr::" << R.getName() << ", "
<< (R.getValueAsBit("LateParsed") ? "true" : "false");
Make attribute instantiation instantiate all attributes, not just the first of each kind. Attribute instantiation would previously default to instantiating each kind of attribute only once. This was overridden by a flag whose intended purpose was to permit attributes from a prior declaration to be inherited onto a new declaration even if that new declaration had its own copy of the attribute. This is the wrong behavior: when instantiating attributes from a template, we should always instantiate all the attributes that were written on that template. This patch renames the flag in the Attr class (and TableGen sources) to more clearly identify what it's actually for, and removes the usage of the flag from template instantiation. I also removed the flag from AlignedAttr, which was only added to work around the incorrect suppression of duplicate attribute instantiation. llvm-svn: 321834
2018-01-05 07:42:29 +08:00
if (Inheritable) {
OS << ", "
<< (R.getValueAsBit("InheritEvenIfAlreadyPresent") ? "true"
: "false");
}
OS << ")\n";
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
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
for (auto const &ai : Args) {
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
OS << " , ";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
if (!shouldEmitArg(ai)) {
ai->writeCtorDefaultInitializers(OS);
} else {
ai->writeCtorInitializers(OS);
}
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
OS << "\n";
}
OS << " {\n";
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
for (auto const &ai : Args) {
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
if (!shouldEmitArg(ai)) continue;
ai->writeCtorBody(OS);
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
}
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << "}\n\n";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
};
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << "\n // Constructors\n";
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// Emit a constructor that includes all the arguments.
// This is necessary for cloning.
emitCtor(true, true);
// Emit a constructor that takes all the non-fake arguments.
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
if (HasFakeArg)
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
emitCtor(true, false);
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// Emit a constructor that takes all the non-fake, non-optional arguments.
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
if (HasOptArg)
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
emitCtor(false, false);
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
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header) {
OS << '\n';
OS << " " << R.getName() << "Attr *clone(ASTContext &C) const;\n";
OS << " void printPretty(raw_ostream &OS,\n"
<< " const PrintingPolicy &Policy) const;\n";
OS << " const char *getSpelling() const;\n";
}
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
if (!ElideSpelling) {
assert(!SemanticToSyntacticMap.empty() && "Empty semantic mapping list");
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
OS << " Spelling getSemanticSpelling() const;\n";
else {
OS << R.getName() << "Attr::Spelling " << R.getName()
<< "Attr::getSemanticSpelling() const {\n";
WriteSemanticSpellingSwitch("getAttributeSpellingListIndex()",
SemanticToSyntacticMap, OS);
OS << "}\n";
}
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +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
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header)
writeAttrAccessorDefinition(R, OS);
[Sema][Attr]Fix alignment attribute printing. Remove "IsMSDeclspec" argument from Align attribute since the arguments in Attr.td should only model those appear in source code. Introduce attribute Accessor, and teach TableGen to generate syntax kind accessors for Align attribute, and use those accessors to decide if an alignment attribute is a declspec attribute. llvm-svn: 174133
2013-02-01 09:19:17 +08:00
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
for (auto const &ai : Args) {
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header) {
ai->writeAccessors(OS);
} else {
ai->writeAccessorDefinitions(OS);
}
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
OS << "\n\n";
Tablegen now generates a StringSwitch for attributes containing enumeration arguments to map strings to the proper enumeration value. This makes error checking more consistent and reduces the amount of hand-written code required. llvm-svn: 190545
2013-09-12 03:47:58 +08:00
Add the ability to define "fake" arguments on attributes. Fake arguments are automatically handled for serialization, cloning, and other representational tasks, but aren't included in pretty-printing or parsing (should we eventually ever automate that). This is chiefly useful for attributes that can be written by the user, but which are also frequently synthesized by the compiler, and which we'd like to remember details of the synthesis for. As a simple example, use this to narrow the cases in which we were generating a specialized note for implicitly unavailable declarations. llvm-svn: 251469
2015-10-28 08:17:34 +08:00
// Don't write conversion routines for fake arguments.
if (ai->isFake()) continue;
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
if (ai->isEnumArg())
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
static_cast<const EnumArgument *>(ai.get())->writeConversion(OS,
Header);
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
else if (ai->isVariadicEnumArg())
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
static_cast<const VariadicEnumArgument *>(ai.get())->writeConversion(
OS, Header);
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] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
if (Header) {
OS << R.getValueAsString("AdditionalMembers");
OS << "\n\n";
OS << " static bool classof(const Attr *A) { return A->getKind() == "
<< "attr::" << R.getName() << "; }\n";
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] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
OS << "};\n\n";
} else {
OS << R.getName() << "Attr *" << R.getName()
<< "Attr::clone(ASTContext &C) const {\n";
OS << " auto *A = new (C) " << R.getName() << "Attr(C, *this";
for (auto const &ai : Args) {
OS << ", ";
ai->writeCloneArgs(OS);
}
OS << ");\n";
OS << " A->Inherited = Inherited;\n";
OS << " A->IsPackExpansion = IsPackExpansion;\n";
OS << " A->setImplicit(Implicit);\n";
OS << " return A;\n}\n\n";
Delayed template instantiation of late-parsed attributes. llvm-svn: 148595
2012-01-21 06:50:54 +08:00
[TableGen] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
writePrettyPrintFunction(R, Args, OS);
writeGetSpellingFunction(R, OS);
}
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] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
}
// Emits the class definitions for attributes.
void clang::EmitClangAttrClass(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("Attribute classes' definitions", OS);
OS << "#ifndef LLVM_CLANG_ATTR_CLASSES_INC\n";
OS << "#define LLVM_CLANG_ATTR_CLASSES_INC\n\n";
emitAttributes(Records, OS, true);
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
Use range loops and autos in utils/TableGen/ClangAttrEmitter.cpp and generated code. Differential revision: http://reviews.llvm.org/D15313 llvm-svn: 255042
2015-12-09 02:49:01 +08:00
OS << "#endif // LLVM_CLANG_ATTR_CLASSES_INC\n";
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
}
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
// Emits the class method definitions for attributes.
Use scope qualifiers in Clang's tblgen backends to get useful redeclaration checking. NFC. llvm-svn: 373406
2019-10-02 07:12:57 +08:00
void clang::EmitClangAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
TableGen backends: use emitSourceFileHeader() to emit the warning about file contents being autogenerated llvm-svn: 173979
2013-01-31 05:54:20 +08:00
emitSourceFileHeader("Attribute classes' member function definitions", OS);
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] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
emitAttributes(Records, OS, false);
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] Move generated *Attr class methods out of line After this change, clang spends ~200ms parsing Attrs.inc instead of ~560ms. A large part of the cost was from the StringSwitch instantiations, but this is a good way to avoid similar problems in the future. Reviewed By: aaron.ballman, rjmccall Differential Revision: https://reviews.llvm.org/D76040
2020-03-12 10:43:37 +08:00
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
Devirtualize Attr and all subclasses. We know all subclasses in tblgen so just generate a giant switch for the few virtual methods or turn them into a member variable using spare bits. The giant jump tables aren't pretty but still much smaller than a vtable for every attribute, shrinking Release+Asserts clang by ~400k. Also halves the size of the Attr base class. No functional change intended. llvm-svn: 232726
2015-03-20 00:06:49 +08:00
// Instead of relying on virtual dispatch we just create a huge dispatch
// switch. This is both smaller and faster than virtual functions.
auto EmitFunc = [&](const char *Method) {
OS << " switch (getKind()) {\n";
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
if (!R.getValueAsBit("ASTNode"))
continue;
OS << " case attr::" << R.getName() << ":\n";
OS << " return cast<" << R.getName() << "Attr>(this)->" << Method
<< ";\n";
}
OS << " }\n";
OS << " llvm_unreachable(\"Unexpected attribute kind!\");\n";
OS << "}\n\n";
};
OS << "const char *Attr::getSpelling() const {\n";
EmitFunc("getSpelling()");
OS << "Attr *Attr::clone(ASTContext &C) const {\n";
EmitFunc("clone(C)");
OS << "void Attr::printPretty(raw_ostream &OS, "
"const PrintingPolicy &Policy) const {\n";
EmitFunc("printPretty(OS, Policy)");
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
}
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
static void emitAttrList(raw_ostream &OS, StringRef Class,
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
const std::vector<Record*> &AttrList) {
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
for (auto Cur : AttrList) {
OS << Class << "(" << Cur->getName() << ")\n";
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
}
}
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
// Determines if an attribute has a Pragma spelling.
static bool AttrHasPragmaSpelling(const Record *R) {
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
return llvm::find_if(Spellings, [](const FlattenedSpelling &S) {
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
return S.variety() == "Pragma";
}) != Spellings.end();
}
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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
namespace {
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
struct AttrClassDescriptor {
const char * const MacroName;
const char * const TableGenName;
};
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
} // end anonymous namespace
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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
static const AttrClassDescriptor AttrClassDescriptors[] = {
{ "ATTR", "Attr" },
Model type attributes as regular Attrs. Specifically, AttributedType now tracks a regular attr::Kind rather than having its own parallel Kind enumeration, and AttributedTypeLoc now holds an Attr* instead of holding an ad-hoc collection of Attr fields. Differential Revision: https://reviews.llvm.org/D50526 This reinstates r339623, reverted in r339638, with a fix to not fail template instantiation if we instantiate a QualType with no associated type source information and we encounter an AttributedType. llvm-svn: 340215
2018-08-21 05:47:29 +08:00
{ "TYPE_ATTR", "TypeAttr" },
P0188R1: add support for standard [[fallthrough]] attribute. This is almost exactly the same as clang's existing [[clang::fallthrough]] attribute, which has been updated to have the same semantics. The one significant difference is that [[fallthrough]] is ill-formed if it's not used immediately before a switch label (even when -Wimplicit-fallthrough is disabled). To support that, we now build a CFG of any function that uses a '[[fallthrough]];' statement to check. In passing, fix some bugs with our support for statement attributes -- in particular, diagnose their use on declarations, rather than asserting. llvm-svn: 262881
2016-03-08 08:32:55 +08:00
{ "STMT_ATTR", "StmtAttr" },
[Clang] Make nomerge attribute a function attribute as well as a statement attribute. Differential Revision: https://reviews.llvm.org/D92800
2020-12-08 08:37:14 +08:00
{ "DECL_OR_STMT_ATTR", "DeclOrStmtAttr" },
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
{ "INHERITABLE_ATTR", "InheritableAttr" },
Model type attributes as regular Attrs. Specifically, AttributedType now tracks a regular attr::Kind rather than having its own parallel Kind enumeration, and AttributedTypeLoc now holds an Attr* instead of holding an ad-hoc collection of Attr fields. Differential Revision: https://reviews.llvm.org/D50526 This reinstates r339623, reverted in r339638, with a fix to not fail template instantiation if we instantiate a QualType with no associated type source information and we encounter an AttributedType. llvm-svn: 340215
2018-08-21 05:47:29 +08:00
{ "DECL_OR_TYPE_ATTR", "DeclOrTypeAttr" },
Semantic analysis for the swiftcall calling convention. I've tried to keep the infrastructure behind parameter ABI treatments fairly general. llvm-svn: 262587
2016-03-03 14:39:32 +08:00
{ "INHERITABLE_PARAM_ATTR", "InheritableParamAttr" },
{ "PARAMETER_ABI_ATTR", "ParameterABIAttr" }
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
static void emitDefaultDefine(raw_ostream &OS, StringRef name,
const char *superName) {
OS << "#ifndef " << name << "\n";
OS << "#define " << name << "(NAME) ";
if (superName) OS << superName << "(NAME)";
OS << "\n#endif\n\n";
}
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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
namespace {
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
/// A class of attributes.
struct AttrClass {
const AttrClassDescriptor &Descriptor;
Record *TheRecord;
AttrClass *SuperClass = nullptr;
std::vector<AttrClass*> SubClasses;
std::vector<Record*> Attrs;
AttrClass(const AttrClassDescriptor &Descriptor, Record *R)
: Descriptor(Descriptor), TheRecord(R) {}
void emitDefaultDefines(raw_ostream &OS) const {
// Default the macro unless this is a root class (i.e. Attr).
if (SuperClass) {
emitDefaultDefine(OS, Descriptor.MacroName,
SuperClass->Descriptor.MacroName);
}
}
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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
void emitUndefs(raw_ostream &OS) const {
OS << "#undef " << Descriptor.MacroName << "\n";
}
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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
void emitAttrList(raw_ostream &OS) const {
for (auto SubClass : SubClasses) {
SubClass->emitAttrList(OS);
}
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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
::emitAttrList(OS, Descriptor.MacroName, Attrs);
}
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
void classifyAttrOnRoot(Record *Attr) {
bool result = classifyAttr(Attr);
assert(result && "failed to classify on root"); (void) result;
}
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
void emitAttrRange(raw_ostream &OS) const {
OS << "ATTR_RANGE(" << Descriptor.TableGenName
<< ", " << getFirstAttr()->getName()
<< ", " << getLastAttr()->getName() << ")\n";
}
private:
bool classifyAttr(Record *Attr) {
// Check all the subclasses.
for (auto SubClass : SubClasses) {
if (SubClass->classifyAttr(Attr))
return true;
}
// It's not more specific than this class, but it might still belong here.
if (Attr->isSubClassOf(TheRecord)) {
Attrs.push_back(Attr);
return true;
}
return false;
}
Record *getFirstAttr() const {
if (!SubClasses.empty())
return SubClasses.front()->getFirstAttr();
return Attrs.front();
}
Record *getLastAttr() const {
if (!Attrs.empty())
return Attrs.back();
return SubClasses.back()->getLastAttr();
}
};
/// The entire hierarchy of attribute classes.
class AttrClassHierarchy {
std::vector<std::unique_ptr<AttrClass>> Classes;
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
public:
AttrClassHierarchy(RecordKeeper &Records) {
// Find records for all the classes.
for (auto &Descriptor : AttrClassDescriptors) {
Record *ClassRecord = Records.getClass(Descriptor.TableGenName);
AttrClass *Class = new AttrClass(Descriptor, ClassRecord);
Classes.emplace_back(Class);
}
// Link up the hierarchy.
for (auto &Class : Classes) {
if (AttrClass *SuperClass = findSuperClass(Class->TheRecord)) {
Class->SuperClass = SuperClass;
SuperClass->SubClasses.push_back(Class.get());
}
}
#ifndef NDEBUG
for (auto i = Classes.begin(), e = Classes.end(); i != e; ++i) {
assert((i == Classes.begin()) == ((*i)->SuperClass == nullptr) &&
"only the first class should be a root class!");
}
#endif
}
void emitDefaultDefines(raw_ostream &OS) const {
for (auto &Class : Classes) {
Class->emitDefaultDefines(OS);
}
}
void emitUndefs(raw_ostream &OS) const {
for (auto &Class : Classes) {
Class->emitUndefs(OS);
}
}
void emitAttrLists(raw_ostream &OS) const {
// Just start from the root class.
Classes[0]->emitAttrList(OS);
}
void emitAttrRanges(raw_ostream &OS) const {
for (auto &Class : Classes)
Class->emitAttrRange(OS);
}
void classifyAttr(Record *Attr) {
// Add the attribute to the root class.
Classes[0]->classifyAttrOnRoot(Attr);
}
private:
AttrClass *findClassByRecord(Record *R) const {
for (auto &Class : Classes) {
if (Class->TheRecord == R)
return Class.get();
}
return nullptr;
}
AttrClass *findSuperClass(Record *R) const {
// TableGen flattens the superclass list, so we just need to walk it
// in reverse.
auto SuperClasses = R->getSuperClasses();
for (signed i = 0, e = SuperClasses.size(); i != e; ++i) {
auto SuperClass = findClassByRecord(SuperClasses[e - i - 1].first);
if (SuperClass) return SuperClass;
}
return nullptr;
}
};
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
} // end anonymous namespace
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
namespace clang {
Fix Clang-tidy modernize-use-bool-literals in generated code. Reduce space in empty constructors and between data members and first public section. Fix some Include What You Use warnings. Differential revision: http://reviews.llvm.org/D20213 llvm-svn: 269371
2016-05-13 06:27:08 +08:00
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
// Emits the enumeration list for attributes.
void EmitClangAttrList(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
AttrClassHierarchy Hierarchy(Records);
// Add defaulting macro definitions.
Hierarchy.emitDefaultDefines(OS);
emitDefaultDefine(OS, "PRAGMA_SPELLING_ATTR", nullptr);
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
std::vector<Record *> PragmaAttrs;
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (auto *Attr : Attrs) {
if (!Attr->getValueAsBit("ASTNode"))
Introduce the notion of an attribute that has no direct representation as an AST node, and fold a number of such attributes into Attr.td. llvm-svn: 155995
2012-05-02 23:56:52 +08:00
continue;
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
// Add the attribute to the ad-hoc groups.
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
if (AttrHasPragmaSpelling(Attr))
PragmaAttrs.push_back(Attr);
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
// Place it in the hierarchy.
Hierarchy.classifyAttr(Attr);
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
}
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
// Emit the main attribute list.
Hierarchy.emitAttrLists(OS);
// Emit the ad hoc groups.
emitAttrList(OS, "PRAGMA_SPELLING_ATTR", PragmaAttrs);
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
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
// Emit the attribute ranges.
OS << "#ifdef ATTR_RANGE\n";
Hierarchy.emitAttrRanges(OS);
OS << "#undef ATTR_RANGE\n";
OS << "#endif\n";
Hierarchy.emitUndefs(OS);
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
OS << "#undef PRAGMA_SPELLING_ATTR\n";
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
}
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
// Emits the enumeration list for attributes.
void EmitClangAttrSubjectMatchRuleList(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader(
"List of all attribute subject matching rules that Clang recognizes", OS);
PragmaClangAttributeSupport &PragmaAttributeSupport =
getPragmaAttributeSupport(Records);
emitDefaultDefine(OS, "ATTR_MATCH_RULE", nullptr);
PragmaAttributeSupport.emitMatchRuleList(OS);
OS << "#undef ATTR_MATCH_RULE\n";
}
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
// Emits the code to read an attribute from a precompiled header.
void EmitClangAttrPCHRead(RecordKeeper &Records, raw_ostream &OS) {
TableGen backends: use emitSourceFileHeader() to emit the warning about file contents being autogenerated llvm-svn: 173979
2013-01-31 05:54:20 +08:00
emitSourceFileHeader("Attribute deserialization code", OS);
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
Record *InhClass = Records.getClass("InheritableAttr");
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"),
ArgRecords;
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
std::vector<std::unique_ptr<Argument>> Args;
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
OS << " switch (Kind) {\n";
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
Introduce the notion of an attribute that has no direct representation as an AST node, and fold a number of such attributes into Attr.td. llvm-svn: 155995
2012-05-02 23:56:52 +08:00
if (!R.getValueAsBit("ASTNode"))
continue;
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +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
OS << " case attr::" << R.getName() << ": {\n";
if (R.isSubClassOf(InhClass))
Switch TableGen to emit calls to ASTRecordReader for AttrPCHRead. Summary: This patch changes TableGen-generated code in AttrPCHRead to call functions on ASTRecordReader, instead of passing separate parameters to ASTReader. This is a follow-up to r290217. Reviewers: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D28007 llvm-svn: 292868
2017-01-24 09:04:30 +08:00
OS << " bool isInherited = Record.readInt();\n";
OS << " bool isImplicit = Record.readInt();\n";
[clang] Persist Attr::IsPackExpansion into the PCH Summary: Fixes https://github.com/clangd/clangd/issues/309 Subscribers: ilya-biryukov, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77194
2020-04-01 13:29:58 +08:00
OS << " bool isPackExpansion = Record.readInt();\n";
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
ArgRecords = R.getValueAsListOfDefs("Args");
Args.clear();
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Arg : ArgRecords) {
Args.emplace_back(createArgument(*Arg, R.getName()));
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
Args.back()->writePCHReadDecls(OS);
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
}
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << " New = new (Context) " << R.getName() << "Attr(Context, Info";
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
for (auto const &ri : Args) {
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
OS << ", ";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
ri->writePCHReadArgs(OS);
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
}
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << ");\n";
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
if (R.isSubClassOf(InhClass))
OS << " cast<InheritableAttr>(New)->setInherited(isInherited);\n";
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
OS << " New->setImplicit(isImplicit);\n";
[clang] Persist Attr::IsPackExpansion into the PCH Summary: Fixes https://github.com/clangd/clangd/issues/309 Subscribers: ilya-biryukov, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77194
2020-04-01 13:29:58 +08:00
OS << " New->setPackExpansion(isPackExpansion);\n";
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
OS << " break;\n";
OS << " }\n";
}
OS << " }\n";
}
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
// Emits the code to write an attribute to a precompiled header.
void EmitClangAttrPCHWrite(RecordKeeper &Records, raw_ostream &OS) {
TableGen backends: use emitSourceFileHeader() to emit the warning about file contents being autogenerated llvm-svn: 173979
2013-01-31 05:54:20 +08:00
emitSourceFileHeader("Attribute serialization code", OS);
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
Record *InhClass = Records.getClass("InheritableAttr");
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
OS << " switch (A->getKind()) {\n";
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
Introduce the notion of an attribute that has no direct representation as an AST node, and fold a number of such attributes into Attr.td. llvm-svn: 155995
2012-05-02 23:56:52 +08:00
if (!R.getValueAsBit("ASTNode"))
continue;
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
OS << " case attr::" << R.getName() << ": {\n";
Args = R.getValueAsListOfDefs("Args");
if (R.isSubClassOf(InhClass) || !Args.empty())
Use range loops and autos in utils/TableGen/ClangAttrEmitter.cpp and generated code. Differential revision: http://reviews.llvm.org/D15313 llvm-svn: 255042
2015-12-09 02:49:01 +08:00
OS << " const auto *SA = cast<" << R.getName()
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
<< "Attr>(A);\n";
if (R.isSubClassOf(InhClass))
OS << " Record.push_back(SA->isInherited());\n";
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
OS << " Record.push_back(A->isImplicit());\n";
[clang] Persist Attr::IsPackExpansion into the PCH Summary: Fixes https://github.com/clangd/clangd/issues/309 Subscribers: ilya-biryukov, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77194
2020-04-01 13:29:58 +08:00
OS << " Record.push_back(A->isPackExpansion());\n";
Distinguish between attributes explicitly written at the request of the user, and attributes implicitly generated to assist in bookkeeping by the compiler. This is done so by table generating a CreateImplicit method for each attribute. Additionally, remove the optional nature of the spelling list index when creating attributes. This is supported by table generating a Spelling enumeration when the spellings for an attribute are distinct enough to warrant it. llvm-svn: 199378
2014-01-16 21:03:14 +08:00
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Arg : Args)
createArgument(*Arg, R.getName())->writePCHWrite(OS);
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
OS << " break;\n";
OS << " }\n";
}
OS << " }\n";
}
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
// Helper function for GenerateTargetSpecificAttrChecks that alters the 'Test'
// parameter with only a single check type, if applicable.
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
static bool GenerateTargetSpecificAttrCheck(const Record *R, std::string &Test,
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
std::string *FnName,
StringRef ListName,
StringRef CheckAgainst,
StringRef Scope) {
if (!R->isValueUnset(ListName)) {
Test += " && (";
std::vector<StringRef> Items = R->getValueAsListOfStrings(ListName);
for (auto I = Items.begin(), E = Items.end(); I != E; ++I) {
StringRef Part = *I;
Test += CheckAgainst;
Test += " == ";
Test += Scope;
Test += Part;
if (I + 1 != E)
Test += " || ";
if (FnName)
*FnName += Part;
}
Test += ")";
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
return true;
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
}
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
return false;
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
}
Refactor TableGen backend for ClangAttrEmitter to avoid duplication. GenerateHasAttrSpellingStringSwitch and GenerateTargetRequirements had duplicated code to check the conditions for target-specific attributes. Refactor the duplicated code into a separate function. NFC. llvm-svn: 242731
2015-07-21 06:57:36 +08:00
// Generate a conditional expression to check if the current target satisfies
// the conditions for a TargetSpecificAttr record, and append the code for
// those checks to the Test string. If the FnName string pointer is non-null,
// append a unique suffix to distinguish this set of target checks from other
// TargetSpecificAttr records.
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
static bool GenerateTargetSpecificAttrChecks(const Record *R,
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
std::vector<StringRef> &Arches,
Refactor TableGen backend for ClangAttrEmitter to avoid duplication. GenerateHasAttrSpellingStringSwitch and GenerateTargetRequirements had duplicated code to check the conditions for target-specific attributes. Refactor the duplicated code into a separate function. NFC. llvm-svn: 242731
2015-07-21 06:57:36 +08:00
std::string &Test,
std::string *FnName) {
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
bool AnyTargetChecks = false;
Refactor TableGen backend for ClangAttrEmitter to avoid duplication. GenerateHasAttrSpellingStringSwitch and GenerateTargetRequirements had duplicated code to check the conditions for target-specific attributes. Refactor the duplicated code into a separate function. NFC. llvm-svn: 242731
2015-07-21 06:57:36 +08:00
// It is assumed that there will be an llvm::Triple object
// named "T" and a TargetInfo object named "Target" within
// scope that can be used to determine whether the attribute exists in
// a given target.
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
Test += "true";
// If one or more architectures is specified, check those. Arches are handled
// differently because GenerateTargetRequirements needs to combine the list
// with ParseKind.
if (!Arches.empty()) {
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
AnyTargetChecks = true;
Refactor TableGen backend for ClangAttrEmitter to avoid duplication. GenerateHasAttrSpellingStringSwitch and GenerateTargetRequirements had duplicated code to check the conditions for target-specific attributes. Refactor the duplicated code into a separate function. NFC. llvm-svn: 242731
2015-07-21 06:57:36 +08:00
Test += " && (";
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
for (auto I = Arches.begin(), E = Arches.end(); I != E; ++I) {
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
StringRef Part = *I;
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
Test += "T.getArch() == llvm::Triple::";
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
Test += Part;
Refactor TableGen backend for ClangAttrEmitter to avoid duplication. GenerateHasAttrSpellingStringSwitch and GenerateTargetRequirements had duplicated code to check the conditions for target-specific attributes. Refactor the duplicated code into a separate function. NFC. llvm-svn: 242731
2015-07-21 06:57:36 +08:00
if (I + 1 != E)
Test += " || ";
if (FnName)
*FnName += Part;
}
Test += ")";
}
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
// If the attribute is specific to particular OSes, check those.
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
AnyTargetChecks |= GenerateTargetSpecificAttrCheck(
R, Test, FnName, "OSes", "T.getOS()", "llvm::Triple::");
Add support for ObjectFormat to TargetSpecificAttr Looking through the code, I saw a FIXME on IFunc to switch it to a target specific attribute. In looking through it, i saw that the no-longer-appropriately-named TargetArch didn't support ObjectFormat checking. This patch changes the name of TargetArch to TargetSpecific (since it checks much more than just Arch), makes "Arch" optional, adds support for ObjectFormat, better documents the TargetSpecific type, and changes IFunc over to a TargetSpecificAttr. Differential Revision: https://reviews.llvm.org/D41303 llvm-svn: 321201
2017-12-21 02:51:08 +08:00
// If one or more object formats is specified, check those.
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
AnyTargetChecks |=
GenerateTargetSpecificAttrCheck(R, Test, FnName, "ObjectFormats",
"T.getObjectFormat()", "llvm::Triple::");
// If custom code is specified, emit it.
StringRef Code = R->getValueAsString("CustomCode");
if (!Code.empty()) {
AnyTargetChecks = true;
Test += " && (";
Test += Code;
Test += ")";
}
return AnyTargetChecks;
Refactor TableGen backend for ClangAttrEmitter to avoid duplication. GenerateHasAttrSpellingStringSwitch and GenerateTargetRequirements had duplicated code to check the conditions for target-specific attributes. Refactor the duplicated code into a separate function. NFC. llvm-svn: 242731
2015-07-21 06:57:36 +08:00
}
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
static void GenerateHasAttrSpellingStringSwitch(
const std::vector<Record *> &Attrs, raw_ostream &OS,
const std::string &Variety = "", const std::string &Scope = "") {
for (const auto *Attr : Attrs) {
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
// C++11-style attributes have specific version information associated with
// them. If the attribute has no scope, the version information must not
// have the default value (1), as that's incorrect. Instead, the unscoped
// attribute version information should be taken from the SD-6 standing
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
// document, which can be found at:
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
// https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations
Support the standards-based dates for __has_c_attribute WG14 N2481 was adopted with minor modifications at the latest WG14 meetings. The only modification to the paper was to correct the date for the deprecated attribute to be 201904L (the corrected date value will be present in WG14 N2553 when it gets published).
2020-08-13 20:47:40 +08:00
//
// C2x-style attributes have the same kind of version information
// associated with them. The unscoped attribute version information should
// be taken from the specification of the attribute in the C Standard.
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
int Version = 1;
Support the standards-based dates for __has_c_attribute WG14 N2481 was adopted with minor modifications at the latest WG14 meetings. The only modification to the paper was to correct the date for the deprecated attribute to be 201904L (the corrected date value will be present in WG14 N2553 when it gets published).
2020-08-13 20:47:40 +08:00
if (Variety == "CXX11" || Variety == "C2x") {
std::vector<Record *> Spellings = Attr->getValueAsListOfDefs("Spellings");
for (const auto &Spelling : Spellings) {
if (Spelling->getValueAsString("Variety") == Variety) {
Version = static_cast<int>(Spelling->getValueAsInt("Version"));
if (Scope.empty() && Version == 1)
PrintError(Spelling->getLoc(), "Standard attributes must have "
"valid version information.");
break;
}
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
}
}
__has_attribute now understands target-specific attributes. So when you ask whether an ARM target has the "interrupt" attribute, it will return true for ARM and MSP430 targets, and false for others. llvm-svn: 198897
2014-01-10 06:57:44 +08:00
std::string Test;
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
if (Attr->isSubClassOf("TargetSpecificAttr")) {
const Record *R = Attr->getValueAsDef("Target");
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
GenerateTargetSpecificAttrChecks(R, Arches, Test, nullptr);
Ignore the "novtable" declspec when not using the Microsoft C++ ABI. Clang used to silently ignore __declspec(novtable). It is implemented now, but leaving the vtable uninitialized does not work when using the Itanium ABI, where the class layout for complex class hierarchies is stored in the vtable. It might be possible to honor the novtable attribute in some simple cases and either report an error or ignore it in more complex situations, but it’s not clear if that would be worthwhile. There is also value in having a simple and predictable behavior, so this changes clang to simply ignore novtable when not using the Microsoft C++ ABI. llvm-svn: 242730
2015-07-21 06:57:31 +08:00
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
// If this is the C++11 variety, also add in the LangOpts test.
if (Variety == "CXX11")
Test += " && LangOpts.CPlusPlus11";
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
else if (Variety == "C2x")
Test += " && LangOpts.DoubleSquareBracketAttributes";
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
} else if (Variety == "CXX11")
// C++11 mode should be checked against LangOpts, which is presumed to be
// present in the caller.
Test = "LangOpts.CPlusPlus11";
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
else if (Variety == "C2x")
Test = "LangOpts.DoubleSquareBracketAttributes";
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
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
std::string TestStr =
Fixing a use of stringstream to use an LLVM helper function. Drive-by fixing header include order. NFC. llvm-svn: 222151
2014-11-18 02:17:19 +08:00
!Test.empty() ? Test + " ? " + llvm::itostr(Version) + " : 0" : "1";
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
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*Attr);
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &S : Spellings)
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
if (Variety.empty() || (Variety == S.variety() &&
(Scope.empty() || Scope == S.nameSpace())))
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
OS << " .Case(\"" << S.name() << "\", " << TestStr << ")\n";
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
}
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
OS << " .Default(0);\n";
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
}
// Emits the list of spellings for attributes.
void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("Code to implement the __has_attribute logic", OS);
// Separate all of the attributes out into four group: generic, C++11, GNU,
// and declspecs. Then generate a big switch statement for each of them.
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
Add plumbing for new attribute type "Microsoft". This is for attributes in []-delimited lists preceding a class, like e.g. `[uuid("...")] class Foo {};` Not used by anything yet, so no behavior change. Part of https://reviews.llvm.org/D23895 llvm-svn: 280575
2016-09-03 10:55:10 +08:00
std::vector<Record *> Declspec, Microsoft, GNU, Pragma;
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
std::map<std::string, std::vector<Record *>> CXX, C2x;
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
// Walk over the list of all attributes, and split them out based on the
// spelling variety.
for (auto *R : Attrs) {
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(*R);
for (const auto &SI : Spellings) {
Turn copies into references as suggested by clang-tidy's performance-unnecessary-copy-initialization. llvm-svn: 270994
2016-05-27 21:36:58 +08:00
const std::string &Variety = SI.variety();
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
if (Variety == "GNU")
GNU.push_back(R);
else if (Variety == "Declspec")
Declspec.push_back(R);
Add plumbing for new attribute type "Microsoft". This is for attributes in []-delimited lists preceding a class, like e.g. `[uuid("...")] class Foo {};` Not used by anything yet, so no behavior change. Part of https://reviews.llvm.org/D23895 llvm-svn: 280575
2016-09-03 10:55:10 +08:00
else if (Variety == "Microsoft")
Microsoft.push_back(R);
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
else if (Variety == "CXX11")
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
CXX[SI.nameSpace()].push_back(R);
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
else if (Variety == "C2x")
C2x[SI.nameSpace()].push_back(R);
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
else if (Variety == "Pragma")
Pragma.push_back(R);
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
}
}
Ignore the "novtable" declspec when not using the Microsoft C++ ABI. Clang used to silently ignore __declspec(novtable). It is implemented now, but leaving the vtable uninitialized does not work when using the Itanium ABI, where the class layout for complex class hierarchies is stored in the vtable. It might be possible to honor the novtable attribute in some simple cases and either report an error or ignore it in more complex situations, but it’s not clear if that would be worthwhile. There is also value in having a simple and predictable behavior, so this changes clang to simply ignore novtable when not using the Microsoft C++ ABI. llvm-svn: 242730
2015-07-21 06:57:31 +08:00
OS << "const llvm::Triple &T = Target.getTriple();\n";
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
OS << "switch (Syntax) {\n";
OS << "case AttrSyntax::GNU:\n";
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
OS << " return llvm::StringSwitch<int>(Name)\n";
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
GenerateHasAttrSpellingStringSwitch(GNU, OS, "GNU");
OS << "case AttrSyntax::Declspec:\n";
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
OS << " return llvm::StringSwitch<int>(Name)\n";
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
GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
Add plumbing for new attribute type "Microsoft". This is for attributes in []-delimited lists preceding a class, like e.g. `[uuid("...")] class Foo {};` Not used by anything yet, so no behavior change. Part of https://reviews.llvm.org/D23895 llvm-svn: 280575
2016-09-03 10:55:10 +08:00
OS << "case AttrSyntax::Microsoft:\n";
OS << " return llvm::StringSwitch<int>(Name)\n";
GenerateHasAttrSpellingStringSwitch(Microsoft, OS, "Microsoft");
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
OS << "case AttrSyntax::Pragma:\n";
Complete support for the SD-6 standing document (based off N4200) with support for __has_cpp_attribute. llvm-svn: 221991
2014-11-14 21:44:02 +08:00
OS << " return llvm::StringSwitch<int>(Name)\n";
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
auto fn = [&OS](const char *Spelling, const char *Variety,
const std::map<std::string, std::vector<Record *>> &List) {
OS << "case AttrSyntax::" << Variety << ": {\n";
// C++11-style attributes are further split out based on the Scope.
for (auto I = List.cbegin(), E = List.cend(); I != E; ++I) {
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
if (I != List.cbegin())
OS << " else ";
if (I->first.empty())
OS << "if (ScopeName == \"\") {\n";
else
OS << "if (ScopeName == \"" << I->first << "\") {\n";
OS << " return llvm::StringSwitch<int>(Name)\n";
GenerateHasAttrSpellingStringSwitch(I->second, OS, Spelling, I->first);
OS << "}";
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
}
Silence -Wimplicit-fallthrough warnings with the generated code; NFC. llvm-svn: 316075
2017-10-18 20:11:58 +08:00
OS << "\n} break;\n";
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
};
fn("CXX11", "CXX", CXX);
fn("C2x", "C", C2x);
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
OS << "}\n";
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
}
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
void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
TableGen backends: use emitSourceFileHeader() to emit the warning about file contents being autogenerated llvm-svn: 173979
2013-01-31 05:54:20 +08:00
emitSourceFileHeader("Code to translate different attribute spellings "
"into internal identifiers", OS);
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
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << " switch (getParsedKind()) {\n";
OS << " case IgnoredAttribute:\n";
OS << " case UnknownAttribute:\n";
OS << " case NoSemaHandlerAttribute:\n";
OS << " llvm_unreachable(\"Ignored/unknown shouldn't get here\");\n";
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
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
ParsedAttrMap Attrs = getParsedAttrList(Records);
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &I : Attrs) {
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
const Record &R = *I.second;
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
OS << " case AT_" << I.first << ": {\n";
Remove 'DistinctSpellings' support from Attr.td and change its only user to look at the attribute spelling instead. The 'ownership_*' attributes should probably be split into separate *Attr classes, but that's more than I wanted to do here. llvm-svn: 195805
2013-11-27 09:46:48 +08:00
for (unsigned I = 0; I < Spellings.size(); ++ I) {
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
OS << " if (Name == \"" << Spellings[I].name() << "\" && "
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
<< "getSyntax() == AttributeCommonInfo::AS_" << Spellings[I].variety()
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
<< " && Scope == \"" << Spellings[I].nameSpace() << "\")\n"
<< " return " << I << ";\n";
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
}
Remove 'DistinctSpellings' support from Attr.td and change its only user to look at the attribute spelling instead. The 'ownership_*' attributes should probably be split into separate *Attr classes, but that's more than I wanted to do here. llvm-svn: 195805
2013-11-27 09:46:48 +08:00
OS << " break;\n";
OS << " }\n";
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
}
OS << " }\n";
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
OS << " return 0;\n";
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
}
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
// Emits code used by RecursiveASTVisitor to visit attributes
void EmitClangAttrASTVisitor(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("Used by RecursiveASTVisitor to visit attributes.", OS);
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
// Write method declarations for Traverse* methods.
// We emit this here because we only generate methods for attributes that
// are declared as ASTNodes.
OS << "#ifdef ATTR_VISITOR_DECLS_ONLY\n\n";
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
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
if (!R.getValueAsBit("ASTNode"))
continue;
OS << " bool Traverse"
<< R.getName() << "Attr(" << R.getName() << "Attr *A);\n";
OS << " bool Visit"
<< R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
<< " return true; \n"
Fix -Wextra-semi warnings. Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D11401 llvm-svn: 242931
2015-07-23 04:46:26 +08:00
<< " }\n";
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
}
OS << "\n#else // ATTR_VISITOR_DECLS_ONLY\n\n";
// Write individual Traverse* methods for each attribute class.
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
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
if (!R.getValueAsBit("ASTNode"))
continue;
OS << "template <typename Derived>\n"
Update DataRecursiveASTVisitor so that it visits attributes. llvm-svn: 198249
2013-12-31 05:03:02 +08:00
<< "bool VISITORCLASS<Derived>::Traverse"
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
<< R.getName() << "Attr(" << R.getName() << "Attr *A) {\n"
<< " if (!getDerived().VisitAttr(A))\n"
<< " return false;\n"
<< " if (!getDerived().Visit" << R.getName() << "Attr(A))\n"
<< " return false;\n";
std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Arg : ArgRecords)
createArgument(*Arg, R.getName())->writeASTVisitorTraversal(OS);
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
OS << " return true;\n";
OS << "}\n\n";
}
// Write generic Traverse routine
OS << "template <typename Derived>\n"
Update DataRecursiveASTVisitor so that it visits attributes. llvm-svn: 198249
2013-12-31 05:03:02 +08:00
<< "bool VISITORCLASS<Derived>::TraverseAttr(Attr *A) {\n"
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
<< " if (!A)\n"
<< " return true;\n"
<< "\n"
Infrastructure improvements to Clang attribute TableGen. This should make it easier to add new Attr subclasses. llvm-svn: 262275
2016-03-01 08:18:05 +08:00
<< " switch (A->getKind()) {\n";
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
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
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
if (!R.getValueAsBit("ASTNode"))
continue;
OS << " case attr::" << R.getName() << ":\n"
<< " return getDerived().Traverse" << R.getName() << "Attr("
<< "cast<" << R.getName() << "Attr>(A));\n";
}
Add an llvm_unreachable back to the autogeneration of this covered switch. llvm-svn: 262288
2016-03-01 10:09:20 +08:00
OS << " }\n"; // end switch
OS << " llvm_unreachable(\"bad attribute kind\");\n";
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
OS << "}\n"; // end function
OS << "#endif // ATTR_VISITOR_DECLS_ONLY\n";
}
Correct class-template deprecation behavior-REDUX Correct class-template deprecation behavior Based on the comment in the test, and my reading of the standard, a deprecated warning should be issued in the following case: template<typename T> [[deprecated]] class Foo{}; Foo<int> f; This was not the case, because the ClassTemplateSpecializationDecl creation did not also copy the deprecated attribute. Note: I did NOT audit the complete set of attributes to see WHICH ones should be copied, so instead I simply copy ONLY the deprecated attribute. Previous DiffRev: https://reviews.llvm.org/D27486, was reverted. This patch fixes the issues brought up here by the reverter: https://reviews.llvm.org/rL298410 Differential Revision: https://reviews.llvm.org/D31245 llvm-svn: 298634
2017-03-24 02:51:54 +08:00
void EmitClangAttrTemplateInstantiateHelper(const std::vector<Record *> &Attrs,
raw_ostream &OS,
bool AppliesToDecl) {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
Correct class-template deprecation behavior-REDUX Correct class-template deprecation behavior Based on the comment in the test, and my reading of the standard, a deprecated warning should be issued in the following case: template<typename T> [[deprecated]] class Foo{}; Foo<int> f; This was not the case, because the ClassTemplateSpecializationDecl creation did not also copy the deprecated attribute. Note: I did NOT audit the complete set of attributes to see WHICH ones should be copied, so instead I simply copy ONLY the deprecated attribute. Previous DiffRev: https://reviews.llvm.org/D27486, was reverted. This patch fixes the issues brought up here by the reverter: https://reviews.llvm.org/rL298410 Differential Revision: https://reviews.llvm.org/D31245 llvm-svn: 298634
2017-03-24 02:51:54 +08:00
OS << " switch (At->getKind()) {\n";
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
Introduce the notion of an attribute that has no direct representation as an AST node, and fold a number of such attributes into Attr.td. llvm-svn: 155995
2012-05-02 23:56:52 +08:00
if (!R.getValueAsBit("ASTNode"))
continue;
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << " case attr::" << R.getName() << ": {\n";
Correct class-template deprecation behavior-REDUX Correct class-template deprecation behavior Based on the comment in the test, and my reading of the standard, a deprecated warning should be issued in the following case: template<typename T> [[deprecated]] class Foo{}; Foo<int> f; This was not the case, because the ClassTemplateSpecializationDecl creation did not also copy the deprecated attribute. Note: I did NOT audit the complete set of attributes to see WHICH ones should be copied, so instead I simply copy ONLY the deprecated attribute. Previous DiffRev: https://reviews.llvm.org/D27486, was reverted. This patch fixes the issues brought up here by the reverter: https://reviews.llvm.org/rL298410 Differential Revision: https://reviews.llvm.org/D31245 llvm-svn: 298634
2017-03-24 02:51:54 +08:00
bool ShouldClone = R.getValueAsBit("Clone") &&
(!AppliesToDecl ||
R.getValueAsBit("MeaningfulToClassTemplateDefinition"));
Fix our handling of visibility in explicit template instantiations. * Don't copy the visibility attribute during instantiations. We have to be able to distinguish struct HIDDEN foo {}; template<class T> DEFAULT void bar() {} template DEFAULT void bar<foo>(); from struct HIDDEN foo {}; template<class T> DEFAULT void bar() {} template void bar<foo>(); * If an instantiation has an attribute, it takes precedence over an attribute in the template. * With instantiation attributes handled with the above logic, we can now select the minimum visibility when looking at template arguments. llvm-svn: 156821
2012-05-15 22:09:55 +08:00
if (!ShouldClone) {
Fix Clang-tidy modernize-use-nullptr warnings in headers and generated files; other minor cleanups. By Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13187 llvm-svn: 248828
2015-09-30 04:56:43 +08:00
OS << " return nullptr;\n";
Fix our handling of visibility in explicit template instantiations. * Don't copy the visibility attribute during instantiations. We have to be able to distinguish struct HIDDEN foo {}; template<class T> DEFAULT void bar() {} template DEFAULT void bar<foo>(); from struct HIDDEN foo {}; template<class T> DEFAULT void bar() {} template void bar<foo>(); * If an instantiation has an attribute, it takes precedence over an attribute in the template. * With instantiation attributes handled with the above logic, we can now select the minimum visibility when looking at template arguments. llvm-svn: 156821
2012-05-15 22:09:55 +08:00
OS << " }\n";
continue;
}
Use range loops and autos in utils/TableGen/ClangAttrEmitter.cpp and generated code. Differential revision: http://reviews.llvm.org/D15313 llvm-svn: 255042
2015-12-09 02:49:01 +08:00
OS << " const auto *A = cast<"
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
<< R.getName() << "Attr>(At);\n";
bool TDependent = R.getValueAsBit("TemplateDependent");
if (!TDependent) {
OS << " return A->clone(C);\n";
OS << " }\n";
continue;
}
std::vector<Record*> ArgRecords = R.getValueAsListOfDefs("Args");
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
std::vector<std::unique_ptr<Argument>> Args;
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
Args.reserve(ArgRecords.size());
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *ArgRecord : ArgRecords)
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
Args.emplace_back(createArgument(*ArgRecord, R.getName()));
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
for (auto const &ai : Args)
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
ai->writeTemplateInstantiation(OS);
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-12 09:12:18 +08:00
OS << " return new (C) " << R.getName() << "Attr(C, *A";
[C++11] Using std::unique_ptr to ensure that Argument objects do not leak (since clang-tblgen isn't long-lived, the old leak is probably acceptable, but it offended my senses nonetheless). llvm-svn: 202989
2014-03-06 00:49:55 +08:00
for (auto const &ai : Args) {
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
OS << ", ";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
ai->writeTemplateInstantiationArgs(OS);
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
}
Add new 'preferred_name' attribute. This attribute permits a typedef to be associated with a class template specialization as a preferred way of naming that class template specialization. This permits us to specify that (for example) the preferred way to express 'std::basic_string<char>' is as 'std::string'. The attribute is applied to the various class templates in libc++ that have corresponding well-known typedef names. This is a re-commit. The previous commit was reverted because it exposed a pre-existing bug that has since been fixed / worked around; see PR48434. Differential Revision: https://reviews.llvm.org/D91311
2020-11-12 09:12:18 +08:00
OS << ");\n"
<< " }\n";
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
}
OS << " } // end switch\n"
<< " llvm_unreachable(\"Unknown attribute!\");\n"
Correct class-template deprecation behavior-REDUX Correct class-template deprecation behavior Based on the comment in the test, and my reading of the standard, a deprecated warning should be issued in the following case: template<typename T> [[deprecated]] class Foo{}; Foo<int> f; This was not the case, because the ClassTemplateSpecializationDecl creation did not also copy the deprecated attribute. Note: I did NOT audit the complete set of attributes to see WHICH ones should be copied, so instead I simply copy ONLY the deprecated attribute. Previous DiffRev: https://reviews.llvm.org/D27486, was reverted. This patch fixes the issues brought up here by the reverter: https://reviews.llvm.org/rL298410 Differential Revision: https://reviews.llvm.org/D31245 llvm-svn: 298634
2017-03-24 02:51:54 +08:00
<< " return nullptr;\n";
}
// Emits code to instantiate dependent attributes on templates.
void EmitClangAttrTemplateInstantiate(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("Template instantiation code for attributes", OS);
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr");
OS << "namespace clang {\n"
<< "namespace sema {\n\n"
<< "Attr *instantiateTemplateAttribute(const Attr *At, ASTContext &C, "
<< "Sema &S,\n"
<< " const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/false);
OS << "}\n\n"
<< "Attr *instantiateTemplateAttributeForDecl(const Attr *At,\n"
<< " ASTContext &C, Sema &S,\n"
<< " const MultiLevelTemplateArgumentList &TemplateArgs) {\n";
EmitClangAttrTemplateInstantiateHelper(Attrs, OS, /*AppliesToDecl*/true);
OS << "}\n\n"
Move instantiateTemplateAttribute into the sema namespace, make helpers static. llvm-svn: 149864
2012-02-06 19:13:08 +08:00
<< "} // end namespace sema\n"
<< "} // end namespace clang\n";
Instantiate dependent attributes when instantiating templates. llvm-svn: 148592
2012-01-21 06:37:06 +08:00
}
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
// Emits the list of parsed attributes.
void EmitClangAttrParsedAttrList(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("List of all attributes that Clang recognizes", OS);
OS << "#ifndef PARSED_ATTR\n";
OS << "#define PARSED_ATTR(NAME) NAME\n";
OS << "#endif\n\n";
[OpenMP][Part 2] Use reusable OpenMP context/traits handling This patch implements an almost complete handling of OpenMP contexts/traits such that we can reuse most of the logic in Flang through the OMPContext.{h,cpp} in llvm/Frontend/OpenMP. All but construct SIMD specifiers, e.g., inbranch, and the device ISA selector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From these definitions we generate the enum classes `TraitSet`, `TraitSelector`, and `TraitProperty` as well as conversion and helper functions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`. The above enum classes are used in the parser, sema, and the AST attribute. The latter is not a collection of multiple primitive variant arguments that contain encodings via numbers and strings but instead a tree that mirrors the `match` clause (see `struct OpenMPTraitInfo`). The changes to the parser make it more forgiving when wrong syntax is read and they also resulted in more specialized diagnostics. The tests are updated and the core issues are detected as before. Here and elsewhere this patch tries to be generic, thus we do not distinguish what selector set, selector, or property is parsed except if they do behave exceptionally, as for example `user={condition(EXPR)}` does. The sema logic changed in two ways: First, the OMPDeclareVariantAttr representation changed, as mentioned above, and the sema was adjusted to work with the new `OpenMPTraitInfo`. Second, the matching and scoring logic moved into `OMPContext.{h,cpp}`. It is implemented on a flat representation of the `match` clause that is not tied to clang. `OpenMPTraitInfo` provides a method to generate this flat structure (see `struct VariantMatchInfo`) by computing integer score values and boolean user conditions from the `clang::Expr` we keep for them. The OpenMP context is now an explicit object (see `struct OMPContext`). This is in anticipation of construct traits that need to be tracked. The OpenMP context, as well as the `VariantMatchInfo`, are basically made up of a set of active or respectively required traits, e.g., 'host', and an ordered container of constructs which allows duplication. Matching and scoring is kept as generic as possible to allow easy extension in the future. --- Test changes: The messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have been auto generated to match the new warnings and notes of the parser. The "subset" checks were reversed causing the wrong version to be picked. The tests have been adjusted to correct this. We do not print scores if the user did not provide one. We print spaces to make lists in the `match` clause more legible. Reviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim Subscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D71830
2019-12-20 10:42:12 +08:00
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
ParsedAttrMap Names = getParsedAttrList(Records);
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &I : Names) {
OS << "PARSED_ATTR(" << I.first << ")\n";
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
}
}
Automate attribute argument count semantic checking when there are variadic or optional arguments present. With this, the only time you should have to manually check attribute argument counts is when HasCustomParsing is set to true, or when you have variadic arguments that aren't really variadic (like ownership_holds and friends). Updating the diagnostics in the launch_bounds test since they have been improved in that case. Adding a test for nonnull since it has little test coverage, but has truly variadic arguments. llvm-svn: 214407
2014-08-01 00:37:04 +08:00
static bool isArgVariadic(const Record &R, StringRef AttrName) {
return createArgument(R, AttrName)->isVariadic();
}
Replace usage of std::stringstream with raw_string_ostream Typically we don't use the stringstream, so instead use raw_string_stream. Additionally, the dependent function changed to use raw_ostream. llvm-svn: 315950
2017-10-17 06:47:26 +08:00
static void emitArgInfo(const Record &R, raw_ostream &OS) {
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
// This function will count the number of arguments specified for the
// attribute and emit the number of required arguments followed by the
// number of optional arguments.
std::vector<Record *> Args = R.getValueAsListOfDefs("Args");
unsigned ArgCount = 0, OptCount = 0;
Automate attribute argument count semantic checking when there are variadic or optional arguments present. With this, the only time you should have to manually check attribute argument counts is when HasCustomParsing is set to true, or when you have variadic arguments that aren't really variadic (like ownership_holds and friends). Updating the diagnostics in the launch_bounds test since they have been improved in that case. Adding a test for nonnull since it has little test coverage, but has truly variadic arguments. llvm-svn: 214407
2014-08-01 00:37:04 +08:00
bool HasVariadic = false;
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Arg : Args) {
[TableGen] Ignore fake args for parsing-related arg counts. We should complain about the following: ``` void foo() __attribute__((unavailable("a", "b"))); ``` Instead, we currently just ignore "b". (...We also end up ignoring "a", because we assume elsewhere that this attribute can only have 1 or 0 args.) This happens because `unavailable` has a fake enum arg, and `AttributeList::{getMinArgs,getMaxArgs}` include fake args in their counts. llvm-svn: 288388
2016-12-02 01:52:39 +08:00
// If the arg is fake, it's the user's job to supply it: general parsing
// logic shouldn't need to know anything about it.
if (Arg->getValueAsBit("Fake"))
continue;
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
Arg->getValueAsBit("Optional") ? ++OptCount : ++ArgCount;
Automate attribute argument count semantic checking when there are variadic or optional arguments present. With this, the only time you should have to manually check attribute argument counts is when HasCustomParsing is set to true, or when you have variadic arguments that aren't really variadic (like ownership_holds and friends). Updating the diagnostics in the launch_bounds test since they have been improved in that case. Adding a test for nonnull since it has little test coverage, but has truly variadic arguments. llvm-svn: 214407
2014-08-01 00:37:04 +08:00
if (!HasVariadic && isArgVariadic(*Arg, R.getName()))
HasVariadic = true;
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
}
Automate attribute argument count semantic checking when there are variadic or optional arguments present. With this, the only time you should have to manually check attribute argument counts is when HasCustomParsing is set to true, or when you have variadic arguments that aren't really variadic (like ownership_holds and friends). Updating the diagnostics in the launch_bounds test since they have been improved in that case. Adding a test for nonnull since it has little test coverage, but has truly variadic arguments. llvm-svn: 214407
2014-08-01 00:37:04 +08:00
// If there is a variadic argument, we will set the optional argument count
// to its largest value. Since it's currently a 4-bit number, we set it to 15.
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << " NumArgs = " << ArgCount << ";\n";
OS << " OptArgs = " << (HasVariadic ? 15 : OptCount) << ";\n";
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
}
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
static std::string GetDiagnosticSpelling(const Record &R) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string Ret = std::string(R.getValueAsString("DiagSpelling"));
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
if (!Ret.empty())
return Ret;
// If we couldn't find the DiagSpelling in this object, we can check to see
// if the object is one that has a base, and if it is, loop up to the Base
// member recursively.
[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
if (auto Base = R.getValueAsOptionalDef(BaseFieldName))
return GetDiagnosticSpelling(*Base);
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
return "";
}
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
static std::string CalculateDiagnostic(const Record &S) {
// If the SubjectList object has a custom diagnostic associated with it,
// return that directly.
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef CustomDiag = S.getValueAsString("CustomDiag");
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
if (!CustomDiag.empty())
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
return ("\"" + Twine(CustomDiag) + "\"").str();
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
std::vector<std::string> DiagList;
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
std::vector<Record *> Subjects = S.getValueAsListOfDefs("Subjects");
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Subject : Subjects) {
const Record &R = *Subject;
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
// Get the diagnostic text from the Decl or Stmt node given.
std::string V = GetDiagnosticSpelling(R);
if (V.empty()) {
PrintError(R.getLoc(),
"Could not determine diagnostic spelling for the node: " +
R.getName() + "; please add one to DeclNodes.td");
} else {
// The node may contain a list of elements itself, so split the elements
// by a comma, and trim any whitespace.
SmallVector<StringRef, 2> Frags;
llvm::SplitString(V, Frags, ",");
for (auto Str : Frags) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
DiagList.push_back(std::string(Str.trim()));
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
}
}
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
}
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
if (DiagList.empty()) {
PrintFatalError(S.getLoc(),
"Could not deduce diagnostic argument for Attr subjects");
return "";
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
}
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
// FIXME: this is not particularly good for localization purposes and ideally
// should be part of the diagnostics engine itself with some sort of list
// specifier.
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
// A single member of the list can be returned directly.
if (DiagList.size() == 1)
return '"' + DiagList.front() + '"';
if (DiagList.size() == 2)
return '"' + DiagList[0] + " and " + DiagList[1] + '"';
// If there are more than two in the list, we serialize the first N - 1
// elements with a comma. This leaves the string in the state: foo, bar,
// baz (but misses quux). We can then add ", and " for the last element
// manually.
std::string Diag = llvm::join(DiagList.begin(), DiagList.end() - 1, ", ");
return '"' + Diag + ", and " + *(DiagList.end() - 1) + '"';
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
}
Factored some function-like type reasoning out of SemaDeclAttr and onto Decl itself. This allows for more declarative subjects in attribute tablegen where the attribute appertains to something function-like, but not strictly a FunctionDecl. llvm-svn: 199387
2014-01-16 21:55:42 +08:00
static std::string GetSubjectWithSuffix(const Record *R) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
const std::string &B = std::string(R->getName());
Factored some function-like type reasoning out of SemaDeclAttr and onto Decl itself. This allows for more declarative subjects in attribute tablegen where the attribute appertains to something function-like, but not strictly a FunctionDecl. llvm-svn: 199387
2014-01-16 21:55:42 +08:00
if (B == "DeclBase")
return "Decl";
return B + "Decl";
}
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
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
static std::string functionNameForCustomAppertainsTo(const Record &Subject) {
return "is" + Subject.getName().str();
}
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
static void GenerateCustomAppertainsTo(const Record &Subject, raw_ostream &OS) {
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
std::string FnName = functionNameForCustomAppertainsTo(Subject);
Using the proper set key when determining whether a SubsetSubject helper method has been previously generated. llvm-svn: 196103
2013-12-02 22:58:17 +08:00
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
// If this code has already been generated, we don't need to do anything.
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
static std::set<std::string> CustomSubjectSet;
Use range loops and autos in utils/TableGen/ClangAttrEmitter.cpp and generated code. Differential revision: http://reviews.llvm.org/D15313 llvm-svn: 255042
2015-12-09 02:49:01 +08:00
auto I = CustomSubjectSet.find(FnName);
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
if (I != CustomSubjectSet.end())
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
[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
// This only works with non-root Decls.
Record *Base = Subject.getValueAsDef(BaseFieldName);
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
// Not currently support custom subjects within custom subjects.
if (Base->isSubClassOf("SubsetSubject")) {
PrintFatalError(Subject.getLoc(),
"SubsetSubjects within SubsetSubjects is not supported");
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
}
OS << "static bool " << FnName << "(const Decl *D) {\n";
revert r338831 - Fix unused variable warning in tablegen generated code No longer necessary thanks to r338889 (and friends). llvm-svn: 338893
2018-08-03 22:24:34 +08:00
OS << " if (const auto *S = dyn_cast<";
OS << GetSubjectWithSuffix(Base);
OS << ">(D))\n";
OS << " return " << Subject.getValueAsString("CheckCode") << ";\n";
Fixing a warning that causes the sanitizer build disliked about mixing && and ||. Since this is generated code, the && has been removed from the expression entirely. llvm-svn: 199392
2014-01-16 22:32:03 +08:00
OS << " return false;\n";
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
OS << "}\n\n";
CustomSubjectSet.insert(FnName);
}
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
static void GenerateAppertainsTo(const Record &Attr, raw_ostream &OS) {
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
// If the attribute does not contain a Subjects definition, then use the
// default appertainsTo logic.
if (Attr.isValueUnset("Subjects"))
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
const Record *SubjectObj = Attr.getValueAsDef("Subjects");
std::vector<Record*> Subjects = SubjectObj->getValueAsListOfDefs("Subjects");
// If the list of subjects is empty, it is assumed that the attribute
// appertains to everything.
if (Subjects.empty())
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
bool Warn = SubjectObj->getValueAsDef("Diag")->getValueAsBit("Warn");
// Otherwise, generate an appertainsTo check specific to this attribute which
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
// checks all of the given subjects against the Decl passed in.
[P0936R0] add [[clang::lifetimebound]] attribute This patch adds support for a new attribute, [[clang::lifetimebound]], that indicates that the lifetime of a function result is related to one of the function arguments. When walking an initializer to make sure that the lifetime of the initial value is at least as long as the lifetime of the initialized object, we step through parameters (including the implicit object parameter of a non-static member function) that are marked with this attribute. There's nowhere to write an attribute on the implicit object parameter, so in lieu of that, it may be applied to a function type (where it appears immediately after the cv-qualifiers and ref-qualifier, which is as close to a declaration of the implicit object parameter as we have). I'm currently modeling this in the AST as the attribute appertaining to the function type. Differential Revision: https://reviews.llvm.org/D49922 llvm-svn: 338464
2018-08-01 08:33:25 +08:00
//
// If D is null, that means the attribute was not applied to a declaration
// at all (for instance because it was applied to a type), or that the caller
// has determined that the check should fail (perhaps prior to the creation
// of the declaration).
[clang] Add 'override' to virtual function overrides generated by ClangAttrEmitter ClangAttrEmitter.cpp generates ParsedAttr derived classes with virtual overrides in them (which end up in AttrParsedAttrImpl.inc); this patch ensures these generated functions are marked override, and not (redundantly) virtual. I hesitate to say NFC since this does of course affect the behavior of the generator code, but the generated code behaves the same as it did before, so it's NFC in that sense. Differential Revision: https://reviews.llvm.org/D83616
2020-07-15 00:36:43 +08:00
OS << "bool diagAppertainsToDecl(Sema &S, ";
OS << "const ParsedAttr &Attr, const Decl *D) const override {\n";
The generated code does not need to check for a null Decl; NFC. It is already assumed to be nonnull by the code calling diagAppertainsToDecl.
2020-03-22 03:46:40 +08:00
OS << " if (";
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
// If the subject has custom code associated with it, use the generated
// function for it. The function cannot be inlined into this check (yet)
// because it requires the subject to be of a specific type, and were that
// information inlined here, it would not support an attribute with multiple
// custom subjects.
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
if ((*I)->isSubClassOf("SubsetSubject")) {
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << "!" << functionNameForCustomAppertainsTo(**I) << "(D)";
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
} else {
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << "!isa<" << GetSubjectWithSuffix(*I) << ">(D)";
Enables support for custom subject lists for attributes. As a testbed, uses the custom subject for the ibaction attribute. llvm-svn: 195960
2013-11-29 22:57:58 +08:00
}
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
if (I + 1 != E)
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << " && ";
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
}
The generated code does not need to check for a null Decl; NFC. It is already assumed to be nonnull by the code calling diagAppertainsToDecl.
2020-03-22 03:46:40 +08:00
OS << ") {\n";
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << " S.Diag(Attr.getLoc(), diag::";
OS << (Warn ? "warn_attribute_wrong_decl_type_str" :
Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the "attribute only applies to" diagnostic needs to be generated manually as part of semantic processing. This also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc). Many of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute). llvm-svn: 319002
2017-11-27 04:01:12 +08:00
"err_attribute_wrong_decl_type_str");
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << ")\n";
OS << " << Attr << ";
OS << CalculateDiagnostic(*SubjectObj) << ";\n";
OS << " return false;\n";
OS << " }\n";
OS << " return true;\n";
OS << "}\n\n";
Laying the basic groundwork for table generating the diagnostics for attribute subjects. This makes some modifications to the way subjects are listed in Attr.td, and updates the attr emitter to handle the new constructs. I have disabled some attribute subject lines on purpose in Attr.td; this part is a WIP with the goal being to restore those subjects incrementally. By commenting them out, it leaves the original behavior the same as before for those attributes and so those are not functionality changes. llvm-svn: 195841
2013-11-27 21:27:02 +08:00
}
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
static void
emitAttributeMatchRules(PragmaClangAttributeSupport &PragmaAttributeSupport,
raw_ostream &OS) {
OS << "static bool checkAttributeMatchRuleAppliesTo(const Decl *D, "
<< AttributeSubjectMatchRule::EnumName << " rule) {\n";
OS << " switch (rule) {\n";
for (const auto &Rule : PragmaAttributeSupport.Rules) {
if (Rule.isAbstractRule()) {
OS << " case " << Rule.getEnumValue() << ":\n";
OS << " assert(false && \"Abstract matcher rule isn't allowed\");\n";
OS << " return false;\n";
continue;
}
std::vector<Record *> Subjects = Rule.getSubjects();
assert(!Subjects.empty() && "Missing subjects");
OS << " case " << Rule.getEnumValue() << ":\n";
OS << " return ";
for (auto I = Subjects.begin(), E = Subjects.end(); I != E; ++I) {
// If the subject has custom code associated with it, use the function
// that was generated for GenerateAppertainsTo to check if the declaration
// is valid.
if ((*I)->isSubClassOf("SubsetSubject"))
OS << functionNameForCustomAppertainsTo(**I) << "(D)";
else
OS << "isa<" << GetSubjectWithSuffix(*I) << ">(D)";
if (I + 1 != E)
OS << " || ";
}
OS << ";\n";
}
OS << " }\n";
OS << " llvm_unreachable(\"Invalid match rule\");\nreturn false;\n";
OS << "}\n\n";
}
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
static void GenerateLangOptRequirements(const Record &R,
raw_ostream &OS) {
Automate attribute language option checking by specifying the list of options to test in tablegen. llvm-svn: 196138
2013-12-03 03:30:36 +08:00
// If the attribute has an empty or unset list of language requirements,
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
// use the default handler.
Automate attribute language option checking by specifying the list of options to test in tablegen. llvm-svn: 196138
2013-12-03 03:30:36 +08:00
std::vector<Record *> LangOpts = R.getValueAsListOfDefs("LangOpts");
if (LangOpts.empty())
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
[clang] Add 'override' to virtual function overrides generated by ClangAttrEmitter ClangAttrEmitter.cpp generates ParsedAttr derived classes with virtual overrides in them (which end up in AttrParsedAttrImpl.inc); this patch ensures these generated functions are marked override, and not (redundantly) virtual. I hesitate to say NFC since this does of course affect the behavior of the generator code, but the generated code behaves the same as it did before, so it's NFC in that sense. Differential Revision: https://reviews.llvm.org/D83616
2020-07-15 00:36:43 +08:00
OS << "bool diagLangOpts(Sema &S, const ParsedAttr &Attr) ";
OS << "const override {\n";
Add the `objc_class_stub` attribute. Swift requires certain classes to be not just initialized lazily on first use, but actually allocated lazily using information that is only available at runtime. This is incompatible with ObjC class initialization, or at least not efficiently compatible, because there is no meaningful class symbol that can be put in a class-ref variable at load time. This leaves ObjC code unable to access such classes, which is undesirable. objc_class_stub says that class references should be resolved by calling a new ObjC runtime function with a pointer to a new "class stub" structure. Non-ObjC compilers (like Swift) can simply emit this structure when ObjC interop is required for a class that cannot be statically allocated, then apply this attribute to the `@interface` in the generated ObjC header for the class. This attribute can be thought of as a generalization of the existing `objc_runtime_visible` attribute which permits more efficient class resolution as well as supporting the additon of categories to the class. Subclassing these classes from ObjC is currently not allowed. Patch by Slava Pestov! llvm-svn: 362054
2019-05-30 12:09:01 +08:00
OS << " auto &LangOpts = S.LangOpts;\n";
OS << " if (" << GenerateTestExpression(LangOpts) << ")\n";
Automate attribute language option checking by specifying the list of options to test in tablegen. llvm-svn: 196138
2013-12-03 03:30:36 +08:00
OS << " return true;\n\n";
OS << " S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) ";
[NFCI]Create CommonAttributeInfo Type as base type of *Attr and ParsedAttr. In order to enable future improvements to our attribute diagnostics, this moves info from ParsedAttr into CommonAttributeInfo, then makes this type the base of the *Attr and ParsedAttr types. Quite a bit of refactoring took place, including removing a bunch of redundant Spelling Index propogation. Differential Revision: https://reviews.llvm.org/D67368 llvm-svn: 371875
2019-09-14 01:39:31 +08:00
OS << "<< Attr;\n";
Automate attribute language option checking by specifying the list of options to test in tablegen. llvm-svn: 196138
2013-12-03 03:30:36 +08:00
OS << " return false;\n";
OS << "}\n\n";
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
}
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
static void GenerateTargetRequirements(const Record &Attr,
const ParsedAttrMap &Dupes,
raw_ostream &OS) {
// If the attribute is not a target specific attribute, use the default
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
// target handler.
if (!Attr.isSubClassOf("TargetSpecificAttr"))
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
// Get the list of architectures to be tested for.
const Record *R = Attr.getValueAsDef("Target");
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
std::vector<StringRef> Arches = R->getValueAsListOfStrings("Arches");
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
// If there are other attributes which share the same parsed attribute kind,
// such as target-specific attributes with a shared spelling, collapse the
// duplicate architectures. This is required because a shared target-specific
[NFC] Rename clang::AttributeList to clang::ParsedAttr Since The type no longer contains the 'next' item anymore, it isn't a list, so rename it to ParsedAttr to be more accurate. llvm-svn: 337005
2018-07-13 23:07:47 +08:00
// attribute has only one ParsedAttr::Kind enumeration value, but it
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
// applies to multiple target architectures. In order for the attribute to be
// considered valid, all of its architectures need to be included.
if (!Attr.isValueUnset("ParseKind")) {
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef APK = Attr.getValueAsString("ParseKind");
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &I : Dupes) {
if (I.first == APK) {
[TableGen] Clang changes to support Record::getValueAsString and getValueAsListOfStrings returning StringRef instead of std::string This is the clang version of D33710. Differential Revision: https://reviews.llvm.org/D33711 llvm-svn: 304326
2017-06-01 03:01:22 +08:00
std::vector<StringRef> DA =
I.second->getValueAsDef("Target")->getValueAsListOfStrings(
"Arches");
Arches.insert(Arches.end(), DA.begin(), DA.end());
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
}
}
}
Refactor TableGen backend for ClangAttrEmitter to avoid duplication. GenerateHasAttrSpellingStringSwitch and GenerateTargetRequirements had duplicated code to check the conditions for target-specific attributes. Refactor the duplicated code into a separate function. NFC. llvm-svn: 242731
2015-07-21 06:57:36 +08:00
std::string FnName = "isTarget";
std::string Test;
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
bool UsesT = GenerateTargetSpecificAttrChecks(R, Arches, Test, &FnName);
Ignore the "novtable" declspec when not using the Microsoft C++ ABI. Clang used to silently ignore __declspec(novtable). It is implemented now, but leaving the vtable uninitialized does not work when using the Itanium ABI, where the class layout for complex class hierarchies is stored in the vtable. It might be possible to honor the novtable attribute in some simple cases and either report an error or ignore it in more complex situations, but it’s not clear if that would be worthwhile. There is also value in having a simple and predictable behavior, so this changes clang to simply ignore novtable when not using the Microsoft C++ ABI. llvm-svn: 242730
2015-07-21 06:57:31 +08:00
[clang] Add 'override' to virtual function overrides generated by ClangAttrEmitter ClangAttrEmitter.cpp generates ParsedAttr derived classes with virtual overrides in them (which end up in AttrParsedAttrImpl.inc); this patch ensures these generated functions are marked override, and not (redundantly) virtual. I hesitate to say NFC since this does of course affect the behavior of the generator code, but the generated code behaves the same as it did before, so it's NFC in that sense. Differential Revision: https://reviews.llvm.org/D83616
2020-07-15 00:36:43 +08:00
OS << "bool existsInTarget(const TargetInfo &Target) const override {\n";
P0840R2: support for [[no_unique_address]] attribute Summary: Add support for the C++2a [[no_unique_address]] attribute for targets using the Itanium C++ ABI. This depends on D63371. Reviewers: rjmccall, aaron.ballman Subscribers: dschuff, aheejin, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D63451 llvm-svn: 363976
2019-06-21 04:44:45 +08:00
if (UsesT)
OS << " const llvm::Triple &T = Target.getTriple(); (void)T;\n";
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
OS << " return " << Test << ";\n";
OS << "}\n\n";
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
}
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
static void GenerateSpellingIndexToSemanticSpelling(const Record &Attr,
raw_ostream &OS) {
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
// If the attribute does not have a semantic form, we can bail out early.
if (!Attr.getValueAsBit("ASTNode"))
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
// If there are zero or one spellings, or all of the spellings share the same
// name, we can also bail out early.
if (Spellings.size() <= 1 || SpellingNamesAreCommon(Spellings))
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
return;
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
// Generate the enumeration we will use for the mapping.
SemanticSpellingMap SemanticToSyntacticMap;
std::string Enum = CreateSemanticSpellings(Spellings, SemanticToSyntacticMap);
TableGen: Adapt to llvm r288612 llvm-svn: 288614
2016-12-04 13:55:09 +08:00
std::string Name = Attr.getName().str() + "AttrSpellingMap";
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
[clang] Add 'override' to virtual function overrides generated by ClangAttrEmitter ClangAttrEmitter.cpp generates ParsedAttr derived classes with virtual overrides in them (which end up in AttrParsedAttrImpl.inc); this patch ensures these generated functions are marked override, and not (redundantly) virtual. I hesitate to say NFC since this does of course affect the behavior of the generator code, but the generated code behaves the same as it did before, so it's NFC in that sense. Differential Revision: https://reviews.llvm.org/D83616
2020-07-15 00:36:43 +08:00
OS << "unsigned spellingIndexToSemanticSpelling(";
OS << "const ParsedAttr &Attr) const override {\n";
Adds a getSemanticSpelling function to semantic attribute subclasses which have a meaningful semantic spelling. Adds a sibling function to parsed attribtues (via AttributeList) for getting the semantic spelling, if one were to exist. This can be used for cleaner code that deals directly with the semantic spellings (such as the MSInheritance attribute). llvm-svn: 200041
2014-01-25 05:32:49 +08:00
OS << Enum;
OS << " unsigned Idx = Attr.getAttributeSpellingListIndex();\n";
WriteSemanticSpellingSwitch("Idx", SemanticToSyntacticMap, OS);
OS << "}\n\n";
}
Add ParsedAttrInfo::handleDeclAttribute This makes it possible for plugin attributes to actually do something, and also removes a lot of boilerplate for simple attributes in SemaDeclAttr.cpp. Differential Revision: https://reviews.llvm.org/D31342
2020-02-28 22:51:30 +08:00
static void GenerateHandleDeclAttribute(const Record &Attr, raw_ostream &OS) {
// Only generate if Attr can be handled simply.
if (!Attr.getValueAsBit("SimpleHandler"))
return;
// Generate a function which just converts from ParsedAttr to the Attr type.
[clang] Add 'override' to virtual function overrides generated by ClangAttrEmitter ClangAttrEmitter.cpp generates ParsedAttr derived classes with virtual overrides in them (which end up in AttrParsedAttrImpl.inc); this patch ensures these generated functions are marked override, and not (redundantly) virtual. I hesitate to say NFC since this does of course affect the behavior of the generator code, but the generated code behaves the same as it did before, so it's NFC in that sense. Differential Revision: https://reviews.llvm.org/D83616
2020-07-15 00:36:43 +08:00
OS << "AttrHandling handleDeclAttribute(Sema &S, Decl *D,";
OS << "const ParsedAttr &Attr) const override {\n";
Add ParsedAttrInfo::handleDeclAttribute This makes it possible for plugin attributes to actually do something, and also removes a lot of boilerplate for simple attributes in SemaDeclAttr.cpp. Differential Revision: https://reviews.llvm.org/D31342
2020-02-28 22:51:30 +08:00
OS << " D->addAttr(::new (S.Context) " << Attr.getName();
OS << "Attr(S.Context, Attr));\n";
OS << " return AttributeApplied;\n";
OS << "}\n\n";
}
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
static bool IsKnownToGCC(const Record &Attr) {
// Look at the spellings for this subject; if there are any spellings which
// claim to be known to GCC, the attribute is known to GCC.
[TableGen] Minor clean-ups. NFC. Primarily: try to use DenseSet<StringRef> instead of std::set<std::string>, and use pretty range algos where we can. Small sizes were arbitrarily chosen. llvm-svn: 288297
2016-12-01 08:13:18 +08:00
return llvm::any_of(
GetFlattenedSpellings(Attr),
[](const FlattenedSpelling &S) { return S.knownToGCC(); });
Remove some hard-coded specialness for thread-safety attributes from the parser, and made it more declarative. If an attribute is allowed to appear on a function definition when late parsed, it can now use the FunctionDefinition attribute subject. It's treated as a FunctionDecl for most purposes, except it also gets exposed on the AttributeList so that it can be used while parsing. llvm-svn: 199676
2014-01-21 01:18:35 +08:00
}
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
/// Emits the parsed attribute helpers
void EmitClangAttrParsedAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("Parsed attribute helpers", OS);
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
PragmaClangAttributeSupport &PragmaAttributeSupport =
getPragmaAttributeSupport(Records);
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
// Get the list of parsed attributes, and accept the optional list of
// duplicates due to the ParseKind.
ParsedAttrMap Dupes;
ParsedAttrMap Attrs = getParsedAttrList(Records, &Dupes);
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
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
// Generate all of the custom appertainsTo functions that the attributes
// will be using.
for (auto I : Attrs) {
const Record &Attr = *I.second;
if (Attr.isValueUnset("Subjects"))
continue;
const Record *SubjectObj = Attr.getValueAsDef("Subjects");
for (auto Subject : SubjectObj->getValueAsListOfDefs("Subjects"))
if (Subject->isSubClassOf("SubsetSubject"))
GenerateCustomAppertainsTo(*Subject, OS);
}
// Generate a ParsedAttrInfo struct for each of the attributes.
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
// TODO: If the attribute's kind appears in the list of duplicates, that is
// because it is a target-specific attribute that appears multiple times.
// It would be beneficial to test whether the duplicates are "similar
// enough" to each other to not cause problems. For instance, check that
Fix comment typos llvm-svn: 199563
2014-01-19 05:49:37 +08:00
// the spellings are identical, and custom parsing rules match, etc.
Removing the notion of TargetAttributesSema and replacing it with one where the parsed attributes are responsible for knowing their target-specific nature, instead of letting Sema figure it out. This is necessary so that __has_attribute can eventually determine whether a parsed attribute applies to the given target or not. llvm-svn: 198896
2014-01-10 06:48:32 +08:00
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
// We need to generate struct instances based off ParsedAttrInfo from
[NFC] Rename clang::AttributeList to clang::ParsedAttr Since The type no longer contains the 'next' item anymore, it isn't a list, so rename it to ParsedAttr to be more accurate. llvm-svn: 337005
2018-07-13 23:07:47 +08:00
// ParsedAttr.cpp.
Add an attribute registry so plugins can add attributes When constructing a ParsedAttr the ParsedAttrInfo gets looked up in the AttrInfoMap, which is auto-generated using tablegen. If that lookup fails then we look through the ParsedAttrInfos that plugins have added to the registry and check if any has a spelling that matches. Differential Revision: https://reviews.llvm.org/D31338
2020-02-07 22:21:13 +08:00
const std::string &AttrName = I->first;
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
const Record &Attr = *I->second;
Const-initialize ParsedAttrInfos Gets rid of a 150k static initializer (Release clang)
2020-03-29 01:12:28 +08:00
auto Spellings = GetFlattenedSpellings(Attr);
if (!Spellings.empty()) {
OS << "static constexpr ParsedAttrInfo::Spelling " << I->first
<< "Spellings[] = {\n";
for (const auto &S : Spellings) {
const std::string &RawSpelling = S.name();
std::string Spelling;
if (!S.nameSpace().empty())
Spelling += S.nameSpace() + "::";
if (S.variety() == "GNU")
Spelling += NormalizeGNUAttrSpelling(RawSpelling);
else
Spelling += RawSpelling;
OS << " {AttributeCommonInfo::AS_" << S.variety();
OS << ", \"" << Spelling << "\"},\n";
}
OS << "};\n";
}
OS << "struct ParsedAttrInfo" << I->first
<< " final : public ParsedAttrInfo {\n";
Remove constexpr that MSVC doesn't like
2020-03-29 02:21:56 +08:00
OS << " ParsedAttrInfo" << I->first << "() {\n";
Add an attribute registry so plugins can add attributes When constructing a ParsedAttr the ParsedAttrInfo gets looked up in the AttrInfoMap, which is auto-generated using tablegen. If that lookup fails then we look through the ParsedAttrInfos that plugins have added to the registry and check if any has a spelling that matches. Differential Revision: https://reviews.llvm.org/D31338
2020-02-07 22:21:13 +08:00
OS << " AttrKind = ParsedAttr::AT_" << AttrName << ";\n";
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
emitArgInfo(Attr, OS);
OS << " HasCustomParsing = ";
OS << Attr.getValueAsBit("HasCustomParsing") << ";\n";
OS << " IsTargetSpecific = ";
OS << Attr.isSubClassOf("TargetSpecificAttr") << ";\n";
OS << " IsType = ";
OS << (Attr.isSubClassOf("TypeAttr") ||
Attr.isSubClassOf("DeclOrTypeAttr")) << ";\n";
OS << " IsStmt = ";
[Clang] Make nomerge attribute a function attribute as well as a statement attribute. Differential Revision: https://reviews.llvm.org/D92800
2020-12-08 08:37:14 +08:00
OS << (Attr.isSubClassOf("StmtAttr") || Attr.isSubClassOf("DeclOrStmtAttr"))
<< ";\n";
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << " IsKnownToGCC = ";
OS << IsKnownToGCC(Attr) << ";\n";
OS << " IsSupportedByPragmaAttribute = ";
OS << PragmaAttributeSupport.isAttributedSupported(*I->second) << ";\n";
Const-initialize ParsedAttrInfos Gets rid of a 150k static initializer (Release clang)
2020-03-29 01:12:28 +08:00
if (!Spellings.empty())
OS << " Spellings = " << I->first << "Spellings;\n";
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << " }\n";
GenerateAppertainsTo(Attr, OS);
GenerateLangOptRequirements(Attr, OS);
GenerateTargetRequirements(Attr, Dupes, OS);
GenerateSpellingIndexToSemanticSpelling(Attr, OS);
PragmaAttributeSupport.generateStrictConformsTo(*I->second, OS);
Add ParsedAttrInfo::handleDeclAttribute This makes it possible for plugin attributes to actually do something, and also removes a lot of boilerplate for simple attributes in SemaDeclAttr.cpp. Differential Revision: https://reviews.llvm.org/D31342
2020-02-28 22:51:30 +08:00
GenerateHandleDeclAttribute(Attr, OS);
Use virtual functions in ParsedAttrInfo instead of function pointers This doesn't do anything on its own, but it's the first step towards allowing plugins to define attributes. It does simplify the ParsedAttrInfo generation in ClangAttrEmitter a little though. Differential Revision: https://reviews.llvm.org/D31337
2020-02-27 00:31:24 +08:00
OS << "static const ParsedAttrInfo" << I->first << " Instance;\n";
OS << "};\n";
OS << "const ParsedAttrInfo" << I->first << " ParsedAttrInfo" << I->first
<< "::Instance;\n";
}
OS << "static const ParsedAttrInfo *AttrInfoMap[] = {\n";
for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
OS << "&ParsedAttrInfo" << I->first << "::Instance,\n";
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
}
OS << "};\n\n";
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
// Generate the attribute match rules.
emitAttributeMatchRules(PragmaAttributeSupport, OS);
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
}
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
// Emits the kind list of parsed attributes
void EmitClangAttrParsedAttrKinds(RecordKeeper &Records, raw_ostream &OS) {
TableGen backends: use emitSourceFileHeader() to emit the warning about file contents being autogenerated llvm-svn: 173979
2013-01-31 05:54:20 +08:00
emitSourceFileHeader("Attribute name matcher", OS);
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
Add plumbing for new attribute type "Microsoft". This is for attributes in []-delimited lists preceding a class, like e.g. `[uuid("...")] class Foo {};` Not used by anything yet, so no behavior change. Part of https://reviews.llvm.org/D23895 llvm-svn: 280575
2016-09-03 10:55:10 +08:00
std::vector<StringMatcher::StringPair> GNU, Declspec, Microsoft, CXX11,
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
Keywords, Pragma, C2x;
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
std::set<std::string> Seen;
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *A : Attrs) {
const Record &Attr = *A;
Remove 'DistinctSpellings' support from Attr.td and change its only user to look at the attribute spelling instead. The 'ownership_*' attributes should probably be split into separate *Attr classes, but that's more than I wanted to do here. llvm-svn: 195805
2013-11-27 09:46:48 +08:00
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
bool SemaHandler = Attr.getValueAsBit("SemaHandler");
Introduce the notion of 'ignored' attributes, so that all attributes we accept are not modeled somehow via Attr.td. llvm-svn: 155998
2012-05-03 00:18:45 +08:00
bool Ignored = Attr.getValueAsBit("Ignored");
if (SemaHandler || Ignored) {
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
// Attribute spellings can be shared between target-specific attributes,
// and can be shared between syntaxes for the same attribute. For
// instance, an attribute can be spelled GNU<"interrupt"> for an ARM-
// specific attribute, or MSP430-specific attribute. Additionally, an
// attribute can be spelled GNU<"dllexport"> and Declspec<"dllexport">
// for the same semantic attribute. Ultimately, we need to map each of
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
// these to a single AttributeCommonInfo::Kind value, but the
// StringMatcher class cannot handle duplicate match strings. So we
// generate a list of string to match based on the syntax, and emit
// multiple string matchers depending on the syntax used.
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
std::string AttrName;
if (Attr.isSubClassOf("TargetSpecificAttr") &&
!Attr.isValueUnset("ParseKind")) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
AttrName = std::string(Attr.getValueAsString("ParseKind"));
Allow target-specific attributes to share a spelling between different attributes via the ParseKind field. Attributes will be given a common parsed attribute identifier (the AttributeList::AT_* enum), but retain distinct Attr subclasses. This new functionality is used to implement the ARM and MSP430 interrupt attribute. Patch reviewed by Richard Smith over IRC. llvm-svn: 197343
2013-12-15 21:05:48 +08:00
if (Seen.find(AttrName) != Seen.end())
continue;
Seen.insert(AttrName);
} else
AttrName = NormalizeAttrName(StringRef(Attr.getName())).str();
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attr);
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &S : Spellings) {
Turn copies into references as suggested by clang-tidy's performance-unnecessary-copy-initialization. llvm-svn: 270994
2016-05-27 21:36:58 +08:00
const std::string &RawSpelling = S.name();
[C++11] Use 'nullptr'. llvm-svn: 208163
2014-05-07 14:21:57 +08:00
std::vector<StringMatcher::StringPair> *Matches = nullptr;
Turn copies into references as suggested by clang-tidy's performance-unnecessary-copy-initialization. llvm-svn: 270994
2016-05-27 21:36:58 +08:00
std::string Spelling;
const std::string &Variety = S.variety();
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
if (Variety == "CXX11") {
Matches = &CXX11;
Don't normalise CXX11/C2X attribute names to start with :: Currently square-bracket-style (CXX11/C2X) attribute names are normalised to start with :: if they don't have a namespace. This is a bit odd, as such names are rejected when parsing, so don't do this. Differential Revision: https://reviews.llvm.org/D76704
2020-03-25 18:53:30 +08:00
if (!S.nameSpace().empty())
Spelling += S.nameSpace() + "::";
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
} else if (Variety == "C2x") {
Matches = &C2x;
Don't normalise CXX11/C2X attribute names to start with :: Currently square-bracket-style (CXX11/C2X) attribute names are normalised to start with :: if they don't have a namespace. This is a bit odd, as such names are rejected when parsing, so don't do this. Differential Revision: https://reviews.llvm.org/D76704
2020-03-25 18:53:30 +08:00
if (!S.nameSpace().empty())
Spelling += S.nameSpace() + "::";
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
} else if (Variety == "GNU")
Matches = &GNU;
else if (Variety == "Declspec")
Matches = &Declspec;
Add plumbing for new attribute type "Microsoft". This is for attributes in []-delimited lists preceding a class, like e.g. `[uuid("...")] class Foo {};` Not used by anything yet, so no behavior change. Part of https://reviews.llvm.org/D23895 llvm-svn: 280575
2016-09-03 10:55:10 +08:00
else if (Variety == "Microsoft")
Matches = &Microsoft;
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
else if (Variety == "Keyword")
Matches = &Keywords;
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
else if (Variety == "Pragma")
Matches = &Pragma;
Handle C++11 attribute namespaces automatically. Now, as long as the 'Namespaces' variable is correct inside Attr.td, the generated code will correctly admit a C++11 attribute only when it has the appropriate namespace(s). llvm-svn: 158661
2012-06-19 00:13:52 +08:00
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
assert(Matches && "Unsupported spelling variety found");
[TableGen] Only normalize the spelling of GNU-style attributes. Summary: When Sema looks up an attribute name, it strips off leading and trailing "__" if the attribute is GNU-style. That is, __attribute__((foo)) and __attribute__((__foo__)) are equivalent. This is only true for GNU-style attributes. In particular, __declspec(__foo__) is not equivalent to __declspec(foo), and Sema respects this difference. This patch fixes TableGen to match Sema's behavior. The spelling 'GNU<"__foo__">' should be normalized to 'GNU<"foo">', but 'Declspec<"__foo__">' should not be changed. This is necessary to make CUDA compilation work on Windows, because e.g. the __device__ attribute is spelled __declspec(__device__). Attr.td does not contain any Declspec spellings that start or end with "__", so this change should not affect any other attributes. Reviewers: rnk Subscribers: cfe-commits, tra Differential Revision: https://reviews.llvm.org/D28318 llvm-svn: 291129
2017-01-06 00:51:54 +08:00
if (Variety == "GNU")
Spelling += NormalizeGNUAttrSpelling(RawSpelling);
else
Spelling += RawSpelling;
Introduce the notion of 'ignored' attributes, so that all attributes we accept are not modeled somehow via Attr.td. llvm-svn: 155998
2012-05-03 00:18:45 +08:00
if (SemaHandler)
[NFC] Rename clang::AttributeList to clang::ParsedAttr Since The type no longer contains the 'next' item anymore, it isn't a list, so rename it to ParsedAttr to be more accurate. llvm-svn: 337005
2018-07-13 23:07:47 +08:00
Matches->push_back(StringMatcher::StringPair(
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
Spelling, "return AttributeCommonInfo::AT_" + AttrName + ";"));
Introduce the notion of 'ignored' attributes, so that all attributes we accept are not modeled somehow via Attr.td. llvm-svn: 155998
2012-05-03 00:18:45 +08:00
else
[NFC] Rename clang::AttributeList to clang::ParsedAttr Since The type no longer contains the 'next' item anymore, it isn't a list, so rename it to ParsedAttr to be more accurate. llvm-svn: 337005
2018-07-13 23:07:47 +08:00
Matches->push_back(StringMatcher::StringPair(
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
Spelling, "return AttributeCommonInfo::IgnoredAttribute;"));
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
}
}
}
[NFC] Rename clang::AttributeList to clang::ParsedAttr Since The type no longer contains the 'next' item anymore, it isn't a list, so rename it to ParsedAttr to be more accurate. llvm-svn: 337005
2018-07-13 23:07:47 +08:00
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << "static AttributeCommonInfo::Kind getAttrKind(StringRef Name, ";
OS << "AttributeCommonInfo::Syntax Syntax) {\n";
OS << " if (AttributeCommonInfo::AS_GNU == Syntax) {\n";
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
StringMatcher("Name", GNU, OS).Emit();
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << " } else if (AttributeCommonInfo::AS_Declspec == Syntax) {\n";
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
StringMatcher("Name", Declspec, OS).Emit();
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << " } else if (AttributeCommonInfo::AS_Microsoft == Syntax) {\n";
Add plumbing for new attribute type "Microsoft". This is for attributes in []-delimited lists preceding a class, like e.g. `[uuid("...")] class Foo {};` Not used by anything yet, so no behavior change. Part of https://reviews.llvm.org/D23895 llvm-svn: 280575
2016-09-03 10:55:10 +08:00
StringMatcher("Name", Microsoft, OS).Emit();
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << " } else if (AttributeCommonInfo::AS_CXX11 == Syntax) {\n";
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
StringMatcher("Name", CXX11, OS).Emit();
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << " } else if (AttributeCommonInfo::AS_C2x == Syntax) {\n";
Add -f[no-]double-square-bracket-attributes as new driver options to control use of [[]] attributes in all language modes. This is the initial implementation of WG14 N2165, which is a proposal to add [[]] attributes to C2x, but also allows you to enable these attributes in C++98, or disable them in C++11 or later. llvm-svn: 315856
2017-10-15 23:01:42 +08:00
StringMatcher("Name", C2x, OS).Emit();
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << " } else if (AttributeCommonInfo::AS_Keyword == Syntax || ";
OS << "AttributeCommonInfo::AS_ContextSensitiveKeyword == Syntax) {\n";
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
StringMatcher("Name", Keywords, OS).Emit();
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << " } else if (AttributeCommonInfo::AS_Pragma == Syntax) {\n";
Adds a Pragma spelling for attributes to tablegen and makes use of it for loop hint attributes. Includes tests for pragma printing and for attribute order which is incorrectly reversed by ParsedAttributes. Reviewed by Aaron Ballman llvm-svn: 210925
2014-06-14 01:57:25 +08:00
StringMatcher("Name", Pragma, OS).Emit();
When determining the attribute's parsed kind, pay attention to the syntax used. This fixes bugs where an attribute has differing GNU and Declspec spellings, but they are treated as the same. Eg) __declspec(aligned) when it should be __attribute__((aligned)), and __attribute__((align)) when it should be __declspec(align). llvm-svn: 199144
2014-01-14 05:42:39 +08:00
OS << " }\n";
Move some definitions from Sema to Basic to fix shared libs build r371875 moved some functionality around to a Basic header file, but didn't move its definitions as well. This patch moves some things around so that shared library building can work. llvm-svn: 371985
2019-09-16 21:58:59 +08:00
OS << " return AttributeCommonInfo::UnknownAttribute;\n"
Replace the StringSwitch in AttributeList::getKind() with a TableGen-generated StringMatcher, for a 1.2% speedup in -fparse-only time in <rdar://problem/11004361>. Thanks to Benjamin for pointing me at StringMatcher! llvm-svn: 156003
2012-05-03 01:33:51 +08:00
<< "}\n";
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
}
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
// Emits the code to dump an attribute.
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
void EmitClangAttrTextNodeDump(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("Attribute text node dumper", OS);
TableGen backends: use emitSourceFileHeader() to emit the warning about file contents being autogenerated llvm-svn: 173979
2013-01-31 05:54:20 +08:00
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
std::vector<Record*> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
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
if (!R.getValueAsBit("ASTNode"))
continue;
If an attribute has a semantically meaningful spelling (such as ArgumentWithTypeTagAttr or MSInheritanceAttr), display the spelling used for the attribute as part of the AST dump. This should ease debugging the AST for these attributes. Attributes without semantically meaningful spelling variations are not affected. llvm-svn: 199834
2014-01-23 05:51:20 +08:00
// If the attribute has a semantically-meaningful name (which is determined
// by whether there is a Spelling enumeration for it), then write out the
// spelling used for the attribute.
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
std::string FunctionContent;
llvm::raw_string_ostream SS(FunctionContent);
Add a new attribute meta-spelling called "GCC" -- it widens into being a GNU spelling, and a CXX11 spelling with the namespace "gnu". It also sets a bit on the spelling certifying that it is known to GCC. From this, we can warn about the extension appropriately. As a consequence, the FunctionDefinition functionality is completely removed. Replacing the functionality from r199676, which didn't solve the problem as elegantly. llvm-svn: 200252
2014-01-28 06:10:04 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(R);
If an attribute has a semantically meaningful spelling (such as ArgumentWithTypeTagAttr or MSInheritanceAttr), display the spelling used for the attribute as part of the AST dump. This should ease debugging the AST for these attributes. Attributes without semantically meaningful spelling variations are not affected. llvm-svn: 199834
2014-01-23 05:51:20 +08:00
if (Spellings.size() > 1 && !SpellingNamesAreCommon(Spellings))
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
SS << " OS << \" \" << A->getSpelling();\n";
If an attribute has a semantically meaningful spelling (such as ArgumentWithTypeTagAttr or MSInheritanceAttr), display the spelling used for the attribute as part of the AST dump. This should ease debugging the AST for these attributes. Attributes without semantically meaningful spelling variations are not affected. llvm-svn: 199834
2014-01-23 05:51:20 +08:00
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
Args = R.getValueAsListOfDefs("Args");
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
for (const auto *Arg : Args)
createArgument(*Arg, R.getName())->writeDump(SS);
if (SS.tell()) {
OS << " void Visit" << R.getName() << "Attr(const " << R.getName()
<< "Attr *A) {\n";
if (!Args.empty())
OS << " const auto *SA = cast<" << R.getName()
<< "Attr>(A); (void)SA;\n";
OS << SS.str();
OS << " }\n";
}
}
}
void EmitClangAttrNodeTraverse(RecordKeeper &Records, raw_ostream &OS) {
emitSourceFileHeader("Attribute text node traverser", OS);
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr"), Args;
for (const auto *Attr : Attrs) {
const Record &R = *Attr;
if (!R.getValueAsBit("ASTNode"))
continue;
Add indents to AST dumping and removed parenthesis from AST nodes. Indents were given the color blue when outputting with color. AST dumping now looks like this: Node |-Node | `-Node `-Node `-Node Compared to the previous: (Node (Node (Node)) (Node (Node))) llvm-svn: 174022
2013-01-31 09:44:26 +08:00
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
std::string FunctionContent;
llvm::raw_string_ostream SS(FunctionContent);
Args = R.getValueAsListOfDefs("Args");
for (const auto *Arg : Args)
createArgument(*Arg, R.getName())->writeDumpChildren(SS);
if (SS.tell()) {
OS << " void Visit" << R.getName() << "Attr(const " << R.getName()
<< "Attr *A) {\n";
if (!Args.empty())
OS << " const auto *SA = cast<" << R.getName()
<< "Attr>(A); (void)SA;\n";
OS << SS.str();
OS << " }\n";
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
}
}
}
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
void EmitClangAttrParserStringSwitches(RecordKeeper &Records,
raw_ostream &OS) {
emitSourceFileHeader("Parser-related llvm::StringSwitch cases", OS);
emitClangAttrArgContextList(Records, OS);
emitClangAttrIdentifierArgList(Records, OS);
Implement cpu_dispatch/cpu_specific Multiversioning As documented here: https://software.intel.com/en-us/node/682969 and https://software.intel.com/en-us/node/523346. cpu_dispatch multiversioning is an ICC feature that provides for function multiversioning. This feature is implemented with two attributes: First, cpu_specific, which specifies the individual function versions. Second, cpu_dispatch, which specifies the location of the resolver function and the list of resolvable functions. This is valuable since it provides a mechanism where the resolver's TU can be specified in one location, and the individual implementions each in their own translation units. The goal of this patch is to be source-compatible with ICC, so this implementation diverges from the ICC implementation in a few ways: 1- Linux x86/64 only: This implementation uses ifuncs in order to properly dispatch functions. This is is a valuable performance benefit over the ICC implementation. A future patch will be provided to enable this feature on Windows, but it will obviously more closely fit ICC's implementation. 2- CPU Identification functions: ICC uses a set of custom functions to identify the feature list of the host processor. This patch uses the cpu_supports functionality in order to better align with 'target' multiversioning. 1- cpu_dispatch function def/decl: ICC's cpu_dispatch requires that the function marked cpu_dispatch be an empty definition. This patch supports that as well, however declarations are also permitted, since the linker will solve the issue of multiple emissions. Differential Revision: https://reviews.llvm.org/D47474 llvm-svn: 337552
2018-07-20 22:13:28 +08:00
emitClangAttrVariadicIdentifierArgList(Records, OS);
Emit !callback metadata and introduce the callback attribute With commit r351627, LLVM gained the ability to apply (existing) IPO optimizations on indirections through callbacks, or transitive calls. The general idea is that we use an abstraction to hide the middle man and represent the callback call in the context of the initial caller. It is described in more detail in the commit message of the LLVM patch r351627, the llvm::AbstractCallSite class description, and the language reference section on callback-metadata. This commit enables clang to emit !callback metadata that is understood by LLVM. It does so in three different cases: 1) For known broker functions declarations that are directly generated, e.g., __kmpc_fork_call for the OpenMP pragma parallel. 2) For known broker functions that are identified by their name and source location through the builtin detection, e.g., pthread_create from the POSIX thread API. 3) For user annotated functions that carry the "callback(callee, ...)" attribute. The attribute has to include the name, or index, of the callback callee and how the passed arguments can be identified (as many as the callback callee has). See the callback attribute documentation for detailed information. Differential Revision: https://reviews.llvm.org/D55483 llvm-svn: 351629
2019-01-19 13:36:54 +08:00
emitClangAttrThisIsaIdentifierArgList(Records, OS);
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
emitClangAttrTypeArgList(Records, OS);
emitClangAttrLateParsedList(Records, OS);
}
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
void EmitClangAttrSubjectMatchRulesParserStringSwitches(RecordKeeper &Records,
raw_ostream &OS) {
getPragmaAttributeSupport(Records).generateParsingHelpers(OS);
}
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
enum class SpellingKind {
GNU,
CXX11,
C2x,
Declspec,
Microsoft,
Keyword,
Pragma,
};
static const size_t NumSpellingKinds = (size_t)SpellingKind::Pragma + 1;
class SpellingList {
std::vector<std::string> Spellings[NumSpellingKinds];
public:
ArrayRef<std::string> operator[](SpellingKind K) const {
return Spellings[(size_t)K];
}
void add(const Record &Attr, FlattenedSpelling Spelling) {
SpellingKind Kind = StringSwitch<SpellingKind>(Spelling.variety())
.Case("GNU", SpellingKind::GNU)
.Case("CXX11", SpellingKind::CXX11)
.Case("C2x", SpellingKind::C2x)
.Case("Declspec", SpellingKind::Declspec)
.Case("Microsoft", SpellingKind::Microsoft)
.Case("Keyword", SpellingKind::Keyword)
.Case("Pragma", SpellingKind::Pragma);
std::string Name;
if (!Spelling.nameSpace().empty()) {
switch (Kind) {
case SpellingKind::CXX11:
case SpellingKind::C2x:
Name = Spelling.nameSpace() + "::";
break;
case SpellingKind::Pragma:
Name = Spelling.nameSpace() + " ";
break;
default:
PrintFatalError(Attr.getLoc(), "Unexpected namespace in spelling");
}
}
Name += Spelling.name();
Spellings[(size_t)Kind].push_back(Name);
}
};
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
class DocumentationData {
public:
The default assignment operator could not be generated by all of the bots, but it's required by std::vector to operate properly. llvm-svn: 201518
2014-02-18 00:18:32 +08:00
const Record *Documentation;
const Record *Attribute;
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
std::string Heading;
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
SpellingList SupportedSpellings;
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
DocumentationData(const Record &Documentation, const Record &Attribute,
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
std::pair<std::string, SpellingList> HeadingAndSpellings)
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
: Documentation(&Documentation), Attribute(&Attribute),
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
Heading(std::move(HeadingAndSpellings.first)),
SupportedSpellings(std::move(HeadingAndSpellings.second)) {}
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
};
Refactored the way attribute category headers are handled so that it is possible to use custom categories. This allows for moving the consumable attributes (consumable, callable_when, return_typestate, etc) to be grouped together, with a content heading, like they were in the language extensions documentation. Moved the consumable attribute documentation from the language extensions into the attribute documentation table. llvm-svn: 201732
2014-02-20 06:59:32 +08:00
static void WriteCategoryHeader(const Record *DocCategory,
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
raw_ostream &OS) {
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef Name = DocCategory->getValueAsString("Name");
OS << Name << "\n" << std::string(Name.size(), '=') << "\n";
Refactored the way attribute category headers are handled so that it is possible to use custom categories. This allows for moving the consumable attributes (consumable, callable_when, return_typestate, etc) to be grouped together, with a content heading, like they were in the language extensions documentation. Moved the consumable attribute documentation from the language extensions into the attribute documentation table. llvm-svn: 201732
2014-02-20 06:59:32 +08:00
// If there is content, print that as well.
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef ContentStr = DocCategory->getValueAsString("Content");
[tblgen] Use StringRef::trim llvm-svn: 234643
2015-04-11 05:37:21 +08:00
// Trim leading and trailing newlines and spaces.
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
OS << ContentStr.trim();
[tblgen] Use StringRef::trim llvm-svn: 234643
2015-04-11 05:37:21 +08:00
Refactored the way attribute category headers are handled so that it is possible to use custom categories. This allows for moving the consumable attributes (consumable, callable_when, return_typestate, etc) to be grouped together, with a content heading, like they were in the language extensions documentation. Moved the consumable attribute documentation from the language extensions into the attribute documentation table. llvm-svn: 201732
2014-02-20 06:59:32 +08:00
OS << "\n\n";
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
}
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
static std::pair<std::string, SpellingList>
GetAttributeHeadingAndSpellings(const Record &Documentation,
const Record &Attribute) {
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
// FIXME: there is no way to have a per-spelling category for the attribute
// documentation. This may not be a limiting factor since the spellings
// should generally be consistently applied across the category.
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
std::vector<FlattenedSpelling> Spellings = GetFlattenedSpellings(Attribute);
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
if (Spellings.empty())
PrintFatalError(Attribute.getLoc(),
"Attribute has no supported spellings; cannot be "
"documented");
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
// Determine the heading to be used for this attribute.
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string Heading = std::string(Documentation.getValueAsString("Heading"));
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
if (Heading.empty()) {
// If there's only one spelling, we can simply use that.
if (Spellings.size() == 1)
Heading = Spellings.begin()->name();
else {
std::set<std::string> Uniques;
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (auto I = Spellings.begin(), E = Spellings.end();
I != E && Uniques.size() <= 1; ++I) {
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-29 03:23:46 +08:00
std::string Spelling =
std::string(NormalizeNameForSpellingComparison(I->name()));
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
Uniques.insert(Spelling);
}
// If the semantic map has only one spelling, that is sufficient for our
// needs.
if (Uniques.size() == 1)
Heading = *Uniques.begin();
}
}
// If the heading is still empty, it is an error.
if (Heading.empty())
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
PrintFatalError(Attribute.getLoc(),
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
"This attribute requires a heading to be specified");
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
SpellingList SupportedSpellings;
for (const auto &I : Spellings)
SupportedSpellings.add(Attribute, I);
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
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
return std::make_pair(std::move(Heading), std::move(SupportedSpellings));
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
}
static void WriteDocumentation(RecordKeeper &Records,
const DocumentationData &Doc, raw_ostream &OS) {
OS << Doc.Heading << "\n" << std::string(Doc.Heading.length(), '-') << "\n";
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
// List what spelling syntaxes the attribute supports.
OS << ".. csv-table:: Supported Syntaxes\n";
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
OS << " :header: \"GNU\", \"C++11\", \"C2x\", \"``__declspec``\",";
OS << " \"Keyword\", \"``#pragma``\", \"``#pragma clang attribute``\"\n\n";
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
OS << " \"";
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
for (size_t Kind = 0; Kind != NumSpellingKinds; ++Kind) {
SpellingKind K = (SpellingKind)Kind;
Update FIXME as requested in code review. llvm-svn: 341100
2018-08-31 03:19:15 +08:00
// TODO: List Microsoft (IDL-style attribute) spellings once we fully
// support them.
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
if (K == SpellingKind::Microsoft)
continue;
bool PrintedAny = false;
for (StringRef Spelling : Doc.SupportedSpellings[K]) {
if (PrintedAny)
OS << " |br| ";
OS << "``" << Spelling << "``";
PrintedAny = true;
}
OS << "\",\"";
}
if (getPragmaAttributeSupport(Records).isAttributedSupported(
*Doc.Attribute))
OS << "Yes";
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
OS << "\"\n\n";
// If the attribute is deprecated, print a message about it, and possibly
// provide a replacement attribute.
The default assignment operator could not be generated by all of the bots, but it's required by std::vector to operate properly. llvm-svn: 201518
2014-02-18 00:18:32 +08:00
if (!Doc.Documentation->isValueUnset("Deprecated")) {
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
OS << "This attribute has been deprecated, and may be removed in a future "
<< "version of Clang.";
The default assignment operator could not be generated by all of the bots, but it's required by std::vector to operate properly. llvm-svn: 201518
2014-02-18 00:18:32 +08:00
const Record &Deprecated = *Doc.Documentation->getValueAsDef("Deprecated");
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef Replacement = Deprecated.getValueAsString("Replacement");
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
if (!Replacement.empty())
Test commit access: apply clang-format suggestion llvm-svn: 326332
2018-03-01 00:57:33 +08:00
OS << " This attribute has been superseded by ``" << Replacement
<< "``.";
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
OS << "\n\n";
}
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef ContentStr = Doc.Documentation->getValueAsString("Content");
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
// Trim leading and trailing newlines and spaces.
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
OS << ContentStr.trim();
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
OS << "\n\n\n";
}
void EmitClangAttrDocs(RecordKeeper &Records, raw_ostream &OS) {
// Get the documentation introduction paragraph.
const Record *Documentation = Records.getDef("GlobalDocumentation");
if (!Documentation) {
PrintFatalError("The Documentation top-level definition is missing, "
"no documentation will be generated.");
return;
}
Refactored the way attribute category headers are handled so that it is possible to use custom categories. This allows for moving the consumable attributes (consumable, callable_when, return_typestate, etc) to be grouped together, with a content heading, like they were in the language extensions documentation. Moved the consumable attribute documentation from the language extensions into the attribute documentation table. llvm-svn: 201732
2014-02-20 06:59:32 +08:00
OS << Documentation->getValueAsString("Intro") << "\n";
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
// Gather the Documentation lists from each of the attributes, based on the
// category provided.
std::vector<Record *> Attrs = Records.getAllDerivedDefinitions("Attr");
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
std::map<const Record *, std::vector<DocumentationData>> SplitDocs;
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *A : Attrs) {
const Record &Attr = *A;
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
std::vector<Record *> Docs = Attr.getValueAsListOfDefs("Documentation");
Cleaning up some range-based for loops so that the automatic type deduction is more explicit about pointers and const. Did some minor drive-by const correctness fixes and identifier updates as well. No functional changes. llvm-svn: 209233
2014-05-21 03:47:14 +08:00
for (const auto *D : Docs) {
const Record &Doc = *D;
Refactored the way attribute category headers are handled so that it is possible to use custom categories. This allows for moving the consumable attributes (consumable, callable_when, return_typestate, etc) to be grouped together, with a content heading, like they were in the language extensions documentation. Moved the consumable attribute documentation from the language extensions into the attribute documentation table. llvm-svn: 201732
2014-02-20 06:59:32 +08:00
const Record *Category = Doc.getValueAsDef("Category");
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
// If the category is "undocumented", then there cannot be any other
// documentation categories (otherwise, the attribute would become
// documented).
Fix usage in TableGen of getValueAsString Record::getValueAsString returns a stringref to an interned string (apparently had been changed since most of tablegen was written). In this patch, I audited the usage of getValueAsString to find places where we can trivially stop storing 'std::string' and instead keep the stringref. There was one instance where an unnecessary 'stringstream' was being used, so that has been removed as well to unblock the stringref replacing string fix. Differential Revision: https://reviews.llvm.org/D38979 llvm-svn: 315956
2017-10-17 07:25:24 +08:00
const StringRef Cat = Category->getValueAsString("Name");
Refactored the way attribute category headers are handled so that it is possible to use custom categories. This allows for moving the consumable attributes (consumable, callable_when, return_typestate, etc) to be grouped together, with a content heading, like they were in the language extensions documentation. Moved the consumable attribute documentation from the language extensions into the attribute documentation table. llvm-svn: 201732
2014-02-20 06:59:32 +08:00
bool Undocumented = Cat == "Undocumented";
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
if (Undocumented && Docs.size() > 1)
PrintFatalError(Doc.getLoc(),
"Attribute is \"Undocumented\", but has multiple "
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
"documentation categories");
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
if (!Undocumented)
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
SplitDocs[Category].push_back(DocumentationData(
Improve attribute documentation to list which spellings are used in which syntaxes. Summary: Instead of listing all the spellings (including attribute namespaces) in the section heading, only list the actual attribute names there, and list the spellings in the supported syntaxes table. This allows us to properly describe things like [[fallthrough]], for which we allow a clang:: prefix in C++ but not in C, and AlwaysInline, which has one spelling as a GNU attribute and a different spelling as a keyword, without needing to repeat the syntax description in the documentation text. Sample rendering: https://pste.eu/p/T1ZV.html Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D51473 llvm-svn: 341097
2018-08-31 03:16:33 +08:00
Doc, Attr, GetAttributeHeadingAndSpellings(Doc, Attr)));
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
}
}
// Having split the attributes out based on what documentation goes where,
// we can begin to generate sections of documentation.
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
for (auto &I : SplitDocs) {
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
WriteCategoryHeader(I.first, OS);
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
Use the container form llvm::sort(C, ...) There are a few leftovers of rC343147 that are not (\w+)\.begin but in the form of ([-[:alnum:]>.]+)\.begin or spanning two lines. Change them to use the container form in this commit. The 12 occurrences have been inspected manually for safety. llvm-svn: 343425
2018-10-01 05:41:11 +08:00
llvm::sort(I.second,
[clang] Change std::sort to llvm::sort in response to r327219 r327219 added wrappers to std::sort which randomly shuffle the container before sorting. This will help in uncovering non-determinism caused due to undefined sorting order of objects having the same key. To make use of that infrastructure we need to invoke llvm::sort instead of std::sort. llvm-svn: 328636
2018-03-28 00:50:00 +08:00
[](const DocumentationData &D1, const DocumentationData &D2) {
return D1.Heading < D2.Heading;
Use the container form llvm::sort(C, ...) There are a few leftovers of rC343147 that are not (\w+)\.begin but in the form of ([-[:alnum:]>.]+)\.begin or spanning two lines. Change them to use the container form in this commit. The 12 occurrences have been inspected manually for safety. llvm-svn: 343425
2018-10-01 05:41:11 +08:00
});
Sort Attributes by "HeaderName" Attributes in the docs were previously sorted (apparently) by the attribute name, so AnyX86Interrupt ended up being the first one, rather than in a meaningful place. This resulted in the 4 'interrupt' titled sections being all in different places. This replaces it with a naive alphabetical sort (case sensitive, underscore and special characters first, etc). Differential Revision: https://reviews.llvm.org/D38969 llvm-svn: 315931
2017-10-17 04:31:05 +08:00
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
// Walk over each of the attributes in the category and write out their
// documentation.
Simplifying attribute generation with range-based for loops. No functional changes intended. llvm-svn: 202654
2014-03-03 01:38:37 +08:00
for (const auto &Doc : I.second)
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
WriteDocumentation(Records, Doc, OS);
}
}
void EmitTestPragmaAttributeSupportedAttributes(RecordKeeper &Records,
raw_ostream &OS) {
PragmaClangAttributeSupport Support = getPragmaAttributeSupport(Records);
ParsedAttrMap Attrs = getParsedAttrList(Records);
NFC: Make this test kinder on downstream forks Downstream forks that have their own attributes often run into this test failing when a new attribute is added to clang because the number of supported attributes no longer match. This is redundant information for this test, so we can get by without it. rdar://46288577 llvm-svn: 348218
2018-12-04 08:31:31 +08:00
OS << "#pragma clang attribute supports the following attributes:\n";
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
for (const auto &I : Attrs) {
if (!Support.isAttributedSupported(*I.second))
continue;
OS << I.first;
if (I.second->isValueUnset("Subjects")) {
OS << " ()\n";
continue;
}
const Record *SubjectObj = I.second->getValueAsDef("Subjects");
std::vector<Record *> Subjects =
SubjectObj->getValueAsListOfDefs("Subjects");
OS << " (";
for (const auto &Subject : llvm::enumerate(Subjects)) {
if (Subject.index())
OS << ", ";
Add #pragma clang attribute support to the external_source_symbol attribute Prior to this commit the external_source_symbol attribute wasn't supported by #pragma clang attribute for the following two reasons: - The Named attribute subject hasn't been supported by TableGen. - There was no way to specify a subject match rule for #pragma clang attribute that could operate on a set of attribute subjects (e.g. the ones that derive from NamedDecl). This commit fixes the two issues and thus adds external_source_symbol support to #pragma clang attribute. rdar://31169028 Differential Revision: https://reviews.llvm.org/D32176 llvm-svn: 300712
2017-04-19 23:52:11 +08:00
PragmaClangAttributeSupport::RuleOrAggregateRuleSet &RuleSet =
Support.SubjectsToRules.find(Subject.value())->getSecond();
if (RuleSet.isRule()) {
OS << RuleSet.getRule().getEnumValueName();
continue;
}
OS << "(";
for (const auto &Rule : llvm::enumerate(RuleSet.getAggregateRuleSet())) {
if (Rule.index())
OS << ", ";
OS << Rule.value().getEnumValueName();
}
OS << ")";
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
}
OS << ")\n";
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
}
NFC: Make this test kinder on downstream forks Downstream forks that have their own attributes often run into this test failing when a new attribute is added to clang because the number of supported attributes no longer match. This is redundant information for this test, so we can get by without it. rdar://46288577 llvm-svn: 348218
2018-12-04 08:31:31 +08:00
OS << "End of supported attributes.\n";
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
}
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
} // end namespace clang