Skip to content

Commit 1d901ab

Browse files
piotrAMDpiotrAMD
committed
Manually merged master:4ece6f051bd into amd-gfx:26c8789ad97
Local branch amd-gfx 26c8789 Merge "[AMDGPU] Reorder target-specific passes" into amd-gfx Remote branch master 4ece6f0 [Sema][SVE] Reject "delete" with sizeless types Change-Id: I7db2914f682e258099beddbc57dffec877f1975d
2 parents 26c8789 + 4ece6f0 commit 1d901ab

File tree

459 files changed

+86690
-8397
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

459 files changed

+86690
-8397
lines changed

‎clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -649,9 +649,14 @@ StringRef LoopConvertCheck::getContainerString(ASTContext *Context,
649649
const ForStmt *Loop,
650650
const Expr *ContainerExpr) {
651651
StringRef ContainerString;
652-
if (isa<CXXThisExpr>(ContainerExpr->IgnoreParenImpCasts())) {
652+
ContainerExpr = ContainerExpr->IgnoreParenImpCasts();
653+
if (isa<CXXThisExpr>(ContainerExpr)) {
653654
ContainerString = "this";
654655
} else {
656+
// For CXXOperatorCallExpr (e.g. vector_ptr->size()), its first argument is
657+
// the class object (vector_ptr) we are targeting.
658+
if (const auto* E = dyn_cast<CXXOperatorCallExpr>(ContainerExpr))
659+
ContainerExpr = E->getArg(0);
655660
ContainerString =
656661
getStringFromRange(Context->getSourceManager(), Context->getLangOpts(),
657662
ContainerExpr->getSourceRange());

‎clang-tools-extra/clangd/unittests/SelectionTests.cpp

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -380,6 +380,14 @@ TEST(SelectionTest, CommonAncestor) {
380380
{"struct foo { [[^~foo()]]; };", "CXXDestructorDecl"},
381381
// FIXME: The following to should be class itself instead.
382382
{"struct foo { [[fo^o(){}]] };", "CXXConstructorDecl"},
383+
384+
{R"cpp(
385+
struct S1 { void f(); };
386+
struct S2 { S1 * operator->(); };
387+
void test(S2 s2) {
388+
s2[[-^>]]f();
389+
}
390+
)cpp", "DeclRefExpr"} // DeclRefExpr to the "operator->" method.
383391
};
384392
for (const Case &C : Cases) {
385393
Annotations Test(C.Code);

‎clang-tools-extra/clangd/unittests/XRefsTests.cpp

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -452,6 +452,14 @@ TEST(LocateSymbol, All) {
452452
}
453453
)cpp",
454454

455+
R"cpp(
456+
struct S1 { void f(); };
457+
struct S2 { S1 * $decl[[operator]]->(); };
458+
void test(S2 s2) {
459+
s2-^>f();
460+
}
461+
)cpp",
462+
455463
R"cpp(// Declaration of explicit template specialization
456464
template <typename T>
457465
struct $decl[[Foo]] {};

‎clang/include/clang/AST/ComputeDependence.h

Lines changed: 182 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,182 @@
1+
//===--- ComputeDependence.h -------------------------------------- C++ -*-===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
//
9+
// Calculate various template dependency flags for the AST.
10+
//
11+
//===----------------------------------------------------------------------===//
12+
13+
#ifndef LLVM_CLANG_AST_COMPUTE_DEPENDENCE_H
14+
#define LLVM_CLANG_AST_COMPUTE_DEPENDENCE_H
15+
16+
#include "clang/AST/DependenceFlags.h"
17+
#include "clang/Basic/ExceptionSpecificationType.h"
18+
#include "llvm/ADT/ArrayRef.h"
19+
20+
namespace clang {
21+
22+
class ASTContext;
23+
24+
class Expr;
25+
class FullExpr;
26+
class OpaqueValueExpr;
27+
class ParenExpr;
28+
class UnaryOperator;
29+
class UnaryExprOrTypeTraitExpr;
30+
class ArraySubscriptExpr;
31+
class CompoundLiteralExpr;
32+
class CastExpr;
33+
class BinaryOperator;
34+
class ConditionalOperator;
35+
class BinaryConditionalOperator;
36+
class StmtExpr;
37+
class ConvertVectorExpr;
38+
class VAArgExpr;
39+
class ChooseExpr;
40+
class NoInitExpr;
41+
class ArrayInitLoopExpr;
42+
class ImplicitValueInitExpr;
43+
class InitListExpr;
44+
class ExtVectorElementExpr;
45+
class BlockExpr;
46+
class AsTypeExpr;
47+
class DeclRefExpr;
48+
class CXXRewrittenBinaryOperator;
49+
class CXXStdInitializerListExpr;
50+
class CXXTypeidExpr;
51+
class MSPropertyRefExpr;
52+
class MSPropertySubscriptExpr;
53+
class CXXUuidofExpr;
54+
class CXXThisExpr;
55+
class CXXThrowExpr;
56+
class CXXBindTemporaryExpr;
57+
class CXXScalarValueInitExpr;
58+
class CXXDeleteExpr;
59+
class ArrayTypeTraitExpr;
60+
class ExpressionTraitExpr;
61+
class CXXNoexceptExpr;
62+
class SubstNonTypeTemplateParmExpr;
63+
class CoroutineSuspendExpr;
64+
class DependentCoawaitExpr;
65+
class CXXNewExpr;
66+
class CXXPseudoDestructorExpr;
67+
class OverloadExpr;
68+
class DependentScopeDeclRefExpr;
69+
class CXXConstructExpr;
70+
class LambdaExpr;
71+
class CXXUnresolvedConstructExpr;
72+
class CXXDependentScopeMemberExpr;
73+
class MaterializeTemporaryExpr;
74+
class TypeTraitExpr;
75+
class ConceptSpecializationExpr;
76+
class PredefinedExpr;
77+
class CallExpr;
78+
class OffsetOfExpr;
79+
class MemberExpr;
80+
class ShuffleVectorExpr;
81+
class GenericSelectionExpr;
82+
class DesignatedInitExpr;
83+
class ParenListExpr;
84+
class PseudoObjectExpr;
85+
class AtomicExpr;
86+
class OMPArraySectionExpr;
87+
class ObjCArrayLiteral;
88+
class ObjCDictionaryLiteral;
89+
class ObjCBoxedExpr;
90+
class ObjCEncodeExpr;
91+
class ObjCIvarRefExpr;
92+
class ObjCPropertyRefExpr;
93+
class ObjCSubscriptRefExpr;
94+
class ObjCIsaExpr;
95+
class ObjCIndirectCopyRestoreExpr;
96+
class ObjCMessageExpr;
97+
98+
// The following functions are called from constructors of `Expr`, so they
99+
// should not access anything beyond basic
100+
ExprDependence computeDependence(FullExpr *E);
101+
ExprDependence computeDependence(OpaqueValueExpr *E);
102+
ExprDependence computeDependence(ParenExpr *E);
103+
ExprDependence computeDependence(UnaryOperator *E);
104+
ExprDependence computeDependence(UnaryExprOrTypeTraitExpr *E);
105+
ExprDependence computeDependence(ArraySubscriptExpr *E);
106+
ExprDependence computeDependence(CompoundLiteralExpr *E);
107+
ExprDependence computeDependence(CastExpr *E);
108+
ExprDependence computeDependence(BinaryOperator *E);
109+
ExprDependence computeDependence(ConditionalOperator *E);
110+
ExprDependence computeDependence(BinaryConditionalOperator *E);
111+
ExprDependence computeDependence(StmtExpr *E, unsigned TemplateDepth);
112+
ExprDependence computeDependence(ConvertVectorExpr *E);
113+
ExprDependence computeDependence(VAArgExpr *E);
114+
ExprDependence computeDependence(ChooseExpr *E);
115+
ExprDependence computeDependence(NoInitExpr *E);
116+
ExprDependence computeDependence(ArrayInitLoopExpr *E);
117+
ExprDependence computeDependence(ImplicitValueInitExpr *E);
118+
ExprDependence computeDependence(InitListExpr *E);
119+
ExprDependence computeDependence(ExtVectorElementExpr *E);
120+
ExprDependence computeDependence(BlockExpr *E);
121+
ExprDependence computeDependence(AsTypeExpr *E);
122+
ExprDependence computeDependence(DeclRefExpr *E, const ASTContext &Ctx);
123+
ExprDependence computeDependence(CXXRewrittenBinaryOperator *E);
124+
ExprDependence computeDependence(CXXStdInitializerListExpr *E);
125+
ExprDependence computeDependence(CXXTypeidExpr *E);
126+
ExprDependence computeDependence(MSPropertyRefExpr *E);
127+
ExprDependence computeDependence(MSPropertySubscriptExpr *E);
128+
ExprDependence computeDependence(CXXUuidofExpr *E);
129+
ExprDependence computeDependence(CXXThisExpr *E);
130+
ExprDependence computeDependence(CXXThrowExpr *E);
131+
ExprDependence computeDependence(CXXBindTemporaryExpr *E);
132+
ExprDependence computeDependence(CXXScalarValueInitExpr *E);
133+
ExprDependence computeDependence(CXXDeleteExpr *E);
134+
ExprDependence computeDependence(ArrayTypeTraitExpr *E);
135+
ExprDependence computeDependence(ExpressionTraitExpr *E);
136+
ExprDependence computeDependence(CXXNoexceptExpr *E, CanThrowResult CT);
137+
ExprDependence computeDependence(SubstNonTypeTemplateParmExpr *E);
138+
ExprDependence computeDependence(CoroutineSuspendExpr *E);
139+
ExprDependence computeDependence(DependentCoawaitExpr *E);
140+
ExprDependence computeDependence(CXXNewExpr *E);
141+
ExprDependence computeDependence(CXXPseudoDestructorExpr *E);
142+
ExprDependence computeDependence(OverloadExpr *E, bool KnownDependent,
143+
bool KnownInstantiationDependent,
144+
bool KnownContainsUnexpandedParameterPack);
145+
ExprDependence computeDependence(DependentScopeDeclRefExpr *E);
146+
ExprDependence computeDependence(CXXConstructExpr *E);
147+
ExprDependence computeDependence(LambdaExpr *E,
148+
bool ContainsUnexpandedParameterPack);
149+
ExprDependence computeDependence(CXXUnresolvedConstructExpr *E);
150+
ExprDependence computeDependence(CXXDependentScopeMemberExpr *E);
151+
ExprDependence computeDependence(MaterializeTemporaryExpr *E);
152+
ExprDependence computeDependence(TypeTraitExpr *E);
153+
ExprDependence computeDependence(ConceptSpecializationExpr *E,
154+
bool ValueDependent);
155+
156+
ExprDependence computeDependence(PredefinedExpr *E);
157+
ExprDependence computeDependence(CallExpr *E, llvm::ArrayRef<Expr *> PreArgs);
158+
ExprDependence computeDependence(OffsetOfExpr *E);
159+
ExprDependence computeDependence(MemberExpr *E);
160+
ExprDependence computeDependence(ShuffleVectorExpr *E);
161+
ExprDependence computeDependence(GenericSelectionExpr *E,
162+
bool ContainsUnexpandedPack);
163+
ExprDependence computeDependence(DesignatedInitExpr *E);
164+
ExprDependence computeDependence(ParenListExpr *E);
165+
ExprDependence computeDependence(PseudoObjectExpr *E);
166+
ExprDependence computeDependence(AtomicExpr *E);
167+
168+
ExprDependence computeDependence(OMPArraySectionExpr *E);
169+
170+
ExprDependence computeDependence(ObjCArrayLiteral *E);
171+
ExprDependence computeDependence(ObjCDictionaryLiteral *E);
172+
ExprDependence computeDependence(ObjCBoxedExpr *E);
173+
ExprDependence computeDependence(ObjCEncodeExpr *E);
174+
ExprDependence computeDependence(ObjCIvarRefExpr *E);
175+
ExprDependence computeDependence(ObjCPropertyRefExpr *E);
176+
ExprDependence computeDependence(ObjCSubscriptRefExpr *E);
177+
ExprDependence computeDependence(ObjCIsaExpr *E);
178+
ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E);
179+
ExprDependence computeDependence(ObjCMessageExpr *E);
180+
181+
} // namespace clang
182+
#endif

‎clang/include/clang/AST/DeclCXX.h

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -2415,17 +2415,6 @@ class CXXConstructorDecl final
24152415
: ExplicitSpecKind::ResolvedFalse);
24162416
}
24172417

