mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-28 05:56:05 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/clang/lib/AST/TextNodeDumper.cpp

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

3115 lines
87 KiB
C++
Raw Normal View History

NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
//===--- TextNodeDumper.cpp - Printing of AST nodes -----------------------===//
//
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 08:50:56 +00: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
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
//
//===----------------------------------------------------------------------===//
//
// This file implements AST dumping of components of individual AST nodes.
//
//===----------------------------------------------------------------------===//
#include "clang/AST/TextNodeDumper.h"
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
#include "clang/AST/APValue.h"
NFC: Move Decl node handling to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56643 llvm-svn: 351175
2019-01-15 09:35:52 +00:00
#include "clang/AST/DeclFriend.h"
#include "clang/AST/DeclOpenMP.h"
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
#include "clang/AST/DeclTemplate.h"
[ASTDump] NFC: Move Type Visit implementation to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56639 llvm-svn: 351114
2019-01-14 20:11:02 +00:00
#include "clang/AST/LocInfoType.h"
[AST] Fix nested name specifiers printing as NamespaceNamespace (#65266) This happens because we print both the kind of the NNS and the kind of decl (when it refers to one). These are always the same string.
2023-09-05 18:15:06 +02:00
#include "clang/AST/NestedNameSpecifier.h"
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
#include "clang/AST/Type.h"
[AST] Add dump() method to TypeLoc (#65484) The ability to dump AST nodes is important to ad-hoc debugging, and the fact this doesn't work with TypeLoc nodes is an obvious missing feature in e.g. clang-query (`set output dump` simply does nothing). Having TypeLoc::dump(), and enabling DynTypedNode::dump() for such nodes seems like a clear win. It looks like this: ``` int main(int argc, char **argv); FunctionProtoTypeLoc <test.cc:3:1, col:31> 'int (int, char **)' cdecl |-ParmVarDecl 0x30071a8 <col:10, col:14> col:14 argc 'int' | `-BuiltinTypeLoc <col:10> 'int' |-ParmVarDecl 0x3007250 <col:20, col:27> col:27 argv 'char **' | `-PointerTypeLoc <col:20, col:26> 'char **' | `-PointerTypeLoc <col:20, col:25> 'char *' | `-BuiltinTypeLoc <col:20> 'char' `-BuiltinTypeLoc <col:1> 'int' ``` It dumps the lexically nested tree of type locs. This often looks similar to how types are dumped, but unlike types we don't look at desugaring e.g. typedefs, as their underlying types are not lexically spelled here. --- Less clear is exactly when to include these nodes in existing text AST dumps rooted at (TranslationUnit)Decls. These already omit supported nodes sometimes, e.g. NestedNameSpecifiers are often mentioned but not recursively dumped. TypeLocs are a more extreme case: they're ~always more verbose than the current AST dump. So this patch punts on that, TypeLocs are only ever printed recursively as part of a TypeLoc::dump() call. It would also be nice to be able to invoke `clang` to dump a typeloc somehow, like `clang -cc1 -ast-dump`. But I don't know exactly what the best verison of that is, so this patch doesn't do it. --- There are similar (less critical!) nodes: TemplateArgumentLoc etc, these also don't have dump() functions today and are obvious extensions. I suspect that we should add these, and Loc nodes should dump each other (e.g. the ElaboratedTypeLoc `vector<int>::iterator` should dump the NestedNameSpecifierLoc `vector<int>::`, which dumps the TemplateSpecializationTypeLoc `vector<int>::` etc). Maybe this generalizes further to a "full syntactic dump" mode, where even Decls and Stmts would print the TypeLocs they lexically contain. But this may be more complex than useful. --- While here, ConceptReference JSON dumping must be implemented. It's not totally clear to me why this implementation wasn't required before but is now...
2024-01-31 16:40:29 +01:00
#include "clang/AST/TypeLocVisitor.h"
Avoid including Module.h from ExternalASTSource.h Module.h takes 86ms to parse, mostly parsing the class itself. Avoid it if possible. ASTContext.h depends on ExternalASTSource.h. A few NFC changes were needed to make this possible: - Move ASTSourceDescriptor to Module.h. This needs Module to be complete, and seems more related to modules and AST files than external AST sources. - Move "import complete" bit from Module* pointer int pair to NextLocalImport pointer. Required because PointerIntPair<Module*,...> requires Module to be complete, and now it may not be. Reviewed By: aaron.ballman, hans Differential Revision: https://reviews.llvm.org/D75784
2020-02-27 18:13:54 -08:00
#include "clang/Basic/Module.h"
Avoid SourceManager.h include in RawCommentList.h, add missing incs SourceManager.h includes FileManager.h, which is expensive due to dependencies on LLVM FS headers. Remove dead BeforeThanCompare specialization. Sink ASTContext::addComment to cpp file. This reduces the time to compile a file that does nothing but include ASTContext.h from ~3.4s to ~2.8s for me. Saves these includes: 219 - ../clang/include/clang/Basic/SourceManager.h 204 - ../clang/include/clang/Basic/FileSystemOptions.h 204 - ../clang/include/clang/Basic/FileManager.h 165 - ../llvm/include/llvm/Support/VirtualFileSystem.h 164 - ../llvm/include/llvm/Support/SourceMgr.h 164 - ../llvm/include/llvm/Support/SMLoc.h 161 - ../llvm/include/llvm/Support/Path.h 141 - ../llvm/include/llvm/ADT/BitVector.h 128 - ../llvm/include/llvm/Support/MemoryBuffer.h 124 - ../llvm/include/llvm/Support/FileSystem.h 124 - ../llvm/include/llvm/Support/Chrono.h 124 - .../MSVCSTL/include/stack 122 - ../llvm/include/llvm-c/Types.h 122 - ../llvm/include/llvm/Support/NativeFormatting.h 122 - ../llvm/include/llvm/Support/FormatProviders.h 122 - ../llvm/include/llvm/Support/CBindingWrapping.h 122 - .../MSVCSTL/include/xtimec.h 122 - .../MSVCSTL/include/ratio 122 - .../MSVCSTL/include/chrono 121 - ../llvm/include/llvm/Support/FormatVariadicDetails.h 118 - ../llvm/include/llvm/Support/MD5.h 109 - .../MSVCSTL/include/deque 105 - ../llvm/include/llvm/Support/Host.h 105 - ../llvm/include/llvm/Support/Endian.h Reviewed By: aaron.ballman, hans Differential Revision: https://reviews.llvm.org/D75279
2020-02-27 11:01:58 -08:00
#include "clang/Basic/SourceManager.h"
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-27 18:17:07 +02:00
#include "clang/Basic/Specifiers.h"
[clang][NFC] Generate the {Type,ArrayType,UnaryExprOrType,Expression}Traits... ...enumerations from TokenKinds.def and use the new macros from TokenKinds.def to remove the hard-coded lists of traits. All the information needed to generate these enumerations is already present in TokenKinds.def. The motivation here is to be able to dump the trait spelling without hard-coding the list in yet another place. Note that this change the order of the enumerators in the enumerations (except that in the TypeTrait enumeration all unary type traits are before all binary type traits, and all binary type traits are before all n-ary type traits). Apart from the aforementioned ordering which is relied upon, after this patch no code in clang or in the various clang tools depend on the specific ordering of the enumerators. No functional changes intended. Differential Revision: https://reviews.llvm.org/D81455 Reviewed By: aaron.ballman
2020-06-11 14:08:27 +01:00
#include "clang/Basic/TypeTraits.h"
[ADT] Remove APInt/APSInt toString() std::string variants <string> is currently the highest impact header in a clang+llvm build: https://commondatastorage.googleapis.com/chromium-browser-clang/llvm-include-analysis.html One of the most common places this is being included is the APInt.h header, which needs it for an old toString() implementation that returns std::string - an inefficient method compared to the SmallString versions that it actually wraps. This patch replaces these APInt/APSInt methods with a pair of llvm::toString() helpers inside StringExtras.h, adjusts users accordingly and removes the <string> from APInt.h - I was hoping that more of these users could be converted to use the SmallString methods, but it appears that most end up creating a std::string anyhow. I avoided trying to use the raw_ostream << operators as well as I didn't want to lose having the integer radix explicit in the code. Differential Revision: https://reviews.llvm.org/D103888
2021-06-11 13:19:00 +01:00
#include "llvm/ADT/StringExtras.h"
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
#include <algorithm>
#include <utility>
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
using namespace clang;
NFC: Move Decl node handling to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56643 llvm-svn: 351175
2019-01-15 09:35:52 +00:00
static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
template <typename T>
static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
const T *First = D->getFirstDecl();
if (First != D)
OS << " first " << First;
}
template <typename T>
static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
const T *Prev = D->getPreviousDecl();
if (Prev)
OS << " prev " << Prev;
}
/// Dump the previous declaration in the redeclaration chain for a declaration,
/// if any.
static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
switch (D->getKind()) {
#define DECL(DERIVED, BASE) \
case Decl::DERIVED: \
return dumpPreviousDeclImpl(OS, cast<DERIVED##Decl>(D));
#define ABSTRACT_DECL(DECL)
#include "clang/AST/DeclNodes.inc"
}
llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
}
[clang][NFC] Store a pointer to the ASTContext in ASTDumper and TextNodeDumper In general there is no way to get to the ASTContext from most AST nodes (Decls are one of the exception). This will be a problem when implementing the rest of APValue::dump since we need the ASTContext to dump some kinds of APValues. The ASTContext* in ASTDumper and TextNodeDumper is not always non-null. This is because we still want to be able to use the various dump() functions in a debugger. No functional changes intended. Reverted in fcf4d5e4499a391dff42ea1a096f146db44147b6 since a few dump() functions in lldb where missed.
2020-07-03 13:54:10 +01:00
TextNodeDumper::TextNodeDumper(raw_ostream &OS, const ASTContext &Context,
bool ShowColors)
: TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors),
Context(&Context), SM(&Context.getSourceManager()),
PrintPolicy(Context.getPrintingPolicy()),
Traits(&Context.getCommentCommandTraits()) {}
TextNodeDumper::TextNodeDumper(raw_ostream &OS, bool ShowColors)
: TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors) {}
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
void TextNodeDumper::Visit(const comments::Comment *C,
const comments::FullComment *FC) {
if (!C) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>>";
return;
}
{
ColorScope Color(OS, ShowColors, CommentColor);
OS << C->getCommentKindName();
}
dumpPointer(C);
dumpSourceRange(C->getSourceRange());
ConstCommentVisitor<TextNodeDumper, void,
const comments::FullComment *>::visit(C, FC);
}
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00: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-11 19:16:01 +00:00
void TextNodeDumper::Visit(const Attr *A) {
{
ColorScope Color(OS, ShowColors, AttrColor);
switch (A->getKind()) {
#define ATTR(X) \
case attr::X: \
OS << #X; \
break;
#include "clang/Basic/AttrList.inc"
}
OS << "Attr";
}
dumpPointer(A);
dumpSourceRange(A->getRange());
if (A->isInherited())
OS << " Inherited";
if (A->isImplicit())
OS << " Implicit";
ConstAttrVisitor<TextNodeDumper>::Visit(A);
}
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
const Decl *From, StringRef Label) {
OS << "TemplateArgument";
if (R.isValid())
dumpSourceRange(R);
NFC: Fix nits I missed before llvm-svn: 351112
2019-01-14 19:50:34 +00:00
if (From)
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
dumpDeclRef(From, Label);
ConstTemplateArgumentVisitor<TextNodeDumper>::Visit(TA);
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
void TextNodeDumper::Visit(const Stmt *Node) {
if (!Node) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>>";
return;
}
{
ColorScope Color(OS, ShowColors, StmtColor);
OS << Node->getStmtClassName();
}
dumpPointer(Node);
dumpSourceRange(Node->getSourceRange());
if (const auto *E = dyn_cast<Expr>(Node)) {
dumpType(E->getType());
[AST] Add a flag indicating if any subexpression had errors The only subexpression that is considered an error now is TypoExpr, but we plan to add expressions with errors to improve editor tooling on broken code. We intend to use the same mechanism to guard against spurious diagnostics on those as well. See the follow-up revision for an actual usage of the flag. Original patch from Ilya. Reviewers: sammccall Reviewed By: sammccall Tags: #clang Differential Revision: https://reviews.llvm.org/D65591
2020-03-17 10:36:19 +01:00
if (E->containsErrors()) {
ColorScope Color(OS, ShowColors, ErrorsColor);
OS << " contains-errors";
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
{
ColorScope Color(OS, ShowColors, ValueKindColor);
switch (E->getValueKind()) {
[clang] NFC: Rename rvalue to prvalue This renames the expression value categories from rvalue to prvalue, keeping nomenclature consistent with C++11 onwards. C++ has the most complicated taxonomy here, and every other language only uses a subset of it, so it's less confusing to use the C++ names consistently, and mentally remap to the C names when working on that context (prvalue -> rvalue, no xvalues, etc). Renames: * VK_RValue -> VK_PRValue * Expr::isRValue -> Expr::isPRValue * SK_QualificationConversionRValue -> SK_QualificationConversionPRValue * JSON AST Dumper Expression nodes value category: "rvalue" -> "prvalue" Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Reviewed By: rsmith Differential Revision: https://reviews.llvm.org/D103720
2021-06-04 23:15:23 +02:00
case VK_PRValue:
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
break;
case VK_LValue:
OS << " lvalue";
break;
case VK_XValue:
OS << " xvalue";
break;
}
}
{
ColorScope Color(OS, ShowColors, ObjectKindColor);
switch (E->getObjectKind()) {
case OK_Ordinary:
break;
case OK_BitField:
OS << " bitfield";
break;
case OK_ObjCProperty:
OS << " objcproperty";
break;
case OK_ObjCSubscript:
OS << " objcsubscript";
break;
case OK_VectorComponent:
OS << " vectorcomponent";
break;
[Matrix] Implement matrix index expressions ([][]). This patch implements matrix index expressions (matrix[RowIdx][ColumnIdx]). It does so by introducing a new MatrixSubscriptExpr(Base, RowIdx, ColumnIdx). MatrixSubscriptExprs are built in 2 steps in ActOnMatrixSubscriptExpr. First, if the base of a subscript is of matrix type, we create a incomplete MatrixSubscriptExpr(base, idx, nullptr). Second, if the base is an incomplete MatrixSubscriptExpr, we create a complete MatrixSubscriptExpr(base->getBase(), base->getRowIdx(), idx) Similar to vector elements, it is not possible to take the address of a MatrixSubscriptExpr. For CodeGen, a new MatrixElt type is added to LValue, which is very similar to VectorElt. The only difference is that we may need to cast the type of the base from an array to a vector type when accessing it. Reviewers: rjmccall, anemet, Bigcheese, rsmith, martong Reviewed By: rjmccall Differential Revision: https://reviews.llvm.org/D76791
2020-06-01 19:42:03 +01:00
case OK_MatrixComponent:
OS << " matrixcomponent";
break;
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
}
}
ConstStmtVisitor<TextNodeDumper>::Visit(Node);
}
[ASTDump] NFC: Move Type Visit implementation to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56639 llvm-svn: 351114
2019-01-14 20:11:02 +00:00
void TextNodeDumper::Visit(const Type *T) {
if (!T) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>>";
return;
}
if (isa<LocInfoType>(T)) {
{
ColorScope Color(OS, ShowColors, TypeColor);
OS << "LocInfo Type";
}
dumpPointer(T);
return;
}
{
ColorScope Color(OS, ShowColors, TypeColor);
OS << T->getTypeClassName() << "Type";
}
dumpPointer(T);
OS << " ";
dumpBareType(QualType(T, 0), false);
QualType SingleStepDesugar =
T->getLocallyUnqualifiedSingleStepDesugaredType();
if (SingleStepDesugar != QualType(T, 0))
OS << " sugar";
[AST] Dump containsErrors bit for the Type. Reviewers: sammccall Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D81912
2020-06-16 09:08:02 +02:00
if (T->containsErrors()) {
ColorScope Color(OS, ShowColors, ErrorsColor);
OS << " contains-errors";
}
[ASTDump] NFC: Move Type Visit implementation to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56639 llvm-svn: 351114
2019-01-14 20:11:02 +00:00
if (T->isDependentType())
OS << " dependent";
else if (T->isInstantiationDependentType())
OS << " instantiation_dependent";
if (T->isVariablyModifiedType())
OS << " variably_modified";
if (T->containsUnexpandedParameterPack())
OS << " contains_unexpanded_pack";
if (T->isFromAST())
OS << " imported";
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
TypeVisitor<TextNodeDumper>::Visit(T);
[ASTDump] NFC: Move Type Visit implementation to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56639 llvm-svn: 351114
2019-01-14 20:11:02 +00:00
}
[ASTDump] NFC: Move dumping of QualType node to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56641 llvm-svn: 351116
2019-01-14 20:15:29 +00:00
void TextNodeDumper::Visit(QualType T) {
OS << "QualType";
dumpPointer(T.getAsOpaquePtr());
OS << " ";
dumpBareType(T, false);
OS << " " << T.split().Quals.getAsString();
}
[AST] Add dump() method to TypeLoc (#65484) The ability to dump AST nodes is important to ad-hoc debugging, and the fact this doesn't work with TypeLoc nodes is an obvious missing feature in e.g. clang-query (`set output dump` simply does nothing). Having TypeLoc::dump(), and enabling DynTypedNode::dump() for such nodes seems like a clear win. It looks like this: ``` int main(int argc, char **argv); FunctionProtoTypeLoc <test.cc:3:1, col:31> 'int (int, char **)' cdecl |-ParmVarDecl 0x30071a8 <col:10, col:14> col:14 argc 'int' | `-BuiltinTypeLoc <col:10> 'int' |-ParmVarDecl 0x3007250 <col:20, col:27> col:27 argv 'char **' | `-PointerTypeLoc <col:20, col:26> 'char **' | `-PointerTypeLoc <col:20, col:25> 'char *' | `-BuiltinTypeLoc <col:20> 'char' `-BuiltinTypeLoc <col:1> 'int' ``` It dumps the lexically nested tree of type locs. This often looks similar to how types are dumped, but unlike types we don't look at desugaring e.g. typedefs, as their underlying types are not lexically spelled here. --- Less clear is exactly when to include these nodes in existing text AST dumps rooted at (TranslationUnit)Decls. These already omit supported nodes sometimes, e.g. NestedNameSpecifiers are often mentioned but not recursively dumped. TypeLocs are a more extreme case: they're ~always more verbose than the current AST dump. So this patch punts on that, TypeLocs are only ever printed recursively as part of a TypeLoc::dump() call. It would also be nice to be able to invoke `clang` to dump a typeloc somehow, like `clang -cc1 -ast-dump`. But I don't know exactly what the best verison of that is, so this patch doesn't do it. --- There are similar (less critical!) nodes: TemplateArgumentLoc etc, these also don't have dump() functions today and are obvious extensions. I suspect that we should add these, and Loc nodes should dump each other (e.g. the ElaboratedTypeLoc `vector<int>::iterator` should dump the NestedNameSpecifierLoc `vector<int>::`, which dumps the TemplateSpecializationTypeLoc `vector<int>::` etc). Maybe this generalizes further to a "full syntactic dump" mode, where even Decls and Stmts would print the TypeLocs they lexically contain. But this may be more complex than useful. --- While here, ConceptReference JSON dumping must be implemented. It's not totally clear to me why this implementation wasn't required before but is now...
2024-01-31 16:40:29 +01:00
void TextNodeDumper::Visit(TypeLoc TL) {
if (!TL) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>>";
return;
}
{
ColorScope Color(OS, ShowColors, TypeColor);
OS << (TL.getTypeLocClass() == TypeLoc::Qualified
? "Qualified"
: TL.getType()->getTypeClassName())
<< "TypeLoc";
}
dumpSourceRange(TL.getSourceRange());
OS << ' ';
dumpBareType(TL.getType(), /*Desugar=*/false);
TypeLocVisitor<TextNodeDumper>::Visit(TL);
}
NFC: Move Decl node handling to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56643 llvm-svn: 351175
2019-01-15 09:35:52 +00:00
void TextNodeDumper::Visit(const Decl *D) {
if (!D) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>>";
return;
}
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << D->getDeclKindName() << "Decl";
}
dumpPointer(D);
if (D->getLexicalDeclContext() != D->getDeclContext())
OS << " parent " << cast<Decl>(D->getDeclContext());
dumpPreviousDecl(OS, D);
dumpSourceRange(D->getSourceRange());
OS << ' ';
dumpLocation(D->getLocation());
if (D->isFromASTFile())
OS << " imported";
if (Module *M = D->getOwningModule())
OS << " in " << M->getFullModuleName();
if (auto *ND = dyn_cast<NamedDecl>(D))
for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
const_cast<NamedDecl *>(ND)))
AddChild([=] { OS << "also in " << M->getFullModuleName(); });
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
[clang] Rename Decl::isHidden() to isUnconditionallyVisible(). Also invert the sense of the return value. As pointed out by the FIXME that this change resolves, isHidden() wasn't a very accurate name for this function. I haven't yet changed any of the strings that are output in ASTDumper.cpp / JSONNodeDumper.cpp / TextNodeDumper.cpp in response to whether isHidden() is set because a) I'm not sure whether it's actually desired to change these strings (would appreciate feedback on this), and b) In any case, I'd like to get this pure rename out of the way first, without any changes to tests. Changing the strings that are output in the various ...Dumper.cpp files will require changes to quite a few tests, and I'd like to make those in a separate change. Differential Revision: https://reviews.llvm.org/D81392 Reviewed By: rsmith
2020-06-08 15:37:44 +02:00
if (!ND->isUnconditionallyVisible())
NFC: Move Decl node handling to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56643 llvm-svn: 351175
2019-01-15 09:35:52 +00:00
OS << " hidden";
if (D->isImplicit())
OS << " implicit";
if (D->isUsed())
OS << " used";
else if (D->isThisDeclarationReferenced())
OS << " referenced";
if (D->isInvalidDecl())
OS << " invalid";
[C++20] add Basic consteval specifier Summary: this revision adds Lexing, Parsing and Basic Semantic for the consteval specifier as specified by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1073r3.html with this patch, the consteval specifier is treated as constexpr but can only be applied to function declaration. Changes: - add the consteval keyword. - add parsing of consteval specifier for normal declarations and lambdas expressions. - add the whether a declaration is constexpr is now represented by and enum everywhere except for variable because they can't be consteval. - adapt diagnostic about constexpr to print constexpr or consteval depending on the case. - add tests for basic semantic. Reviewers: rsmith, martong, shafik Reviewed By: rsmith Subscribers: eraman, efriedma, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61790 llvm-svn: 363362
2019-06-14 08:56:20 +00:00
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
if (FD->isConstexprSpecified())
NFC: Move Decl node handling to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56643 llvm-svn: 351175
2019-01-15 09:35:52 +00:00
OS << " constexpr";
[C++20] add Basic consteval specifier Summary: this revision adds Lexing, Parsing and Basic Semantic for the consteval specifier as specified by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1073r3.html with this patch, the consteval specifier is treated as constexpr but can only be applied to function declaration. Changes: - add the consteval keyword. - add parsing of consteval specifier for normal declarations and lambdas expressions. - add the whether a declaration is constexpr is now represented by and enum everywhere except for variable because they can't be consteval. - adapt diagnostic about constexpr to print constexpr or consteval depending on the case. - add tests for basic semantic. Reviewers: rsmith, martong, shafik Reviewed By: rsmith Subscribers: eraman, efriedma, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61790 llvm-svn: 363362
2019-06-14 08:56:20 +00:00
if (FD->isConsteval())
OS << " consteval";
[clang] Implement P2564 "consteval must propagate up" Reviewed By: aaron.ballman, #clang-language-wg Differential Revision: https://reviews.llvm.org/D151094
2023-05-08 12:18:43 +02:00
else if (FD->isImmediateFunction())
OS << " immediate";
[clang] Produce a "multiversion" annotation in textual AST output. This change adds a "multiversion" annotation to textual AST output. For example: FunctionDecl 0xb6628b0 <t.c:1:1, col:13> col:5 multiversion foo 'int (void)' Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D121961
2022-03-02 14:10:33 -08:00
if (FD->isMultiVersion())
OS << " multiversion";
[C++20] add Basic consteval specifier Summary: this revision adds Lexing, Parsing and Basic Semantic for the consteval specifier as specified by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1073r3.html with this patch, the consteval specifier is treated as constexpr but can only be applied to function declaration. Changes: - add the consteval keyword. - add parsing of consteval specifier for normal declarations and lambdas expressions. - add the whether a declaration is constexpr is now represented by and enum everywhere except for variable because they can't be consteval. - adapt diagnostic about constexpr to print constexpr or consteval depending on the case. - add tests for basic semantic. Reviewers: rsmith, martong, shafik Reviewed By: rsmith Subscribers: eraman, efriedma, rnkovacs, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D61790 llvm-svn: 363362
2019-06-14 08:56:20 +00:00
}
Move decl context dumping to TextNodeDumper Summary: Only an obscure case is moved. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56829 llvm-svn: 351637
2019-01-19 09:05:55 +00:00
if (!isa<FunctionDecl>(*D)) {
const auto *MD = dyn_cast<ObjCMethodDecl>(D);
if (!MD || !MD->isThisDeclarationADefinition()) {
const auto *DC = dyn_cast<DeclContext>(D);
if (DC && DC->hasExternalLexicalStorage()) {
ColorScope Color(OS, ShowColors, UndeserializedColor);
OS << " <undeserialized declarations>";
}
}
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
[clang][AST] TextNodeDumper learned to output friend information for functions Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D158188
2023-08-17 22:18:21 +00:00
switch (D->getFriendObjectKind()) {
case Decl::FOK_None:
break;
case Decl::FOK_Declared:
OS << " friend";
break;
case Decl::FOK_Undeclared:
OS << " friend_undeclared";
break;
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
ConstDeclVisitor<TextNodeDumper>::Visit(D);
NFC: Move Decl node handling to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56643 llvm-svn: 351175
2019-01-15 09:35:52 +00:00
}
Implement CXXCtorInitializer dump in terms of Visitor Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56707 llvm-svn: 351235
2019-01-15 20:17:33 +00:00
void TextNodeDumper::Visit(const CXXCtorInitializer *Init) {
OS << "CXXCtorInitializer";
if (Init->isAnyMemberInitializer()) {
OS << ' ';
dumpBareDeclRef(Init->getAnyMember());
} else if (Init->isBaseInitializer()) {
dumpType(QualType(Init->getBaseClass(), 0));
} else if (Init->isDelegatingInitializer()) {
dumpType(Init->getTypeSourceInfo()->getType());
} else {
llvm_unreachable("Unknown initializer type");
}
}
Implement BlockDecl::Capture dump in terms of visitors Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56709 llvm-svn: 351239
2019-01-15 20:41:37 +00:00
void TextNodeDumper::Visit(const BlockDecl::Capture &C) {
OS << "capture";
if (C.isByRef())
OS << " byref";
if (C.isNested())
OS << " nested";
if (C.getVariable()) {
OS << ' ';
dumpBareDeclRef(C.getVariable());
}
}
NFC: Implement OMPClause dump in terms of visitors Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56708 llvm-svn: 351236
2019-01-15 20:31:31 +00:00
void TextNodeDumper::Visit(const OMPClause *C) {
if (!C) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>> OMPClause";
return;
}
{
ColorScope Color(OS, ShowColors, AttrColor);
[OpenMP][NFCI] Move OpenMP clause information to `lib/Frontend/OpenMP` This is a cleanup and normalization patch that also enables reuse with Flang later on. A follow up will clean up and move the directive -> clauses mapping. Reviewed By: fghanim Differential Revision: https://reviews.llvm.org/D77112
2020-03-30 19:58:40 -05:00
StringRef ClauseName(llvm::omp::getOpenMPClauseName(C->getClauseKind()));
NFC: Implement OMPClause dump in terms of visitors Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56708 llvm-svn: 351236
2019-01-15 20:31:31 +00:00
OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
<< ClauseName.drop_front() << "Clause";
}
dumpPointer(C);
dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
if (C->isImplicit())
OS << " <implicit>";
}
[OpenACC] Implement 'tile' attribute AST (#110999) The 'tile' clause shares quite a bit of the rules with 'collapse', so a followup patch will add those tests/behaviors. This patch deals with adding the AST node. The 'tile' clause takes a series of integer constant expressions, or *. The asterisk is now represented by a new OpenACCAsteriskSizeExpr node, else this clause is very similar to others.
2024-10-03 08:34:43 -07:00
void TextNodeDumper::VisitOpenACCAsteriskSizeExpr(
const OpenACCAsteriskSizeExpr *E) {
// Nothing to do here, only location exists, and that is printed elsewhere.
}
[OpenACC][NFC] Add OpenACC Clause AST Nodes/infrastructure (#87675) As a first step in adding clause support for OpenACC to Semantic Analysis, this patch adds the 'base' AST nodes required for clauses. This patch has no functional effect at the moment, but followup patches will add the semantic analysis of clauses (plus individual clauses).
2024-04-05 10:06:44 -07:00
void TextNodeDumper::Visit(const OpenACCClause *C) {
if (!C) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>> OpenACCClause";
return;
}
{
ColorScope Color(OS, ShowColors, AttrColor);
OS << C->getClauseKind();
[OpenACC] Implement Default clause for Compute Constructs (#88135) As a followup to my previous commits, this is an implementation of a single clause, in this case the 'default' clause. This implements all semantic analysis for it on compute clauses, and continues to leave it rejected for all others (some as 'doesnt appertain', others as 'not implemented' as appropriate). This also implements and tests the TreeTransform as requested in the previous patch.
2024-04-10 07:10:24 -07:00
// Handle clauses with parens for types that have no children, likely
// because there is no sub expression.
switch (C->getClauseKind()) {
case OpenACCClauseKind::Default:
OS << '(' << cast<OpenACCDefaultClause>(C)->getDefaultClauseKind() << ')';
break;
[OpenACC] Implement 'async' clause sema for compute constructs This is a pretty simple clause, it takes an 'async-argument', which effectively needs to be just parsed as an 'int' argument, since it can be an arbitrarly integer at runtime (and negative values are legal for implementation defined values). This patch also cleans up the async-argument parsing, so 'wait' got some minor quality-of-life improvements for parsing (both clause and construct).
2024-05-06 12:02:15 -07:00
case OpenACCClauseKind::Async:
[OpenACC] Implement auto/seq/independent clause Sema for 'loop' These three clauses are all quite trivial, as they take no parameters. They are mutually exclusive, and 'seq' has some other exclusives that are implemented here. The ONE thing that isn't implemented is 2.9's restriction (line 2010): 'A loop associated with a 'loop' construct that does not have a 'seq' clause must be written to meet all the following conditions'. Future clauses will require similar work, so it'll be done as a followup.
2024-05-31 07:57:24 -07:00
case OpenACCClauseKind::Auto:
[OpenACC] Implement 'deviceptr' and 'attach' sema for compute constructs These two are very similar to the other 'var-list' variants, except they require that the type of the variable be a pointer. This patch implements that restriction.
2024-05-03 08:54:06 -07:00
case OpenACCClauseKind::Attach:
[OpenACC] Implement copy clause for compute constructs. Like present, no_create, and first_private, copy is a clause that takes just a var-list, and follows the same rules as the others. The one unique part of this clause is that it ALSO supports two deprecated/backwards-compatibility spellings, so this patch adds them and implements them.
2024-05-02 10:49:14 -07:00
case OpenACCClauseKind::Copy:
case OpenACCClauseKind::PCopy:
case OpenACCClauseKind::PresentOrCopy:
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
case OpenACCClauseKind::Host:
[OpenACC] Implement 'if' clause for Compute Constructs (#88411) Like with the 'default' clause, this is being applied to only Compute Constructs for now. The 'if' clause takes a condition expression which is used as a runtime value. This is not a particularly complex semantic implementation, as there isn't much to this clause, other than its interactions with 'self', which will be managed in the patch to implement that.
2024-04-12 14:13:31 -07:00
case OpenACCClauseKind::If:
[OpenACC] Implement 'if_present' clause sema The 'if_present' clause controls the replacement of addresses in the var-list in current device memory. This clause can only go on 'host_device'. From a Sema perspective, there isn't anything to do beyond add this to AST and pass it on.
2024-12-13 10:55:34 -08:00
case OpenACCClauseKind::IfPresent:
[OpenACC] Implement auto/seq/independent clause Sema for 'loop' These three clauses are all quite trivial, as they take no parameters. They are mutually exclusive, and 'seq' has some other exclusives that are implemented here. The ONE thing that isn't implemented is 2.9's restriction (line 2010): 'A loop associated with a 'loop' construct that does not have a 'seq' clause must be written to meet all the following conditions'. Future clauses will require similar work, so it'll be done as a followup.
2024-05-31 07:57:24 -07:00
case OpenACCClauseKind::Independent:
[OpenACC] implement 'detach' clause sema This is another new clause specific to 'exit data' that takes a pointer argument. This patch implements this the same way we do a few other clauses (like attach) that have the same restrictions.
2024-12-13 13:49:02 -08:00
case OpenACCClauseKind::Detach:
[OpenACC] Implement 'delete' AST/Sema for 'exit data' construct 'delete' is another clause that has very little compile-time implication, but needs a full AST that takes a var list. This patch ipmlements it fully, plus adds sufficient test coverage.
2024-12-16 06:27:59 -08:00
case OpenACCClauseKind::Delete:
[OpenACC] Implement 'device' and 'host' clauses for 'update' These two clauses just take a 'var-list' and specify where the variables should be copied from/to. This patch implements the AST nodes for them and ensures they properly take a var-list.
2025-01-09 07:15:05 -08:00
case OpenACCClauseKind::Device:
[OpenACC] Implement 'device_num' clause sema for 'init'/'shutdown' This is a very simple sema implementation, and just required AST node plus the existing diagnostics. This patch adds tests and adds the AST node required, plus enables it for 'init' and 'shutdown' (only!)
2024-12-19 09:41:07 -08:00
case OpenACCClauseKind::DeviceNum:
[OpenACC] Implement 'default_async' sema A fairly simple one, only valid on the 'set' construct, this clause takes an int expression. Most of the work was already done as a part of parsing, so this patch ends up being a lot of infrastructure.
2025-01-06 10:31:30 -08:00
case OpenACCClauseKind::DefaultAsync:
[OpenACC] Implement 'declare' construct AST/Sema The 'declare' construct is the first of two 'declaration' level constructs, so it is legal in any place a declaration is, including as a statement, which this accomplishes by wrapping it in a DeclStmt. All clauses on this have a 'same scope' requirement, which this enforces as declaration context instead, which makes it possible to implement these as a template. The 'link' and 'device_resident' clauses are also added, which have some similar/small restrictions, but are otherwise pretty rote. This patch implements all of the above.
2025-01-21 11:27:23 -08:00
case OpenACCClauseKind::DeviceResident:
[OpenACC] Implement 'deviceptr' and 'attach' sema for compute constructs These two are very similar to the other 'var-list' variants, except they require that the type of the variable be a pointer. This patch implements that restriction.
2024-05-03 08:54:06 -07:00
case OpenACCClauseKind::DevicePtr:
[OpenACC] Implement 'finalize' clause sema This is a very simple clause as far as sema is concerned. It is only valid on 'exit data', and doesn't have any rules involving it, so it is simply applied and passed onto the MLIR.
2024-12-13 09:34:25 -08:00
case OpenACCClauseKind::Finalize:
[OpenACC] Implement firstprivate clause for compute constructs This clause is pretty nearly copy/paste from private, except that it doesn't support 'loop', and thus 'kernelsloop' for appertainment.
2024-05-02 07:13:24 -07:00
case OpenACCClauseKind::FirstPrivate:
[OpenACC] Implement 'declare' construct AST/Sema The 'declare' construct is the first of two 'declaration' level constructs, so it is legal in any place a declaration is, including as a statement, which this accomplishes by wrapping it in a DeclStmt. All clauses on this have a 'same scope' requirement, which this enforces as declaration context instead, which makes it possible to implement these as a template. The 'link' and 'device_resident' clauses are also added, which have some similar/small restrictions, but are otherwise pretty rote. This patch implements all of the above.
2025-01-21 11:27:23 -08:00
case OpenACCClauseKind::Link:
[OpenACC] Implement no_create and present clauses on compute constructs These two are, from a semantic checking perspective, identical to first-private/private/etc, other than appertainment. This patch implements both.
2024-05-02 08:10:57 -07:00
case OpenACCClauseKind::NoCreate:
[OpenACC] Implement 'nohost' construct AST/Sema 'nohost' is only valid on routine, and states that the compiler shouldn't compile this routine for the host. It has no arguments, so no checking is required besides putting it in the AST.
2025-03-06 12:15:27 -08:00
case OpenACCClauseKind::NoHost:
[OpenACC] Implement 'num_gangs' sema for compute constructs (#89460) num_gangs takes an 'int-expr-list', for 'parallel', and an 'int-expr' for 'kernels'. This patch changes the parsing to always parse it as an 'int-expr-list', then correct the expression count during Sema. It also implements the rest of the semantic analysis changes for this clause.
2024-04-22 08:57:25 -07:00
case OpenACCClauseKind::NumGangs:
[OpenACC] Implement 'num_workers' clause for compute constructs (#89151) This clause just takes an 'int expr', which is not optional. This patch implements the clause on compute constructs.
2024-04-18 12:42:22 -07:00
case OpenACCClauseKind::NumWorkers:
[OpenACC] Implement no_create and present clauses on compute constructs These two are, from a semantic checking perspective, identical to first-private/private/etc, other than appertainment. This patch implements both.
2024-05-02 08:10:57 -07:00
case OpenACCClauseKind::Present:
[OpenACC] Private Clause on Compute Constructs (#90521) The private clause is the first that takes a 'var-list', thus this has a lot of additional work to enable the var-list type. A 'var' is a traditional variable reference, subscript, member-expression, or array-section, so checking of these is pretty minor. Note: This ran into some issues with array-sections (aka sub-arrays) that will be fixed in a follow-up patch.
2024-04-30 11:28:37 -07:00
case OpenACCClauseKind::Private:
[OpenACC] Implement firstprivate clause for compute constructs This clause is pretty nearly copy/paste from private, except that it doesn't support 'loop', and thus 'kernelsloop' for appertainment.
2024-05-02 07:13:24 -07:00
case OpenACCClauseKind::Self:
[OpenACC] Implement auto/seq/independent clause Sema for 'loop' These three clauses are all quite trivial, as they take no parameters. They are mutually exclusive, and 'seq' has some other exclusives that are implemented here. The ONE thing that isn't implemented is 2.9's restriction (line 2010): 'A loop associated with a 'loop' construct that does not have a 'seq' clause must be written to meet all the following conditions'. Future clauses will require similar work, so it'll be done as a followup.
2024-05-31 07:57:24 -07:00
case OpenACCClauseKind::Seq:
[OpenACC] Implement 'tile' attribute AST (#110999) The 'tile' clause shares quite a bit of the rules with 'collapse', so a followup patch will add those tests/behaviors. This patch deals with adding the AST node. The 'tile' clause takes a series of integer constant expressions, or *. The asterisk is now represented by a new OpenACCAsteriskSizeExpr node, else this clause is very similar to others.
2024-10-03 08:34:43 -07:00
case OpenACCClauseKind::Tile:
[OpenACC] implement loop 'worker' clause. (#112206) The worker clause specifies iterations of the loop/ that are executed in parallel by distributing the iterations among the multiple works within a single gang. The sema rules for this type are simply that it cannot be combined with a `kernel` construct with a `num_workers` clause, child `loop` clauses cannot contain a `gang` or `worker` clause, and that the argument is oly allowed when associated with a `kernel`.
2024-10-14 09:08:24 -07:00
case OpenACCClauseKind::Worker:
[OpenACC] Implement 'use_device' clause AST/Sema This is a clause that is only valid on 'host_data' constructs, and identifies variables which it should use the current device address. From a Sema perspective, the only thing novel here is mild changes to how ActOnVar works for this clause, else this is very much like the rest of the 'var-list' clauses.
2024-12-16 09:07:10 -08:00
case OpenACCClauseKind::UseDevice:
[OpenACC] Implement 'loop' 'vector' clause (#112259) The 'vector' clause specifies the iterations to be executed in vector or SIMD mode. There are some limitations on which associated compute contexts may be associated with this and have arguments, but otherwise this is a fairly unrestricted clause. It DOES have region limits like 'gang' and 'worker'.
2024-10-15 06:12:19 -07:00
case OpenACCClauseKind::Vector:
[OpenACC] Implement 'vector_length' clause On compute constructs The 'vector_length' clause is semantically identical to the 'num_workers' clause, in that it takes a mandatory single int-expr. This is implemented identically to it.
2024-04-18 12:42:22 -07:00
case OpenACCClauseKind::VectorLength:
[OpenACC] Implement 'if' clause for Compute Constructs (#88411) Like with the 'default' clause, this is being applied to only Compute Constructs for now. The 'if' clause takes a condition expression which is used as a runtime value. This is not a particularly complex semantic implementation, as there isn't much to this clause, other than its interactions with 'self', which will be managed in the patch to implement that.
2024-04-12 14:13:31 -07:00
// The condition expression will be printed as a part of the 'children',
// but print 'clause' here so it is clear what is happening from the dump.
OS << " clause";
break;
[OpenACC] Implement loop 'gang' clause. (#112006) The 'gang' clause is used to specify parallel execution of loops, thus has some complicated rules depending on the 'loop's associated compute construct. This patch implements all of those.
2024-10-11 09:05:19 -07:00
case OpenACCClauseKind::Gang: {
OS << " clause";
// print the list of all GangKinds, so that there is some sort of
// relationship to the expressions listed afterwards.
auto *GC = cast<OpenACCGangClause>(C);
for (unsigned I = 0; I < GC->getNumExprs(); ++I) {
OS << " " << GC->getExpr(I).first;
}
break;
}
[OpenACC] Add 'collapse' clause AST/basic Sema implementation (#109461) The 'collapse' clause on a 'loop' construct is used to specify how many nested loops are associated with the 'loop' construct. It takes an optional 'force' tag, and an integer constant expression as arguments. There are many other restrictions based on the contents of the loop/etc, but those are implemented in followup patches, for now, this patch just adds the AST node and does basic argument checking on the loop-count.
2024-10-01 06:40:21 -07:00
case OpenACCClauseKind::Collapse:
OS << " clause";
if (cast<OpenACCCollapseClause>(C)->hasForce())
OS << ": force";
break;
[OpenACC] Implement copyin, copyout, create clauses for compute construct Like 'copy', these also have alternate names, so this implements that as well. Additionally, these have an optional tag of either 'readonly' or 'zero' depending on the clause. Otherwise, this is a pretty rote implementation of the clause, as there aren't any special rules for it.
2024-05-02 14:11:17 -07:00
case OpenACCClauseKind::CopyIn:
case OpenACCClauseKind::PCopyIn:
case OpenACCClauseKind::PresentOrCopyIn:
OS << " clause";
if (cast<OpenACCCopyInClause>(C)->isReadOnly())
OS << " : readonly";
break;
case OpenACCClauseKind::CopyOut:
case OpenACCClauseKind::PCopyOut:
case OpenACCClauseKind::PresentOrCopyOut:
OS << " clause";
if (cast<OpenACCCopyOutClause>(C)->isZero())
OS << " : zero";
break;
case OpenACCClauseKind::Create:
case OpenACCClauseKind::PCreate:
case OpenACCClauseKind::PresentOrCreate:
OS << " clause";
if (cast<OpenACCCreateClause>(C)->isZero())
OS << " : zero";
break;
[OpenACC] 'wait' clause for compute construct sema 'wait' takes a few int-exprs (well, a series of async-arguments, but those are effectively just an int-expr), plus a pair of tags. This patch adds the support for this to the AST, and does the appropriate semantic analysis for them.
2024-05-07 13:30:07 -07:00
case OpenACCClauseKind::Wait:
OS << " clause";
if (cast<OpenACCWaitClause>(C)->hasDevNumExpr())
OS << " has devnum";
if (cast<OpenACCWaitClause>(C)->hasQueuesTag())
OS << " has queues tag";
break;
Reapply "[OpenACC] device_type clause Sema for Compute constructs" device_type, also spelled as dtype, specifies the applicability of the clauses following it, and takes a series of identifiers representing the architectures it applies to. As we don't have a source for the valid architectures yet, this patch just accepts all. Semantically, this also limits the list of clauses that can be applied after the device_type, so this implements that as well. This reverts commit 06f04b2e27f2586d3db2204ed4e54f8b78fea74e. This reapplies commit c4a9a374749deb5f2a932a7d4ef9321be1b2ae5d. The build failures were caused by the patch depending on the order of evaluation of arguments to a function. This reapplication separates out the capture of one of the values.
2024-05-13 08:43:15 -07:00
case OpenACCClauseKind::DeviceType:
case OpenACCClauseKind::DType:
OS << "(";
llvm::interleaveComma(
cast<OpenACCDeviceTypeClause>(C)->getArchitectures(), OS,
[&](const DeviceTypeArgument &Arch) {
if (Arch.first == nullptr)
OS << "*";
else
OS << Arch.first->getName();
});
OS << ")";
break;
[OpenACC] Implement 'reduction' sema for compute constructs (#92808) 'reduction' has a few restrictions over normal 'var-list' clauses: 1- On parallel, a num_gangs can only have 1 argument when combined with reduction. These two aren't able to be combined on any other of the compute constructs however. 2- The vars all must be 'numerical data types' types of some sort, or a 'composite of numerical data types'. A list of types is given in the standard as a minimum, so we choose 'isScalar', which covers all of these types and keeps types that are actually numeric. Other compilers don't seem to implement the 'composite of numerical data types', though we do. 3- Because of the above restrictions, member-of-composite is not allowed, so any access via a memberexpr is disallowed. Array-element and sub-arrays (aka array sections) are both permitted, so long as they meet the requirements of #2. This patch implements all of these for compute constructs.
2024-05-21 06:51:25 -07:00
case OpenACCClauseKind::Reduction:
OS << " clause Operator: "
<< cast<OpenACCReductionClause>(C)->getReductionOp();
break;
[OpenACC] Implement Default clause for Compute Constructs (#88135) As a followup to my previous commits, this is an implementation of a single clause, in this case the 'default' clause. This implements all semantic analysis for it on compute clauses, and continues to leave it rejected for all others (some as 'doesnt appertain', others as 'not implemented' as appropriate). This also implements and tests the TreeTransform as requested in the previous patch.
2024-04-10 07:10:24 -07:00
default:
// Nothing to do here.
break;
}
[OpenACC][NFC] Add OpenACC Clause AST Nodes/infrastructure (#87675) As a first step in adding clause support for OpenACC to Semantic Analysis, this patch adds the 'base' AST nodes required for clauses. This patch has no functional effect at the moment, but followup patches will add the semantic analysis of clauses (plus individual clauses).
2024-04-05 10:06:44 -07:00
}
dumpPointer(C);
dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
}
NFC: Implement GenericSelectionExpr::Association dump with Visitor Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56960 llvm-svn: 352552
2019-01-29 22:22:55 +00:00
void TextNodeDumper::Visit(const GenericSelectionExpr::ConstAssociation &A) {
const TypeSourceInfo *TSI = A.getTypeSourceInfo();
if (TSI) {
OS << "case ";
dumpType(TSI->getType());
} else {
OS << "default";
}
if (A.isSelected())
OS << " selected";
}
[AST] Support ConceptReference in DynTypedNode, add dump(). The dump() is not actually included recursively in any other nodes' dump, as this is too verbose (similar to NNS) but useful in its own right. It's unfortunate to not have the actual tests yet, but the DynTypedNode tests are matcher-based and adding matchers is a larger task than DynTypedNode support (but can't be done first). (I've got a clangd change stacked on this that uses DynTypedNode and dump(), and both work. I'll send a change for matchers next). Differential Revision: https://reviews.llvm.org/D159300
2023-08-31 20:11:28 +02:00
void TextNodeDumper::Visit(const ConceptReference *R) {
if (!R) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>> ConceptReference";
return;
}
OS << "ConceptReference";
dumpPointer(R);
dumpSourceRange(R->getSourceRange());
OS << ' ';
dumpBareDeclRef(R->getNamedConcept());
}
Add dumping support for RequiresExpr. In passing, fix an ast-print bug that inserted a spurious extra `;` after a concept definition.
2021-06-30 14:05:34 -07:00
void TextNodeDumper::Visit(const concepts::Requirement *R) {
if (!R) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>> Requirement";
return;
}
{
ColorScope Color(OS, ShowColors, StmtColor);
switch (R->getKind()) {
case concepts::Requirement::RK_Type:
OS << "TypeRequirement";
break;
case concepts::Requirement::RK_Simple:
OS << "SimpleRequirement";
break;
case concepts::Requirement::RK_Compound:
OS << "CompoundRequirement";
break;
case concepts::Requirement::RK_Nested:
OS << "NestedRequirement";
break;
}
}
dumpPointer(R);
if (auto *ER = dyn_cast<concepts::ExprRequirement>(R)) {
if (ER->hasNoexceptRequirement())
OS << " noexcept";
}
if (R->isDependent())
OS << " dependent";
else
OS << (R->isSatisfied() ? " satisfied" : " unsatisfied");
if (R->containsUnexpandedParameterPack())
OS << " contains_unexpanded_pack";
}
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
static double GetApproxValue(const llvm::APFloat &F) {
llvm::APFloat V = F;
bool ignored;
V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
&ignored);
return V.convertToDouble();
}
/// True if the \p APValue \p Value can be folded onto the current line.
static bool isSimpleAPValue(const APValue &Value) {
switch (Value.getKind()) {
case APValue::None:
case APValue::Indeterminate:
case APValue::Int:
case APValue::Float:
case APValue::FixedPoint:
case APValue::ComplexInt:
case APValue::ComplexFloat:
case APValue::LValue:
case APValue::MemberPointer:
case APValue::AddrLabelDiff:
return true;
case APValue::Vector:
case APValue::Array:
case APValue::Struct:
return false;
case APValue::Union:
return isSimpleAPValue(Value.getUnionValue());
}
llvm_unreachable("unexpected APValue kind!");
}
/// Dump the children of the \p APValue \p Value.
///
/// \param[in] Value The \p APValue to visit
/// \param[in] Ty The \p QualType passed to \p Visit
///
/// \param[in] IdxToChildFun A function mapping an \p APValue and an index
/// to one of the child of the \p APValue
///
/// \param[in] NumChildren \p IdxToChildFun will be called on \p Value with
/// the indices in the range \p [0,NumChildren(
///
/// \param[in] LabelSingular The label to use on a line with a single child
/// \param[in] LabelPlurial The label to use on a line with multiple children
void TextNodeDumper::dumpAPValueChildren(
const APValue &Value, QualType Ty,
const APValue &(*IdxToChildFun)(const APValue &, unsigned),
unsigned NumChildren, StringRef LabelSingular, StringRef LabelPlurial) {
// To save some vertical space we print up to MaxChildrenPerLine APValues
// considered to be simple (by isSimpleAPValue) on a single line.
constexpr unsigned MaxChildrenPerLine = 4;
unsigned I = 0;
while (I < NumChildren) {
unsigned J = I;
while (J < NumChildren) {
if (isSimpleAPValue(IdxToChildFun(Value, J)) &&
(J - I < MaxChildrenPerLine)) {
++J;
continue;
}
break;
}
J = std::max(I + 1, J);
// Print [I,J) on a single line.
AddChild(J - I > 1 ? LabelPlurial : LabelSingular, [=]() {
for (unsigned X = I; X < J; ++X) {
Visit(IdxToChildFun(Value, X), Ty);
if (X + 1 != J)
OS << ", ";
}
});
I = J;
}
}
void TextNodeDumper::Visit(const APValue &Value, QualType Ty) {
ColorScope Color(OS, ShowColors, ValueKindColor);
switch (Value.getKind()) {
case APValue::None:
OS << "None";
return;
case APValue::Indeterminate:
OS << "Indeterminate";
return;
case APValue::Int:
OS << "Int ";
{
ColorScope Color(OS, ShowColors, ValueColor);
OS << Value.getInt();
}
return;
case APValue::Float:
OS << "Float ";
{
ColorScope Color(OS, ShowColors, ValueColor);
OS << GetApproxValue(Value.getFloat());
}
return;
case APValue::FixedPoint:
OS << "FixedPoint ";
{
ColorScope Color(OS, ShowColors, ValueColor);
OS << Value.getFixedPoint();
}
return;
case APValue::Vector: {
unsigned VectorLength = Value.getVectorLength();
OS << "Vector length=" << VectorLength;
dumpAPValueChildren(
Value, Ty,
[](const APValue &Value, unsigned Index) -> const APValue & {
return Value.getVectorElt(Index);
},
VectorLength, "element", "elements");
return;
}
case APValue::ComplexInt:
OS << "ComplexInt ";
{
ColorScope Color(OS, ShowColors, ValueColor);
OS << Value.getComplexIntReal() << " + " << Value.getComplexIntImag()
<< 'i';
}
return;
case APValue::ComplexFloat:
OS << "ComplexFloat ";
{
ColorScope Color(OS, ShowColors, ValueColor);
OS << GetApproxValue(Value.getComplexFloatReal()) << " + "
<< GetApproxValue(Value.getComplexFloatImag()) << 'i';
}
return;
[clang] Add dump() support for lvalue APValues (#124476) Add some lvalue information to the `dump()` output of lvalue APValues.
2025-01-27 11:54:06 +01:00
case APValue::LValue: {
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
(void)Context;
[clang] Add dump() support for lvalue APValues (#124476) Add some lvalue information to the `dump()` output of lvalue APValues.
2025-01-27 11:54:06 +01:00
OS << "LValue Base=";
APValue::LValueBase B = Value.getLValueBase();
if (B.isNull())
OS << "null";
else if (const auto *BE = B.dyn_cast<const Expr *>()) {
OS << BE->getStmtClassName() << ' ';
dumpPointer(BE);
} else {
const auto *VDB = B.get<const ValueDecl *>();
OS << VDB->getDeclKindName() << "Decl";
dumpPointer(VDB);
}
OS << ", Null=" << Value.isNullPointer()
<< ", Offset=" << Value.getLValueOffset().getQuantity()
<< ", HasPath=" << Value.hasLValuePath();
if (Value.hasLValuePath()) {
OS << ", PathLength=" << Value.getLValuePath().size();
OS << ", Path=(";
llvm::ListSeparator Sep;
for (const auto &PathEntry : Value.getLValuePath()) {
// We're printing all entries as array indices because don't have the
// type information here to do anything else.
OS << Sep << PathEntry.getAsArrayIndex();
}
OS << ")";
}
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
return;
[clang] Add dump() support for lvalue APValues (#124476) Add some lvalue information to the `dump()` output of lvalue APValues.
2025-01-27 11:54:06 +01:00
}
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
case APValue::Array: {
unsigned ArraySize = Value.getArraySize();
unsigned NumInitializedElements = Value.getArrayInitializedElts();
OS << "Array size=" << ArraySize;
dumpAPValueChildren(
Value, Ty,
[](const APValue &Value, unsigned Index) -> const APValue & {
return Value.getArrayInitializedElt(Index);
},
NumInitializedElements, "element", "elements");
if (Value.hasArrayFiller()) {
AddChild("filler", [=] {
{
ColorScope Color(OS, ShowColors, ValueColor);
OS << ArraySize - NumInitializedElements << " x ";
}
Visit(Value.getArrayFiller(), Ty);
});
}
return;
}
case APValue::Struct: {
OS << "Struct";
dumpAPValueChildren(
Value, Ty,
[](const APValue &Value, unsigned Index) -> const APValue & {
return Value.getStructBase(Index);
},
Value.getStructNumBases(), "base", "bases");
dumpAPValueChildren(
Value, Ty,
[](const APValue &Value, unsigned Index) -> const APValue & {
return Value.getStructField(Index);
},
Value.getStructNumFields(), "field", "fields");
return;
}
case APValue::Union: {
OS << "Union";
{
ColorScope Color(OS, ShowColors, ValueColor);
if (const FieldDecl *FD = Value.getUnionField())
OS << " ." << *cast<NamedDecl>(FD);
}
// If the union value is considered to be simple, fold it into the
// current line to save some vertical space.
const APValue &UnionValue = Value.getUnionValue();
if (isSimpleAPValue(UnionValue)) {
OS << ' ';
Visit(UnionValue, Ty);
} else {
AddChild([=] { Visit(UnionValue, Ty); });
}
return;
}
case APValue::MemberPointer:
OS << "MemberPointer <todo>";
return;
case APValue::AddrLabelDiff:
OS << "AddrLabelDiff <todo>";
return;
}
llvm_unreachable("Unknown APValue kind!");
}
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
void TextNodeDumper::dumpPointer(const void *Ptr) {
ColorScope Color(OS, ShowColors, AddressColor);
OS << ' ' << Ptr;
}
void TextNodeDumper::dumpLocation(SourceLocation Loc) {
if (!SM)
return;
ColorScope Color(OS, ShowColors, LocationColor);
SourceLocation SpellingLoc = SM->getSpellingLoc(Loc);
// The general format we print out is filename:line:col, but we drop pieces
// that haven't changed since the last loc printed.
PresumedLoc PLoc = SM->getPresumedLoc(SpellingLoc);
if (PLoc.isInvalid()) {
OS << "<invalid sloc>";
return;
}
if (strcmp(PLoc.getFilename(), LastLocFilename) != 0) {
OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
<< PLoc.getColumn();
LastLocFilename = PLoc.getFilename();
LastLocLine = PLoc.getLine();
} else if (PLoc.getLine() != LastLocLine) {
OS << "line" << ':' << PLoc.getLine() << ':' << PLoc.getColumn();
LastLocLine = PLoc.getLine();
} else {
OS << "col" << ':' << PLoc.getColumn();
}
}
void TextNodeDumper::dumpSourceRange(SourceRange R) {
// Can't translate locations if a SourceManager isn't available.
if (!SM)
return;
OS << " <";
dumpLocation(R.getBegin());
if (R.getBegin() != R.getEnd()) {
OS << ", ";
dumpLocation(R.getEnd());
}
OS << ">";
// <t2.c:123:421[blah], t2.c:412:321>
}
void TextNodeDumper::dumpBareType(QualType T, bool Desugar) {
ColorScope Color(OS, ShowColors, TypeColor);
SplitQualType T_split = T.split();
[AST] Only dump desugared type when visibly different (#65214) These are an artifact of how types are structured but serve little purpose, merely showing that the type is sugared in some way. For example, ElaboratedType's existence means struct S gets printed as 'struct S':'struct S' in the AST, which is unnecessary visual clutter. Note that skipping the second print when the types have the same string matches what we do for diagnostics, where the aka will be skipped.
2023-10-26 19:28:28 +01:00
std::string T_str = QualType::getAsString(T_split, PrintPolicy);
OS << "'" << T_str << "'";
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
if (Desugar && !T.isNull()) {
[AST] Only dump desugared type when visibly different (#65214) These are an artifact of how types are structured but serve little purpose, merely showing that the type is sugared in some way. For example, ElaboratedType's existence means struct S gets printed as 'struct S':'struct S' in the AST, which is unnecessary visual clutter. Note that skipping the second print when the types have the same string matches what we do for diagnostics, where the aka will be skipped.
2023-10-26 19:28:28 +01:00
// If the type is sugared, also dump a (shallow) desugared type when
// it is visibly different.
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
SplitQualType D_split = T.getSplitDesugaredType();
[AST] Only dump desugared type when visibly different (#65214) These are an artifact of how types are structured but serve little purpose, merely showing that the type is sugared in some way. For example, ElaboratedType's existence means struct S gets printed as 'struct S':'struct S' in the AST, which is unnecessary visual clutter. Note that skipping the second print when the types have the same string matches what we do for diagnostics, where the aka will be skipped.
2023-10-26 19:28:28 +01:00
if (T_split != D_split) {
std::string D_str = QualType::getAsString(D_split, PrintPolicy);
if (T_str != D_str)
OS << ":'" << QualType::getAsString(D_split, PrintPolicy) << "'";
}
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
}
}
void TextNodeDumper::dumpType(QualType T) {
OS << ' ';
dumpBareType(T);
}
void TextNodeDumper::dumpBareDeclRef(const Decl *D) {
if (!D) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>>";
return;
}
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << D->getDeclKindName();
}
dumpPointer(D);
if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
ColorScope Color(OS, ShowColors, DeclNameColor);
Reland: [clang] improve print / dump of anonymous declarations (#124858)
2025-01-29 00:31:53 -03:00
if (DeclarationName Name = ND->getDeclName())
OS << " '" << Name << '\'';
else
switch (ND->getKind()) {
case Decl::Decomposition: {
auto *DD = cast<DecompositionDecl>(ND);
OS << " first_binding '" << DD->bindings()[0]->getDeclName() << '\'';
break;
}
case Decl::Field: {
auto *FD = cast<FieldDecl>(ND);
OS << " field_index " << FD->getFieldIndex();
break;
}
case Decl::ParmVar: {
auto *PD = cast<ParmVarDecl>(ND);
OS << " depth " << PD->getFunctionScopeDepth() << " index "
<< PD->getFunctionScopeIndex();
break;
}
case Decl::TemplateTypeParm: {
auto *TD = cast<TemplateTypeParmDecl>(ND);
OS << " depth " << TD->getDepth() << " index " << TD->getIndex();
break;
}
case Decl::NonTypeTemplateParm: {
auto *TD = cast<NonTypeTemplateParmDecl>(ND);
OS << " depth " << TD->getDepth() << " index " << TD->getIndex();
break;
}
default:
// Var, Namespace, (CXX)Record: Nothing else besides source location.
dumpSourceRange(ND->getSourceRange());
break;
}
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
}
if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
dumpType(VD->getType());
}
void TextNodeDumper::dumpName(const NamedDecl *ND) {
if (ND->getDeclName()) {
ColorScope Color(OS, ShowColors, DeclNameColor);
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << ' ' << ND->getDeclName();
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
}
}
void TextNodeDumper::dumpAccessSpecifier(AccessSpecifier AS) {
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-27 18:17:07 +02:00
const auto AccessSpelling = getAccessSpelling(AS);
if (AccessSpelling.empty())
return;
OS << AccessSpelling;
NFC: Extract TextNodeDumper class Summary: Start by moving some utilities to it. It will eventually house dumping of individual nodes (after indentation etc has already been accounted for). Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55189 llvm-svn: 348412
2018-12-05 21:12:39 +00:00
}
[CodeGen] Emit destructor calls to destruct compound literals Fix a bug in IRGen where it wasn't destructing compound literals in C that are ObjC pointer arrays or non-trivial structs. Also diagnose jumps that enter or exit the lifetime of the compound literals. rdar://problem/51867864 Differential Revision: https://reviews.llvm.org/D64464
2020-03-10 14:06:25 -07:00
void TextNodeDumper::dumpCleanupObject(
const ExprWithCleanups::CleanupObject &C) {
[AST] Migrate away from PointerUnion::dyn_cast (NFC) (#125022) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> Literal migration would result in dyn_cast_if_present (see the definition of PointerUnion::dyn_cast), but this patch uses dyn_cast because we expect C to be nonnull.
2025-01-30 17:58:10 -08:00
if (auto *BD = dyn_cast<BlockDecl *>(C))
[CodeGen] Emit destructor calls to destruct compound literals Fix a bug in IRGen where it wasn't destructing compound literals in C that are ObjC pointer arrays or non-trivial structs. Also diagnose jumps that enter or exit the lifetime of the compound literals. rdar://problem/51867864 Differential Revision: https://reviews.llvm.org/D64464
2020-03-10 14:06:25 -07:00
dumpDeclRef(BD, "cleanup");
[AST] Migrate away from PointerUnion::dyn_cast (NFC) (#125022) Note that PointerUnion::dyn_cast has been soft deprecated in PointerUnion.h: // FIXME: Replace the uses of is(), get() and dyn_cast() with // isa<T>, cast<T> and the llvm::dyn_cast<T> Literal migration would result in dyn_cast_if_present (see the definition of PointerUnion::dyn_cast), but this patch uses dyn_cast because we expect C to be nonnull.
2025-01-30 17:58:10 -08:00
else if (auto *CLE = dyn_cast<CompoundLiteralExpr *>(C))
[CodeGen] Emit destructor calls to destruct compound literals Fix a bug in IRGen where it wasn't destructing compound literals in C that are ObjC pointer arrays or non-trivial structs. Also diagnose jumps that enter or exit the lifetime of the compound literals. rdar://problem/51867864 Differential Revision: https://reviews.llvm.org/D64464
2020-03-10 14:06:25 -07:00
AddChild([=] {
OS << "cleanup ";
{
ColorScope Color(OS, ShowColors, StmtColor);
OS << CLE->getStmtClassName();
}
dumpPointer(CLE);
});
else
llvm_unreachable("unexpected cleanup type");
}
[clang][AST] TextNodeDumper learned to output template specialization kind Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157705
2023-08-15 14:17:24 +00:00
void clang::TextNodeDumper::dumpTemplateSpecializationKind(
TemplateSpecializationKind TSK) {
switch (TSK) {
case TSK_Undeclared:
break;
case TSK_ImplicitInstantiation:
OS << " implicit_instantiation";
break;
case TSK_ExplicitSpecialization:
OS << " explicit_specialization";
break;
case TSK_ExplicitInstantiationDeclaration:
OS << " explicit_instantiation_declaration";
break;
case TSK_ExplicitInstantiationDefinition:
OS << " explicit_instantiation_definition";
break;
}
}
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
void clang::TextNodeDumper::dumpNestedNameSpecifier(const NestedNameSpecifier *NNS) {
if (!NNS)
return;
AddChild([=] {
OS << "NestedNameSpecifier";
switch (NNS->getKind()) {
case NestedNameSpecifier::Identifier:
OS << " Identifier";
OS << " '" << NNS->getAsIdentifier()->getName() << "'";
break;
case NestedNameSpecifier::Namespace:
[AST] Fix nested name specifiers printing as NamespaceNamespace (#65266) This happens because we print both the kind of the NNS and the kind of decl (when it refers to one). These are always the same string.
2023-09-05 18:15:06 +02:00
OS << " "; // "Namespace" is printed as the decl kind.
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
dumpBareDeclRef(NNS->getAsNamespace());
break;
case NestedNameSpecifier::NamespaceAlias:
[AST] Fix nested name specifiers printing as NamespaceNamespace (#65266) This happens because we print both the kind of the NNS and the kind of decl (when it refers to one). These are always the same string.
2023-09-05 18:15:06 +02:00
OS << " "; // "NamespaceAlias" is printed as the decl kind.
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
dumpBareDeclRef(NNS->getAsNamespaceAlias());
break;
case NestedNameSpecifier::TypeSpec:
OS << " TypeSpec";
dumpType(QualType(NNS->getAsType(), 0));
break;
case NestedNameSpecifier::TypeSpecWithTemplate:
OS << " TypeSpecWithTemplate";
dumpType(QualType(NNS->getAsType(), 0));
break;
case NestedNameSpecifier::Global:
OS << " Global";
break;
case NestedNameSpecifier::Super:
OS << " Super";
break;
}
dumpNestedNameSpecifier(NNS->getPrefix());
});
}
[ASTDump] Change parameter to StringRef llvm-svn: 351011
2019-01-12 15:45:05 +00:00
void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
[ASTDump] NFC: Move dumpDeclRef to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55337 llvm-svn: 350677
2019-01-08 23:11:24 +00:00
if (!D)
return;
NFC: Change case of identifiers llvm-svn: 350890
2019-01-10 20:58:21 +00:00
AddChild([=] {
[ASTDump] Change parameter to StringRef llvm-svn: 351011
2019-01-12 15:45:05 +00:00
if (!Label.empty())
[ASTDump] NFC: Move dumpDeclRef to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55337 llvm-svn: 350677
2019-01-08 23:11:24 +00:00
OS << Label << ' ';
dumpBareDeclRef(D);
});
}
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
void TextNodeDumper::dumpTemplateArgument(const TemplateArgument &TA) {
llvm::SmallString<128> Str;
{
llvm::raw_svector_ostream SS(Str);
TA.print(PrintPolicy, SS, /*IncludeType=*/true);
}
OS << " '" << Str << "'";
[clang] NFCI: Make ASTContext optional in the AST text dumper again (#94522)
2024-06-06 04:14:10 -03:00
if (!Context)
return;
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
if (TemplateArgument CanonTA = Context->getCanonicalTemplateArgument(TA);
!CanonTA.structurallyEquals(TA)) {
llvm::SmallString<128> CanonStr;
{
llvm::raw_svector_ostream SS(CanonStr);
CanonTA.print(PrintPolicy, SS, /*IncludeType=*/true);
}
if (CanonStr != Str)
OS << ":'" << CanonStr << "'";
}
}
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
const char *TextNodeDumper::getCommandName(unsigned CommandID) {
if (Traits)
return Traits->getCommandInfo(CommandID)->Name;
const comments::CommandInfo *Info =
comments::CommandTraits::getBuiltinCommandInfo(CommandID);
if (Info)
return Info->Name;
return "<not a builtin command>";
}
[AST][FPEnv] Keep FP options in trailing storage of CallExpr This change allow a CallExpr to have optional FPOptionsOverride object, stored in trailing storage. The implementaion is made similar to the way used in BinaryOperator. Differential Revision: https://reviews.llvm.org/D84343
2020-07-24 12:04:19 +07:00
void TextNodeDumper::printFPOptions(FPOptionsOverride FPO) {
#define OPTION(NAME, TYPE, WIDTH, PREVIOUS) \
if (FPO.has##NAME##Override()) \
OS << " " #NAME "=" << FPO.get##NAME##Override();
#include "clang/Basic/FPOptions.def"
}
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
void TextNodeDumper::visitTextComment(const comments::TextComment *C,
const comments::FullComment *) {
OS << " Text=\"" << C->getText() << "\"";
}
void TextNodeDumper::visitInlineCommandComment(
const comments::InlineCommandComment *C, const comments::FullComment *) {
OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
switch (C->getRenderKind()) {
[clang][NFC] Refactor `InlineCommandComment::RenderKind` This patch converts `InlineCommandComment::RenderKind` to a scoped enum at namespace scope, making it eligible for forward declaring. This is useful for e.g. annotating bit-fields with `preferred_type`.
2023-11-06 22:38:29 +03:00
case comments::InlineCommandRenderKind::Normal:
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
OS << " RenderNormal";
break;
[clang][NFC] Refactor `InlineCommandComment::RenderKind` This patch converts `InlineCommandComment::RenderKind` to a scoped enum at namespace scope, making it eligible for forward declaring. This is useful for e.g. annotating bit-fields with `preferred_type`.
2023-11-06 22:38:29 +03:00
case comments::InlineCommandRenderKind::Bold:
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
OS << " RenderBold";
break;
[clang][NFC] Refactor `InlineCommandComment::RenderKind` This patch converts `InlineCommandComment::RenderKind` to a scoped enum at namespace scope, making it eligible for forward declaring. This is useful for e.g. annotating bit-fields with `preferred_type`.
2023-11-06 22:38:29 +03:00
case comments::InlineCommandRenderKind::Monospaced:
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
OS << " RenderMonospaced";
break;
[clang][NFC] Refactor `InlineCommandComment::RenderKind` This patch converts `InlineCommandComment::RenderKind` to a scoped enum at namespace scope, making it eligible for forward declaring. This is useful for e.g. annotating bit-fields with `preferred_type`.
2023-11-06 22:38:29 +03:00
case comments::InlineCommandRenderKind::Emphasized:
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
OS << " RenderEmphasized";
break;
[clang][NFC] Refactor `InlineCommandComment::RenderKind` This patch converts `InlineCommandComment::RenderKind` to a scoped enum at namespace scope, making it eligible for forward declaring. This is useful for e.g. annotating bit-fields with `preferred_type`.
2023-11-06 22:38:29 +03:00
case comments::InlineCommandRenderKind::Anchor:
[Wdocumentation] Implement \anchor Differential revision: https://reviews.llvm.org/D69223
2019-12-21 14:47:52 +01:00
OS << " RenderAnchor";
break;
NFC: Move dump of individual comment nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55190 llvm-svn: 348719
2018-12-09 13:30:17 +00:00
}
for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
}
void TextNodeDumper::visitHTMLStartTagComment(
const comments::HTMLStartTagComment *C, const comments::FullComment *) {
OS << " Name=\"" << C->getTagName() << "\"";
if (C->getNumAttrs() != 0) {
OS << " Attrs: ";
for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
const comments::HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
}
}
if (C->isSelfClosing())
OS << " SelfClosing";
}
void TextNodeDumper::visitHTMLEndTagComment(
const comments::HTMLEndTagComment *C, const comments::FullComment *) {
OS << " Name=\"" << C->getTagName() << "\"";
}
void TextNodeDumper::visitBlockCommandComment(
const comments::BlockCommandComment *C, const comments::FullComment *) {
OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
}
void TextNodeDumper::visitParamCommandComment(
const comments::ParamCommandComment *C, const comments::FullComment *FC) {
OS << " "
<< comments::ParamCommandComment::getDirectionAsString(C->getDirection());
if (C->isDirectionExplicit())
OS << " explicitly";
else
OS << " implicitly";
if (C->hasParamName()) {
if (C->isParamIndexValid())
OS << " Param=\"" << C->getParamName(FC) << "\"";
else
OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
}
if (C->isParamIndexValid() && !C->isVarArgParam())
OS << " ParamIndex=" << C->getParamIndex();
}
void TextNodeDumper::visitTParamCommandComment(
const comments::TParamCommandComment *C, const comments::FullComment *FC) {
if (C->hasParamName()) {
if (C->isPositionValid())
OS << " Param=\"" << C->getParamName(FC) << "\"";
else
OS << " Param=\"" << C->getParamNameAsWritten() << "\"";
}
if (C->isPositionValid()) {
OS << " Position=<";
for (unsigned i = 0, e = C->getDepth(); i != e; ++i) {
OS << C->getIndex(i);
if (i != e - 1)
OS << ", ";
}
OS << ">";
}
}
void TextNodeDumper::visitVerbatimBlockComment(
const comments::VerbatimBlockComment *C, const comments::FullComment *) {
OS << " Name=\"" << getCommandName(C->getCommandID())
<< "\""
" CloseName=\""
<< C->getCloseName() << "\"";
}
void TextNodeDumper::visitVerbatimBlockLineComment(
const comments::VerbatimBlockLineComment *C,
const comments::FullComment *) {
OS << " Text=\"" << C->getText() << "\"";
}
void TextNodeDumper::visitVerbatimLineComment(
const comments::VerbatimLineComment *C, const comments::FullComment *) {
OS << " Text=\"" << C->getText() << "\"";
}
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
void TextNodeDumper::VisitNullTemplateArgument(const TemplateArgument &) {
OS << " null";
}
void TextNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
OS << " type";
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
dumpTemplateArgument(TA);
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
}
void TextNodeDumper::VisitDeclarationTemplateArgument(
const TemplateArgument &TA) {
OS << " decl";
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
dumpTemplateArgument(TA);
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
dumpDeclRef(TA.getAsDecl());
}
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &TA) {
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
OS << " nullptr";
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
dumpTemplateArgument(TA);
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
}
void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
OS << " integral";
dumpTemplateArgument(TA);
}
[clang] [ASTDump] Add support for structural value template arguments in TextNodeDumper (#126341) It was missed in 5518a9d which introduced this new template argument kind.
2025-02-13 14:06:45 +08:00
void TextNodeDumper::VisitStructuralValueTemplateArgument(
const TemplateArgument &TA) {
OS << " structural value";
dumpTemplateArgument(TA);
}
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
void TextNodeDumper::dumpTemplateName(TemplateName TN, StringRef Label) {
AddChild(Label, [=] {
{
llvm::SmallString<128> Str;
{
llvm::raw_svector_ostream SS(Str);
TN.print(SS, PrintPolicy);
}
[clang] Don't print extra space when dumping template names (#95213)
2024-06-13 08:29:05 +02:00
OS << "'" << Str << "'";
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
[clang] NFCI: Make ASTContext optional in the AST text dumper again (#94522)
2024-06-06 04:14:10 -03:00
if (Context) {
if (TemplateName CanonTN = Context->getCanonicalTemplateName(TN);
CanonTN != TN) {
llvm::SmallString<128> CanonStr;
{
llvm::raw_svector_ostream SS(CanonStr);
CanonTN.print(SS, PrintPolicy);
}
if (CanonStr != Str)
OS << ":'" << CanonStr << "'";
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
}
}
}
dumpBareTemplateName(TN);
});
}
void TextNodeDumper::dumpBareTemplateName(TemplateName TN) {
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
switch (TN.getKind()) {
case TemplateName::Template:
AddChild([=] { Visit(TN.getAsTemplateDecl()); });
return;
case TemplateName::UsingTemplate: {
const UsingShadowDecl *USD = TN.getAsUsingShadowDecl();
AddChild([=] { Visit(USD); });
AddChild("target", [=] { Visit(USD->getTargetDecl()); });
return;
}
case TemplateName::QualifiedTemplate: {
OS << " qualified";
const QualifiedTemplateName *QTN = TN.getAsQualifiedTemplateName();
if (QTN->hasTemplateKeyword())
OS << " keyword";
dumpNestedNameSpecifier(QTN->getQualifier());
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
dumpBareTemplateName(QTN->getUnderlyingTemplate());
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
return;
}
case TemplateName::DependentTemplate: {
OS << " dependent";
const DependentTemplateName *DTN = TN.getAsDependentTemplateName();
dumpNestedNameSpecifier(DTN->getQualifier());
return;
}
case TemplateName::SubstTemplateTemplateParm: {
OS << " subst";
const SubstTemplateTemplateParmStorage *STS =
TN.getAsSubstTemplateTemplateParm();
OS << " index " << STS->getIndex();
if (std::optional<unsigned int> PackIndex = STS->getPackIndex())
OS << " pack_index " << *PackIndex;
if (const TemplateTemplateParmDecl *P = STS->getParameter())
AddChild("parameter", [=] { Visit(P); });
dumpDeclRef(STS->getAssociatedDecl(), "associated");
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
dumpTemplateName(STS->getReplacement(), "replacement");
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
return;
}
[clang] Implement CWG2398 provisional TTP matching to class templates (#94981) This extends default argument deduction to cover class templates as well, applying only to partial ordering, adding to the provisional wording introduced in https://github.com/llvm/llvm-project/pull/89807. This solves some ambuguity introduced in P0522 regarding how template template parameters are partially ordered, and should reduce the negative impact of enabling `-frelaxed-template-template-args` by default. Given the following example: ```C++ template <class T1, class T2 = float> struct A; template <class T3> struct B; template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1 template <class T6, class T7> struct B<A<T6, T7>>; // #2 template struct B<A<int>>; ``` Prior to P0522, `#2` was picked. Afterwards, this became ambiguous. This patch restores the pre-P0522 behavior, `#2` is picked again.
2024-09-07 15:49:07 -03:00
case TemplateName::DeducedTemplate: {
OS << " deduced";
const DeducedTemplateStorage *DTS = TN.getAsDeducedTemplateName();
dumpTemplateName(DTS->getUnderlying(), "underlying");
AddChild("defaults", [=] {
auto [StartPos, Args] = DTS->getDefaultArguments();
OS << " start " << StartPos;
for (const TemplateArgument &Arg : Args)
AddChild([=] { Visit(Arg, SourceRange()); });
});
return;
}
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
// FIXME: Implement these.
case TemplateName::OverloadedTemplate:
OS << " overloaded";
return;
case TemplateName::AssumedTemplate:
OS << " assumed";
return;
case TemplateName::SubstTemplateTemplateParmPack:
OS << " subst_pack";
return;
}
llvm_unreachable("Unexpected TemplateName Kind");
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
}
void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
OS << " template";
dumpTemplateArgument(TA);
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
dumpBareTemplateName(TA.getAsTemplate());
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
}
void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
const TemplateArgument &TA) {
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
OS << " template expansion";
dumpTemplateArgument(TA);
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
dumpBareTemplateName(TA.getAsTemplateOrTemplatePattern());
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
}
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
void TextNodeDumper::VisitExpressionTemplateArgument(
const TemplateArgument &TA) {
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
OS << " expr";
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
dumpTemplateArgument(TA);
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
}
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &TA) {
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
OS << " pack";
[clang] Improve ast-dumper text printing of TemplateArgument (#93431) This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
2024-05-29 15:23:44 -03:00
dumpTemplateArgument(TA);
Implement TemplateArgument dumping in terms of Visitor Summary: Split the output streaming from the traversal to other AST nodes. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55491 llvm-svn: 351012
2019-01-12 16:35:37 +00:00
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
if (Node->path_empty())
return;
OS << " (";
bool First = true;
for (CastExpr::path_const_iterator I = Node->path_begin(),
E = Node->path_end();
I != E; ++I) {
const CXXBaseSpecifier *Base = *I;
if (!First)
OS << " -> ";
Silence static analyzer getAs<RecordType> null dereference warnings. NFCI. The static analyzer is warning about potential null dereferences, but in these cases we should be able to use castAs<RecordType> directly and if not assert will fire for us. llvm-svn: 373584
2019-10-03 11:22:48 +00:00
const auto *RD =
cast<CXXRecordDecl>(Base->getType()->castAs<RecordType>()->getDecl());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
if (Base->isVirtual())
OS << "virtual ";
OS << RD->getName();
First = false;
}
OS << ')';
}
void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
if (Node->hasInitStorage())
OS << " has_init";
if (Node->hasVarStorage())
OS << " has_var";
if (Node->hasElseStorage())
OS << " has_else";
Implement if consteval (P1938) Modify the IfStmt node to suppoort constant evaluated expressions. Add a new ExpressionEvaluationContext::ImmediateFunctionContext to keep track of immediate function contexts. This proved easier/better/probably more efficient than walking the AST backward as it allows diagnosing nested if consteval statements.
2021-10-05 08:02:53 -04:00
if (Node->isConstexpr())
OS << " constexpr";
if (Node->isConsteval()) {
OS << " ";
if (Node->isNegatedConsteval())
OS << "!";
OS << "consteval";
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitSwitchStmt(const SwitchStmt *Node) {
if (Node->hasInitStorage())
OS << " has_init";
if (Node->hasVarStorage())
OS << " has_var";
}
void TextNodeDumper::VisitWhileStmt(const WhileStmt *Node) {
if (Node->hasVarStorage())
OS << " has_var";
}
void TextNodeDumper::VisitLabelStmt(const LabelStmt *Node) {
OS << " '" << Node->getName() << "'";
[Windows SEH]: HARDWARE EXCEPTION HANDLING (MSVC -EHa) - Part 1 This patch is the Part-1 (FE Clang) implementation of HW Exception handling. This new feature adds the support of Hardware Exception for Microsoft Windows SEH (Structured Exception Handling). This is the first step of this project; only X86_64 target is enabled in this patch. Compiler options: For clang-cl.exe, the option is -EHa, the same as MSVC. For clang.exe, the extra option is -fasync-exceptions, plus -triple x86_64-windows -fexceptions and -fcxx-exceptions as usual. NOTE:: Without the -EHa or -fasync-exceptions, this patch is a NO-DIFF change. The rules for C code: For C-code, one way (MSVC approach) to achieve SEH -EHa semantic is to follow three rules: * First, no exception can move in or out of _try region., i.e., no "potential faulty instruction can be moved across _try boundary. * Second, the order of exceptions for instructions 'directly' under a _try must be preserved (not applied to those in callees). * Finally, global states (local/global/heap variables) that can be read outside of _try region must be updated in memory (not just in register) before the subsequent exception occurs. The impact to C++ code: Although SEH is a feature for C code, -EHa does have a profound effect on C++ side. When a C++ function (in the same compilation unit with option -EHa ) is called by a SEH C function, a hardware exception occurs in C++ code can also be handled properly by an upstream SEH _try-handler or a C++ catch(...). As such, when that happens in the middle of an object's life scope, the dtor must be invoked the same way as C++ Synchronous Exception during unwinding process. Design: A natural way to achieve the rules above in LLVM today is to allow an EH edge added on memory/computation instruction (previous iload/istore idea) so that exception path is modeled in Flow graph preciously. However, tracking every single memory instruction and potential faulty instruction can create many Invokes, complicate flow graph and possibly result in negative performance impact for downstream optimization and code generation. Making all optimizations be aware of the new semantic is also substantial. This design does not intend to model exception path at instruction level. Instead, the proposed design tracks and reports EH state at BLOCK-level to reduce the complexity of flow graph and minimize the performance-impact on CPP code under -EHa option. One key element of this design is the ability to compute State number at block-level. Our algorithm is based on the following rationales: A _try scope is always a SEME (Single Entry Multiple Exits) region as jumping into a _try is not allowed. The single entry must start with a seh_try_begin() invoke with a correct State number that is the initial state of the SEME. Through control-flow, state number is propagated into all blocks. Side exits marked by seh_try_end() will unwind to parent state based on existing SEHUnwindMap[]. Note side exits can ONLY jump into parent scopes (lower state number). Thus, when a block succeeds various states from its predecessors, the lowest State triumphs others. If some exits flow to unreachable, propagation on those paths terminate, not affecting remaining blocks. For CPP code, object lifetime region is usually a SEME as SEH _try. However there is one rare exception: jumping into a lifetime that has Dtor but has no Ctor is warned, but allowed: Warning: jump bypasses variable with a non-trivial destructor In that case, the region is actually a MEME (multiple entry multiple exits). Our solution is to inject a eha_scope_begin() invoke in the side entry block to ensure a correct State. Implementation: Part-1: Clang implementation described below. Two intrinsic are created to track CPP object scopes; eha_scope_begin() and eha_scope_end(). _scope_begin() is immediately added after ctor() is called and EHStack is pushed. So it must be an invoke, not a call. With that it's also guaranteed an EH-cleanup-pad is created regardless whether there exists a call in this scope. _scope_end is added before dtor(). These two intrinsics make the computation of Block-State possible in downstream code gen pass, even in the presence of ctor/dtor inlining. Two intrinsic, seh_try_begin() and seh_try_end(), are added for C-code to mark _try boundary and to prevent from exceptions being moved across _try boundary. All memory instructions inside a _try are considered as 'volatile' to assure 2nd and 3rd rules for C-code above. This is a little sub-optimized. But it's acceptable as the amount of code directly under _try is very small. Part-2 (will be in Part-2 patch): LLVM implementation described below. For both C++ & C-code, the state of each block is computed at the same place in BE (WinEHPreparing pass) where all other EH tables/maps are calculated. In addition to _scope_begin & _scope_end, the computation of block state also rely on the existing State tracking code (UnwindMap and InvokeStateMap). For both C++ & C-code, the state of each block with potential trap instruction is marked and reported in DAG Instruction Selection pass, the same place where the state for -EHsc (synchronous exceptions) is done. If the first instruction in a reported block scope can trap, a Nop is injected before this instruction. This nop is needed to accommodate LLVM Windows EH implementation, in which the address in IPToState table is offset by +1. (note the purpose of that is to ensure the return address of a call is in the same scope as the call address. The handler for catch(...) for -EHa must handle HW exception. So it is 'adjective' flag is reset (it cannot be IsStdDotDot (0x40) that only catches C++ exceptions). Suppress push/popTerminate() scope (from noexcept/noTHrow) so that HW exceptions can be passed through. Original llvm-dev [RFC] discussions can be found in these two threads below: https://lists.llvm.org/pipermail/llvm-dev/2020-March/140541.html https://lists.llvm.org/pipermail/llvm-dev/2020-April/141338.html Differential Revision: https://reviews.llvm.org/D80344/new/
2021-05-17 22:06:32 -07:00
if (Node->isSideEntry())
OS << " side_entry";
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitGotoStmt(const GotoStmt *Node) {
OS << " '" << Node->getLabel()->getName() << "'";
dumpPointer(Node->getLabel());
}
void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
if (Node->caseStmtIsGNURange())
OS << " gnu_range";
}
[clang][AST] TextNodeDumper learned to dump NRVO candidates of return stmts Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157687
2023-08-15 15:59:15 +00:00
void clang::TextNodeDumper::VisitReturnStmt(const ReturnStmt *Node) {
if (const VarDecl *Cand = Node->getNRVOCandidate()) {
OS << " nrvo_candidate(";
dumpBareDeclRef(Cand);
OS << ")";
}
}
[AST] Teach TextNodeDumper to print the "implicit" bit for coroutine AST nodes (#77311)
2024-01-09 10:32:06 +01:00
void clang::TextNodeDumper::VisitCoawaitExpr(const CoawaitExpr *Node) {
if (Node->isImplicit())
OS << " implicit";
}
void clang::TextNodeDumper::VisitCoreturnStmt(const CoreturnStmt *Node) {
if (Node->isImplicit())
OS << " implicit";
}
[clang] Add storage for APValue in ConstantExpr Summary: When using ConstantExpr we often need the result of the expression to be kept in the AST. Currently this is done on a by the node that needs the result and has been done multiple times for enumerator, for constexpr variables... . This patch adds to ConstantExpr the ability to store the result of evaluating the expression. no functional changes expected. Changes: - Add trailling object to ConstantExpr that can hold an APValue or an uint64_t. the uint64_t is here because most ConstantExpr yield integral values so there is an optimized layout for integral values. - Add basic* serialization support for the trailing result. - Move conversion functions from an enum to a fltSemantics from clang::FloatingLiteral to llvm::APFloatBase. this change is to make it usable for serializing APValues. - Add basic* Import support for the trailing result. - ConstantExpr created in CheckConvertedConstantExpression now stores the result in the ConstantExpr Node. - Adapt AST dump to print the result when present. basic* : None, Indeterminate, Int, Float, FixedPoint, ComplexInt, ComplexFloat, the result is not yet used anywhere but for -ast-dump. Reviewers: rsmith, martong, shafik Reviewed By: rsmith Subscribers: rnkovacs, hiraditya, dexonsmith, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D62399 llvm-svn: 363493
2019-06-15 10:24:47 +00:00
void TextNodeDumper::VisitConstantExpr(const ConstantExpr *Node) {
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
if (Node->hasAPValueResult())
AddChild("value",
[=] { Visit(Node->getAPValueResult(), Node->getType()); });
[clang] Add storage for APValue in ConstantExpr Summary: When using ConstantExpr we often need the result of the expression to be kept in the AST. Currently this is done on a by the node that needs the result and has been done multiple times for enumerator, for constexpr variables... . This patch adds to ConstantExpr the ability to store the result of evaluating the expression. no functional changes expected. Changes: - Add trailling object to ConstantExpr that can hold an APValue or an uint64_t. the uint64_t is here because most ConstantExpr yield integral values so there is an optimized layout for integral values. - Add basic* serialization support for the trailing result. - Move conversion functions from an enum to a fltSemantics from clang::FloatingLiteral to llvm::APFloatBase. this change is to make it usable for serializing APValues. - Add basic* Import support for the trailing result. - ConstantExpr created in CheckConvertedConstantExpression now stores the result in the ConstantExpr Node. - Adapt AST dump to print the result when present. basic* : None, Indeterminate, Int, Float, FixedPoint, ComplexInt, ComplexFloat, the result is not yet used anywhere but for -ast-dump. Reviewers: rsmith, martong, shafik Reviewed By: rsmith Subscribers: rnkovacs, hiraditya, dexonsmith, cfe-commits, llvm-commits Tags: #clang, #llvm Differential Revision: https://reviews.llvm.org/D62399 llvm-svn: 363493
2019-06-15 10:24:47 +00:00
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
if (Node->usesADL())
OS << " adl";
[AST][FPEnv] Keep FP options in trailing storage of CallExpr This change allow a CallExpr to have optional FPOptionsOverride object, stored in trailing storage. The implementaion is made similar to the way used in BinaryOperator. Differential Revision: https://reviews.llvm.org/D84343
2020-07-24 12:04:19 +07:00
if (Node->hasStoredFPFeatures())
printFPOptions(Node->getFPFeatures());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
[clang][AST] TextNodeDumper: dump the operator spelling for overloaded operators. This mirrors what is done for built-in operators.
2020-06-09 15:03:22 +01:00
void TextNodeDumper::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node) {
const char *OperatorSpelling = clang::getOperatorSpelling(Node->getOperator());
if (OperatorSpelling)
OS << " '" << OperatorSpelling << "'";
VisitCallExpr(Node);
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
void TextNodeDumper::VisitCastExpr(const CastExpr *Node) {
OS << " <";
{
ColorScope Color(OS, ShowColors, CastColor);
OS << Node->getCastKindName();
}
dumpBasePath(OS, Node);
OS << ">";
[AST][FPEnv] Keep FP options in trailing storage of CastExpr This is recommit of 6c8041aa0f, reverted in de044f7562 because of some fails. Original commit message is below. This change allow a CastExpr to have optional FPOptionsOverride object, stored in trailing storage. Of all cast nodes only ImplicitCastExpr, CStyleCastExpr, CXXFunctionalCastExpr and CXXStaticCastExpr are allowed to have FPOptions. Differential Revision: https://reviews.llvm.org/D85960
2020-09-12 21:54:14 +07:00
if (Node->hasStoredFPFeatures())
printFPOptions(Node->getFPFeatures());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
VisitCastExpr(Node);
if (Node->isPartOfExplicitCast())
OS << " part_of_explicit_cast";
}
void TextNodeDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
OS << " ";
dumpBareDeclRef(Node->getDecl());
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
dumpNestedNameSpecifier(Node->getQualifier());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
if (Node->getDecl() != Node->getFoundDecl()) {
OS << " (";
dumpBareDeclRef(Node->getFoundDecl());
OS << ")";
}
For DR712: store on a DeclRefExpr whether it constitutes an odr-use. Begin restructuring to support the forms of non-odr-use reference permitted by DR712. llvm-svn: 363086
2019-06-11 17:50:32 +00:00
switch (Node->isNonOdrUse()) {
case NOUR_None: break;
case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
case NOUR_Constant: OS << " non_odr_use_constant"; break;
case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
}
[Clang] [Sema] Fix dependence of DREs in lambdas with an explicit object parameter (#84473) This fixes some problems wrt dependence of captures in lambdas with an explicit object parameter. [temp.dep.expr] states that > An id-expression is type-dependent if [...] its terminal name is > - associated by name lookup with an entity captured by copy > ([expr.prim.lambda.capture]) in a lambda-expression that has > an explicit object parameter whose type is dependent [dcl.fct]. There were several issues with our implementation of this: 1. we were treating by-reference captures as dependent rather than by-value captures; 2. tree transform wasn't checking whether referring to such a by-value capture should make a DRE dependent; 3. when checking whether a DRE refers to such a by-value capture, we were only looking at the immediately enclosing lambda, and not at any parent lambdas; 4. we also forgot to check for implicit by-value captures; 5. lastly, we were attempting to determine whether a lambda has an explicit object parameter by checking the `LambdaScopeInfo`'s `ExplicitObjectParameter`, but it seems that that simply wasn't set (yet) by the time we got to the check. All of these should be fixed now. This fixes #70604, #79754, #84163, #84425, #86054, #86398, and #86399.
2024-04-09 14:52:52 +02:00
if (Node->isCapturedByCopyInLambdaWithExplicitObjectParameter())
OS << " dependent_capture";
else if (Node->refersToEnclosingVariableOrCapture())
[clang][AST] TextNodeDumper learned to output refers_to_enclosing_variable_or_capture flag for DeclRefExpr Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D158265
2023-08-18 13:54:55 +00:00
OS << " refers_to_enclosing_variable_or_capture";
[Clang] [Sema] Fix dependence of DREs in lambdas with an explicit object parameter (#84473) This fixes some problems wrt dependence of captures in lambdas with an explicit object parameter. [temp.dep.expr] states that > An id-expression is type-dependent if [...] its terminal name is > - associated by name lookup with an entity captured by copy > ([expr.prim.lambda.capture]) in a lambda-expression that has > an explicit object parameter whose type is dependent [dcl.fct]. There were several issues with our implementation of this: 1. we were treating by-reference captures as dependent rather than by-value captures; 2. tree transform wasn't checking whether referring to such a by-value capture should make a DRE dependent; 3. when checking whether a DRE refers to such a by-value capture, we were only looking at the immediately enclosing lambda, and not at any parent lambdas; 4. we also forgot to check for implicit by-value captures; 5. lastly, we were attempting to determine whether a lambda has an explicit object parameter by checking the `LambdaScopeInfo`'s `ExplicitObjectParameter`, but it seems that that simply wasn't set (yet) by the time we got to the check. All of these should be fixed now. This fixes #70604, #79754, #84163, #84425, #86054, #86398, and #86399.
2024-04-09 14:52:52 +02:00
[clang] Implement P2564 "consteval must propagate up" Reviewed By: aaron.ballman, #clang-language-wg Differential Revision: https://reviews.llvm.org/D151094
2023-05-08 12:18:43 +02:00
if (Node->isImmediateEscalating())
OS << " immediate-escalating";
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
void clang::TextNodeDumper::VisitDependentScopeDeclRefExpr(
const DependentScopeDeclRefExpr *Node) {
dumpNestedNameSpecifier(Node->getQualifier());
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
void TextNodeDumper::VisitUnresolvedLookupExpr(
const UnresolvedLookupExpr *Node) {
OS << " (";
if (!Node->requiresADL())
OS << "no ";
OS << "ADL) = '" << Node->getName() << '\'';
UnresolvedLookupExpr::decls_iterator I = Node->decls_begin(),
E = Node->decls_end();
if (I == E)
OS << " empty";
for (; I != E; ++I)
dumpPointer(*I);
}
void TextNodeDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
}
OS << "='" << *Node->getDecl() << "'";
dumpPointer(Node->getDecl());
if (Node->isFreeIvar())
OS << " isFreeIvar";
}
Reimplement __builtin_unique_stable_name- The original version of this was reverted, and @rjmcall provided some advice to architect a new solution. This is that solution. This implements a builtin to provide a unique name that is stable across compilations of this TU for the purposes of implementing the library component of the unnamed kernel feature of SYCL. It does this by running the Itanium mangler with a few modifications. Because it is somewhat common to wrap non-kernel-related lambdas in macros that aren't present on the device (such as for logging), this uniquely generates an ID for all lambdas involved in the naming of a kernel. It uses the lambda-mangling number to do this, except replaces this with its own number (starting at 10000 for readabililty reasons) for lambdas used to name a kernel. Additionally, this implements itself as constexpr with a slight catch: if a name would be invalidated by the use of this lambda in a later kernel invocation, it is diagnosed as an error (see the Sema tests). Differential Revision: https://reviews.llvm.org/D103112
2021-04-23 08:22:35 -07:00
void TextNodeDumper::VisitSYCLUniqueStableNameExpr(
const SYCLUniqueStableNameExpr *Node) {
dumpType(Node->getTypeSourceInfo()->getType());
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
void TextNodeDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
}
void TextNodeDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
ColorScope Color(OS, ShowColors, ValueColor);
OS << " " << Node->getValue();
}
void TextNodeDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
bool isSigned = Node->getType()->isSignedIntegerType();
ColorScope Color(OS, ShowColors, ValueColor);
[ADT] Remove APInt/APSInt toString() std::string variants <string> is currently the highest impact header in a clang+llvm build: https://commondatastorage.googleapis.com/chromium-browser-clang/llvm-include-analysis.html One of the most common places this is being included is the APInt.h header, which needs it for an old toString() implementation that returns std::string - an inefficient method compared to the SmallString versions that it actually wraps. This patch replaces these APInt/APSInt methods with a pair of llvm::toString() helpers inside StringExtras.h, adjusts users accordingly and removes the <string> from APInt.h - I was hoping that more of these users could be converted to use the SmallString methods, but it appears that most end up creating a std::string anyhow. I avoided trying to use the raw_ostream << operators as well as I didn't want to lose having the integer radix explicit in the code. Differential Revision: https://reviews.llvm.org/D103888
2021-06-11 13:19:00 +01:00
OS << " " << toString(Node->getValue(), 10, isSigned);
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitFixedPointLiteral(const FixedPointLiteral *Node) {
ColorScope Color(OS, ShowColors, ValueColor);
OS << " " << Node->getValueAsString(/*Radix=*/10);
}
void TextNodeDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
ColorScope Color(OS, ShowColors, ValueColor);
OS << " " << Node->getValueAsApproximateDouble();
}
void TextNodeDumper::VisitStringLiteral(const StringLiteral *Str) {
ColorScope Color(OS, ShowColors, ValueColor);
OS << " ";
Str->outputString(OS);
}
void TextNodeDumper::VisitInitListExpr(const InitListExpr *ILE) {
if (auto *Field = ILE->getInitializedFieldInUnion()) {
OS << " field ";
dumpBareDeclRef(Field);
}
}
NFC: Move GenericSelectionExpr dump to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56961 llvm-svn: 352558
2019-01-29 22:58:28 +00:00
void TextNodeDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
if (E->isResultDependent())
OS << " result_dependent";
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
void TextNodeDumper::VisitUnaryOperator(const UnaryOperator *Node) {
OS << " " << (Node->isPostfix() ? "postfix" : "prefix") << " '"
<< UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
if (!Node->canOverflow())
OS << " cannot overflow";
[AST][FPEnv] Keep FP options in trailing storage of CallExpr This change allow a CallExpr to have optional FPOptionsOverride object, stored in trailing storage. The implementaion is made similar to the way used in BinaryOperator. Differential Revision: https://reviews.llvm.org/D84343
2020-07-24 12:04:19 +07:00
if (Node->hasStoredFPFeatures())
printFPOptions(Node->getStoredFPFeatures());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitUnaryExprOrTypeTraitExpr(
const UnaryExprOrTypeTraitExpr *Node) {
[clang][NFC] Generate the {Type,ArrayType,UnaryExprOrType,Expression}Traits... ...enumerations from TokenKinds.def and use the new macros from TokenKinds.def to remove the hard-coded lists of traits. All the information needed to generate these enumerations is already present in TokenKinds.def. The motivation here is to be able to dump the trait spelling without hard-coding the list in yet another place. Note that this change the order of the enumerators in the enumerations (except that in the TypeTrait enumeration all unary type traits are before all binary type traits, and all binary type traits are before all n-ary type traits). Apart from the aforementioned ordering which is relied upon, after this patch no code in clang or in the various clang tools depend on the specific ordering of the enumerators. No functional changes intended. Differential Revision: https://reviews.llvm.org/D81455 Reviewed By: aaron.ballman
2020-06-11 14:08:27 +01:00
OS << " " << getTraitSpelling(Node->getKind());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
if (Node->isArgumentType())
dumpType(Node->getArgumentType());
}
void TextNodeDumper::VisitMemberExpr(const MemberExpr *Node) {
OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
dumpPointer(Node->getMemberDecl());
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
dumpNestedNameSpecifier(Node->getQualifier());
For DR712: store on a MemberExpr whether it constitutes an odr-use. llvm-svn: 363087
2019-06-11 17:50:36 +00:00
switch (Node->isNonOdrUse()) {
case NOUR_None: break;
case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
case NOUR_Constant: OS << " non_odr_use_constant"; break;
case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitExtVectorElementExpr(
const ExtVectorElementExpr *Node) {
OS << " " << Node->getAccessor().getNameStart();
}
void TextNodeDumper::VisitBinaryOperator(const BinaryOperator *Node) {
OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
[AST][FPEnv] Keep FP options in trailing storage of CallExpr This change allow a CallExpr to have optional FPOptionsOverride object, stored in trailing storage. The implementaion is made similar to the way used in BinaryOperator. Differential Revision: https://reviews.llvm.org/D84343
2020-07-24 12:04:19 +07:00
if (Node->hasStoredFPFeatures())
printFPOptions(Node->getStoredFPFeatures());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitCompoundAssignOperator(
const CompoundAssignOperator *Node) {
OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
<< "' ComputeLHSTy=";
dumpBareType(Node->getComputationLHSType());
OS << " ComputeResultTy=";
dumpBareType(Node->getComputationResultType());
[FPEnv] Evaluate constant expressions under non-default rounding modes The change implements evaluation of constant floating point expressions under non-default rounding modes. The main objective was to support evaluation of global variable initializers, where constant rounding mode may be specified by `#pragma STDC FENV_ROUND`. Differential Revision: https://reviews.llvm.org/D87822
2020-09-17 14:10:07 +07:00
if (Node->hasStoredFPFeatures())
printFPOptions(Node->getStoredFPFeatures());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
OS << " " << Node->getLabel()->getName();
dumpPointer(Node->getLabel());
}
void TextNodeDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
OS << " " << Node->getCastName() << "<"
<< Node->getTypeAsWritten().getAsString() << ">"
<< " <" << Node->getCastKindName();
dumpBasePath(OS, Node);
OS << ">";
}
void TextNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
OS << " " << (Node->getValue() ? "true" : "false");
}
void TextNodeDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
[ASTDump] Add a flag indicating whether a CXXThisExpr is implicit There is currently no way to distinguish implicit from explicit CXXThisExpr in the AST dump output. Differential Revision: https://reviews.llvm.org/D57649 Reviewed By: steveire llvm-svn: 353003
2019-02-03 18:20:27 +00:00
if (Node->isImplicit())
OS << " implicit";
[Clang] [Sema] Fix dependence of DREs in lambdas with an explicit object parameter (#84473) This fixes some problems wrt dependence of captures in lambdas with an explicit object parameter. [temp.dep.expr] states that > An id-expression is type-dependent if [...] its terminal name is > - associated by name lookup with an entity captured by copy > ([expr.prim.lambda.capture]) in a lambda-expression that has > an explicit object parameter whose type is dependent [dcl.fct]. There were several issues with our implementation of this: 1. we were treating by-reference captures as dependent rather than by-value captures; 2. tree transform wasn't checking whether referring to such a by-value capture should make a DRE dependent; 3. when checking whether a DRE refers to such a by-value capture, we were only looking at the immediately enclosing lambda, and not at any parent lambdas; 4. we also forgot to check for implicit by-value captures; 5. lastly, we were attempting to determine whether a lambda has an explicit object parameter by checking the `LambdaScopeInfo`'s `ExplicitObjectParameter`, but it seems that that simply wasn't set (yet) by the time we got to the check. All of these should be fixed now. This fixes #70604, #79754, #84163, #84425, #86054, #86398, and #86399.
2024-04-09 14:52:52 +02:00
if (Node->isCapturedByCopyInLambdaWithExplicitObjectParameter())
OS << " dependent_capture";
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
OS << " this";
}
void TextNodeDumper::VisitCXXFunctionalCastExpr(
const CXXFunctionalCastExpr *Node) {
OS << " functional cast to " << Node->getTypeAsWritten().getAsString() << " <"
<< Node->getCastKindName() << ">";
[AST][FPEnv] Keep FP options in trailing storage of CastExpr This is recommit of 6c8041aa0f, reverted in de044f7562 because of some fails. Original commit message is below. This change allow a CastExpr to have optional FPOptionsOverride object, stored in trailing storage. Of all cast nodes only ImplicitCastExpr, CStyleCastExpr, CXXFunctionalCastExpr and CXXStaticCastExpr are allowed to have FPOptions. Differential Revision: https://reviews.llvm.org/D85960
2020-09-12 21:54:14 +07:00
if (Node->hasStoredFPFeatures())
printFPOptions(Node->getFPFeatures());
}
void TextNodeDumper::VisitCXXStaticCastExpr(const CXXStaticCastExpr *Node) {
VisitCXXNamedCastExpr(Node);
if (Node->hasStoredFPFeatures())
printFPOptions(Node->getFPFeatures());
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitCXXUnresolvedConstructExpr(
const CXXUnresolvedConstructExpr *Node) {
dumpType(Node->getTypeAsWritten());
if (Node->isListInitialization())
OS << " list";
}
void TextNodeDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
CXXConstructorDecl *Ctor = Node->getConstructor();
dumpType(Ctor->getType());
if (Node->isElidable())
OS << " elidable";
if (Node->isListInitialization())
OS << " list";
if (Node->isStdInitListInitialization())
OS << " std::initializer_list";
if (Node->requiresZeroInitialization())
OS << " zeroing";
[clang] Implement P2564 "consteval must propagate up" Reviewed By: aaron.ballman, #clang-language-wg Differential Revision: https://reviews.llvm.org/D151094
2023-05-08 12:18:43 +02:00
if (Node->isImmediateEscalating())
OS << " immediate-escalating";
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitCXXBindTemporaryExpr(
const CXXBindTemporaryExpr *Node) {
Removing a helper function that was trivial to inline into its only use; NFC. llvm-svn: 363935
2019-06-20 15:10:45 +00:00
OS << " (CXXTemporary";
dumpPointer(Node);
OS << ")";
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
if (Node->isGlobalNew())
OS << " global";
if (Node->isArray())
OS << " array";
if (Node->getOperatorNew()) {
OS << ' ';
dumpBareDeclRef(Node->getOperatorNew());
}
// We could dump the deallocation function used in case of error, but it's
// usually not that interesting.
}
void TextNodeDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
if (Node->isGlobalDelete())
OS << " global";
if (Node->isArrayForm())
OS << " array";
if (Node->getOperatorDelete()) {
OS << ' ';
dumpBareDeclRef(Node->getOperatorDelete());
}
}
[clang] TextNodeDumper: Dump the trait spelling of {Type,ArrayType,Expression}TraitExpr nodes using the new helper functions introduced in 78e636b3f2f0b0487130b31fade4f95ab179a18c.
2020-06-11 17:36:28 +01:00
void TextNodeDumper::VisitTypeTraitExpr(const TypeTraitExpr *Node) {
OS << " " << getTraitSpelling(Node->getTrait());
}
void TextNodeDumper::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *Node) {
OS << " " << getTraitSpelling(Node->getTrait());
}
void TextNodeDumper::VisitExpressionTraitExpr(const ExpressionTraitExpr *Node) {
OS << " " << getTraitSpelling(Node->getTrait());
}
[Clang] Dump the rewritten sub-expressions in CXXDefaultArgExpr/CXXDefaultInitExpr (#80001) This patch dump the rewritten sub-expressions in `CXXDefaultArgExpr` and `CXXDefaultInitExpr`. This machinery is useful for checking whether the materialized temporaries is lifetime-extended in the sub-AST of `CXXDefaultArgExpr` (`CXXDefaultInitExpr` has not been lifetime extendend now). Signed-off-by: yronglin <yronglin777@gmail.com>
2024-01-31 06:33:21 +08:00
void TextNodeDumper::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *Node) {
[Clang] Fix AST dump for {CXXDefaultArgExpr, CXXDefaultInitExpr} (#88269) This PR fix a AST dump issue since https://github.com/llvm/llvm-project/pull/80001 When Clang dumps `CXXDefaultArgExpr`/`CXXDefaultInitExpr`, there has no recursively dump the complete `CXXDefaultArgExpr`/`CXXDefaultInitExpr`. Since this PR, Clang will recursively dump a `CXXDefaultArgExpr`/`CXXDefaultInitExpr` node, even if the node has no rewritten init. *Consider*: ``` struct A { int arr[1]; }; struct B { const A &a = A{{0}}; }; void test() { B b{}; } ``` *Before*: ``` `-FunctionDecl <line:9:1, line:11:1> line:9:6 test 'void ()' `-CompoundStmt <col:13, line:11:1> `-DeclStmt <line:10:3, col:8> `-VarDecl <col:3, col:7> col:5 b 'B' listinit `-InitListExpr <col:6, col:7> 'B' `-CXXDefaultInitExpr <col:7> 'const A' lvalue has rewritten init `-ExprWithCleanups <line:6:16, col:21> 'const A' lvalue ``` *After*: ``` `-FunctionDecl 0x15a9455a8 <line:9:1, line:11:1> line:9:6 test 'void ()' `-CompoundStmt 0x15a945850 <col:13, line:11:1> `-DeclStmt 0x15a945838 <line:10:3, col:8> `-VarDecl 0x15a945708 <col:3, col:7> col:5 b 'B' listinit `-InitListExpr 0x15a9457b0 <col:6, col:7> 'B' `-CXXDefaultInitExpr 0x15a9457f8 <col:7> 'const A' lvalue has rewritten init `-ExprWithCleanups 0x15a945568 <line:6:16, col:21> 'const A' lvalue `-MaterializeTemporaryExpr 0x15a945500 <col:16, col:21> 'const A' lvalue extended by Field 0x15a945160 'a' 'const A &' `-ImplicitCastExpr 0x15a9454e8 <col:16, col:21> 'const A' <NoOp> `-CXXFunctionalCastExpr 0x15a9454c0 <col:16, col:21> 'A' functional cast to A <NoOp> `-InitListExpr 0x15a9452c0 <col:17, col:21> 'A' `-InitListExpr 0x15a945308 <col:18, col:20> 'int[1]' `-IntegerLiteral 0x15a945210 <col:19> 'int' 0 ``` --------- Signed-off-by: yronglin <yronglin777@gmail.com>
2024-04-12 22:39:40 +08:00
if (Node->hasRewrittenInit())
[Clang] Dump the rewritten sub-expressions in CXXDefaultArgExpr/CXXDefaultInitExpr (#80001) This patch dump the rewritten sub-expressions in `CXXDefaultArgExpr` and `CXXDefaultInitExpr`. This machinery is useful for checking whether the materialized temporaries is lifetime-extended in the sub-AST of `CXXDefaultArgExpr` (`CXXDefaultInitExpr` has not been lifetime extendend now). Signed-off-by: yronglin <yronglin777@gmail.com>
2024-01-31 06:33:21 +08:00
OS << " has rewritten init";
}
void TextNodeDumper::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *Node) {
[Clang] Fix AST dump for {CXXDefaultArgExpr, CXXDefaultInitExpr} (#88269) This PR fix a AST dump issue since https://github.com/llvm/llvm-project/pull/80001 When Clang dumps `CXXDefaultArgExpr`/`CXXDefaultInitExpr`, there has no recursively dump the complete `CXXDefaultArgExpr`/`CXXDefaultInitExpr`. Since this PR, Clang will recursively dump a `CXXDefaultArgExpr`/`CXXDefaultInitExpr` node, even if the node has no rewritten init. *Consider*: ``` struct A { int arr[1]; }; struct B { const A &a = A{{0}}; }; void test() { B b{}; } ``` *Before*: ``` `-FunctionDecl <line:9:1, line:11:1> line:9:6 test 'void ()' `-CompoundStmt <col:13, line:11:1> `-DeclStmt <line:10:3, col:8> `-VarDecl <col:3, col:7> col:5 b 'B' listinit `-InitListExpr <col:6, col:7> 'B' `-CXXDefaultInitExpr <col:7> 'const A' lvalue has rewritten init `-ExprWithCleanups <line:6:16, col:21> 'const A' lvalue ``` *After*: ``` `-FunctionDecl 0x15a9455a8 <line:9:1, line:11:1> line:9:6 test 'void ()' `-CompoundStmt 0x15a945850 <col:13, line:11:1> `-DeclStmt 0x15a945838 <line:10:3, col:8> `-VarDecl 0x15a945708 <col:3, col:7> col:5 b 'B' listinit `-InitListExpr 0x15a9457b0 <col:6, col:7> 'B' `-CXXDefaultInitExpr 0x15a9457f8 <col:7> 'const A' lvalue has rewritten init `-ExprWithCleanups 0x15a945568 <line:6:16, col:21> 'const A' lvalue `-MaterializeTemporaryExpr 0x15a945500 <col:16, col:21> 'const A' lvalue extended by Field 0x15a945160 'a' 'const A &' `-ImplicitCastExpr 0x15a9454e8 <col:16, col:21> 'const A' <NoOp> `-CXXFunctionalCastExpr 0x15a9454c0 <col:16, col:21> 'A' functional cast to A <NoOp> `-InitListExpr 0x15a9452c0 <col:17, col:21> 'A' `-InitListExpr 0x15a945308 <col:18, col:20> 'int[1]' `-IntegerLiteral 0x15a945210 <col:19> 'int' 0 ``` --------- Signed-off-by: yronglin <yronglin777@gmail.com>
2024-04-12 22:39:40 +08:00
if (Node->hasRewrittenInit())
[Clang] Dump the rewritten sub-expressions in CXXDefaultArgExpr/CXXDefaultInitExpr (#80001) This patch dump the rewritten sub-expressions in `CXXDefaultArgExpr` and `CXXDefaultInitExpr`. This machinery is useful for checking whether the materialized temporaries is lifetime-extended in the sub-AST of `CXXDefaultArgExpr` (`CXXDefaultInitExpr` has not been lifetime extendend now). Signed-off-by: yronglin <yronglin777@gmail.com>
2024-01-31 06:33:21 +08:00
OS << " has rewritten init";
}
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
void TextNodeDumper::VisitMaterializeTemporaryExpr(
const MaterializeTemporaryExpr *Node) {
if (const ValueDecl *VD = Node->getExtendingDecl()) {
OS << " extended by ";
dumpBareDeclRef(VD);
}
}
void TextNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
[CodeGen] Emit destructor calls to destruct compound literals Fix a bug in IRGen where it wasn't destructing compound literals in C that are ObjC pointer arrays or non-trivial structs. Also diagnose jumps that enter or exit the lifetime of the compound literals. rdar://problem/51867864 Differential Revision: https://reviews.llvm.org/D64464
2020-03-10 14:06:25 -07:00
dumpCleanupObject(Node->getObject(i));
[ASTDump] NFC: Move dump of individual Stmts to TextNodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D55340 llvm-svn: 351014
2019-01-12 16:53:27 +00:00
}
void TextNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
dumpPointer(Node->getPack());
dumpName(Node->getPack());
}
void TextNodeDumper::VisitCXXDependentScopeMemberExpr(
const CXXDependentScopeMemberExpr *Node) {
OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
}
void TextNodeDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
OS << " selector=";
Node->getSelector().print(OS);
switch (Node->getReceiverKind()) {
case ObjCMessageExpr::Instance:
break;
case ObjCMessageExpr::Class:
OS << " class=";
dumpBareType(Node->getClassReceiver());
break;
case ObjCMessageExpr::SuperInstance:
OS << " super (instance)";
break;
case ObjCMessageExpr::SuperClass:
OS << " super (class)";
break;
}
}
void TextNodeDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
if (auto *BoxingMethod = Node->getBoxingMethod()) {
OS << " selector=";
BoxingMethod->getSelector().print(OS);
}
}
void TextNodeDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
if (!Node->getCatchParamDecl())
OS << " catch all";
}
void TextNodeDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
dumpType(Node->getEncodedType());
}
void TextNodeDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
OS << " ";
Node->getSelector().print(OS);
}
void TextNodeDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
OS << ' ' << *Node->getProtocol();
}
void TextNodeDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
if (Node->isImplicitProperty()) {
OS << " Kind=MethodRef Getter=\"";
if (Node->getImplicitPropertyGetter())
Node->getImplicitPropertyGetter()->getSelector().print(OS);
else
OS << "(null)";
OS << "\" Setter=\"";
if (ObjCMethodDecl *Setter = Node->getImplicitPropertySetter())
Setter->getSelector().print(OS);
else
OS << "(null)";
OS << "\"";
} else {
OS << " Kind=PropertyRef Property=\"" << *Node->getExplicitProperty()
<< '"';
}
if (Node->isSuperReceiver())
OS << " super";
OS << " Messaging=";
if (Node->isMessagingGetter() && Node->isMessagingSetter())
OS << "Getter&Setter";
else if (Node->isMessagingGetter())
OS << "Getter";
else if (Node->isMessagingSetter())
OS << "Setter";
}
void TextNodeDumper::VisitObjCSubscriptRefExpr(
const ObjCSubscriptRefExpr *Node) {
if (Node->isArraySubscriptRefExpr())
OS << " Kind=ArraySubscript GetterForArray=\"";
else
OS << " Kind=DictionarySubscript GetterForDictionary=\"";
if (Node->getAtIndexMethodDecl())
Node->getAtIndexMethodDecl()->getSelector().print(OS);
else
OS << "(null)";
if (Node->isArraySubscriptRefExpr())
OS << "\" SetterForArray=\"";
else
OS << "\" SetterForDictionary=\"";
if (Node->setAtIndexMethodDecl())
Node->setAtIndexMethodDecl()->getSelector().print(OS);
else
OS << "(null)";
}
void TextNodeDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
}
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
[OPENMP50]Add initial support for OpenMP 5.0 iterator. Added basic parsing/semantic analysis/(de)serialization support for iterator expression introduced in OpenMP 5.0.
2020-04-01 15:06:38 -04:00
void TextNodeDumper::VisitOMPIteratorExpr(const OMPIteratorExpr *Node) {
OS << " ";
for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {
Visit(Node->getIteratorDecl(I));
OS << " = ";
const OMPIteratorExpr::IteratorRange Range = Node->getIteratorRange(I);
OS << " begin ";
Visit(Range.Begin);
OS << " end ";
Visit(Range.End);
if (Range.Step) {
OS << " step ";
Visit(Range.Step);
}
}
}
[Concepts] Include the found concept decl when dumping the ConceptSpecializationExpr Differential Revision: https://reviews.llvm.org/D85124
2020-08-04 15:58:12 +02:00
void TextNodeDumper::VisitConceptSpecializationExpr(
const ConceptSpecializationExpr *Node) {
OS << " ";
dumpBareDeclRef(Node->getFoundDecl());
}
Add dumping support for RequiresExpr. In passing, fix an ast-print bug that inserted a spurious extra `;` after a concept definition.
2021-06-30 14:05:34 -07:00
void TextNodeDumper::VisitRequiresExpr(
const RequiresExpr *Node) {
if (!Node->isValueDependent())
OS << (Node->isSatisfied() ? " satisfied" : " unsatisfied");
}
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
void TextNodeDumper::VisitRValueReferenceType(const ReferenceType *T) {
if (T->isSpelledAsLValue())
OS << " written as lvalue reference";
}
void TextNodeDumper::VisitArrayType(const ArrayType *T) {
switch (T->getSizeModifier()) {
[clang][NFC] Refactor `ArrayType::ArraySizeModifier` This patch moves `ArraySizeModifier` before `Type` declaration so that it's complete at `ArrayTypeBitfields` declaration. It's also converted to scoped enum along the way.
2023-10-31 17:43:10 +03:00
case ArraySizeModifier::Normal:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
break;
[clang][NFC] Refactor `ArrayType::ArraySizeModifier` This patch moves `ArraySizeModifier` before `Type` declaration so that it's complete at `ArrayTypeBitfields` declaration. It's also converted to scoped enum along the way.
2023-10-31 17:43:10 +03:00
case ArraySizeModifier::Static:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
OS << " static";
break;
[clang][NFC] Refactor `ArrayType::ArraySizeModifier` This patch moves `ArraySizeModifier` before `Type` declaration so that it's complete at `ArrayTypeBitfields` declaration. It's also converted to scoped enum along the way.
2023-10-31 17:43:10 +03:00
case ArraySizeModifier::Star:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
OS << " *";
break;
}
OS << " " << T->getIndexTypeQualifiers().getAsString();
}
void TextNodeDumper::VisitConstantArrayType(const ConstantArrayType *T) {
OS << " " << T->getSize();
VisitArrayType(T);
}
void TextNodeDumper::VisitVariableArrayType(const VariableArrayType *T) {
OS << " ";
dumpSourceRange(T->getBracketsRange());
VisitArrayType(T);
}
void TextNodeDumper::VisitDependentSizedArrayType(
const DependentSizedArrayType *T) {
VisitArrayType(T);
OS << " ";
dumpSourceRange(T->getBracketsRange());
}
void TextNodeDumper::VisitDependentSizedExtVectorType(
const DependentSizedExtVectorType *T) {
OS << " ";
dumpLocation(T->getAttributeLoc());
}
void TextNodeDumper::VisitVectorType(const VectorType *T) {
switch (T->getVectorKind()) {
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::Generic:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::AltiVecVector:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
OS << " altivec";
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::AltiVecPixel:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
OS << " altivec pixel";
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::AltiVecBool:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
OS << " altivec bool";
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::Neon:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
OS << " neon";
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::NeonPoly:
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
OS << " neon poly";
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::SveFixedLengthData:
[Sema][AArch64] Support arm_sve_vector_bits attribute This patch implements the semantics for the 'arm_sve_vector_bits' type attribute, defined by the Arm C Language Extensions (ACLE) for SVE [1]. The purpose of this attribute is to define vector-length-specific (VLS) versions of existing vector-length-agnostic (VLA) types. The semantics were already implemented by D83551, although the implementation approach has since changed to represent VLSTs as VectorType in the AST and fixed-length vectors in the IR everywhere except in function args/returns. This is described in the prototype patch D85128 demonstrating the new approach. The semantic changes added in D83551 are changed since the AttributedType is replaced by VectorType in the AST. Minimal changes were necessary in the previous patch as the canonical type for both VLA and VLS was the same (i.e. sizeless), except in constructs such as globals and structs where sizeless types are unsupported. This patch reverts the changes that permitted VLS types that were represented as sizeless types in such circumstances, and adds support for implicit casting between VLA <-> VLS types as described in section 3.7.3.2 of the ACLE. Since the SVE builtin types for bool and uint8 are both represented as BuiltinType::UChar in VLSTs, two new vector kinds are implemented to distinguish predicate and data vectors. [1] https://developer.arm.com/documentation/100987/latest Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D85736
2020-08-11 13:04:21 +00:00
OS << " fixed-length sve data vector";
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::SveFixedLengthPredicate:
[Sema][AArch64] Support arm_sve_vector_bits attribute This patch implements the semantics for the 'arm_sve_vector_bits' type attribute, defined by the Arm C Language Extensions (ACLE) for SVE [1]. The purpose of this attribute is to define vector-length-specific (VLS) versions of existing vector-length-agnostic (VLA) types. The semantics were already implemented by D83551, although the implementation approach has since changed to represent VLSTs as VectorType in the AST and fixed-length vectors in the IR everywhere except in function args/returns. This is described in the prototype patch D85128 demonstrating the new approach. The semantic changes added in D83551 are changed since the AttributedType is replaced by VectorType in the AST. Minimal changes were necessary in the previous patch as the canonical type for both VLA and VLS was the same (i.e. sizeless), except in constructs such as globals and structs where sizeless types are unsupported. This patch reverts the changes that permitted VLS types that were represented as sizeless types in such circumstances, and adds support for implicit casting between VLA <-> VLS types as described in section 3.7.3.2 of the ACLE. Since the SVE builtin types for bool and uint8 are both represented as BuiltinType::UChar in VLSTs, two new vector kinds are implemented to distinguish predicate and data vectors. [1] https://developer.arm.com/documentation/100987/latest Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D85736
2020-08-11 13:04:21 +00:00
OS << " fixed-length sve predicate vector";
break;
[clang][NFC] Refactor `VectorType::VectorKind` This patch moves `VectorKind` to namespace scope, and make it complete at the point its bit-field is declared. It also converts it to a scoped enum.
2023-10-31 21:48:42 +03:00
case VectorKind::RVVFixedLengthData:
[RISCV] Add attribute(riscv_rvv_vector_bits(N)) based on AArch64 arm_sve_vector_bits. This allows the user to set the size of the scalable vector so they can be used in structs and as the type of global variables. This works by representing the type as a fixed vector instead of a scalable vector in IR. Conversions to and from scalable vectors are made where necessary like function arguments/returns and intrinsics. This features has been requested here https://github.com/riscv-non-isa/rvv-intrinsic-doc/issues/176 I know arm_sve_vector_bits is used by the Eigen library so this could be used to port Eigen to RVV. This patch adds a new preprocessor define `__riscv_v_fixed_vlen` that is set when -mrvv_vector_bits is passed on the command line. The code is largely based on the AArch64 code. A lot of code was copy/pasted and then modiied to RVV. There may be some opportunities for sharing. This first patch only supports the LMUL=1 types. Additional changes will be needed to support other LMULs. I have also not supported mask vectors. Differential Revision: https://reviews.llvm.org/D145088
2023-04-28 15:41:17 -07:00
OS << " fixed-length rvv data vector";
break;
Recommit "[RISCV] Support __riscv_v_fixed_vlen for vbool types. (#76551)" Test updated to expect i8 gep. Original message: This adopts a similar behavior to AArch64 SVE, where bool vectors are represented as a vector of chars with 1/8 the number of elements. This ensures the vector always occupies a power of 2 number of bytes. A consequence of this is that vbool64_t, vbool32_t, and vool16_t can only be used with a vector length that guarantees at least 8 bits.
2024-01-25 09:39:29 -08:00
case VectorKind::RVVFixedLengthMask:
[RISCV] full support for riscv_rvv_vector_bits attribute (#100110) Add support for using attribute((rvv_vector_bits(N))), when N < 8. It allows using all fixed length vector mask types regardless VLEN value.
2024-08-08 12:45:20 +03:00
case VectorKind::RVVFixedLengthMask_1:
case VectorKind::RVVFixedLengthMask_2:
case VectorKind::RVVFixedLengthMask_4:
Recommit "[RISCV] Support __riscv_v_fixed_vlen for vbool types. (#76551)" Test updated to expect i8 gep. Original message: This adopts a similar behavior to AArch64 SVE, where bool vectors are represented as a vector of chars with 1/8 the number of elements. This ensures the vector always occupies a power of 2 number of bytes. A consequence of this is that vbool64_t, vbool32_t, and vool16_t can only be used with a vector length that guarantees at least 8 bits.
2024-01-25 09:39:29 -08:00
OS << " fixed-length rvv mask vector";
break;
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
}
OS << " " << T->getNumElements();
}
void TextNodeDumper::VisitFunctionType(const FunctionType *T) {
auto EI = T->getExtInfo();
if (EI.getNoReturn())
OS << " noreturn";
if (EI.getProducesResult())
OS << " produces_result";
if (EI.getHasRegParm())
OS << " regparm " << EI.getRegParm();
OS << " " << FunctionType::getNameForCallConv(EI.getCC());
}
void TextNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
auto EPI = T->getExtProtoInfo();
if (EPI.HasTrailingReturn)
OS << " trailing_return";
if (T->isConst())
OS << " const";
if (T->isVolatile())
OS << " volatile";
if (T->isRestrict())
OS << " restrict";
[ASTDump] Mark variadic declarations with a tag instead of child node Summary: This makes it easier to separate traversal of the AST from output generation. Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56751 llvm-svn: 351597
2019-01-18 21:38:30 +00:00
if (T->getExtProtoInfo().Variadic)
OS << " variadic";
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
switch (EPI.RefQualifier) {
case RQ_None:
break;
case RQ_LValue:
OS << " &";
break;
case RQ_RValue:
OS << " &&";
break;
}
[clang][AST] TextNodeDumper learned to output exception specifications Extended TextNodeDumper::VisitFunctionProtoType to output exception specifications Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D155383
2023-08-10 18:45:56 +00:00
switch (EPI.ExceptionSpec.Type) {
case EST_None:
break;
case EST_DynamicNone:
OS << " exceptionspec_dynamic_none";
break;
case EST_Dynamic:
OS << " exceptionspec_dynamic";
break;
case EST_MSAny:
OS << " exceptionspec_ms_any";
break;
case EST_NoThrow:
OS << " exceptionspec_nothrow";
break;
case EST_BasicNoexcept:
OS << " exceptionspec_basic_noexcept";
break;
case EST_DependentNoexcept:
OS << " exceptionspec_dependent_noexcept";
break;
case EST_NoexceptFalse:
OS << " exceptionspec_noexcept_false";
break;
case EST_NoexceptTrue:
OS << " exceptionspec_noexcept_true";
break;
case EST_Unevaluated:
OS << " exceptionspec_unevaluated";
break;
case EST_Uninstantiated:
OS << " exceptionspec_uninstantiated";
break;
case EST_Unparsed:
OS << " exceptionspec_unparsed";
break;
}
if (!EPI.ExceptionSpec.Exceptions.empty()) {
AddChild([=] {
OS << "Exceptions:";
for (unsigned I = 0, N = EPI.ExceptionSpec.Exceptions.size(); I != N;
++I) {
if (I)
OS << ",";
dumpType(EPI.ExceptionSpec.Exceptions[I]);
}
});
}
if (EPI.ExceptionSpec.NoexceptExpr) {
AddChild([=] {
OS << "NoexceptExpr: ";
Visit(EPI.ExceptionSpec.NoexceptExpr);
});
}
dumpDeclRef(EPI.ExceptionSpec.SourceDecl, "ExceptionSourceDecl");
dumpDeclRef(EPI.ExceptionSpec.SourceTemplate, "ExceptionSourceTemplate");
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
// FIXME: Consumed parameters.
VisitFunctionType(T);
}
void TextNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
dumpDeclRef(T->getDecl());
}
Reland "[AST] Add UsingType: a sugar type for types found via UsingDecl" This reverts commit cc56c66f27e131b914082d3bd21180646e842e9a. Fixed a bad assertion, the target of a UsingShadowDecl must not have *local* qualifiers, but it can be a typedef whose underlying type is qualified.
2021-12-20 18:01:33 +01:00
void TextNodeDumper::VisitUsingType(const UsingType *T) {
dumpDeclRef(T->getFoundDecl());
[clang] Implement divergence for TypedefType and UsingType With this patch, TypedefTypes and UsingTypes can have an underlying type which diverges from their corresponding declarations. For the TypedefType case, this can be seen when getting the common sugared type between two redeclarations with different sugar. For both cases, this will become important as resugaring is implemented, as this will allow us to resugar these when they were dependent before instantiation. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D133468
2022-09-04 04:45:40 +02:00
if (!T->typeMatchesDecl())
OS << " divergent";
Reland "[AST] Add UsingType: a sugar type for types found via UsingDecl" This reverts commit cc56c66f27e131b914082d3bd21180646e842e9a. Fixed a bad assertion, the target of a UsingShadowDecl must not have *local* qualifiers, but it can be a typedef whose underlying type is qualified.
2021-12-20 18:01:33 +01:00
}
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
void TextNodeDumper::VisitTypedefType(const TypedefType *T) {
dumpDeclRef(T->getDecl());
[clang] Implement divergence for TypedefType and UsingType With this patch, TypedefTypes and UsingTypes can have an underlying type which diverges from their corresponding declarations. For the TypedefType case, this can be seen when getting the common sugared type between two redeclarations with different sugar. For both cases, this will become important as resugaring is implemented, as this will allow us to resugar these when they were dependent before instantiation. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D133468
2022-09-04 04:45:40 +02:00
if (!T->typeMatchesDecl())
OS << " divergent";
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
}
void TextNodeDumper::VisitUnaryTransformType(const UnaryTransformType *T) {
switch (T->getUTTKind()) {
[clang] adds unary type transformations as compiler built-ins Adds * `__add_lvalue_reference` * `__add_pointer` * `__add_rvalue_reference` * `__decay` * `__make_signed` * `__make_unsigned` * `__remove_all_extents` * `__remove_extent` * `__remove_const` * `__remove_volatile` * `__remove_cv` * `__remove_pointer` * `__remove_reference` * `__remove_cvref` These are all compiler built-in equivalents of the unary type traits found in [[meta.trans]][1]. The compiler already has all of the information it needs to answer these transformations, so we can skip needing to make partial specialisations in standard library implementations (we already do this for a lot of the query traits). This will hopefully improve compile times, as we won't need use as much memory in such a base part of the standard library. [1]: http://wg21.link/meta.trans Co-authored-by: zoecarver Reviewed By: aaron.ballman, rsmith Differential Revision: https://reviews.llvm.org/D116203
2022-08-22 00:27:10 +00:00
#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait) \
case UnaryTransformType::Enum: \
OS << " " #Trait; \
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
break;
[clang] adds unary type transformations as compiler built-ins Adds * `__add_lvalue_reference` * `__add_pointer` * `__add_rvalue_reference` * `__decay` * `__make_signed` * `__make_unsigned` * `__remove_all_extents` * `__remove_extent` * `__remove_const` * `__remove_volatile` * `__remove_cv` * `__remove_pointer` * `__remove_reference` * `__remove_cvref` These are all compiler built-in equivalents of the unary type traits found in [[meta.trans]][1]. The compiler already has all of the information it needs to answer these transformations, so we can skip needing to make partial specialisations in standard library implementations (we already do this for a lot of the query traits). This will hopefully improve compile times, as we won't need use as much memory in such a base part of the standard library. [1]: http://wg21.link/meta.trans Co-authored-by: zoecarver Reviewed By: aaron.ballman, rsmith Differential Revision: https://reviews.llvm.org/D116203
2022-08-22 00:27:10 +00:00
#include "clang/Basic/TransformTypeTraits.def"
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
}
}
void TextNodeDumper::VisitTagType(const TagType *T) {
dumpDeclRef(T->getDecl());
}
void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
OS << " depth " << T->getDepth() << " index " << T->getIndex();
if (T->isParameterPack())
OS << " pack";
dumpDeclRef(T->getDecl());
}
[clang] Fix AST representation of expanded template arguments. Extend clang's SubstTemplateTypeParm to represent the pack substitution index. Fixes PR56099. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D128113
2022-06-18 04:21:59 +02:00
void TextNodeDumper::VisitSubstTemplateTypeParmType(
const SubstTemplateTypeParmType *T) {
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
dumpDeclRef(T->getAssociatedDecl());
VisitTemplateTypeParmDecl(T->getReplacedParameter());
[clang] Fix AST representation of expanded template arguments. Extend clang's SubstTemplateTypeParm to represent the pack substitution index. Fixes PR56099. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D128113
2022-06-18 04:21:59 +02:00
if (auto PackIndex = T->getPackIndex())
OS << " pack_index " << *PackIndex;
}
[clang] Track the templated entity in type substitution. This is a change to how we represent type subsitution in the AST. Instead of only storing the replaced type, we track the templated entity we are substituting, plus an index. We modify MLTAL to track the templated entity at each level. Otherwise, it's much more expensive to go from the template parameter back to the templated entity, and not possible to do in some cases, as when we instantiate outer templates, parameters might still reference the original entity. This also allows us to very cheaply lookup the templated entity we saw in the naming context and find the corresponding argument it was replaced from, such as for implementing template specialization resugaring. Signed-off-by: Matheus Izvekov <mizvekov@gmail.com> Differential Revision: https://reviews.llvm.org/D131858
2022-08-14 13:48:18 +02:00
void TextNodeDumper::VisitSubstTemplateTypeParmPackType(
const SubstTemplateTypeParmPackType *T) {
dumpDeclRef(T->getAssociatedDecl());
VisitTemplateTypeParmDecl(T->getReplacedParameter());
}
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
void TextNodeDumper::VisitAutoType(const AutoType *T) {
if (T->isDecltypeAuto())
OS << " decltype(auto)";
if (!T->isDeduced())
OS << " undeduced";
[AST] Add dump() method to TypeLoc (#65484) The ability to dump AST nodes is important to ad-hoc debugging, and the fact this doesn't work with TypeLoc nodes is an obvious missing feature in e.g. clang-query (`set output dump` simply does nothing). Having TypeLoc::dump(), and enabling DynTypedNode::dump() for such nodes seems like a clear win. It looks like this: ``` int main(int argc, char **argv); FunctionProtoTypeLoc <test.cc:3:1, col:31> 'int (int, char **)' cdecl |-ParmVarDecl 0x30071a8 <col:10, col:14> col:14 argc 'int' | `-BuiltinTypeLoc <col:10> 'int' |-ParmVarDecl 0x3007250 <col:20, col:27> col:27 argv 'char **' | `-PointerTypeLoc <col:20, col:26> 'char **' | `-PointerTypeLoc <col:20, col:25> 'char *' | `-BuiltinTypeLoc <col:20> 'char' `-BuiltinTypeLoc <col:1> 'int' ``` It dumps the lexically nested tree of type locs. This often looks similar to how types are dumped, but unlike types we don't look at desugaring e.g. typedefs, as their underlying types are not lexically spelled here. --- Less clear is exactly when to include these nodes in existing text AST dumps rooted at (TranslationUnit)Decls. These already omit supported nodes sometimes, e.g. NestedNameSpecifiers are often mentioned but not recursively dumped. TypeLocs are a more extreme case: they're ~always more verbose than the current AST dump. So this patch punts on that, TypeLocs are only ever printed recursively as part of a TypeLoc::dump() call. It would also be nice to be able to invoke `clang` to dump a typeloc somehow, like `clang -cc1 -ast-dump`. But I don't know exactly what the best verison of that is, so this patch doesn't do it. --- There are similar (less critical!) nodes: TemplateArgumentLoc etc, these also don't have dump() functions today and are obvious extensions. I suspect that we should add these, and Loc nodes should dump each other (e.g. the ElaboratedTypeLoc `vector<int>::iterator` should dump the NestedNameSpecifierLoc `vector<int>::`, which dumps the TemplateSpecializationTypeLoc `vector<int>::` etc). Maybe this generalizes further to a "full syntactic dump" mode, where even Decls and Stmts would print the TypeLocs they lexically contain. But this may be more complex than useful. --- While here, ConceptReference JSON dumping must be implemented. It's not totally clear to me why this implementation wasn't required before but is now...
2024-01-31 16:40:29 +01:00
if (T->isConstrained())
[Concepts] Placeholder constraints and abbreviated templates This patch implements P1141R2 "Yet another approach for constrained declarations". General strategy for this patch was: - Expand AutoType to include optional type-constraint, reflecting the wording and easing the integration of constraints. - Replace autos in parameter type specifiers with invented parameters in GetTypeSpecTypeForDeclarator, using the same logic previously used for generic lambdas, now unified with abbreviated templates, by: - Tracking the template parameter lists in the Declarator object - Tracking the template parameter depth before parsing function declarators (at which point we can match template parameters against scope specifiers to know if we have an explicit template parameter list to append invented parameters to or not). - When encountering an AutoType in a parameter context we check a stack of InventedTemplateParameterInfo structures that contain the info required to create and accumulate invented template parameters (fields that were already present in LambdaScopeInfo, which now inherits from this class and is looked up when an auto is encountered in a lambda context). Resubmit after fixing MSAN failures caused by incomplete initialization of AutoTypeLocs in TypeSpecLocFiller. Differential Revision: https://reviews.llvm.org/D65042
2020-01-22 02:03:05 +02:00
dumpDeclRef(T->getTypeConstraintConcept());
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
}
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
void TextNodeDumper::VisitDeducedTemplateSpecializationType(
const DeducedTemplateSpecializationType *T) {
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
dumpTemplateName(T->getTemplateName(), "name");
Reland "[AST] Add a new TemplateKind for template decls found via a using decl."" This is the template version of https://reviews.llvm.org/D114251. This patch introduces a new template name kind (UsingTemplateName). The UsingTemplateName stores the found using-shadow decl (and underlying template can be retrieved from the using-shadow decl). With the new template name, we can be able to find the using decl that a template typeloc (e.g. TemplateSpecializationTypeLoc) found its underlying template, which is useful for tooling use cases (include cleaner etc). This patch merely focuses on adding the node to the AST. Next steps: - support using-decl in qualified template name; - update the clangd and other tools to use this new node; - add ast matchers for matching different kinds of template names; Differential Revision: https://reviews.llvm.org/D123127
2022-04-12 15:51:16 +02:00
}
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
void TextNodeDumper::VisitTemplateSpecializationType(
const TemplateSpecializationType *T) {
if (T->isTypeAlias())
OS << " alias";
[clang] text ast-dumper: dump TemplateName for TST and DTST (#93766) Implement AST text dumping of the TemplateName for TemplateSpecializationType and DeducedTemplateSpecializationType.
2024-05-30 04:48:45 -03:00
dumpTemplateName(T->getTemplateName(), "name");
[ASTDump] NFC: Move dump of type nodes to NodeDumper Reviewers: aaron.ballman Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D56642 llvm-svn: 351172
2019-01-15 09:30:00 +00:00
}
void TextNodeDumper::VisitInjectedClassNameType(
const InjectedClassNameType *T) {
dumpDeclRef(T->getDecl());
}
void TextNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
dumpDeclRef(T->getDecl());
}
void TextNodeDumper::VisitPackExpansionType(const PackExpansionType *T) {
if (auto N = T->getNumExpansions())
OS << " expansions " << *N;
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
[AST] Add dump() method to TypeLoc (#65484) The ability to dump AST nodes is important to ad-hoc debugging, and the fact this doesn't work with TypeLoc nodes is an obvious missing feature in e.g. clang-query (`set output dump` simply does nothing). Having TypeLoc::dump(), and enabling DynTypedNode::dump() for such nodes seems like a clear win. It looks like this: ``` int main(int argc, char **argv); FunctionProtoTypeLoc <test.cc:3:1, col:31> 'int (int, char **)' cdecl |-ParmVarDecl 0x30071a8 <col:10, col:14> col:14 argc 'int' | `-BuiltinTypeLoc <col:10> 'int' |-ParmVarDecl 0x3007250 <col:20, col:27> col:27 argv 'char **' | `-PointerTypeLoc <col:20, col:26> 'char **' | `-PointerTypeLoc <col:20, col:25> 'char *' | `-BuiltinTypeLoc <col:20> 'char' `-BuiltinTypeLoc <col:1> 'int' ``` It dumps the lexically nested tree of type locs. This often looks similar to how types are dumped, but unlike types we don't look at desugaring e.g. typedefs, as their underlying types are not lexically spelled here. --- Less clear is exactly when to include these nodes in existing text AST dumps rooted at (TranslationUnit)Decls. These already omit supported nodes sometimes, e.g. NestedNameSpecifiers are often mentioned but not recursively dumped. TypeLocs are a more extreme case: they're ~always more verbose than the current AST dump. So this patch punts on that, TypeLocs are only ever printed recursively as part of a TypeLoc::dump() call. It would also be nice to be able to invoke `clang` to dump a typeloc somehow, like `clang -cc1 -ast-dump`. But I don't know exactly what the best verison of that is, so this patch doesn't do it. --- There are similar (less critical!) nodes: TemplateArgumentLoc etc, these also don't have dump() functions today and are obvious extensions. I suspect that we should add these, and Loc nodes should dump each other (e.g. the ElaboratedTypeLoc `vector<int>::iterator` should dump the NestedNameSpecifierLoc `vector<int>::`, which dumps the TemplateSpecializationTypeLoc `vector<int>::` etc). Maybe this generalizes further to a "full syntactic dump" mode, where even Decls and Stmts would print the TypeLocs they lexically contain. But this may be more complex than useful. --- While here, ConceptReference JSON dumping must be implemented. It's not totally clear to me why this implementation wasn't required before but is now...
2024-01-31 16:40:29 +01:00
void TextNodeDumper::VisitTypeLoc(TypeLoc TL) {
// By default, add extra Type details with no extra loc info.
TypeVisitor<TextNodeDumper>::Visit(TL.getTypePtr());
}
// FIXME: override behavior for TypeLocs that have interesting location
// information, such as the qualifier in ElaboratedTypeLoc.
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
void TextNodeDumper::VisitLabelDecl(const LabelDecl *D) { dumpName(D); }
void TextNodeDumper::VisitTypedefDecl(const TypedefDecl *D) {
dumpName(D);
dumpType(D->getUnderlyingType());
if (D->isModulePrivate())
OS << " __module_private__";
}
void TextNodeDumper::VisitEnumDecl(const EnumDecl *D) {
if (D->isScoped()) {
if (D->isScopedUsingClassTag())
OS << " class";
else
OS << " struct";
}
dumpName(D);
if (D->isModulePrivate())
OS << " __module_private__";
if (D->isFixed())
dumpType(D->getIntegerType());
[Clang] Add 'instantiated_from' for enums in TextNodeDumper (#124409) This commit adds "instantiated_from" to the AST dump for EnumDecl, improving consistency with CXXRecordDecl and FunctionDecl, which also include this information. To achieve this, TextNodeDumper::VisitEnumDecl is updated with analogous lines found in TextNodeDumper::VisitFunctionDecl and TextNodeDumper::VisitCXXRecordDecl.
2025-02-18 17:07:03 +01:00
if (const auto *Instance = D->getInstantiatedFromMemberEnum()) {
OS << " instantiated_from";
dumpPointer(Instance);
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
void TextNodeDumper::VisitRecordDecl(const RecordDecl *D) {
OS << ' ' << D->getKindName();
dumpName(D);
if (D->isModulePrivate())
OS << " __module_private__";
if (D->isCompleteDefinition())
OS << " definition";
}
void TextNodeDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
dumpName(D);
dumpType(D->getType());
}
void TextNodeDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
dumpName(D);
dumpType(D->getType());
for (const auto *Child : D->chain())
dumpDeclRef(Child);
}
void TextNodeDumper::VisitFunctionDecl(const FunctionDecl *D) {
dumpName(D);
dumpType(D->getType());
[clang][AST] TextNodeDumper learned to output template specialization kind Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157705
2023-08-15 14:17:24 +00:00
dumpTemplateSpecializationKind(D->getTemplateSpecializationKind());
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
StorageClass SC = D->getStorageClass();
Revert "[NFC, Refactor] Modernize StorageClass from Specifiers.h to a scoped enum (II)" This reverts commit efc82c4ad2bcb256a4f4c20238d08cd3afba4d2d.
2021-01-04 23:17:45 +01:00
if (SC != SC_None)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
if (D->isInlineSpecified())
OS << " inline";
if (D->isVirtualAsWritten())
OS << " virtual";
if (D->isModulePrivate())
OS << " __module_private__";
[Clang][NFC] Rename CXXMethodDecl::isPure -> is VirtualPure (#78463) To avoid any possible confusion with the notion of pure function and the gnu::pure attribute.
2024-01-18 15:30:58 +01:00
if (D->isPureVirtual())
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " pure";
if (D->isDefaulted()) {
OS << " default";
if (D->isDeleted())
OS << "_delete";
}
if (D->isDeletedAsWritten())
OS << " delete";
if (D->isTrivial())
OS << " trivial";
[Clang] [C++26] Implement P2573R2: `= delete("should have a reason");` (#86526) This implements support for the `= delete("message")` syntax that was only just added to C++26 ([P2573R2](https://isocpp.org/files/papers/P2573R2.html#proposal-scope)).
2024-04-14 12:30:01 +02:00
if (const StringLiteral *M = D->getDeletedMessage())
AddChild("delete message", [=] { Visit(M); });
[Concepts] Implement overload resolution for destructors (P0848) This patch implements a necessary part of P0848, the overload resolution for destructors. It is now possible to overload destructors based on constraints, and the eligible destructor will be selected at the end of the class. The approach this patch takes is to perform the overload resolution in Sema::ActOnFields and to mark the selected destructor using a new property in FunctionDeclBitfields. CXXRecordDecl::getDestructor is then modified to use this property to return the correct destructor. This closes https://github.com/llvm/llvm-project/issues/45614. Reviewed By: #clang-language-wg, erichkeane Differential Revision: https://reviews.llvm.org/D126194
2022-06-16 20:52:12 +03:00
if (D->isIneligibleOrNotSelected())
OS << (isa<CXXDestructorDecl>(D) ? " not_selected" : " ineligible");
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
if (const auto *FPT = D->getType()->getAs<FunctionProtoType>()) {
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
switch (EPI.ExceptionSpec.Type) {
default:
break;
case EST_Unevaluated:
OS << " noexcept-unevaluated " << EPI.ExceptionSpec.SourceDecl;
break;
case EST_Uninstantiated:
OS << " noexcept-uninstantiated " << EPI.ExceptionSpec.SourceTemplate;
break;
}
}
if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
if (MD->size_overridden_methods() != 0) {
auto dumpOverride = [=](const CXXMethodDecl *D) {
SplitQualType T_split = D->getType().split();
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << D << " " << D->getParent()->getName() << "::" << D->getDeclName()
<< " '" << QualType::getAsString(T_split, PrintPolicy) << "'";
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
};
AddChild([=] {
auto Overrides = MD->overridden_methods();
OS << "Overrides: [ ";
dumpOverride(*Overrides.begin());
Use llvm::drop_begin and llvm::drop_end (NFC)
2023-09-22 17:29:10 -07:00
for (const auto *Override : llvm::drop_begin(Overrides)) {
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << ", ";
dumpOverride(Override);
}
OS << " ]";
});
}
}
re-land [C++20][Modules] Update handling of implicit inlines [P1779R3] re-land fixes an unwanted interaction with module-map modules, seen in Greendragon testing. This provides updates to [class.mfct]: Pre C++20 [class.mfct]p2: A member function may be defined (8.4) in its class definition, in which case it is an inline member function (7.1.2) Post C++20 [class.mfct]p1: If a member function is attached to the global module and is defined in its class definition, it is inline. and [class.friend]: Pre-C++20 [class.friend]p5 A function can be defined in a friend declaration of a class . . . . Such a function is implicitly inline. Post C++20 [class.friend]p7 Such a function is implicitly an inline function if it is attached to the global module. We add the output of implicit-inline to the TextNodeDumper, and amend a couple of existing tests to account for this, plus add tests for the cases covered above. Differential Revision: https://reviews.llvm.org/D129045
2022-07-03 14:27:10 +01:00
if (!D->isInlineSpecified() && D->isInlined()) {
OS << " implicit-inline";
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
// Since NumParams comes from the FunctionProtoType of the FunctionDecl and
// the Params are set later, it is possible for a dump during debugging to
// encounter a FunctionDecl that has been created but hasn't been assigned
// ParmVarDecls yet.
if (!D->param_empty() && !D->param_begin())
OS << " <<<NULL params x " << D->getNumParams() << ">>>";
[clang][AST] TextNodeDumper learned to output instantiated_from information Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D158165
2023-08-17 13:23:00 +00:00
if (const auto *Instance = D->getInstantiatedFromMemberFunction()) {
OS << " instantiated_from";
dumpPointer(Instance);
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
[AST] Print the "aggregate" for aggregate deduction guide decl. (#84018) I found this is useful for debugging purpose to identify different kind of deduction guide decl.
2024-03-28 13:07:58 +01:00
void TextNodeDumper::VisitCXXDeductionGuideDecl(
const CXXDeductionGuideDecl *D) {
VisitFunctionDecl(D);
switch (D->getDeductionCandidateKind()) {
case DeductionCandidate::Normal:
case DeductionCandidate::Copy:
return;
case DeductionCandidate::Aggregate:
OS << " aggregate ";
break;
}
}
[clang][modules] Add support for merging lifetime-extended temporaries Summary: Add support for merging lifetime-extended temporaries Reviewers: rsmith Reviewed By: rsmith Subscribers: xbolva00, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70190
2019-11-30 16:42:33 +01:00
void TextNodeDumper::VisitLifetimeExtendedTemporaryDecl(
const LifetimeExtendedTemporaryDecl *D) {
OS << " extended by ";
dumpBareDeclRef(D->getExtendingDecl());
OS << " mangling ";
{
ColorScope Color(OS, ShowColors, ValueColor);
OS << D->getManglingNumber();
}
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
dumpName(D);
dumpType(D->getType());
if (D->isMutable())
OS << " mutable";
if (D->isModulePrivate())
OS << " __module_private__";
}
void TextNodeDumper::VisitVarDecl(const VarDecl *D) {
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
dumpNestedNameSpecifier(D->getQualifier());
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
dumpName(D);
[C++] Implement "Deducing this" (P0847R7) This patch implements P0847R7 (partially), CWG2561 and CWG2653. Reviewed By: aaron.ballman, #clang-language-wg Differential Revision: https://reviews.llvm.org/D140828
2022-01-27 13:55:08 +01:00
if (const auto *P = dyn_cast<ParmVarDecl>(D);
P && P->isExplicitObjectParameter())
OS << " this";
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
dumpType(D->getType());
[clang][AST] TextNodeDumper learned to output template specialization kind Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157705
2023-08-15 14:17:24 +00:00
dumpTemplateSpecializationKind(D->getTemplateSpecializationKind());
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
StorageClass SC = D->getStorageClass();
Revert "[NFC, Refactor] Modernize StorageClass from Specifiers.h to a scoped enum (II)" This reverts commit efc82c4ad2bcb256a4f4c20238d08cd3afba4d2d.
2021-01-04 23:17:45 +01:00
if (SC != SC_None)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << ' ' << VarDecl::getStorageClassSpecifierString(SC);
switch (D->getTLSKind()) {
case VarDecl::TLS_None:
break;
case VarDecl::TLS_Static:
OS << " tls";
break;
case VarDecl::TLS_Dynamic:
OS << " tls_dynamic";
break;
}
if (D->isModulePrivate())
OS << " __module_private__";
if (D->isNRVOVariable())
OS << " nrvo";
if (D->isInline())
OS << " inline";
if (D->isConstexpr())
OS << " constexpr";
if (D->hasInit()) {
switch (D->getInitStyle()) {
case VarDecl::CInit:
OS << " cinit";
break;
case VarDecl::CallInit:
OS << " callinit";
break;
case VarDecl::ListInit:
OS << " listinit";
break;
[clang] Reland parenthesized aggregate init patches This commit relands the patches for implementing P0960R3 and P1975R0, which describe initializing aggregates via a parenthesized list. The relanded commits are: * 40c52159d3ee - P0960R3 and P1975R0: Allow initializing aggregates from a parenthesized list of values * c77a91bb7ba7 - Remove overly restrictive aggregate paren init logic * 32d7aae04fdb - Fix a clang crash on invalid code in C++20 mode This patch also fixes a crash in the original implementation. Previously, if the input tried to call an implicitly deleted copy or move constructor of a union, we would then try to initialize the union by initializing it's first element with a reference to a union. This behavior is incorrect (we should fail to initialize) and if the type of the first element has a constructor with a single template typename parameter, then Clang will explode. This patch fixes that issue by checking that constructor overload resolution did not result in a deleted function before attempting parenthesized aggregate initialization. Additionally, this patch also includes D140159, which contains some minor fixes made in response to code review comments in the original implementation that were made after that patch was submitted. Co-authored-by: Sheng <ox59616e@gmail.com> Fixes #54040, Fixes #59675 Reviewed By: ilya-biryukov Differential Revision: https://reviews.llvm.org/D141546
2023-01-04 15:12:00 -08:00
case VarDecl::ParenListInit:
OS << " parenlistinit";
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
}
For P0784R7: compute whether a variable has constant destruction if it has a constexpr destructor. For constexpr variables, reject if the variable does not have constant destruction. In all cases, do not emit runtime calls to the destructor for variables with constant destruction. llvm-svn: 373159
2019-09-29 05:08:46 +00:00
if (D->needsDestruction(D->getASTContext()))
OS << " destroyed";
[c++20] P0780R2: Support pack-expansion of init-captures. This permits an init-capture to introduce a new pack: template<typename ...T> auto x = [...a = T()] { /* a is a pack */ }; To support this, the mechanism for allowing ParmVarDecls to be packs has been extended to support arbitrary local VarDecls. llvm-svn: 361300
2019-05-21 20:10:50 +00:00
if (D->isParameterPack())
OS << " pack";
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
if (D->hasInit()) {
const Expr *E = D->getInit();
// Only dump the value of constexpr VarDecls for now.
[clang][AST] TextNodeDumper should not evaluate the initializer of constexpr variable declaration when it has a dependent type `TextNodeDumper` enabed through `-ast-dump` flag should not evlauate the initializer when it visits a constexpr `VarDecl` node if it has a dependent type. I found a crashing case fixed by this change and added it as a test case. `template <typename T> constexpr T call_init(0);` Link: https://godbolt.org/z/3bG9Pjj5E This is a fix for the regression caused by D146358 Differential Revision: https://reviews.llvm.org/D151033
2023-05-23 00:29:20 +09:00
if (E && !E->isValueDependent() && D->isConstexpr() &&
!D->getType()->isDependentType()) {
[clang] Rework how and when APValues are dumped Currently APValues are dumped as a single string. This becomes quickly completely unreadable since APValue is a tree-like structure. Even a simple example is not pretty: struct S { int arr[4]; float f; }; constexpr S s = { .arr = {1,2}, .f = 3.1415f }; // Struct fields: Array: Int: 1, Int: 2, 2 x Int: 0, Float: 3.141500e+00 With this patch this becomes: -Struct |-field: Array size=4 | |-elements: Int 1, Int 2 | `-filler: 2 x Int 0 `-field: Float 3.141500e+00 Additionally APValues are currently only dumped as part of visiting a ConstantExpr. This patch also dump the value of the initializer of constexpr variable declarations: constexpr int foo(int a, int b) { return a + b - 42; } constexpr int a = 1, b = 2; constexpr int c = foo(a, b) > 0 ? foo(a, b) : foo(b, a); // VarDecl 0x62100008aec8 <col:3, col:57> col:17 c 'const int' constexpr cinit // |-value: Int -39 // `-ConditionalOperator 0x62100008b4d0 <col:21, col:57> 'int' // <snip> Do the above by moving the dump functions to TextNodeDumper which already has the machinery to display trees. The cases APValue::LValue, APValue::MemberPointer and APValue::AddrLabelDiff are left as they were before (unimplemented). We try to display multiple elements on the same line if they are considered to be "simple". This is to avoid wasting large amounts of vertical space in an example like: constexpr int arr[8] = {0,1,2,3,4,5,6,7}; // VarDecl 0x62100008bb78 <col:3, col:42> col:17 arr 'int const[8]' constexpr cinit // |-value: Array size=8 // | |-elements: Int 0, Int 1, Int 2, Int 3 // | `-elements: Int 4, Int 5, Int 6, Int 7 Differential Revision: https://reviews.llvm.org/D83183 Reviewed By: aaron.ballman
2020-07-06 21:50:23 +01:00
const APValue *Value = D->evaluateValue();
if (Value)
AddChild("value", [=] { Visit(*Value, E->getType()); });
}
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
void TextNodeDumper::VisitBindingDecl(const BindingDecl *D) {
dumpName(D);
dumpType(D->getType());
}
void TextNodeDumper::VisitCapturedDecl(const CapturedDecl *D) {
if (D->isNothrow())
OS << " nothrow";
}
void TextNodeDumper::VisitImportDecl(const ImportDecl *D) {
OS << ' ' << D->getImportedModule()->getFullModuleName();
[modules] Fix handling of initializers for templated global variables. For global variables with unordered initialization that are instantiated within a module, we previously did not emit the global (or its initializer) at all unless it was used in the importing translation unit (and sometimes not even then!), leading to misbehavior and link errors. We now emit the initializer for an instantiated global variable with unordered initialization with side-effects in a module into every translation unit that imports the module. This is unfortunate, but mostly matches the behavior of a non-modular compilation and seems to be the best that we can reasonably do. llvm-svn: 353240
2019-02-05 23:37:13 +00:00
for (Decl *InitD :
D->getASTContext().getModuleInitializers(D->getImportedModule()))
dumpDeclRef(InitD, "initializer");
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
void TextNodeDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
OS << ' ';
switch (D->getCommentKind()) {
case PCK_Unknown:
llvm_unreachable("unexpected pragma comment kind");
case PCK_Compiler:
OS << "compiler";
break;
case PCK_ExeStr:
OS << "exestr";
break;
case PCK_Lib:
OS << "lib";
break;
case PCK_Linker:
OS << "linker";
break;
case PCK_User:
OS << "user";
break;
}
StringRef Arg = D->getArg();
if (!Arg.empty())
OS << " \"" << Arg << "\"";
}
void TextNodeDumper::VisitPragmaDetectMismatchDecl(
const PragmaDetectMismatchDecl *D) {
OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
}
[clang][OpeMP] Model OpenMP structured-block in AST (PR40563) Summary: https://www.openmp.org/wp-content/uploads/OpenMP-API-Specification-5.0.pdf, page 3: ``` structured block For C/C++, an executable statement, possibly compound, with a single entry at the top and a single exit at the bottom, or an OpenMP construct. COMMENT: See Section 2.1 on page 38 for restrictions on structured blocks. ``` ``` 2.1 Directive Format Some executable directives include a structured block. A structured block: • may contain infinite loops where the point of exit is never reached; • may halt due to an IEEE exception; • may contain calls to exit(), _Exit(), quick_exit(), abort() or functions with a _Noreturn specifier (in C) or a noreturn attribute (in C/C++); • may be an expression statement, iteration statement, selection statement, or try block, provided that the corresponding compound statement obtained by enclosing it in { and } would be a structured block; and Restrictions Restrictions to structured blocks are as follows: • Entry to a structured block must not be the result of a branch. • The point of exit cannot be a branch out of the structured block. C / C++ • The point of entry to a structured block must not be a call to setjmp(). • longjmp() and throw() must not violate the entry/exit criteria. ``` Of particular note here is the fact that OpenMP structured blocks are as-if `noexcept`, in the same sense as with the normal `noexcept` functions in C++. I.e. if throw happens, and it attempts to travel out of the `noexcept` function (here: out of the current structured-block), then the program terminates. Now, one of course can say that since it is explicitly prohibited by the Specification, then any and all programs that violate this Specification contain undefined behavior, and are unspecified, and thus no one should care about them. Just don't write broken code /s But i'm not sure this is a reasonable approach. I have personally had oss-fuzz issues of this origin - exception thrown inside of an OpenMP structured-block that is not caught, thus causing program termination. This issue isn't all that hard to catch, it's not any particularly different from diagnosing the same situation with the normal `noexcept` function. Now, clang static analyzer does not presently model exceptions. But clang-tidy has a simplisic [[ https://clang.llvm.org/extra/clang-tidy/checks/bugprone-exception-escape.html | bugprone-exception-escape ]] check, and it is even refactored as a `ExceptionAnalyzer` class for reuse. So it would be trivial to use that analyzer to check for exceptions escaping out of OpenMP structured blocks. (D59466) All that sounds too great to be true. Indeed, there is a caveat. Presently, it's practically impossible to do. To check a OpenMP structured block you need to somehow 'get' the OpenMP structured block, and you can't because it's simply not modelled in AST. `CapturedStmt`/`CapturedDecl` is not it's representation. Now, it is of course possible to write e.g. some AST matcher that would e.g. match every OpenMP executable directive, and then return the whatever `Stmt` is the structured block of said executable directive, if any. But i said //practically//. This isn't practical for the following reasons: 1. This **will** bitrot. That matcher will need to be kept up-to-date, and refreshed with every new OpenMP spec version. 2. Every single piece of code that would want that knowledge would need to have such matcher. Well, okay, if it is an AST matcher, it could be shared. But then you still have `RecursiveASTVisitor` and friends. `2 > 1`, so now you have code duplication. So it would be reasonable (and is fully within clang AST spirit) to not force every single consumer to do that work, but instead store that knowledge in the correct, and appropriate place - AST, class structure. Now, there is another hoop we need to get through. It isn't fully obvious //how// to model this. The best solution would of course be to simply add a `OMPStructuredBlock` transparent node. It would be optimal, it would give us two properties: * Given this `OMPExecutableDirective`, what's it OpenMP structured block? * It is trivial to check whether the `Stmt*` is a OpenMP structured block (`isa<OMPStructuredBlock>(ptr)`) But OpenMP structured block isn't **necessarily** the first, direct child of `OMP*Directive`. (even ignoring the clang's `CapturedStmt`/`CapturedDecl` that were inserted inbetween). So i'm not sure whether or not we could re-create AST statements after they were already created? There would be other costs to a new AST node: https://bugs.llvm.org/show_bug.cgi?id=40563#c12 ``` 1. You will need to break the representation of loops. The body should be replaced by the "structured block" entity. 2. You will need to support serialization/deserialization. 3. You will need to support template instantiation. 4. You will need to support codegen and take this new construct to account in each OpenMP directive. ``` Instead, there **is** an functionally-equivalent, alternative solution, consisting of two parts. Part 1: * Add a member function `isStandaloneDirective()` to the `OMPExecutableDirective` class, that will tell whether this directive is stand-alone or not, as per the spec. We need it because we can't just check for the existance of associated statements, see code comment. * Add a member function `getStructuredBlock()` to the OMPExecutableDirective` class itself, that assert that this is not a stand-alone directive, and either return the correct loop body if this is a loop-like directive, or the captured statement. This way, given an `OMPExecutableDirective`, we can get it's structured block. Also, since the knowledge is ingrained into the clang OpenMP implementation, it will not cause any duplication, and //hopefully// won't bitrot. Great we achieved 1 of 2 properties of `OMPStructuredBlock` approach. Thus, there is a second part needed: * How can we check whether a given `Stmt*` is `OMPStructuredBlock`? Well, we can't really, in general. I can see this workaround: ``` class FunctionASTVisitor : public RecursiveASTVisitor<FunctionASTVisitor> { using Base = RecursiveASTVisitor<FunctionASTVisitor>; public: bool VisitOMPExecDir(OMPExecDir *D) { OmpStructuredStmts.emplace_back(D.getStructuredStmt()); } bool VisitSOMETHINGELSE(???) { if(InOmpStructuredStmt) HI! } bool TraverseStmt(Stmt *Node) { if (!Node) return Base::TraverseStmt(Node); if (OmpStructuredStmts.back() == Node) ++InOmpStructuredStmt; Base::TraverseStmt(Node); if (OmpStructuredStmts.back() == Node) { OmpStructuredStmts.pop_back(); --InOmpStructuredStmt; } return true; } std::vector<Stmt*> OmpStructuredStmts; int InOmpStructuredStmt = 0; }; ``` But i really don't see using it in practice. It's just too intrusive; and again, requires knowledge duplication. .. but no. The solution lies right on the ground. Why don't we simply store this `i'm a openmp structured block` in the bitfield of the `Stmt` itself? This does not appear to have any impact on the memory footprint of the clang AST, since it's just a single extra bit in the bitfield. At least the static assertions don't fail. Thus, indeed, we can achieve both of the properties without a new AST node. We can cheaply set that bit right in sema, at the end of `Sema::ActOnOpenMPExecutableDirective()`, by just calling the `getStructuredBlock()` that we just added. Test coverage that demonstrates all this has been added. This isn't as great with serialization though. Most of it does not use abbrevs, so we do end up paying the full price (4 bytes?) instead of a single bit. That price, of course, can be reclaimed by using abbrevs. In fact, i suspect that //might// not just reclaim these bytes, but pack these PCH significantly. I'm not seeing a third solution. If there is one, it would be interesting to hear about it. ("just don't write code that would require `isa<OMPStructuredBlock>(ptr)`" is not a solution.) Fixes [[ https://bugs.llvm.org/show_bug.cgi?id=40563 | PR40563 ]]. Reviewers: ABataev, rjmccall, hfinkel, rsmith, riccibruno, gribozavr Reviewed By: ABataev, gribozavr Subscribers: mgorny, aaron.ballman, steveire, guansong, jfb, jdoerfert, cfe-commits Tags: #clang, #openmp Differential Revision: https://reviews.llvm.org/D59214 llvm-svn: 356570
2019-03-20 16:32:36 +00:00
void TextNodeDumper::VisitOMPExecutableDirective(
const OMPExecutableDirective *D) {
if (D->isStandaloneDirective())
OS << " openmp_standalone_directive";
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
void TextNodeDumper::VisitOMPDeclareReductionDecl(
const OMPDeclareReductionDecl *D) {
dumpName(D);
dumpType(D->getType());
OS << " combiner";
dumpPointer(D->getCombiner());
if (const auto *Initializer = D->getInitializer()) {
OS << " initializer";
dumpPointer(Initializer);
switch (D->getInitializerKind()) {
[clang][NFC] Refactor `OMPDeclareReductionDecl::InitKind` This patch moves `OMPDeclareReductionDecl::InitKind` to DeclBase.h, so that it's complete at the point where corresponding bit-field is declared. This patch also converts it to scoped enum named `OMPDeclareReductionInitKind`
2023-11-01 12:39:33 +03:00
case OMPDeclareReductionInitKind::Direct:
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " omp_priv = ";
break;
[clang][NFC] Refactor `OMPDeclareReductionDecl::InitKind` This patch moves `OMPDeclareReductionDecl::InitKind` to DeclBase.h, so that it's complete at the point where corresponding bit-field is declared. This patch also converts it to scoped enum named `OMPDeclareReductionInitKind`
2023-11-01 12:39:33 +03:00
case OMPDeclareReductionInitKind::Copy:
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " omp_priv ()";
break;
[clang][NFC] Refactor `OMPDeclareReductionDecl::InitKind` This patch moves `OMPDeclareReductionDecl::InitKind` to DeclBase.h, so that it's complete at the point where corresponding bit-field is declared. This patch also converts it to scoped enum named `OMPDeclareReductionInitKind`
2023-11-01 12:39:33 +03:00
case OMPDeclareReductionInitKind::Call:
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
break;
}
}
}
void TextNodeDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
for (const auto *C : D->clauselists()) {
AddChild([=] {
if (!C) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>> OMPClause";
return;
}
{
ColorScope Color(OS, ShowColors, AttrColor);
[OpenMP][NFCI] Move OpenMP clause information to `lib/Frontend/OpenMP` This is a cleanup and normalization patch that also enables reuse with Flang later on. A follow up will clean up and move the directive -> clauses mapping. Reviewed By: fghanim Differential Revision: https://reviews.llvm.org/D77112
2020-03-30 19:58:40 -05:00
StringRef ClauseName(
llvm::omp::getOpenMPClauseName(C->getClauseKind()));
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
<< ClauseName.drop_front() << "Clause";
}
dumpPointer(C);
dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
});
}
}
void TextNodeDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
dumpName(D);
dumpType(D->getType());
}
void TextNodeDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
dumpName(D);
if (D->isInline())
OS << " inline";
[clang] Add [is|set]Nested methods to NamespaceDecl Adds support for NamespaceDecl to inform if its part of a nested namespace. This flag only corresponds to the inner namespaces in a nested namespace declaration. In this example: namespace <X>::<Y>::<Z> {} Only <Y> and <Z> will be classified as nested. This flag isn't meant for assisting in building the AST, more for static analysis and refactorings. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D90568
2022-11-24 12:44:33 +00:00
if (D->isNested())
OS << " nested";
[Clang][AST] Move NamespaceDecl bits to DeclContext (#98567) Currently, `NamespaceDecl` has a member `AnonOrFirstNamespaceAndFlags` which stores a few pieces of data: - a bit indicating whether the namespace was declared `inline`, and - a bit indicating whether the namespace was declared as a _nested-namespace-definition_, and - a pointer a `NamespaceDecl` that either stores: - a pointer to the first declaration of that namespace if the declaration is no the first declaration, or - a pointer to the unnamed namespace that inhabits the namespace otherwise. `Redeclarable` already stores a pointer to the first declaration of an entity, so it's unnecessary to store this in `NamespaceDecl`. `DeclContext` has 8 bytes in which various bitfields can be stored for a declaration, so it's not necessary to store these in `NamespaceDecl` either. We only need to store a pointer to the unnamed namespace that inhabits the first declaration of a namespace. This patch moves the two bits currently stored in `NamespaceDecl` to `DeclContext`, and only stores a pointer to the unnamed namespace that inhabits a namespace in the first declaration of that namespace. Since `getOriginalNamespace` always returns the same `NamespaceDecl` as `getFirstDecl`, this function is removed to avoid confusion.
2024-07-15 13:57:56 -04:00
if (!D->isFirstDecl())
dumpDeclRef(D->getFirstDecl(), "original");
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
void TextNodeDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
OS << ' ';
dumpBareDeclRef(D->getNominatedNamespace());
}
void TextNodeDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
dumpName(D);
dumpDeclRef(D->getAliasedNamespace());
}
void TextNodeDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
dumpName(D);
dumpType(D->getUnderlyingType());
}
void TextNodeDumper::VisitTypeAliasTemplateDecl(
const TypeAliasTemplateDecl *D) {
dumpName(D);
}
void TextNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
VisitRecordDecl(D);
[clang][AST] TextNodeDumper learned to output instantiated_from information Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D158165
2023-08-17 13:23:00 +00:00
if (const auto *Instance = D->getInstantiatedFromMemberClass()) {
OS << " instantiated_from";
dumpPointer(Instance);
}
Reland: [clang] fix P3310 overload resolution flag propagation (#125791) Class templates might be only instantiated when they are required to be complete, but checking the template args against the primary template is immediate. This result is cached so that later when the class is instantiated, checking against the primary template is not repeated. The 'MatchedPackOnParmToNonPackOnArg' flag is also produced upon checking against the primary template, so it needs to be cached in the specialziation as well. This fixes a bug which has not been in any release, so there are no release notes. Fixes #125290
2025-02-05 12:02:24 -03:00
if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
[clang][AST] TextNodeDumper learned to output template specialization kind Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157705
2023-08-15 14:17:24 +00:00
dumpTemplateSpecializationKind(CTSD->getSpecializationKind());
[clang] NFC: rename MatchedPackOnParmToNonPackOnArg to StrictPackMatch (#125418) This rename follows the proposed wording in P3310R5, which introduces the term 'strict pack match' to refer to the same thing.
2025-02-05 13:16:33 -03:00
if (CTSD->hasStrictPackMatch())
Reland: [clang] fix P3310 overload resolution flag propagation (#125791) Class templates might be only instantiated when they are required to be complete, but checking the template args against the primary template is immediate. This result is cached so that later when the class is instantiated, checking against the primary template is not repeated. The 'MatchedPackOnParmToNonPackOnArg' flag is also produced upon checking against the primary template, so it needs to be cached in the specialziation as well. This fixes a bug which has not been in any release, so there are no release notes. Fixes #125290
2025-02-05 12:02:24 -03:00
OS << " strict-pack-match";
}
[clang][AST] TextNodeDumper learned to output template specialization kind Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157705
2023-08-15 14:17:24 +00:00
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
dumpNestedNameSpecifier(D->getQualifier());
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
if (!D->isCompleteDefinition())
return;
AddChild([=] {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << "DefinitionData";
}
#define FLAG(fn, name) \
if (D->fn()) \
OS << " " #name;
FLAG(isParsingBaseSpecifiers, parsing_base_specifiers);
FLAG(isGenericLambda, generic);
FLAG(isLambda, lambda);
[ASTDump] Add is_anonymous to VisitCXXRecordDecl Summary: Adding is_anonymous the ASTDump for CXXRecordDecl. This turned out to be useful when debugging some problems with how LLDB creates ASTs from DWARF. Differential Revision: https://reviews.llvm.org/D66028 llvm-svn: 368591
2019-08-12 17:07:49 +00:00
FLAG(isAnonymousStructOrUnion, is_anonymous);
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
FLAG(canPassInRegisters, pass_in_registers);
FLAG(isEmpty, empty);
FLAG(isAggregate, aggregate);
FLAG(isStandardLayout, standard_layout);
FLAG(isTriviallyCopyable, trivially_copyable);
FLAG(isPOD, pod);
FLAG(isTrivial, trivial);
FLAG(isPolymorphic, polymorphic);
FLAG(isAbstract, abstract);
FLAG(isLiteral, literal);
FLAG(hasUserDeclaredConstructor, has_user_declared_ctor);
FLAG(hasConstexprNonCopyMoveConstructor, has_constexpr_non_copy_move_ctor);
FLAG(hasMutableFields, has_mutable_fields);
FLAG(hasVariantMembers, has_variant_members);
FLAG(allowConstDefaultInit, can_const_default_init);
AddChild([=] {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << "DefaultConstructor";
}
FLAG(hasDefaultConstructor, exists);
FLAG(hasTrivialDefaultConstructor, trivial);
FLAG(hasNonTrivialDefaultConstructor, non_trivial);
FLAG(hasUserProvidedDefaultConstructor, user_provided);
FLAG(hasConstexprDefaultConstructor, constexpr);
FLAG(needsImplicitDefaultConstructor, needs_implicit);
FLAG(defaultedDefaultConstructorIsConstexpr, defaulted_is_constexpr);
});
AddChild([=] {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << "CopyConstructor";
}
FLAG(hasSimpleCopyConstructor, simple);
FLAG(hasTrivialCopyConstructor, trivial);
FLAG(hasNonTrivialCopyConstructor, non_trivial);
FLAG(hasUserDeclaredCopyConstructor, user_declared);
FLAG(hasCopyConstructorWithConstParam, has_const_param);
FLAG(needsImplicitCopyConstructor, needs_implicit);
FLAG(needsOverloadResolutionForCopyConstructor,
needs_overload_resolution);
if (!D->needsOverloadResolutionForCopyConstructor())
FLAG(defaultedCopyConstructorIsDeleted, defaulted_is_deleted);
FLAG(implicitCopyConstructorHasConstParam, implicit_has_const_param);
});
AddChild([=] {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << "MoveConstructor";
}
FLAG(hasMoveConstructor, exists);
FLAG(hasSimpleMoveConstructor, simple);
FLAG(hasTrivialMoveConstructor, trivial);
FLAG(hasNonTrivialMoveConstructor, non_trivial);
FLAG(hasUserDeclaredMoveConstructor, user_declared);
FLAG(needsImplicitMoveConstructor, needs_implicit);
FLAG(needsOverloadResolutionForMoveConstructor,
needs_overload_resolution);
if (!D->needsOverloadResolutionForMoveConstructor())
FLAG(defaultedMoveConstructorIsDeleted, defaulted_is_deleted);
});
AddChild([=] {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << "CopyAssignment";
}
PR46209: properly determine whether a copy assignment operator is trivial. We previously took a shortcut by assuming that if a subobject had a trivial copy assignment operator (with a few side-conditions), we would always invoke it, and could avoid going through overload resolution. That turns out to not be correct in the presenve of ref-qualifiers (and also won't be the case for copy-assignments with requires-clauses either). Use the same logic for lazy declaration of copy-assignments that we use for all other special member functions. Previously committed as c57f8a3a20540fcf9fbf98c0a73f381ec32fce2a. This now also includes an extension of LLDB's workaround for handling special members without the help of Sema to cover copy assignments.
2020-06-04 19:16:05 -07:00
FLAG(hasSimpleCopyAssignment, simple);
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
FLAG(hasTrivialCopyAssignment, trivial);
FLAG(hasNonTrivialCopyAssignment, non_trivial);
FLAG(hasCopyAssignmentWithConstParam, has_const_param);
FLAG(hasUserDeclaredCopyAssignment, user_declared);
FLAG(needsImplicitCopyAssignment, needs_implicit);
FLAG(needsOverloadResolutionForCopyAssignment, needs_overload_resolution);
FLAG(implicitCopyAssignmentHasConstParam, implicit_has_const_param);
});
AddChild([=] {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << "MoveAssignment";
}
FLAG(hasMoveAssignment, exists);
FLAG(hasSimpleMoveAssignment, simple);
FLAG(hasTrivialMoveAssignment, trivial);
FLAG(hasNonTrivialMoveAssignment, non_trivial);
FLAG(hasUserDeclaredMoveAssignment, user_declared);
FLAG(needsImplicitMoveAssignment, needs_implicit);
FLAG(needsOverloadResolutionForMoveAssignment, needs_overload_resolution);
});
AddChild([=] {
{
ColorScope Color(OS, ShowColors, DeclKindNameColor);
OS << "Destructor";
}
FLAG(hasSimpleDestructor, simple);
FLAG(hasIrrelevantDestructor, irrelevant);
FLAG(hasTrivialDestructor, trivial);
FLAG(hasNonTrivialDestructor, non_trivial);
FLAG(hasUserDeclaredDestructor, user_declared);
Revert "[clang] Prevent that Decl::dump on a CXXRecordDecl deserialises further declarations." This reverts commit 0478720157f6413fad7595b8eff9c70d2d99b637. This probably doesn't work when forcing deserialising while dumping (which the ASTDumper optionally supports).
2020-09-07 14:50:13 +02:00
FLAG(hasConstexprDestructor, constexpr);
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
FLAG(needsImplicitDestructor, needs_implicit);
FLAG(needsOverloadResolutionForDestructor, needs_overload_resolution);
if (!D->needsOverloadResolutionForDestructor())
FLAG(defaultedDestructorIsDeleted, defaulted_is_deleted);
});
});
for (const auto &I : D->bases()) {
AddChild([=] {
if (I.isVirtual())
OS << "virtual ";
dumpAccessSpecifier(I.getAccessSpecifier());
dumpType(I.getType());
if (I.isPackExpansion())
OS << "...";
});
}
}
void TextNodeDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
dumpName(D);
}
void TextNodeDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
dumpName(D);
}
void TextNodeDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
dumpName(D);
}
void TextNodeDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
dumpName(D);
}
void TextNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
[Concepts] Type Constraints Add support for type-constraints in template type parameters. Also add support for template type parameters as pack expansions (where the type constraint can now contain an unexpanded parameter pack). Differential Revision: https://reviews.llvm.org/D44352
2020-01-15 02:48:42 +02:00
if (const auto *TC = D->getTypeConstraint()) {
OS << " ";
dumpBareDeclRef(TC->getNamedConcept());
if (TC->getNamedConcept() != TC->getFoundDecl()) {
OS << " (";
dumpBareDeclRef(TC->getFoundDecl());
OS << ")";
}
} else if (D->wasDeclaredWithTypename())
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " typename";
else
OS << " class";
OS << " depth " << D->getDepth() << " index " << D->getIndex();
if (D->isParameterPack())
OS << " ...";
dumpName(D);
}
void TextNodeDumper::VisitNonTypeTemplateParmDecl(
const NonTypeTemplateParmDecl *D) {
dumpType(D->getType());
OS << " depth " << D->getDepth() << " index " << D->getIndex();
if (D->isParameterPack())
OS << " ...";
dumpName(D);
}
void TextNodeDumper::VisitTemplateTemplateParmDecl(
const TemplateTemplateParmDecl *D) {
OS << " depth " << D->getDepth() << " index " << D->getIndex();
if (D->isParameterPack())
OS << " ...";
dumpName(D);
}
void TextNodeDumper::VisitUsingDecl(const UsingDecl *D) {
OS << ' ';
if (D->getQualifier())
D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << D->getDeclName();
[clang][AST] TextNodeDumper learned to dump qualifiers (NestedNameSpecifier) Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D157681
2023-08-15 16:26:47 +00:00
dumpNestedNameSpecifier(D->getQualifier());
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
[clang] p1099 using enum part 2 This implements the 'using enum maybe-qualified-enum-tag ;' part of 1099. It introduces a new 'UsingEnumDecl', subclassed from 'BaseUsingDecl'. Much of the diff is the boilerplate needed to get the new class set up. There is one case where we accept ill-formed, but I believe this is merely an extended case of an existing bug, so consider it orthogonal. AFAICT in class-scope the c++20 rule is that no 2 using decls can bring in the same target decl ([namespace.udecl]/8). But we already accept: struct A { enum { a }; }; struct B : A { using A::a; }; struct C : B { using A::a; using B::a; }; // same enumerator this patch permits mixtures of 'using enum Bob;' and 'using Bob::member;' in the same way. Differential Revision: https://reviews.llvm.org/D102241
2021-05-05 08:55:02 -07:00
void TextNodeDumper::VisitUsingEnumDecl(const UsingEnumDecl *D) {
OS << ' ';
dumpBareDeclRef(D->getEnumDecl());
}
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
void TextNodeDumper::VisitUnresolvedUsingTypenameDecl(
const UnresolvedUsingTypenameDecl *D) {
OS << ' ';
if (D->getQualifier())
D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << D->getDeclName();
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
void TextNodeDumper::VisitUnresolvedUsingValueDecl(
const UnresolvedUsingValueDecl *D) {
OS << ' ';
if (D->getQualifier())
D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
[clang][nearly-NFC] Remove some superfluous uses of NamedDecl::getNameAsString `OS << ND->getDeclName();` is equivalent to `OS << ND->getNameAsString();` without the extra temporary string. This is not quite a NFC since two uses of `getNameAsString` in a diagnostic are replaced, which results in the named entity being quoted with additional "'"s (ie: 'var' instead of var).
2020-08-05 11:48:09 +01:00
OS << D->getDeclName();
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
dumpType(D->getType());
}
void TextNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
OS << ' ';
dumpBareDeclRef(D->getTargetDecl());
}
void TextNodeDumper::VisitConstructorUsingShadowDecl(
const ConstructorUsingShadowDecl *D) {
if (D->constructsVirtualBase())
OS << " virtual";
AddChild([=] {
OS << "target ";
dumpBareDeclRef(D->getTargetDecl());
});
AddChild([=] {
OS << "nominated ";
dumpBareDeclRef(D->getNominatedBaseClass());
OS << ' ';
dumpBareDeclRef(D->getNominatedBaseClassShadowDecl());
});
AddChild([=] {
OS << "constructed ";
dumpBareDeclRef(D->getConstructedBaseClass());
OS << ' ';
dumpBareDeclRef(D->getConstructedBaseClassShadowDecl());
});
}
void TextNodeDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
switch (D->getLanguage()) {
[clang][NFC] Refactor `LinkageSpecDecl::LanguageIDs` This patch converts `LinkageSpecDecl::LanguageIDs` into scoped enum, and moves it to namespace scope, so that it can be forward-declared where required.
2023-11-01 16:43:18 +03:00
case LinkageSpecLanguageIDs::C:
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " C";
break;
[clang][NFC] Refactor `LinkageSpecDecl::LanguageIDs` This patch converts `LinkageSpecDecl::LanguageIDs` into scoped enum, and moves it to namespace scope, so that it can be forward-declared where required.
2023-11-01 16:43:18 +03:00
case LinkageSpecLanguageIDs::CXX:
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " C++";
break;
}
}
void TextNodeDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
OS << ' ';
dumpAccessSpecifier(D->getAccess());
}
void TextNodeDumper::VisitFriendDecl(const FriendDecl *D) {
if (TypeSourceInfo *T = D->getFriendType())
dumpType(T->getType());
[Clang] Implement C++26’s P2893R3 ‘Variadic friends’ (#101448) Implement P2893R3 ‘Variadic friends’ for C++26. This closes #98587. Co-authored-by: Younan Zhang <zyn7109@gmail.com>
2024-08-15 21:16:30 +02:00
if (D->isPackExpansion())
OS << "...";
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
}
void TextNodeDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
dumpName(D);
dumpType(D->getType());
if (D->getSynthesize())
OS << " synthesize";
switch (D->getAccessControl()) {
case ObjCIvarDecl::None:
OS << " none";
break;
case ObjCIvarDecl::Private:
OS << " private";
break;
case ObjCIvarDecl::Protected:
OS << " protected";
break;
case ObjCIvarDecl::Public:
OS << " public";
break;
case ObjCIvarDecl::Package:
OS << " package";
break;
}
}
void TextNodeDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
if (D->isInstanceMethod())
OS << " -";
else
OS << " +";
dumpName(D);
dumpType(D->getReturnType());
if (D->isVariadic())
OS << " variadic";
}
void TextNodeDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
dumpName(D);
switch (D->getVariance()) {
case ObjCTypeParamVariance::Invariant:
break;
case ObjCTypeParamVariance::Covariant:
OS << " covariant";
break;
case ObjCTypeParamVariance::Contravariant:
OS << " contravariant";
break;
}
if (D->hasExplicitBound())
OS << " bounded";
dumpType(D->getUnderlyingType());
}
void TextNodeDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
dumpName(D);
dumpDeclRef(D->getClassInterface());
dumpDeclRef(D->getImplementation());
for (const auto *P : D->protocols())
dumpDeclRef(P);
}
void TextNodeDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
dumpName(D);
dumpDeclRef(D->getClassInterface());
dumpDeclRef(D->getCategoryDecl());
}
void TextNodeDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
dumpName(D);
for (const auto *Child : D->protocols())
dumpDeclRef(Child);
}
void TextNodeDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
dumpName(D);
dumpDeclRef(D->getSuperClass(), "super");
dumpDeclRef(D->getImplementation());
for (const auto *Child : D->protocols())
dumpDeclRef(Child);
}
void TextNodeDumper::VisitObjCImplementationDecl(
const ObjCImplementationDecl *D) {
dumpName(D);
dumpDeclRef(D->getSuperClass(), "super");
dumpDeclRef(D->getClassInterface());
}
void TextNodeDumper::VisitObjCCompatibleAliasDecl(
const ObjCCompatibleAliasDecl *D) {
dumpName(D);
dumpDeclRef(D->getClassInterface());
}
void TextNodeDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
dumpName(D);
dumpType(D->getType());
if (D->getPropertyImplementation() == ObjCPropertyDecl::Required)
OS << " required";
else if (D->getPropertyImplementation() == ObjCPropertyDecl::Optional)
OS << " optional";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
ObjCPropertyAttribute::Kind Attrs = D->getPropertyAttributes();
if (Attrs != ObjCPropertyAttribute::kind_noattr) {
if (Attrs & ObjCPropertyAttribute::kind_readonly)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " readonly";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_assign)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " assign";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_readwrite)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " readwrite";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_retain)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " retain";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_copy)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " copy";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_nonatomic)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " nonatomic";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_atomic)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " atomic";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_weak)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " weak";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_strong)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " strong";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_unsafe_unretained)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " unsafe_unretained";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_class)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
OS << " class";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_direct)
Implement __attribute__((objc_direct)), __attribute__((objc_direct_members)) __attribute__((objc_direct)) is an attribute on methods declaration, and __attribute__((objc_direct_members)) on implementation, categories or extensions. A `direct` property specifier is added (@property(direct) type name) These attributes / specifiers cause the method to have no associated Objective-C metadata (for the property or the method itself), and the calling convention to be a direct C function call. The symbol for the method has enforced hidden visibility and such direct calls are hence unreachable cross image. An explicit C function must be made if so desired to wrap them. The implicit `self` and `_cmd` arguments are preserved, however to maintain compatibility with the usual `objc_msgSend` semantics, 3 fundamental precautions are taken: 1) for instance methods, `self` is nil-checked. On arm64 backends this typically adds a single instruction (cbz x0, <closest-ret>) to the codegen, for the vast majority of the cases when the return type is a scalar. 2) for class methods, because the class may not be realized/initialized yet, a call to `[self self]` is emitted. When the proper deployment target is used, this is optimized to `objc_opt_self(self)`. However, long term we might want to emit something better that the optimizer can reason about. When inlining kicks in, these calls aren't optimized away as the optimizer has no idea that a single call is really necessary. 3) the calling convention for the `_cmd` argument is changed: the caller leaves the second argument to the call undefined, and the selector is loaded inside the body when it's referenced only. As far as error reporting goes, the compiler refuses: - making any overloads direct, - making an overload of a direct method, - implementations marked as direct when the declaration in the interface isn't (the other way around is allowed, as the direct attribute is inherited from the declaration), - marking methods required for protocol conformance as direct, - messaging an unqualified `id` with a direct method, - forming any @selector() expression with only direct selectors. As warnings: - any inconsistency of direct-related calling convention when @selector() or messaging is used, - forming any @selector() expression with a possibly direct selector. Lastly an `objc_direct_members` attribute is added that can decorate `@implementation` blocks and causes methods only declared there (and in no `@interface`) to be automatically direct. When decorating an `@interface` then all methods and properties declared in this block are marked direct. Radar-ID: rdar://problem/2684889 Differential Revision: https://reviews.llvm.org/D69991 Reviewed-By: John McCall
2019-11-07 23:14:58 -08:00
OS << " direct";
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_getter)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
dumpDeclRef(D->getGetterMethodDecl(), "getter");
[NFC] Refactoring PropertyAttributeKind for ObjCPropertyDecl and ObjCDeclSpec. This is a code clean up of the PropertyAttributeKind and ObjCPropertyAttributeKind enums in ObjCPropertyDecl and ObjCDeclSpec that are exactly identical. This non-functional change consolidates these enums into one. The changes are to many files across clang (and comments in LLVM) so that everything refers to the new consolidated enum in DeclObjCCommon.h. 2nd Landing Attempt... Differential Revision: https://reviews.llvm.org/D77233
2020-04-23 02:20:56 -04:00
if (Attrs & ObjCPropertyAttribute::kind_setter)
[ASTDump] Move Decl node dumping to TextNodeDumper Reviewers: aaron.ballman Subscribers: jfb, cfe-commits Differential Revision: https://reviews.llvm.org/D57419 llvm-svn: 352655
2019-01-30 19:32:48 +00:00
dumpDeclRef(D->getSetterMethodDecl(), "setter");
}
}
void TextNodeDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
dumpName(D->getPropertyDecl());
if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
OS << " synthesize";
else
OS << " dynamic";
dumpDeclRef(D->getPropertyDecl());
dumpDeclRef(D->getPropertyIvarDecl());
}
void TextNodeDumper::VisitBlockDecl(const BlockDecl *D) {
if (D->isVariadic())
OS << " variadic";
if (D->capturesCXXThis())
OS << " captures_this";
}
[Concepts] Concept definitions (D40381) First in a series of patches to land C++2a Concepts support. This patch adds AST and parsing support for concept-declarations. llvm-svn: 365699
2019-07-10 21:25:49 +00:00
void TextNodeDumper::VisitConceptDecl(const ConceptDecl *D) {
dumpName(D);
Fix a few 'no newline at end of file' warnings that Xcode emits (Xcode even has a snazzy "Fix" button, but clicking that inserts two newlines. So close!) llvm-svn: 365789
2019-07-11 15:26:45 +00:00
}
[FPEnv] Allow CompoundStmt to keep FP options This is a recommit of b822efc7404bf09ccfdc1ab7657475026966c3b2, reverted in dc34d8df4c48b3a8f474360970cae8a58e6c84f0. The commit caused fails because the test ast-print-fp-pragmas.c did not specify particular target, and it failed on targets which do not support constrained intrinsics. The original commit message is below. AST does not have special nodes for pragmas. Instead a pragma modifies some state variables of Sema, which in turn results in modified attributes of AST nodes. This technique applies to floating point operations as well. Every AST node that can depend on FP options keeps current set of them. This technique works well for options like exception behavior or fast math options. They represent instructions to the compiler how to modify code generation for the affected nodes. However treatment of FP control modes has problems with this technique. Modifying FP control mode (like rounding direction) usually requires operations on hardware, like writing to control registers. It must be done prior to the first operation that depends on the control mode. In particular, such operations are required for implementation of `pragma STDC FENV_ROUND`, compiler should set up necessary rounding direction at the beginning of compound statement where the pragma occurs. As there is no representation for pragmas in AST, the code generation becomes a complicated task in this case. To solve this issue FP options are kept inside CompoundStmt. Unlike to FP options in expressions, these does not affect any operation on FP values, but only inform the codegen about the FP options that act in the body of the statement. As all pragmas that modify FP environment may occurs only at the start of compound statement or at global level, such solution works for all relevant pragmas. The options are kept as a difference from the options in the enclosing compound statement or default options, it helps codegen to set only changed control modes. Differential Revision: https://reviews.llvm.org/D123952
2022-07-01 18:32:26 +07:00
void TextNodeDumper::VisitCompoundStmt(const CompoundStmt *S) {
VisitStmt(S);
if (S->hasStoredFPFeatures())
printFPOptions(S->getStoredFPFeatures());
}
[HLSL] Support cbuffer/tbuffer for hlsl. This is first part for support cbuffer/tbuffer. The format for cbuffer/tbuffer is BufferType [Name] [: register(b#)] { VariableDeclaration [: packoffset(c#.xyzw)]; ... }; More details at https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-constants New keyword 'cbuffer' and 'tbuffer' are added. New AST node HLSLBufferDecl is added. Build AST for simple cbuffer/tbuffer without attribute support. The special thing is variables declared inside cbuffer is exposed into global scope. So isTransparentContext should return true for HLSLBuffer. Reviewed By: aaron.ballman Differential Revision: https://reviews.llvm.org/D129883
2022-07-15 10:45:57 -07:00
void TextNodeDumper::VisitHLSLBufferDecl(const HLSLBufferDecl *D) {
if (D->isCBuffer())
OS << " cbuffer";
else
OS << " tbuffer";
dumpName(D);
}
[OpenACC] Implement AST for OpenACC Compute Constructs (#81188) 'serial', 'parallel', and 'kernel' constructs are all considered 'Compute' constructs. This patch creates the AST type, plus the required infrastructure for such a type, plus some base types that will be useful in the future for breaking this up. The only difference between the three is the 'kind'( plus some minor clause legalization rules, but those can be differentiated easily enough), so rather than representing them as separate AST nodes, it seems to make sense to make them the same. Additionally, no clause AST functionality is being implemented yet, as that fits better in a separate patch, and this is enough to get the 'naked' constructs implemented. This is otherwise an 'NFC' patch, as it doesn't alter execution at all, so there aren't any tests. I did this to break up the review workload and to get feedback on the layout.
2024-02-13 06:02:13 -08:00
[HLSL] Implement output parameter (#101083) HLSL output parameters are denoted with the `inout` and `out` keywords in the function declaration. When an argument to an output parameter is constructed a temporary value is constructed for the argument. For `inout` pamameters the argument is initialized via copy-initialization from the argument lvalue expression to the parameter type. For `out` parameters the argument is not initialized before the call. In both cases on return of the function the temporary value is written back to the argument lvalue expression through an implicit assignment binary operator with casting as required. This change introduces a new HLSLOutArgExpr ast node which represents the output argument behavior. The OutArgExpr has three defined children: - An OpaqueValueExpr of the argument lvalue expression. - An OpaqueValueExpr of the copy-initialized parameter. - A BinaryOpExpr assigning the first with the value of the second. Fixes #87526 --------- Co-authored-by: Damyan Pepper <damyanp@microsoft.com> Co-authored-by: John McCall <rjmccall@gmail.com>
2024-08-31 10:59:08 -05:00
void TextNodeDumper::VisitHLSLOutArgExpr(const HLSLOutArgExpr *E) {
OS << (E->isInOut() ? " inout" : " out");
}
[OpenACC] Implement AST for OpenACC Compute Constructs (#81188) 'serial', 'parallel', and 'kernel' constructs are all considered 'Compute' constructs. This patch creates the AST type, plus the required infrastructure for such a type, plus some base types that will be useful in the future for breaking this up. The only difference between the three is the 'kind'( plus some minor clause legalization rules, but those can be differentiated easily enough), so rather than representing them as separate AST nodes, it seems to make sense to make them the same. Additionally, no clause AST functionality is being implemented yet, as that fits better in a separate patch, and this is enough to get the 'naked' constructs implemented. This is otherwise an 'NFC' patch, as it doesn't alter execution at all, so there aren't any tests. I did this to break up the review workload and to get feedback on the layout.
2024-02-13 06:02:13 -08:00
void TextNodeDumper::VisitOpenACCConstructStmt(const OpenACCConstructStmt *S) {
OS << " " << S->getDirectiveKind();
}
[OpenACC] Loop construct basic Sema and AST work (#93742) This patch implements the 'loop' construct AST, as well as the basic appertainment rule. Additionally, it sets up the 'parent' compute construct, which is necessary for codegen/other diagnostics. A 'loop' can apply to a for or range-for loop, otherwise it has no other restrictions (though some of its clauses do).
2024-06-05 06:21:48 -07:00
void TextNodeDumper::VisitOpenACCLoopConstruct(const OpenACCLoopConstruct *S) {
if (S->isOrphanedLoopConstruct())
OS << " <orphan>";
else
[OpenACC] Remove 'loop' link to parent construct After implementing 'loop', we determined that the link to its parent only ever uses the type, not the construct itself. This patch removes it, as it is both a waste and causes problems with serialization.
2024-11-08 09:57:19 -08:00
OS << " parent: " << S->getParentComputeConstructKind();
[OpenACC] Loop construct basic Sema and AST work (#93742) This patch implements the 'loop' construct AST, as well as the basic appertainment rule. Additionally, it sets up the 'parent' compute construct, which is necessary for codegen/other diagnostics. A 'loop' can apply to a for or range-for loop, otherwise it has no other restrictions (though some of its clauses do).
2024-06-05 06:21:48 -07:00
}
Reland [clang][Sema, Lex, Parse] Preprocessor embed in C and C++ (#95802) This commit implements the entirety of the now-accepted [N3017 -Preprocessor Embed](https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3017.htm) and its sister C++ paper [p1967](https://wg21.link/p1967). It implements everything in the specification, and includes an implementation that drastically improves the time it takes to embed data in specific scenarios (the initialization of character type arrays). The mechanisms used to do this are used under the "as-if" rule, and in general when the system cannot detect it is initializing an array object in a variable declaration, will generate EmbedExpr AST node which will be expanded by AST consumers (CodeGen or constant expression evaluators) or expand embed directive as a comma expression. This reverts commit https://github.com/llvm/llvm-project/commit/682d461d5a231cee54d65910e6341769419a67d7. --------- Co-authored-by: The Phantom Derpstorm <phdofthehouse@gmail.com> Co-authored-by: Aaron Ballman <aaron@aaronballman.com> Co-authored-by: cor3ntin <corentinjabot@gmail.com> Co-authored-by: H. Vetinari <h.vetinari@gmx.com>
2024-06-20 14:38:46 +02:00
[OpenACC] Implement AST/Sema for combined constructs Combined constructs (OpenACC 3.3 section 2.11) are a short-cut for writing a `loop` construct immediately inside of a `compute` construct. However, this interaction requires we do additional work to ensure that we get the semantics between the two correct, as well as diagnostics. This patch adds the semantic analysis for the constructs (but no clauses), as well as the AST nodes.
2024-11-07 14:17:55 -08:00
void TextNodeDumper::VisitOpenACCCombinedConstruct(
const OpenACCCombinedConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Implement AST/Sema for combined constructs Combined constructs (OpenACC 3.3 section 2.11) are a short-cut for writing a `loop` construct immediately inside of a `compute` construct. However, this interaction requires we do additional work to ensure that we get the semantics between the two correct, as well as diagnostics. This patch adds the semantic analysis for the constructs (but no clauses), as well as the AST nodes.
2024-11-07 14:17:55 -08:00
}
[OpenACC] Create AST nodes for 'data' constructs These constructs are all very similar and closely related, so this patch creates the AST nodes for them, serialization, printing/etc. Additionally the restrictions are all added as tests/todos in the tests, as those will have to be implemented once we get those clauses implemented.
2024-12-10 12:55:15 -08:00
void TextNodeDumper::VisitOpenACCDataConstruct(const OpenACCDataConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Create AST nodes for 'data' constructs These constructs are all very similar and closely related, so this patch creates the AST nodes for them, serialization, printing/etc. Additionally the restrictions are all added as tests/todos in the tests, as those will have to be implemented once we get those clauses implemented.
2024-12-10 12:55:15 -08:00
}
void TextNodeDumper::VisitOpenACCEnterDataConstruct(
const OpenACCEnterDataConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Create AST nodes for 'data' constructs These constructs are all very similar and closely related, so this patch creates the AST nodes for them, serialization, printing/etc. Additionally the restrictions are all added as tests/todos in the tests, as those will have to be implemented once we get those clauses implemented.
2024-12-10 12:55:15 -08:00
}
void TextNodeDumper::VisitOpenACCExitDataConstruct(
const OpenACCExitDataConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Create AST nodes for 'data' constructs These constructs are all very similar and closely related, so this patch creates the AST nodes for them, serialization, printing/etc. Additionally the restrictions are all added as tests/todos in the tests, as those will have to be implemented once we get those clauses implemented.
2024-12-10 12:55:15 -08:00
}
void TextNodeDumper::VisitOpenACCHostDataConstruct(
const OpenACCHostDataConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Create AST nodes for 'data' constructs These constructs are all very similar and closely related, so this patch creates the AST nodes for them, serialization, printing/etc. Additionally the restrictions are all added as tests/todos in the tests, as those will have to be implemented once we get those clauses implemented.
2024-12-10 12:55:15 -08:00
}
[OpenACC] Implement 'wait' construct The arguments to this are the same as for the 'wait' clause, so this reuses all of that infrastructure. So all this has to do is support a pair of clauses that are already implemented (if and async), plus create an AST node. This patch does so, and adds proper testing.
2024-12-17 07:39:20 -08:00
void TextNodeDumper::VisitOpenACCWaitConstruct(const OpenACCWaitConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Implement 'wait' construct The arguments to this are the same as for the 'wait' clause, so this reuses all of that infrastructure. So all this has to do is support a pair of clauses that are already implemented (if and async), plus create an AST node. This patch does so, and adds proper testing.
2024-12-17 07:39:20 -08:00
}
[OpenACC] Implement 'cache' construct AST/Sema This statement level construct takes no clauses and has no associated statement, and simply labels a number of array elements as valid for caching. The implementation here is pretty simple, but it is a touch of a special case for parsing, so the parsing code reflects that.
2025-03-03 10:26:53 -08:00
void TextNodeDumper::VisitOpenACCCacheConstruct(
const OpenACCCacheConstruct *S) {
VisitOpenACCConstructStmt(S);
if (S->hasReadOnly())
OS <<" readonly";
}
[OpenACC] Implement 'init' and 'shutdown' constructs These two constructs are very simple and similar, and only support 3 different clauses, two of which are already implemented. This patch adds AST nodes for both constructs, and leaves the device_num clause unimplemented, but enables the other two.
2024-12-19 06:11:36 -08:00
void TextNodeDumper::VisitOpenACCInitConstruct(const OpenACCInitConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Implement 'init' and 'shutdown' constructs These two constructs are very simple and similar, and only support 3 different clauses, two of which are already implemented. This patch adds AST nodes for both constructs, and leaves the device_num clause unimplemented, but enables the other two.
2024-12-19 06:11:36 -08:00
}
void TextNodeDumper::VisitOpenACCShutdownConstruct(
const OpenACCShutdownConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
[OpenACC] Implement 'init' and 'shutdown' constructs These two constructs are very simple and similar, and only support 3 different clauses, two of which are already implemented. This patch adds AST nodes for both constructs, and leaves the device_num clause unimplemented, but enables the other two.
2024-12-19 06:11:36 -08:00
}
[OpenACC] Implement 'set' construct sema The 'set' construct is another fairly simple one, it doesn't have an associated statement and only a handful of allowed clauses. This patch implements it and all the rules for it, allowing 3 of its for clauses. The only exception is default_async, which will be implemented in a future patch, because it isn't just being enabled, it needs a complete new implementation.
2025-01-03 10:00:12 -08:00
void TextNodeDumper::VisitOpenACCSetConstruct(const OpenACCSetConstruct *S) {
[OpenACC] Initial sema implementation of 'update' construct This executable construct has a larger list of clauses than some of the others, plus has some additional restrictions. This patch implements the AST node, plus the 'cannot be the body of a if, while, do, switch, or label' statement restriction. Future patches will handle the rest of the restrictions, which are based on clauses.
2025-01-06 11:59:04 -08:00
VisitOpenACCConstructStmt(S);
}
void TextNodeDumper::VisitOpenACCUpdateConstruct(
const OpenACCUpdateConstruct *S) {
VisitOpenACCConstructStmt(S);
[OpenACC] Implement 'set' construct sema The 'set' construct is another fairly simple one, it doesn't have an associated statement and only a handful of allowed clauses. This patch implements it and all the rules for it, allowing 3 of its for clauses. The only exception is default_async, which will be implemented in a future patch, because it isn't just being enabled, it needs a complete new implementation.
2025-01-03 10:00:12 -08:00
}
[OpenACC] Implement 'wait' construct The arguments to this are the same as for the 'wait' clause, so this reuses all of that infrastructure. So all this has to do is support a pair of clauses that are already implemented (if and async), plus create an AST node. This patch does so, and adds proper testing.
2024-12-17 07:39:20 -08:00
[OpenACC] Implement Sema/AST for 'atomic' construct The atomic construct is a particularly complicated one. The directive itself is pretty simple, it has 5 options for the 'atomic-clause'. However, the associated statement is fairly complicated. 'read' accepts: v = x; 'write' accepts: x = expr; 'update' (or no clause) accepts: x++; x--; ++x; --x; x binop= expr; x = x binop expr; x = expr binop x; 'capture' accepts either a compound statement, or: v = x++; v = x--; v = ++x; v = --x; v = x binop= expr; v = x = x binop expr; v = x = expr binop x; IF 'capture' has a compound statement, it accepts: {v = x; x binop= expr; } {x binop= expr; v = x; } {v = x; x = x binop expr; } {v = x; x = expr binop x; } {x = x binop expr ;v = x; } {x = expr binop x; v = x; } {v = x; x = expr; } {v = x; x++; } {v = x; ++x; } {x++; v = x; } {++x; v = x; } {v = x; x--; } {v = x; --x; } {x--; v = x; } {--x; v = x; } While these are all quite complicated, there is a significant amount of similarity between the 'capture' and 'update' lists, so this patch reuses a lot of the same functions. This patch implements the entirety of 'atomic', creating a new Sema file for the sema for it, as it is fairly sizable.
2025-01-22 12:22:03 -08:00
void TextNodeDumper::VisitOpenACCAtomicConstruct(
const OpenACCAtomicConstruct *S) {
VisitOpenACCConstructStmt(S);
OS << ' ' << S->getAtomicKind();
}
[OpenACC] Implement 'declare' construct AST/Sema The 'declare' construct is the first of two 'declaration' level constructs, so it is legal in any place a declaration is, including as a statement, which this accomplishes by wrapping it in a DeclStmt. All clauses on this have a 'same scope' requirement, which this enforces as declaration context instead, which makes it possible to implement these as a template. The 'link' and 'device_resident' clauses are also added, which have some similar/small restrictions, but are otherwise pretty rote. This patch implements all of the above.
2025-01-21 11:27:23 -08:00
void TextNodeDumper::VisitOpenACCDeclareDecl(const OpenACCDeclareDecl *D) {
OS << " " << D->getDirectiveKind();
for (const OpenACCClause *C : D->clauses())
AddChild([=] {
Visit(C);
for (const Stmt *S : C->children())
AddChild([=] { Visit(S); });
});
}
[OpenACC] implement AST/Sema for 'routine' construct with argument The 'routine' construct has two forms, one which takes the name of a function that it applies to, and another where it implicitly figures it out based on the next declaration. This patch implements the former with the required restrictions on the name and the function-static-variables as specified. What has not been implemented is any clauses for this, any of the A.3.4 warnings, or the other form.
2025-01-22 06:47:14 -08:00
void TextNodeDumper::VisitOpenACCRoutineDecl(const OpenACCRoutineDecl *D) {
OS << " " << D->getDirectiveKind();
if (D->hasNameSpecified()) {
OS << " name_specified";
dumpSourceRange(SourceRange{D->getLParenLoc(), D->getRParenLoc()});
}
AddChild([=] { Visit(D->getFunctionReference()); });
for (const OpenACCClause *C : D->clauses())
AddChild([=] {
Visit(C);
for (const Stmt *S : C->children())
AddChild([=] { Visit(S); });
});
}
[OpenACC] Implement 'declare' construct AST/Sema The 'declare' construct is the first of two 'declaration' level constructs, so it is legal in any place a declaration is, including as a statement, which this accomplishes by wrapping it in a DeclStmt. All clauses on this have a 'same scope' requirement, which this enforces as declaration context instead, which makes it possible to implement these as a template. The 'link' and 'device_resident' clauses are also added, which have some similar/small restrictions, but are otherwise pretty rote. This patch implements all of the above.
2025-01-21 11:27:23 -08:00
Reland [clang][Sema, Lex, Parse] Preprocessor embed in C and C++ (#95802) This commit implements the entirety of the now-accepted [N3017 -Preprocessor Embed](https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3017.htm) and its sister C++ paper [p1967](https://wg21.link/p1967). It implements everything in the specification, and includes an implementation that drastically improves the time it takes to embed data in specific scenarios (the initialization of character type arrays). The mechanisms used to do this are used under the "as-if" rule, and in general when the system cannot detect it is initializing an array object in a variable declaration, will generate EmbedExpr AST node which will be expanded by AST consumers (CodeGen or constant expression evaluators) or expand embed directive as a comma expression. This reverts commit https://github.com/llvm/llvm-project/commit/682d461d5a231cee54d65910e6341769419a67d7. --------- Co-authored-by: The Phantom Derpstorm <phdofthehouse@gmail.com> Co-authored-by: Aaron Ballman <aaron@aaronballman.com> Co-authored-by: cor3ntin <corentinjabot@gmail.com> Co-authored-by: H. Vetinari <h.vetinari@gmx.com>
2024-06-20 14:38:46 +02:00
void TextNodeDumper::VisitEmbedExpr(const EmbedExpr *S) {
AddChild("begin", [=] { OS << S->getStartingElementPos(); });
AddChild("number of elements", [=] { OS << S->getDataElementCount(); });
}
[ASTDump] TextNodeDumper learned to dump builtin name for AtomicExpr (#102748) In 4198576157bfd0d08c08b784220d6132b709ae2c, we add support for dumping builtin name for AtomicExpr in JSON dump. This change syncs `TextNodeDumper` with `JSONNodeDumper`, makes `TextNodeDumper` learned to dump builtin name for AtomicExpr.
2024-08-13 09:50:34 +08:00
void TextNodeDumper::VisitAtomicExpr(const AtomicExpr *AE) {
OS << ' ' << AE->getOpAsString();
}
[clang] handle fp options in __builtin_convertvector (#125522) This patch allows using fpfeatures pragmas with __builtin_convertvector: - added TrailingObjects with FPOptionsOverride and methods for handling it to ConvertVectorExpr - added support for codegen, node dumping, and serialization of fpfeatures contained in ConvertVectorExpr
2025-02-19 18:03:18 +01:00
void TextNodeDumper::VisitConvertVectorExpr(const ConvertVectorExpr *S) {
VisitStmt(S);
if (S->hasStoredFPFeatures())
printFPOptions(S->getStoredFPFeatures());
}
Reference in New Issue Copy Permalink