const ASTContext &Context;
public:
+ // Return whether this visitor should recurse into discarded statements for a
+ // 'constexpr-if'.
+ bool shouldVisitDiscardedStmt() const { return true; }
#define PTR(CLASS) typename Ptr<CLASS>::type
explicit EvaluatedExprVisitorBase(const ASTContext &Context) : Context(Context) { }
void VisitCallExpr(PTR(CallExpr) CE) {
if (!CE->isUnevaluatedBuiltinCall(Context))
- return static_cast<ImplClass*>(this)->VisitExpr(CE);
+ return getDerived().VisitExpr(CE);
}
void VisitLambdaExpr(PTR(LambdaExpr) LE) {
this->Visit(SubStmt);
}
+ void VisitIfStmt(PTR(IfStmt) If) {
+ if (!getDerived().shouldVisitDiscardedStmt()) {
+ if (auto SubStmt = If->getNondiscardedCase(Context)) {
+ if (*SubStmt)
+ this->Visit(*SubStmt);
+ return;
+ }
+ }
+
+ getDerived().VisitStmt(If);
+ }
+
+ ImplClass &getDerived() { return *static_cast<ImplClass *>(this); }
+
#undef PTR
};
/// If this is an 'if constexpr', determine which substatement will be taken.
/// Otherwise, or if the condition is value-dependent, returns None.
Optional<const Stmt*> getNondiscardedCase(const ASTContext &Ctx) const;
+ Optional<Stmt *> getNondiscardedCase(const ASTContext &Ctx);
bool isObjCAvailabilityCheck() const;
return isa<ObjCAvailabilityCheckExpr>(getCond());
}
-Optional<const Stmt*> IfStmt::getNondiscardedCase(const ASTContext &Ctx) const {
+Optional<Stmt *> IfStmt::getNondiscardedCase(const ASTContext &Ctx) {
if (!isConstexpr() || getCond()->isValueDependent())
return None;
return !getCond()->EvaluateKnownConstInt(Ctx) ? getElse() : getThen();
}
+Optional<const Stmt *>
+IfStmt::getNondiscardedCase(const ASTContext &Ctx) const {
+ if (Optional<Stmt *> Result =
+ const_cast<IfStmt *>(this)->getNondiscardedCase(Ctx))
+ return *Result;
+ return None;
+}
+
ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
SourceLocation RP)
DeferredDiagnosticsEmitter(Sema &S)
: Inherited(S), ShouldEmitRootNode(false), InOMPDeviceContext(0) {}
+ bool shouldVisitDiscardedStmt() const { return false; }
+
void VisitOMPTargetDirective(OMPTargetDirective *Node) {
++InOMPDeviceContext;
Inherited::VisitOMPTargetDirective(Node);
-// RUN: %clang_cc1 -fcxx-exceptions -fcuda-is-device -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fcxx-exceptions -fcuda-is-device -fsyntax-only -std=c++17 -verify %s
#include "Inputs/cuda.h"
// expected-error@-1 2{{cannot use 'throw' in __host__ __device__ function}}
}
+inline __host__ __device__ void hasInvalid2() {
+ throw NULL;
+ // expected-error@-1 2{{cannot use 'throw' in __host__ __device__ function}}
+}
+
+inline __host__ __device__ void hasInvalidDiscarded() {
+ // This is only used in the discarded statements below, so this should not diagnose.
+ throw NULL;
+}
+
static __device__ void use0() {
hasInvalid(); // expected-note {{called by 'use0'}}
hasInvalid(); // expected-note {{called by 'use0'}}
+
+ if constexpr (true) {
+ hasInvalid2(); // expected-note {{called by 'use0'}}
+ } else {
+ hasInvalidDiscarded();
+ }
+
+ if constexpr (false) {
+ hasInvalidDiscarded();
+ } else {
+ hasInvalid2(); // expected-note {{called by 'use0'}}
+ }
+
+ if constexpr (false) {
+ hasInvalidDiscarded();
+ }
}
// To avoid excessive diagnostic messages, deferred diagnostics are only
// emitted the first time a function is called.
static __device__ void use1() {
- use0(); // expected-note 2{{called by 'use1'}}
+ use0(); // expected-note 4{{called by 'use1'}}
use0();
}
static __device__ void use2() {
- use1(); // expected-note 2{{called by 'use2'}}
+ use1(); // expected-note 4{{called by 'use2'}}
use1();
}
static __device__ void use3() {
- use2(); // expected-note 2{{called by 'use3'}}
+ use2(); // expected-note 4{{called by 'use3'}}
use2();
}
__global__ void use4() {
- use3(); // expected-note 2{{called by 'use4'}}
+ use3(); // expected-note 4{{called by 'use4'}}
use3();
}