| //===- SemaSYCL.cpp - Semantic Analysis for SYCL constructs ---------------===// | |
| // | |
| // 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 | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // This implements Semantic Analysis for SYCL constructs. | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/Sema/SemaSYCL.h" | |
| #include "TreeTransform.h" | |
| #include "clang/AST/Mangle.h" | |
| #include "clang/AST/SYCLKernelInfo.h" | |
| #include "clang/AST/StmtSYCL.h" | |
| #include "clang/AST/SubobjectVisitor.h" | |
| #include "clang/AST/TypeOrdering.h" | |
| #include "clang/Basic/Diagnostic.h" | |
| #include "clang/Sema/Attr.h" | |
| #include "clang/Sema/ParsedAttr.h" | |
| #include "clang/Sema/Sema.h" | |
| using namespace clang; | |
| // ----------------------------------------------------------------------------- | |
| // SYCL device specific diagnostics implementation | |
| // ----------------------------------------------------------------------------- | |
| SemaSYCL::SemaSYCL(Sema &S) : SemaBase(S) {} | |
| Sema::SemaDiagnosticBuilder SemaSYCL::DiagIfDeviceCode(SourceLocation Loc, | |
| unsigned DiagID) { | |
| assert(getLangOpts().SYCLIsDevice && | |
| "Device diagnostics Should only be issued during device compilation"); | |
| SemaDiagnosticBuilder::Kind DiagKind = SemaDiagnosticBuilder::K_Nop; | |
| FunctionDecl *FD = SemaRef.getCurFunctionDecl(/*AllowLambda=*/true); | |
| if (FD) { | |
| Sema::FunctionEmissionStatus FES = SemaRef.getEmissionStatus(FD); | |
| switch (FES) { | |
| case Sema::FunctionEmissionStatus::Emitted: | |
| DiagKind = SemaDiagnosticBuilder::K_ImmediateWithCallStack; | |
| break; | |
| case Sema::FunctionEmissionStatus::Unknown: | |
| case Sema::FunctionEmissionStatus::TemplateDiscarded: | |
| DiagKind = SemaDiagnosticBuilder::K_Deferred; | |
| break; | |
| case Sema::FunctionEmissionStatus::OMPDiscarded: | |
| llvm_unreachable("OMPDiscarded unexpected in SYCL device compilation"); | |
| case Sema::FunctionEmissionStatus::CUDADiscarded: | |
| llvm_unreachable("CUDADiscarded unexpected in SYCL device compilation"); | |
| } | |
| } | |
| return SemaDiagnosticBuilder(DiagKind, Loc, DiagID, FD, SemaRef); | |
| } | |
| static bool isZeroSizedArray(SemaSYCL &S, QualType Ty) { | |
| if (const auto *CAT = S.getASTContext().getAsConstantArrayType(Ty)) | |
| return CAT->isZeroSize(); | |
| return false; | |
| } | |
| void SemaSYCL::deepTypeCheckForDevice(SourceLocation UsedAt, | |
| llvm::DenseSet<QualType> Visited, | |
| ValueDecl *DeclToCheck) { | |
| assert(getLangOpts().SYCLIsDevice && | |
| "Should only be called during SYCL compilation"); | |
| // Emit notes only for the first discovered declaration of unsupported type | |
| // to avoid mess of notes. This flag is to track that error already happened. | |
| bool NeedToEmitNotes = true; | |
| auto Check = [&](QualType TypeToCheck, const ValueDecl *D) { | |
| bool ErrorFound = false; | |
| if (isZeroSizedArray(*this, TypeToCheck)) { | |
| DiagIfDeviceCode(UsedAt, diag::err_typecheck_zero_array_size) << 1; | |
| ErrorFound = true; | |
| } | |
| // Checks for other types can also be done here. | |
| if (ErrorFound) { | |
| if (NeedToEmitNotes) { | |
| if (auto *FD = dyn_cast<FieldDecl>(D)) | |
| DiagIfDeviceCode(FD->getLocation(), | |
| diag::note_illegal_field_declared_here) | |
| << FD->getType()->isPointerType() << FD->getType(); | |
| else | |
| DiagIfDeviceCode(D->getLocation(), diag::note_declared_at); | |
| } | |
| } | |
| return ErrorFound; | |
| }; | |
| // In case we have a Record used do the DFS for a bad field. | |
| SmallVector<const ValueDecl *, 4> StackForRecursion; | |
| StackForRecursion.push_back(DeclToCheck); | |
| // While doing DFS save how we get there to emit a nice set of notes. | |
| SmallVector<const FieldDecl *, 4> History; | |
| History.push_back(nullptr); | |
| do { | |
| const ValueDecl *Next = StackForRecursion.pop_back_val(); | |
| if (!Next) { | |
| assert(!History.empty()); | |
| // Found a marker, we have gone up a level. | |
| History.pop_back(); | |
| continue; | |
| } | |
| QualType NextTy = Next->getType(); | |
| if (!Visited.insert(NextTy).second) | |
| continue; | |
| auto EmitHistory = [&]() { | |
| // The first element is always nullptr. | |
| for (uint64_t Index = 1; Index < History.size(); ++Index) { | |
| DiagIfDeviceCode(History[Index]->getLocation(), | |
| diag::note_within_field_of_type) | |
| << History[Index]->getType(); | |
| } | |
| }; | |
| if (Check(NextTy, Next)) { | |
| if (NeedToEmitNotes) | |
| EmitHistory(); | |
| NeedToEmitNotes = false; | |
| } | |
| // In case pointer/array/reference type is met get pointee type, then | |
| // proceed with that type. | |
| while (NextTy->isAnyPointerType() || NextTy->isArrayType() || | |
| NextTy->isReferenceType()) { | |
| if (NextTy->isArrayType()) | |
| NextTy = QualType{NextTy->getArrayElementTypeNoTypeQual(), 0}; | |
| else | |
| NextTy = NextTy->getPointeeType(); | |
| if (Check(NextTy, Next)) { | |
| if (NeedToEmitNotes) | |
| EmitHistory(); | |
| NeedToEmitNotes = false; | |
| } | |
| } | |
| if (const auto *RecDecl = NextTy->getAsRecordDecl()) { | |
| if (auto *NextFD = dyn_cast<FieldDecl>(Next)) | |
| History.push_back(NextFD); | |
| // When nullptr is discovered, this means we've gone back up a level, so | |
| // the history should be cleaned. | |
| StackForRecursion.push_back(nullptr); | |
| llvm::append_range(StackForRecursion, RecDecl->fields()); | |
| } | |
| } while (!StackForRecursion.empty()); | |
| } | |
| ExprResult SemaSYCL::BuildUniqueStableNameExpr(SourceLocation OpLoc, | |
| SourceLocation LParen, | |
| SourceLocation RParen, | |
| TypeSourceInfo *TSI) { | |
| return SYCLUniqueStableNameExpr::Create(getASTContext(), OpLoc, LParen, | |
| RParen, TSI); | |
| } | |
| ExprResult SemaSYCL::ActOnUniqueStableNameExpr(SourceLocation OpLoc, | |
| SourceLocation LParen, | |
| SourceLocation RParen, | |
| ParsedType ParsedTy) { | |
| TypeSourceInfo *TSI = nullptr; | |
| QualType Ty = SemaRef.GetTypeFromParser(ParsedTy, &TSI); | |
| if (Ty.isNull()) | |
| return ExprError(); | |
| if (!TSI) | |
| TSI = getASTContext().getTrivialTypeSourceInfo(Ty, LParen); | |
| return BuildUniqueStableNameExpr(OpLoc, LParen, RParen, TSI); | |
| } | |
| void SemaSYCL::handleKernelAttr(Decl *D, const ParsedAttr &AL) { | |
| // The 'sycl_kernel' attribute applies only to function templates. | |
| const auto *FD = cast<FunctionDecl>(D); | |
| const FunctionTemplateDecl *FT = FD->getDescribedFunctionTemplate(); | |
| assert(FT && "Function template is expected"); | |
| // Function template must have at least two template parameters. | |
| const TemplateParameterList *TL = FT->getTemplateParameters(); | |
| if (TL->size() < 2) { | |
| Diag(FT->getLocation(), diag::warn_sycl_kernel_num_of_template_params); | |
| return; | |
| } | |
| // Template parameters must be typenames. | |
| for (unsigned I = 0; I < 2; ++I) { | |
| const NamedDecl *TParam = TL->getParam(I); | |
| if (isa<NonTypeTemplateParmDecl>(TParam)) { | |
| Diag(FT->getLocation(), | |
| diag::warn_sycl_kernel_invalid_template_param_type); | |
| return; | |
| } | |
| } | |
| // Function must have at least one argument. | |
| if (getFunctionOrMethodNumParams(D) != 1) { | |
| Diag(FT->getLocation(), diag::warn_sycl_kernel_num_of_function_params); | |
| return; | |
| } | |
| // Function must return void. | |
| QualType RetTy = getFunctionOrMethodResultType(D); | |
| if (!RetTy->isVoidType()) { | |
| Diag(FT->getLocation(), diag::warn_sycl_kernel_return_type); | |
| return; | |
| } | |
| handleSimpleAttribute<SYCLKernelAttr>(*this, D, AL); | |
| } | |
| void SemaSYCL::handleKernelEntryPointAttr(Decl *D, const ParsedAttr &AL) { | |
| ParsedType PT = AL.getTypeArg(); | |
| TypeSourceInfo *TSI = nullptr; | |
| (void)SemaRef.GetTypeFromParser(PT, &TSI); | |
| assert(TSI && "no type source info for attribute argument"); | |
| D->addAttr(::new (SemaRef.Context) | |
| SYCLKernelEntryPointAttr(SemaRef.Context, AL, TSI)); | |
| } | |
| void SemaSYCL::CheckDeviceUseOfDecl(NamedDecl *ND, SourceLocation Loc) { | |
| assert(getLangOpts().SYCLIsDevice && | |
| "Should only be called during SYCL device compilation"); | |
| // Function declarations with the sycl_kernel_entry_point attribute cannot | |
| // be ODR-used in a potentially evaluated context. | |
| if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { | |
| if (const auto *SKEPAttr = FD->getAttr<SYCLKernelEntryPointAttr>()) { | |
| if (SemaRef.currentEvaluationContext().isPotentiallyEvaluated()) { | |
| DiagIfDeviceCode(Loc, diag::err_sycl_entry_point_device_use) | |
| << FD << SKEPAttr; | |
| DiagIfDeviceCode(SKEPAttr->getLocation(), diag::note_attribute) << FD; | |
| } | |
| } | |
| } | |
| } | |
| // Given a potentially qualified type, SourceLocationForUserDeclaredType() | |
| // returns the source location of the canonical declaration of the unqualified | |
| // desugared user declared type, if any. For non-user declared types, an | |
| // invalid source location is returned. The intended usage of this function | |
| // is to identify an appropriate source location, if any, for a | |
| // "entity declared here" diagnostic note. | |
| static SourceLocation SourceLocationForUserDeclaredType(QualType QT) { | |
| SourceLocation Loc; | |
| const Type *T = QT->getUnqualifiedDesugaredType(); | |
| if (const TagType *TT = dyn_cast<TagType>(T)) | |
| Loc = TT->getDecl()->getLocation(); | |
| else if (const auto *ObjCIT = dyn_cast<ObjCInterfaceType>(T)) | |
| Loc = ObjCIT->getDecl()->getLocation(); | |
| return Loc; | |
| } | |
| static bool CheckSYCLKernelName(Sema &S, SourceLocation Loc, | |
| QualType KernelName) { | |
| assert(!KernelName->isDependentType()); | |
| if (!KernelName->isStructureOrClassType()) { | |
| // SYCL 2020 section 5.2, "Naming of kernels", only requires that the | |
| // kernel name be a C++ typename. However, the definition of "kernel name" | |
| // in the glossary states that a kernel name is a class type. Neither | |
| // section explicitly states whether the kernel name type can be | |
| // cv-qualified. For now, kernel name types are required to be class types | |
| // and that they may be cv-qualified. The following issue requests | |
| // clarification from the SYCL WG. | |
| // https://github.com/KhronosGroup/SYCL-Docs/issues/568 | |
| S.Diag(Loc, diag::warn_sycl_kernel_name_not_a_class_type) << KernelName; | |
| SourceLocation DeclTypeLoc = SourceLocationForUserDeclaredType(KernelName); | |
| if (DeclTypeLoc.isValid()) | |
| S.Diag(DeclTypeLoc, diag::note_entity_declared_at) << KernelName; | |
| return true; | |
| } | |
| return false; | |
| } | |
| void SemaSYCL::CheckSYCLExternalFunctionDecl(FunctionDecl *FD) { | |
| const auto *SEAttr = FD->getAttr<SYCLExternalAttr>(); | |
| assert(SEAttr && "Missing sycl_external attribute"); | |
| if (!FD->isInvalidDecl() && !FD->isTemplated()) { | |
| if (!FD->isExternallyVisible()) | |
| if (!FD->isFunctionTemplateSpecialization() || | |
| FD->getTemplateSpecializationInfo()->isExplicitSpecialization()) | |
| Diag(SEAttr->getLocation(), diag::err_sycl_external_invalid_linkage) | |
| << SEAttr; | |
| } | |
| if (FD->isDeletedAsWritten()) { | |
| Diag(SEAttr->getLocation(), | |
| diag::err_sycl_external_invalid_deleted_function) | |
| << SEAttr; | |
| } | |
| } | |
| void SemaSYCL::CheckSYCLEntryPointFunctionDecl(FunctionDecl *FD) { | |
| // Ensure that all attributes present on the declaration are consistent | |
| // and warn about any redundant ones. | |
| SYCLKernelEntryPointAttr *SKEPAttr = nullptr; | |
| for (auto *SAI : FD->specific_attrs<SYCLKernelEntryPointAttr>()) { | |
| if (!SKEPAttr) { | |
| SKEPAttr = SAI; | |
| continue; | |
| } | |
| if (!getASTContext().hasSameType(SAI->getKernelName(), | |
| SKEPAttr->getKernelName())) { | |
| Diag(SAI->getLocation(), diag::err_sycl_entry_point_invalid_redeclaration) | |
| << SKEPAttr << SAI->getKernelName() << SKEPAttr->getKernelName(); | |
| Diag(SKEPAttr->getLocation(), diag::note_previous_attribute); | |
| SAI->setInvalidAttr(); | |
| } else { | |
| Diag(SAI->getLocation(), | |
| diag::warn_sycl_entry_point_redundant_declaration) | |
| << SAI; | |
| Diag(SKEPAttr->getLocation(), diag::note_previous_attribute); | |
| } | |
| } | |
| assert(SKEPAttr && "Missing sycl_kernel_entry_point attribute"); | |
| // Ensure the kernel name type is valid. | |
| if (!SKEPAttr->getKernelName()->isDependentType() && | |
| CheckSYCLKernelName(SemaRef, SKEPAttr->getLocation(), | |
| SKEPAttr->getKernelName())) | |
| SKEPAttr->setInvalidAttr(); | |
| // Ensure that an attribute present on the previous declaration | |
| // matches the one on this declaration. | |
| FunctionDecl *PrevFD = FD->getPreviousDecl(); | |
| if (PrevFD && !PrevFD->isInvalidDecl()) { | |
| const auto *PrevSKEPAttr = PrevFD->getAttr<SYCLKernelEntryPointAttr>(); | |
| if (PrevSKEPAttr && !PrevSKEPAttr->isInvalidAttr()) { | |
| if (!getASTContext().hasSameType(SKEPAttr->getKernelName(), | |
| PrevSKEPAttr->getKernelName())) { | |
| Diag(SKEPAttr->getLocation(), | |
| diag::err_sycl_entry_point_invalid_redeclaration) | |
| << SKEPAttr << SKEPAttr->getKernelName() | |
| << PrevSKEPAttr->getKernelName(); | |
| Diag(PrevSKEPAttr->getLocation(), diag::note_previous_decl) << PrevFD; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| } | |
| } | |
| if (isa<CXXConstructorDecl>(FD)) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::Constructor; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| if (isa<CXXDestructorDecl>(FD)) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::Destructor; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) { | |
| if (MD->isExplicitObjectMemberFunction()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::ExplicitObjectFn; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| } | |
| if (FD->isVariadic()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::VariadicFn; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| if (FD->isDefaulted()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::DefaultedFn; | |
| SKEPAttr->setInvalidAttr(); | |
| } else if (FD->isDeleted()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::DeletedFn; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| if (FD->isConsteval()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::ConstevalFn; | |
| SKEPAttr->setInvalidAttr(); | |
| } else if (FD->isConstexpr()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::ConstexprFn; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| if (FD->isNoReturn()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_invalid) | |
| << SKEPAttr << diag::InvalidSKEPReason::NoreturnFn; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| if (FD->getReturnType()->isUndeducedType()) { | |
| Diag(SKEPAttr->getLocation(), | |
| diag::err_sycl_entry_point_deduced_return_type) | |
| << SKEPAttr; | |
| SKEPAttr->setInvalidAttr(); | |
| } else if (!FD->getReturnType()->isDependentType() && | |
| !FD->getReturnType()->isVoidType()) { | |
| Diag(SKEPAttr->getLocation(), diag::err_sycl_entry_point_return_type) | |
| << SKEPAttr; | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| if (!FD->isInvalidDecl() && !FD->isTemplated() && | |
| !SKEPAttr->isInvalidAttr()) { | |
| const SYCLKernelInfo *SKI = | |
| getASTContext().findSYCLKernelInfo(SKEPAttr->getKernelName()); | |
| if (SKI) { | |
| if (!declaresSameEntity(FD, SKI->getKernelEntryPointDecl())) { | |
| // FIXME: This diagnostic should include the origin of the kernel | |
| // FIXME: names; not just the locations of the conflicting declarations. | |
| Diag(FD->getLocation(), diag::err_sycl_kernel_name_conflict) | |
| << SKEPAttr; | |
| Diag(SKI->getKernelEntryPointDecl()->getLocation(), | |
| diag::note_previous_declaration); | |
| SKEPAttr->setInvalidAttr(); | |
| } | |
| } else { | |
| getASTContext().registerSYCLEntryPointFunction(FD); | |
| } | |
| } | |
| } | |
| ExprResult SemaSYCL::BuildSYCLKernelLaunchIdExpr(FunctionDecl *FD, | |
| QualType KNT) { | |
| // The current context must be the function definition context to ensure | |
| // that name lookup is performed within the correct scope. | |
| assert(SemaRef.CurContext == FD && "The current declaration context does not " | |
| "match the requested function context"); | |
| // An appropriate source location is required to emit diagnostics if | |
| // lookup fails to produce an overload set. The desired location is the | |
| // start of the function body, but that is not yet available since the | |
| // body of the function has not yet been set when this function is called. | |
| // The general location of the function is used instead. | |
| SourceLocation Loc = FD->getLocation(); | |
| ASTContext &Ctx = SemaRef.getASTContext(); | |
| IdentifierInfo &SYCLKernelLaunchID = | |
| Ctx.Idents.get("sycl_kernel_launch", tok::TokenKind::identifier); | |
| // Establish a code synthesis context for the implicit name lookup of | |
| // a template named 'sycl_kernel_launch'. In the event of an error, this | |
| // ensures an appropriate diagnostic note is issued to explain why the | |
| // lookup was performed. | |
| Sema::CodeSynthesisContext CSC; | |
| CSC.Kind = Sema::CodeSynthesisContext::SYCLKernelLaunchLookup; | |
| CSC.Entity = FD; | |
| Sema::ScopedCodeSynthesisContext ScopedCSC(SemaRef, CSC); | |
| // Perform ordinary name lookup for a function or variable template that | |
| // accepts a single type template argument. | |
| LookupResult Result(SemaRef, &SYCLKernelLaunchID, Loc, | |
| Sema::LookupOrdinaryName); | |
| CXXScopeSpec EmptySS; | |
| if (SemaRef.LookupTemplateName(Result, SemaRef.getCurScope(), EmptySS, | |
| /*ObjectType*/ QualType(), | |
| /*EnteringContext*/ false, | |
| Sema::TemplateNameIsRequired)) | |
| return ExprError(); | |
| if (Result.isAmbiguous()) | |
| return ExprError(); | |
| TemplateArgumentListInfo TALI{Loc, Loc}; | |
| TemplateArgument KNTA = TemplateArgument(KNT); | |
| TemplateArgumentLoc TAL = | |
| SemaRef.getTrivialTemplateArgumentLoc(KNTA, QualType(), Loc); | |
| TALI.addArgument(TAL); | |
| ExprResult IdExpr; | |
| if (SemaRef.isPotentialImplicitMemberAccess(EmptySS, Result, | |
| /*IsAddressOfOperand*/ false)) { | |
| // The lookup result allows for a possible implicit member access that | |
| // would require an implicit or explicit 'this' argument. | |
| IdExpr = SemaRef.BuildPossibleImplicitMemberExpr( | |
| EmptySS, SourceLocation(), Result, &TALI, SemaRef.getCurScope()); | |
| } else { | |
| IdExpr = SemaRef.BuildTemplateIdExpr(EmptySS, SourceLocation(), Result, | |
| /*RequiresADL*/ true, &TALI); | |
| } | |
| // The resulting expression may be invalid if, for example, 'FD' is a | |
| // non-static member function and sycl_kernel_launch lookup selects a | |
| // member function (which would require a 'this' argument which is | |
| // not available). | |
| if (IdExpr.isInvalid()) | |
| return ExprError(); | |
| return IdExpr; | |
| } | |
| namespace { | |
| // Constructs the arguments to be passed for the SYCL kernel launch call. | |
| // The first argument is a string literal that contains the SYCL kernel | |
| // name. The remaining arguments are the parameters of 'FD' passed as | |
| // move-elligible xvalues. Returns true on error and false otherwise. | |
| bool BuildSYCLKernelLaunchCallArgs(Sema &SemaRef, FunctionDecl *FD, | |
| const SYCLKernelInfo *SKI, | |
| SmallVectorImpl<Expr *> &Args, | |
| SourceLocation Loc) { | |
| // The current context must be the function definition context to ensure | |
| // that parameter references occur within the correct scope. | |
| assert(SemaRef.CurContext == FD && "The current declaration context does not " | |
| "match the requested function context"); | |
| // Prepare a string literal that contains the kernel name. | |
| ASTContext &Ctx = SemaRef.getASTContext(); | |
| const std::string &KernelName = SKI->GetKernelName(); | |
| QualType KernelNameCharTy = Ctx.CharTy.withConst(); | |
| llvm::APInt KernelNameSize(Ctx.getTypeSize(Ctx.getSizeType()), | |
| KernelName.size() + 1); | |
| QualType KernelNameArrayTy = Ctx.getConstantArrayType( | |
| KernelNameCharTy, KernelNameSize, nullptr, ArraySizeModifier::Normal, 0); | |
| Expr *KernelNameExpr = | |
| StringLiteral::Create(Ctx, KernelName, StringLiteralKind::Ordinary, | |
| /*Pascal*/ false, KernelNameArrayTy, Loc); | |
| Args.push_back(KernelNameExpr); | |
| // Forward all parameters of 'FD' to the SYCL kernel launch function as if | |
| // by std::move(). | |
| for (ParmVarDecl *PVD : FD->parameters()) { | |
| QualType ParamType = PVD->getOriginalType().getNonReferenceType(); | |
| ExprResult E = SemaRef.BuildDeclRefExpr(PVD, ParamType, VK_LValue, Loc); | |
| if (E.isInvalid()) | |
| return true; | |
| if (!PVD->getType()->isLValueReferenceType()) | |
| E = ImplicitCastExpr::Create(SemaRef.Context, E.get()->getType(), CK_NoOp, | |
| E.get(), nullptr, VK_XValue, | |
| FPOptionsOverride()); | |
| if (E.isInvalid()) | |
| return true; | |
| Args.push_back(E.get()); | |
| } | |
| return false; | |
| } | |
| // Constructs the SYCL kernel launch call. | |
| StmtResult BuildSYCLKernelLaunchCallStmt(Sema &SemaRef, FunctionDecl *FD, | |
| const SYCLKernelInfo *SKI, | |
| Expr *IdExpr, SourceLocation Loc) { | |
| SmallVector<Stmt *> Stmts; | |
| // IdExpr may be null if name lookup failed. | |
| if (IdExpr) { | |
| llvm::SmallVector<Expr *, 12> Args; | |
| // Establish a code synthesis context for construction of the arguments | |
| // for the implicit call to 'sycl_kernel_launch'. | |
| { | |
| Sema::CodeSynthesisContext CSC; | |
| CSC.Kind = Sema::CodeSynthesisContext::SYCLKernelLaunchLookup; | |
| CSC.Entity = FD; | |
| Sema::ScopedCodeSynthesisContext ScopedCSC(SemaRef, CSC); | |
| if (BuildSYCLKernelLaunchCallArgs(SemaRef, FD, SKI, Args, Loc)) | |
| return StmtError(); | |
| } | |
| // Establish a code synthesis context for the implicit call to | |
| // 'sycl_kernel_launch'. | |
| { | |
| Sema::CodeSynthesisContext CSC; | |
| CSC.Kind = Sema::CodeSynthesisContext::SYCLKernelLaunchOverloadResolution; | |
| CSC.Entity = FD; | |
| CSC.CallArgs = Args.data(); | |
| CSC.NumCallArgs = Args.size(); | |
| Sema::ScopedCodeSynthesisContext ScopedCSC(SemaRef, CSC); | |
| ExprResult LaunchResult = | |
| SemaRef.BuildCallExpr(SemaRef.getCurScope(), IdExpr, Loc, Args, Loc); | |
| if (LaunchResult.isInvalid()) | |
| return StmtError(); | |
| Stmts.push_back(SemaRef.MaybeCreateExprWithCleanups(LaunchResult).get()); | |
| } | |
| } | |
| return CompoundStmt::Create(SemaRef.getASTContext(), Stmts, | |
| FPOptionsOverride(), Loc, Loc); | |
| } | |
| // The body of a function declared with the [[sycl_kernel_entry_point]] | |
| // attribute is cloned and transformed to substitute references to the original | |
| // function parameters with references to replacement variables that stand in | |
| // for SYCL kernel parameters or local variables that reconstitute a decomposed | |
| // SYCL kernel argument. | |
| class OutlinedFunctionDeclBodyInstantiator | |
| : public TreeTransform<OutlinedFunctionDeclBodyInstantiator> { | |
| public: | |
| using ParmDeclMap = llvm::DenseMap<ParmVarDecl *, VarDecl *>; | |
| OutlinedFunctionDeclBodyInstantiator(Sema &S, ParmDeclMap &M, | |
| FunctionDecl *FD) | |
| : TreeTransform<OutlinedFunctionDeclBodyInstantiator>(S), SemaRef(S), | |
| MapRef(M), FD(FD) {} | |
| // A new set of AST nodes is always required. | |
| bool AlwaysRebuild() { return true; } | |
| // Transform ParmVarDecl references to the supplied replacement variables. | |
| ExprResult TransformDeclRefExpr(DeclRefExpr *DRE) { | |
| const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()); | |
| if (PVD) { | |
| ParmDeclMap::iterator I = MapRef.find(PVD); | |
| if (I != MapRef.end()) { | |
| VarDecl *VD = I->second; | |
| assert(SemaRef.getASTContext().hasSameUnqualifiedType( | |
| PVD->getType().getNonReferenceType(), VD->getType())); | |
| assert(!VD->getType().isMoreQualifiedThan( | |
| PVD->getType().getNonReferenceType(), SemaRef.getASTContext())); | |
| VD->setIsUsed(); | |
| return DeclRefExpr::Create( | |
| SemaRef.getASTContext(), DRE->getQualifierLoc(), | |
| DRE->getTemplateKeywordLoc(), VD, false, DRE->getNameInfo(), | |
| DRE->getType(), DRE->getValueKind()); | |
| } | |
| } | |
| return DRE; | |
| } | |
| // Diagnose CXXThisExpr in a potentially evaluated expression. | |
| ExprResult TransformCXXThisExpr(CXXThisExpr *CTE) { | |
| if (SemaRef.currentEvaluationContext().isPotentiallyEvaluated()) { | |
| SemaRef.Diag(CTE->getExprLoc(), diag::err_sycl_entry_point_invalid_this) | |
| << (CTE->isImplicitCXXThis() ? /* implicit */ 1 : /* empty */ 0) | |
| << FD->getAttr<SYCLKernelEntryPointAttr>(); | |
| } | |
| return CTE; | |
| } | |
| private: | |
| Sema &SemaRef; | |
| ParmDeclMap &MapRef; | |
| FunctionDecl *FD; | |
| }; | |
| OutlinedFunctionDecl *BuildSYCLKernelEntryPointOutline(Sema &SemaRef, | |
| FunctionDecl *FD, | |
| CompoundStmt *Body) { | |
| using ParmDeclMap = OutlinedFunctionDeclBodyInstantiator::ParmDeclMap; | |
| ParmDeclMap ParmMap; | |
| OutlinedFunctionDecl *OFD = OutlinedFunctionDecl::Create( | |
| SemaRef.getASTContext(), FD, FD->getNumParams()); | |
| unsigned i = 0; | |
| for (ParmVarDecl *PVD : FD->parameters()) { | |
| ImplicitParamDecl *IPD = ImplicitParamDecl::Create( | |
| SemaRef.getASTContext(), OFD, SourceLocation(), PVD->getIdentifier(), | |
| PVD->getType().getNonReferenceType(), ImplicitParamKind::Other); | |
| OFD->setParam(i, IPD); | |
| ParmMap[PVD] = IPD; | |
| ++i; | |
| } | |
| OutlinedFunctionDeclBodyInstantiator OFDBodyInstantiator(SemaRef, ParmMap, | |
| FD); | |
| Stmt *OFDBody = OFDBodyInstantiator.TransformStmt(Body).get(); | |
| OFD->setBody(OFDBody); | |
| OFD->setNothrow(); | |
| return OFD; | |
| } | |
| class KernelParamsChecker : public ConstSubobjectVisitor<KernelParamsChecker> { | |
| SemaSYCL &SemaSYCLRef; | |
| bool IsValid = true; | |
| using ObjectAccess = | |
| llvm::PointerUnion<const ParmVarDecl *, const CXXBaseSpecifier *, | |
| const FieldDecl *>; | |
| SmallVector<ObjectAccess, 4> ObjectAccessPath; | |
| void emitObjectAccessPathNotes() { | |
| for (auto Parent : llvm::reverse(ObjectAccessPath)) { | |
| if (auto *FD = dyn_cast<const FieldDecl *>(Parent)) { | |
| const CXXRecordDecl *ParentRD = cast<CXXRecordDecl>(FD->getParent()); | |
| if (ParentRD->isLambda()) { | |
| SemaSYCLRef.Diag(ParentRD->getLocation(), diag::note_within_capture) | |
| << ParentRD->getCapture(FD->getFieldIndex())->getCapturedVar(); | |
| } else { | |
| SemaSYCLRef.Diag(ParentRD->getLocation(), | |
| diag::note_within_field_of_type) | |
| << ParentRD; | |
| } | |
| } else if (auto *BS = dyn_cast<const CXXBaseSpecifier *>(Parent)) { | |
| CXXRecordDecl *RD = BS->getType()->getAsCXXRecordDecl(); | |
| assert(RD); | |
| SemaSYCLRef.Diag(BS->getBeginLoc(), diag::note_within_base_of_type) | |
| << RD; | |
| } else { | |
| auto *Param = cast<const ParmVarDecl *>(Parent); | |
| SemaSYCLRef.Diag(Param->getBeginLoc(), diag::note_within_param_of_type) | |
| << Param << Param->getType(); | |
| } | |
| } | |
| } | |
| public: | |
| KernelParamsChecker(SemaSYCL &SR, SourceLocation Loc) | |
| : ConstSubobjectVisitor<KernelParamsChecker>(SR.getASTContext()), | |
| SemaSYCLRef(SR) {} | |
| void checkParameter(const ParmVarDecl *PVD) { | |
| ObjectAccessPath.push_back(PVD); | |
| // Check the immediate type of the parameter. | |
| if (checkType(PVD->getType())) { | |
| // If type checking wasn't short circuited, visit subobjects to check | |
| // them. | |
| visit(PVD->getType()); | |
| } | |
| ObjectAccessPath.pop_back(); | |
| assert(ObjectAccessPath.empty()); | |
| } | |
| bool visitBaseSpecifierPre(const CXXBaseSpecifier *BS) { | |
| ObjectAccessPath.push_back(BS); | |
| return checkType(BS->getType()); | |
| } | |
| bool visitFieldDeclPre(const FieldDecl *FD) { | |
| ObjectAccessPath.push_back(FD); | |
| return checkType(FD->getType()); | |
| } | |
| // Returns true if subobjects should be visited and false otherwise. | |
| bool checkType(QualType Ty) { | |
| if (Ty->isReferenceType()) { | |
| auto DirectParent = ObjectAccessPath.back(); | |
| // Reference cannot be a base, so just assume we came via a FieldDecl. | |
| if (isa<const ParmVarDecl *>(DirectParent)) { | |
| // If reference is a kernel parameter, there is nothing to do. We allow | |
| // references in direct kernel parameters for better performance of the | |
| // host code and we eliminate them when building actual kernel. | |
| return true; | |
| } | |
| auto *DirectFieldParent = cast<const FieldDecl *>(DirectParent); | |
| SemaSYCLRef.Diag(DirectFieldParent->getLocation(), | |
| diag::err_bad_kernel_param_type) | |
| << DirectFieldParent->getType(); | |
| emitObjectAccessPathNotes(); | |
| // Don't visit the type of the reference since any further invalid | |
| // kernel parameter types contained within the referenced type | |
| // might not be relevant once the programmer addresses the | |
| // invalid use of a reference. | |
| IsValid = false; | |
| return false; | |
| } | |
| return true; | |
| } | |
| void visitFieldDeclPost(const FieldDecl *FD) { ObjectAccessPath.pop_back(); } | |
| void visitBaseSpecifierPost(const CXXBaseSpecifier *BS) { | |
| ObjectAccessPath.pop_back(); | |
| } | |
| bool isInvalid() { return !IsValid; } | |
| }; | |
| bool verifyKernelParams(FunctionDecl *FD, SemaSYCL &SemaSYCLRef) { | |
| KernelParamsChecker KAC(SemaSYCLRef, FD->getLocation()); | |
| for (auto Param : FD->parameters()) | |
| KAC.checkParameter(Param); | |
| return KAC.isInvalid(); | |
| } | |
| } // unnamed namespace | |
| StmtResult SemaSYCL::BuildSYCLKernelCallStmt(FunctionDecl *FD, | |
| CompoundStmt *Body, | |
| Expr *LaunchIdExpr) { | |
| assert(!FD->isInvalidDecl()); | |
| assert(!FD->isTemplated()); | |
| assert(FD->hasPrototype()); | |
| // The current context must be the function definition context to ensure | |
| // that name lookup and parameter and local variable creation are performed | |
| // within the correct scope. | |
| assert(SemaRef.CurContext == FD && "The current declaration context does not " | |
| "match the requested function context"); | |
| const auto *SKEPAttr = FD->getAttr<SYCLKernelEntryPointAttr>(); | |
| assert(SKEPAttr && "Missing sycl_kernel_entry_point attribute"); | |
| assert(!SKEPAttr->isInvalidAttr() && | |
| "sycl_kernel_entry_point attribute is invalid"); | |
| // Ensure that the kernel name was previously registered and that the | |
| // stored declaration matches. | |
| const SYCLKernelInfo &SKI = | |
| getASTContext().getSYCLKernelInfo(SKEPAttr->getKernelName()); | |
| assert(declaresSameEntity(SKI.getKernelEntryPointDecl(), FD) && | |
| "SYCL kernel name conflict"); | |
| if (verifyKernelParams(FD, *this)) | |
| return StmtError(); | |
| // Build the outline of the synthesized device entry point function. | |
| OutlinedFunctionDecl *OFD = | |
| BuildSYCLKernelEntryPointOutline(SemaRef, FD, Body); | |
| assert(OFD); | |
| // Build the host kernel launch statement. An appropriate source location | |
| // is required to emit diagnostics. | |
| SourceLocation Loc = Body->getLBracLoc(); | |
| StmtResult LaunchResult = | |
| BuildSYCLKernelLaunchCallStmt(SemaRef, FD, &SKI, LaunchIdExpr, Loc); | |
| if (LaunchResult.isInvalid()) | |
| return StmtError(); | |
| Stmt *NewBody = | |
| new (getASTContext()) SYCLKernelCallStmt(Body, LaunchResult.get(), OFD); | |
| return NewBody; | |
| } | |
| StmtResult SemaSYCL::BuildUnresolvedSYCLKernelCallStmt(CompoundStmt *Body, | |
| Expr *LaunchIdExpr) { | |
| return UnresolvedSYCLKernelCallStmt::Create(SemaRef.getASTContext(), Body, | |
| LaunchIdExpr); | |
| } |