[clang] [Clang] [CUDA] Support ADL kernel launches (PR #240947)
Ambrose Leeb via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 11 14:55:35 PST 2026
https://github.com/Sirraide updated https://github.com/llvm/llvm-project/pull/240947
>From f2fbe4167d31b34d663cc0ab97a6e29ed1cf0baf Mon Sep 17 00:00:00 2001
From: Ambrose Leeb <aleeb at nvidia.com>
Date: Tue, 10 Nov 2026 18:12:45 +0000
Subject: [PATCH 1/2] [Clang] [CUDA] Support ADL kernel launches
There are a few places where the parser checks if an identifier is
the callee of a function call by looking at the next token and checking
if it is a '('. This meant that kernel launches (where the next token
is '<<<' instead) were incorrectly not being treated as calls sometimes;
in particular, this led to ADL not functioning correctly with kernels.
This patch fixes that by checking for '<<<' alongside '(' where relevant.
Fixes #45327.
Assisted-by: Codex
---
clang/docs/ReleaseNotes.md | 3 ++
clang/include/clang/Parse/Parser.h | 5 +-
clang/include/clang/Sema/Sema.h | 4 +-
clang/lib/Parse/ParseExpr.cpp | 9 ++--
clang/lib/Parse/ParseExprCXX.cpp | 7 +--
clang/lib/Parse/ParseOpenACC.cpp | 6 +--
clang/lib/Sema/SemaCodeComplete.cpp | 2 +-
clang/lib/Sema/SemaDecl.cpp | 12 +++--
clang/lib/Sema/SemaExpr.cpp | 22 ++++-----
clang/lib/Sema/SemaExprObjC.cpp | 2 +-
clang/lib/Sema/SemaStmtAsm.cpp | 4 +-
clang/test/CodeGenCUDA/kernel-call-adl.cu | 55 +++++++++++++++++++++
clang/test/SemaCUDA/kernel-call-adl.cu | 60 +++++++++++++++++++++++
13 files changed, 155 insertions(+), 36 deletions(-)
create mode 100644 clang/test/CodeGenCUDA/kernel-call-adl.cu
create mode 100644 clang/test/SemaCUDA/kernel-call-adl.cu
diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index 7a0169be43980e..14e0257655c68b 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -1353,6 +1353,9 @@ documentation](CIR/index.md) for more information regarding ClangIR's status and
#### CUDA Support
+- Fixed argument-dependent lookup for CUDA and HIP kernel launches, including
+ calls to kernels declared as hidden friends. (#GH45327)
+
- Fixed missing diagnostics for wrong-side functions reached through constructor
and member initializers, as well as inherited constructors. (#GH118415)
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index b19f0ed880ddfe..05c492c704810c 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -4118,8 +4118,9 @@ class Parser : public CodeCompletionHandler {
/// suffix.
bool isPostfixExpressionSuffixStart() {
tok::TokenKind K = Tok.getKind();
- return (K == tok::l_square || K == tok::l_paren || K == tok::period ||
- K == tok::arrow || K == tok::plusplus || K == tok::minusminus);
+ return (K == tok::l_square || K == tok::l_paren || K == tok::lesslessless ||
+ K == tok::period || K == tok::arrow || K == tok::plusplus ||
+ K == tok::minusminus);
}
/// Once the leading part of a postfix-expression is parsed, this
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index ba215e7e18d7ba..2bfa5c047879d0 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -7325,7 +7325,7 @@ class Sema final : public SemaBase {
ExprResult ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
SourceLocation TemplateKWLoc, UnqualifiedId &Id,
- bool HasTrailingLParen, bool IsAddressOfOperand,
+ bool IsCall, bool IsAddressOfOperand,
CorrectionCandidateCallback *CCC = nullptr,
bool IsInlineAsmIdentifier = false);
@@ -7388,7 +7388,7 @@ class Sema final : public SemaBase {
const TemplateArgumentListInfo *TemplateArgs = nullptr);
bool UseArgumentDependentLookup(const CXXScopeSpec &SS, const LookupResult &R,
- bool HasTrailingLParen);
+ bool IsCall);
/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
/// declaration name, generally during template instantiation.
diff --git a/clang/lib/Parse/ParseExpr.cpp b/clang/lib/Parse/ParseExpr.cpp
index d42ffc2ccf0a65..f3169cf0f2f77d 100644
--- a/clang/lib/Parse/ParseExpr.cpp
+++ b/clang/lib/Parse/ParseExpr.cpp
@@ -1034,10 +1034,11 @@ Parser::ParseCastExpression(CastParseKind ParseKind, bool isAddressOfOperand,
Validator.WantRemainingKeywords = Tok.isNot(tok::r_paren);
}
Name.setIdentifier(&II, ILoc);
- Res = Actions.ActOnIdExpression(getCurScope(), ScopeSpec, TemplateKWLoc,
- Name, Tok.is(tok::l_paren),
- isAddressOfOperand, &Validator,
- /*IsInlineAsmIdentifier=*/false);
+ Res =
+ Actions.ActOnIdExpression(getCurScope(), ScopeSpec, TemplateKWLoc, Name,
+ Tok.isOneOf(tok::l_paren, tok::lesslessless),
+ isAddressOfOperand, &Validator,
+ /*IsInlineAsmIdentifier=*/false);
Res = tryParseCXXPackIndexingExpression(Res);
if (!Res.isInvalid() && Tok.is(tok::less))
checkPotentialAngleBracket(Res);
diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp
index f867fc8932bd44..22f309661bdc80 100644
--- a/clang/lib/Parse/ParseExprCXX.cpp
+++ b/clang/lib/Parse/ParseExprCXX.cpp
@@ -650,9 +650,10 @@ ExprResult Parser::tryParseCXXIdExpression(CXXScopeSpec &SS,
if (isAddressOfOperand && isPostfixExpressionSuffixStart())
isAddressOfOperand = false;
- E = Actions.ActOnIdExpression(
- getCurScope(), SS, TemplateKWLoc, Name, Tok.is(tok::l_paren),
- isAddressOfOperand, /*CCC=*/nullptr, /*IsInlineAsmIdentifier=*/false);
+ E = Actions.ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Name,
+ Tok.isOneOf(tok::l_paren, tok::lesslessless),
+ isAddressOfOperand, /*CCC=*/nullptr,
+ /*IsInlineAsmIdentifier=*/false);
break;
}
diff --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp
index eb9106b6730458..692d00d60e91c0 100644
--- a/clang/lib/Parse/ParseOpenACC.cpp
+++ b/clang/lib/Parse/ParseOpenACC.cpp
@@ -1377,10 +1377,10 @@ ExprResult Parser::ParseOpenACCIDExpression() {
Name.setIdentifier(FuncName.getIdentifierInfo(), ConsumeToken());
// Ensure this is a valid identifier. We don't accept causing implicit
- // function declarations per the spec, so always claim to not have trailing
- // L Paren.
+ // function declarations per the spec, so always claim that this isn't
+ // a call.
Res = Actions.ActOnIdExpression(getCurScope(), ScopeSpec, TemplateKWLoc,
- Name, /*HasTrailingLParen=*/false,
+ Name, /*IsCall=*/false,
/*isAddressOfOperand=*/false);
}
diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp
index 2e852281395280..67424c580ddaf8 100644
--- a/clang/lib/Sema/SemaCodeComplete.cpp
+++ b/clang/lib/Sema/SemaCodeComplete.cpp
@@ -8542,7 +8542,7 @@ void SemaCodeCompletion::CodeCompleteObjCSuperMessage(
id.setIdentifier(Super, SuperLoc);
ExprResult SuperExpr =
SemaRef.ActOnIdExpression(S, SS, TemplateKWLoc, id,
- /*HasTrailingLParen=*/false,
+ /*IsCall=*/false,
/*IsAddressOfOperand=*/false);
return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
SelIdents, AtArgumentExpression);
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index f3d38a555a524a..d7484491abbbcc 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -965,9 +965,9 @@ Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS,
Corrected:
switch (Result.getResultKind()) {
case LookupResultKind::NotFound:
- // If an unqualified-id is followed by a '(', then we have a function
- // call.
- if (SS.isEmpty() && NextToken.is(tok::l_paren)) {
+ // If an unqualified-id is followed by '(' or '<<<', then we have a
+ // function call or kernel launch.
+ if (SS.isEmpty() && NextToken.isOneOf(tok::l_paren, tok::lesslessless)) {
// In C++, this is an ADL-only call.
// FIXME: Reference?
if (getLangOpts().CPlusPlus)
@@ -1287,7 +1287,8 @@ Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS,
// that declaration directly. Defer resolving even non-overloaded class
// member accesses, as we need to defer certain access checks until we know
// the context.
- bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
+ bool ADL = UseArgumentDependentLookup(
+ SS, Result, NextToken.isOneOf(tok::l_paren, tok::lesslessless));
if (Result.isSingleResult() && !ADL &&
(!FirstDecl->isCXXClassMember() || isa<EnumConstantDecl>(FirstDecl)))
return NameClassification::NonType(Result.getRepresentativeDecl());
@@ -1333,7 +1334,8 @@ ExprResult Sema::ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS,
Result.addDecl(Found);
Result.resolveKind();
- bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
+ bool ADL = UseArgumentDependentLookup(
+ SS, Result, NextToken.isOneOf(tok::l_paren, tok::lesslessless));
return BuildDeclarationNameExpr(SS, Result, ADL, /*AcceptInvalidDecl=*/true);
}
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index a14c3d50d12851..b4e3a7a40f5f1b 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -1108,7 +1108,7 @@ ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
Name.setIdentifier(PP.getIdentifierInfo("__builtin_trap"),
E->getBeginLoc());
ExprResult TrapFn = ActOnIdExpression(TUScope, SS, TemplateKWLoc, Name,
- /*HasTrailingLParen=*/true,
+ /*IsCall=*/true,
/*IsAddressOfOperand=*/false);
if (TrapFn.isInvalid())
return ExprError();
@@ -2886,12 +2886,12 @@ recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,
ExprResult Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
SourceLocation TemplateKWLoc,
- UnqualifiedId &Id, bool HasTrailingLParen,
+ UnqualifiedId &Id, bool IsCall,
bool IsAddressOfOperand,
CorrectionCandidateCallback *CCC,
bool IsInlineAsmIdentifier) {
- assert(!(IsAddressOfOperand && HasTrailingLParen) &&
- "cannot be direct & operand and have a trailing lparen");
+ assert(!(IsAddressOfOperand && IsCall) &&
+ "cannot be direct & operand and a function call");
if (SS.isInvalid())
return ExprError();
@@ -2990,15 +2990,14 @@ ExprResult Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
// This could be an implicitly declared function reference if the language
// mode allows it as a feature.
- if (R.empty() && HasTrailingLParen && II &&
- getLangOpts().implicitFunctionsAllowed()) {
+ if (R.empty() && IsCall && II && getLangOpts().implicitFunctionsAllowed()) {
NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
if (D) R.addDecl(D);
}
// Determine whether this name might be a candidate for
// argument-dependent lookup.
- bool ADL = UseArgumentDependentLookup(SS, R, HasTrailingLParen);
+ bool ADL = UseArgumentDependentLookup(SS, R, IsCall);
if (R.empty() && !ADL) {
if (SS.isEmpty() && getLangOpts().MSVCCompat) {
@@ -3321,10 +3320,9 @@ ExprResult Sema::PerformObjectMemberConversion(Expr *From,
}
bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS,
- const LookupResult &R,
- bool HasTrailingLParen) {
+ const LookupResult &R, bool IsCall) {
// Only when used directly as the postfix-expression of a call.
- if (!HasTrailingLParen)
+ if (!IsCall)
return false;
// Never if a scope specifier was provided.
@@ -3371,7 +3369,6 @@ bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS,
return true;
}
-
/// Diagnoses obvious problems with the use of the given declaration
/// as an expression. This is only actually called for lookups that
/// were not overloaded, and it doesn't promise that the declaration
@@ -7425,11 +7422,10 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
CallExpr *TheCall;
if (Config) {
- assert(UsesADL == ADLCallKind::NotADL &&
- "CUDAKernelCallExpr should not use ADL");
TheCall = CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config),
Args, ResultTy, VK_PRValue, RParenLoc,
CurFPFeatureOverrides(), NumParams);
+ TheCall->setADLCallKind(UsesADL);
} else {
TheCall =
CallExpr::Create(Context, Fn, Args, ResultTy, VK_PRValue, RParenLoc,
diff --git a/clang/lib/Sema/SemaExprObjC.cpp b/clang/lib/Sema/SemaExprObjC.cpp
index 7a3be956196835..611ad1ba453515 100644
--- a/clang/lib/Sema/SemaExprObjC.cpp
+++ b/clang/lib/Sema/SemaExprObjC.cpp
@@ -5065,7 +5065,7 @@ ExprResult SemaObjC::BuildIvarRefExpr(Scope *S, SourceLocation Loc,
SourceLocation TemplateKWLoc;
ExprResult SelfExpr =
SemaRef.ActOnIdExpression(S, SelfScopeSpec, TemplateKWLoc, SelfName,
- /*HasTrailingLParen=*/false,
+ /*IsCall=*/false,
/*IsAddressOfOperand=*/false);
if (SelfExpr.isInvalid())
return ExprError();
diff --git a/clang/lib/Sema/SemaStmtAsm.cpp b/clang/lib/Sema/SemaStmtAsm.cpp
index bf460ebe75ef10..3eee0580961428 100644
--- a/clang/lib/Sema/SemaStmtAsm.cpp
+++ b/clang/lib/Sema/SemaStmtAsm.cpp
@@ -842,10 +842,10 @@ ExprResult Sema::LookupInlineAsmIdentifier(CXXScopeSpec &SS,
ReuseLambdaContextDecl);
ExprResult Result = ActOnIdExpression(getCurScope(), SS, TemplateKWLoc, Id,
- /*trailing lparen*/ false,
+ /*IsCall=*/false,
/*is & operand*/ false,
/*CorrectionCandidateCallback=*/nullptr,
- /*IsInlineAsmIdentifier=*/ true);
+ /*IsInlineAsmIdentifier=*/true);
if (IsUnevaluatedContext)
PopExpressionEvaluationContext();
diff --git a/clang/test/CodeGenCUDA/kernel-call-adl.cu b/clang/test/CodeGenCUDA/kernel-call-adl.cu
new file mode 100644
index 00000000000000..e58035cfe6b778
--- /dev/null
+++ b/clang/test/CodeGenCUDA/kernel-call-adl.cu
@@ -0,0 +1,55 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple nvptx64-nvidia-cuda -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=HOST
+// RUN: %clang_cc1 -triple nvptx64-nvidia-cuda -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=DEVICE
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple amdgcn-amd-amdhsa -x hip -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=HOST
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -x hip -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=DEVICE
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -ast-dump -ast-dump-filter=gh45327 %s | FileCheck %s --check-prefix=AST
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -emit-pch -o %t.cuda %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -include-pch %t.cuda -x cuda -ast-dump-all -ast-dump-filter=gh45327 /dev/null | FileCheck %s --check-prefix=AST
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -x hip -emit-pch -o %t.hip %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -include-pch %t.hip -x hip -ast-dump-all -ast-dump-filter=gh45327 /dev/null | FileCheck %s --check-prefix=AST
+
+#include "Inputs/cuda.h"
+
+namespace gh45327 {
+// The launch translation unit in the issue sees only this friend declaration;
+// init is defined in another translation unit.
+class MyClass {
+public:
+ friend __global__ void init(MyClass *simulation_map);
+};
+
+// HOST-LABEL: define{{.*}} @_ZN7gh453274testEv(
+// HOST: call void @_ZN7gh45327{{.*}}initEPNS_7MyClassE(
+// AST-LABEL: FunctionDecl {{.*}} test 'void ()'
+// AST: CUDAKernelCallExpr {{.*}} 'void' adl
+void test() {
+ MyClass obj;
+ init<<<1, 1>>>(&obj);
+}
+} // namespace gh45327
+
+namespace associated {
+struct Arg {};
+
+// DEVICE-LABEL: define{{.*}} @_ZN10associated6kernelENS_3ArgE(
+__global__ void kernel(Arg) {}
+
+// DEVICE-LABEL: define{{.*}} @_ZN10associated15template_kernelIiEEvNS_3ArgET_(
+template <class T> __global__ void template_kernel(Arg, T) {}
+} // namespace associated
+
+// HOST-LABEL: define{{.*}} @_Z6launchv(
+// HOST: call void @_ZN10associated{{.*}}kernelENS_3ArgE(
+// HOST: call void @_ZN10associated{{.*}}template_kernelIiEEvNS_3ArgET_(
+void launch() {
+ associated::Arg arg;
+ kernel<<<1, 1>>>(arg);
+ // An explicit template argument list takes the C++ id-expression path.
+ template_kernel<int><<<1, 1>>>(arg, 0);
+}
+
+// Lookup of the kernel is deferred until this function is instantiated.
+template <class T> void dependent_launch(T arg) {
+ kernel<<<1, 1>>>(arg);
+}
+template void dependent_launch(associated::Arg);
diff --git a/clang/test/SemaCUDA/kernel-call-adl.cu b/clang/test/SemaCUDA/kernel-call-adl.cu
new file mode 100644
index 00000000000000..fee11166df002e
--- /dev/null
+++ b/clang/test/SemaCUDA/kernel-call-adl.cu
@@ -0,0 +1,60 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple nvptx64-nvidia-cuda -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
+// RUN: %clang_cc1 -triple nvptx64-nvidia-cuda -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple amdgcn-amd-amdhsa -x hip -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -x hip -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
+
+#include "Inputs/cuda.h"
+
+namespace associated {
+struct Arg {};
+__global__ void kernel(Arg);
+template <class T> __global__ void template_kernel(T);
+void host_function(Arg);
+} // namespace associated
+
+void test(associated::Arg arg) {
+ // Parentheses and qualification still suppress ADL.
+ (kernel)<<<1, 1>>>(arg); // expected-error {{use of undeclared identifier 'kernel'}}
+ ::kernel<<<1, 1>>>(arg); // expected-error {{no member named 'kernel' in the global namespace}}
+ // The address-of operand is the whole call, not the kernel name.
+ &kernel<<<1, 1>>>(arg); // expected-error {{cannot take the address of an rvalue of type 'void'}}
+ &template_kernel<associated::Arg><<<1, 1>>>(arg); // expected-error {{cannot take the address of an rvalue of type 'void'}}
+ // Finding a function by ADL does not make it a kernel.
+ host_function<<<1, 1>>>(arg); // expected-error {{kernel call to non-global function 'host_function'}}
+}
+
+void block_scope(associated::Arg arg) {
+ __global__ void kernel(int); // expected-note {{passing argument to parameter here}}
+ kernel<<<1, 1>>>(arg); // expected-error {{no viable conversion from 'associated::Arg' to 'int'}}
+}
+
+struct Member {
+ static __global__ void kernel(int); // expected-note {{passing argument to parameter here}}
+ void test(associated::Arg arg) {
+ kernel<<<1, 1>>>(arg); // expected-error {{no viable conversion from 'associated::Arg' to 'int'}}
+ }
+};
+
+namespace config {
+struct Grid {
+ operator dim3() const;
+};
+__global__ void only_in_config();
+} // namespace config
+
+void configuration() {
+ // Only the kernel arguments, not the execution configuration, supply
+ // associated namespaces for lookup of the kernel.
+ only_in_config<<<config::Grid{}, 1>>>(); // expected-error {{use of undeclared identifier 'only_in_config'}}
+}
+
+namespace associated {
+__global__ void ambiguous(Arg); // expected-note {{candidate function}}
+} // namespace associated
+
+__global__ void ambiguous(associated::Arg); // expected-note {{candidate function}}
+
+void overloads(associated::Arg arg) {
+ // ADL augments ordinary lookup rather than replacing its candidates.
+ ambiguous<<<1, 1>>>(arg); // expected-error {{call to 'ambiguous' is ambiguous}}
+}
>From 06e1338d92cb81012bb2aeaaacc4e023ff3030c6 Mon Sep 17 00:00:00 2001
From: Ambrose Leeb <aleeb at nvidia.com>
Date: Wed, 11 Nov 2026 22:55:17 +0000
Subject: [PATCH 2/2] address review comments
---
clang/include/clang/AST/ExprCXX.h | 14 +++++++-------
clang/lib/AST/ExprCXX.cpp | 10 +++++-----
clang/lib/Sema/SemaExpr.cpp | 7 +++----
clang/test/CodeGenCUDA/kernel-call-adl.cu | 4 ++--
clang/test/SemaCUDA/kernel-call-adl.cu | 4 ++--
5 files changed, 19 insertions(+), 20 deletions(-)
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
index af1d3be39004e6..e648bdaef5d98a 100644
--- a/clang/include/clang/AST/ExprCXX.h
+++ b/clang/include/clang/AST/ExprCXX.h
@@ -246,17 +246,17 @@ class CUDAKernelCallExpr final : public CallExpr {
CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args,
QualType Ty, ExprValueKind VK, SourceLocation RP,
- FPOptionsOverride FPFeatures, unsigned MinNumArgs);
+ FPOptionsOverride FPFeatures, unsigned MinNumArgs,
+ ADLCallKind UsesADL);
CUDAKernelCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);
public:
- static CUDAKernelCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
- CallExpr *Config, ArrayRef<Expr *> Args,
- QualType Ty, ExprValueKind VK,
- SourceLocation RP,
- FPOptionsOverride FPFeatures,
- unsigned MinNumArgs = 0);
+ static CUDAKernelCallExpr *
+ Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
+ ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
+ SourceLocation RP, FPOptionsOverride FPFeatures,
+ unsigned MinNumArgs = 0, ADLCallKind UsesADL = NotADL);
static CUDAKernelCallExpr *CreateEmpty(const ASTContext &Ctx,
unsigned NumArgs, bool HasFPFeatures,
diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp
index 497957a374f0d5..1db85437db2a50 100644
--- a/clang/lib/AST/ExprCXX.cpp
+++ b/clang/lib/AST/ExprCXX.cpp
@@ -1994,9 +1994,9 @@ CUDAKernelCallExpr::CUDAKernelCallExpr(Expr *Fn, CallExpr *Config,
ArrayRef<Expr *> Args, QualType Ty,
ExprValueKind VK, SourceLocation RP,
FPOptionsOverride FPFeatures,
- unsigned MinNumArgs)
+ unsigned MinNumArgs, ADLCallKind UsesADL)
: CallExpr(CUDAKernelCallExprClass, Fn, /*PreArgs=*/Config, Args, Ty, VK,
- RP, FPFeatures, MinNumArgs, NotADL) {}
+ RP, FPFeatures, MinNumArgs, UsesADL) {}
CUDAKernelCallExpr::CUDAKernelCallExpr(unsigned NumArgs, bool HasFPFeatures,
EmptyShell Empty)
@@ -2007,7 +2007,7 @@ CUDAKernelCallExpr *
CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
SourceLocation RP, FPOptionsOverride FPFeatures,
- unsigned MinNumArgs) {
+ unsigned MinNumArgs, ADLCallKind UsesADL) {
// Allocate storage for the trailing objects of CallExpr.
unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
unsigned SizeOfTrailingObjects = CallExpr::sizeOfTrailingObjects(
@@ -2016,8 +2016,8 @@ CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
Ctx.Allocate(sizeToAllocateForCallExprSubclass<CUDAKernelCallExpr>(
SizeOfTrailingObjects),
alignof(CUDAKernelCallExpr));
- return new (Mem)
- CUDAKernelCallExpr(Fn, Config, Args, Ty, VK, RP, FPFeatures, MinNumArgs);
+ return new (Mem) CUDAKernelCallExpr(Fn, Config, Args, Ty, VK, RP, FPFeatures,
+ MinNumArgs, UsesADL);
}
CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx,
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index b4e3a7a40f5f1b..3329544523fa2f 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -7422,10 +7422,9 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
CallExpr *TheCall;
if (Config) {
- TheCall = CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config),
- Args, ResultTy, VK_PRValue, RParenLoc,
- CurFPFeatureOverrides(), NumParams);
- TheCall->setADLCallKind(UsesADL);
+ TheCall = CUDAKernelCallExpr::Create(
+ Context, Fn, cast<CallExpr>(Config), Args, ResultTy, VK_PRValue,
+ RParenLoc, CurFPFeatureOverrides(), NumParams, UsesADL);
} else {
TheCall =
CallExpr::Create(Context, Fn, Args, ResultTy, VK_PRValue, RParenLoc,
diff --git a/clang/test/CodeGenCUDA/kernel-call-adl.cu b/clang/test/CodeGenCUDA/kernel-call-adl.cu
index e58035cfe6b778..a34a9e54f6000d 100644
--- a/clang/test/CodeGenCUDA/kernel-call-adl.cu
+++ b/clang/test/CodeGenCUDA/kernel-call-adl.cu
@@ -1,7 +1,7 @@
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple nvptx64-nvidia-cuda -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=HOST
// RUN: %clang_cc1 -triple nvptx64-nvidia-cuda -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=DEVICE
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple amdgcn-amd-amdhsa -x hip -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=HOST
-// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -x hip -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=DEVICE
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple amdgpu9.00-amd-amdhsa -x hip -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=HOST
+// RUN: %clang_cc1 -triple amdgpu9.00-amd-amdhsa -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -x hip -std=c++20 -emit-llvm -o - %s | FileCheck %s --check-prefix=DEVICE
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -ast-dump -ast-dump-filter=gh45327 %s | FileCheck %s --check-prefix=AST
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -emit-pch -o %t.cuda %s
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -include-pch %t.cuda -x cuda -ast-dump-all -ast-dump-filter=gh45327 /dev/null | FileCheck %s --check-prefix=AST
diff --git a/clang/test/SemaCUDA/kernel-call-adl.cu b/clang/test/SemaCUDA/kernel-call-adl.cu
index fee11166df002e..134089dee2ce27 100644
--- a/clang/test/SemaCUDA/kernel-call-adl.cu
+++ b/clang/test/SemaCUDA/kernel-call-adl.cu
@@ -1,7 +1,7 @@
// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple nvptx64-nvidia-cuda -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
// RUN: %clang_cc1 -triple nvptx64-nvidia-cuda -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
-// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple amdgcn-amd-amdhsa -x hip -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
-// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -x hip -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -aux-triple amdgpu9.00-amd-amdhsa -x hip -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
+// RUN: %clang_cc1 -triple amdgpu9.00-amd-amdhsa -aux-triple x86_64-unknown-linux-gnu -fcuda-is-device -x hip -std=c++20 -fsyntax-only -fno-spell-checking -verify %s
#include "Inputs/cuda.h"
More information about the cfe-commits
mailing list