2418-
void setExplicitSpecifier(ExplicitSpecifier ES) {
2419-
assert((!ES.getExpr() ||
2420-
CXXConstructorDeclBits.HasTrailingExplicitSpecifier) &&
2421-
"cannot set this explicit specifier. no trail-allocated space for "
2422-
"explicit");
2423-
if (ES.getExpr())
2424-
*getCanonicalDecl()->getTrailingObjects<ExplicitSpecifier>() = ES;
2425-
else
2426-
CXXConstructorDeclBits.IsSimpleExplicit = ES.isExplicit();
2427-
}
2428-
24292418
enum TraillingAllocKind {
24302419
TAKInheritsConstructor = 1,
24312420
TAKHasTailExplicit = 1 << 1,
@@ -2451,6 +2440,17 @@ class CXXConstructorDecl final
24512440
InheritedConstructor Inherited = InheritedConstructor(),
24522441
Expr *TrailingRequiresClause = nullptr);
24532442

2443+
void setExplicitSpecifier(ExplicitSpecifier ES) {
2444+
assert((!ES.getExpr() ||
2445+
CXXConstructorDeclBits.HasTrailingExplicitSpecifier) &&
2446+
"cannot set this explicit specifier. no trail-allocated space for "
2447+
"explicit");
2448+
if (ES.getExpr())
2449+
*getCanonicalDecl()->getTrailingObjects<ExplicitSpecifier>() = ES;
2450+
else
2451+
CXXConstructorDeclBits.IsSimpleExplicit = ES.isExplicit();
2452+
}
2453+
24542454
ExplicitSpecifier getExplicitSpecifier() {
24552455
return getCanonicalDecl()->getExplicitSpecifierInternal();
24562456
}

‎clang/include/clang/AST/DeclTemplate.h

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1927,6 +1927,10 @@ class ClassTemplateSpecializationDecl
19271927
getTemplateSpecializationKind());
19281928
}
19291929

1930+
void setSpecializedTemplate(ClassTemplateDecl *Specialized) {
1931+
SpecializedTemplate = Specialized;
1932+
}
1933+
19301934
void setSpecializationKind(TemplateSpecializationKind TSK) {
19311935
SpecializationKind = TSK;
19321936
}

‎clang/include/clang/AST/DependenceFlags.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ struct ExprDependenceScope {
2323
None = 0,
2424
All = 15,
2525

26+
TypeValue = Type | Value,
2627
TypeInstantiation = Type | Instantiation,
2728
ValueInstantiation = Value | Instantiation,
2829
TypeValueInstantiation = Type | Value | Instantiation,
@@ -94,6 +95,12 @@ inline ExprDependence toExprDependence(TypeDependence TD) {
9495
return toExprDependence(static_cast<TemplateArgumentDependence>(
9596
TD & ~TypeDependence::VariablyModified));
9697
}
98+
inline ExprDependence toExprDependence(NestedNameSpecifierDependence NSD) {
99+
// This hack works because TypeDependence and TemplateArgumentDependence
100+
// share the same bit representation.
101+
return toExprDependence(static_cast<TemplateArgumentDependence>(NSD)) &
102+
~ExprDependence::TypeValue;
103+
}
97104
inline ExprDependence turnTypeToValueDependence(ExprDependence D) {
98105
// Type-dependent expressions are always be value-dependent, so we simply drop
99106
// type dependency.

0 commit comments

Comments
 (0)