fraggamuffin updated this revision to Diff 43746. fraggamuffin marked 3 inline comments as done. fraggamuffin added a comment.
Fixed Comments from Dec 17. http://reviews.llvm.org/D15321 Files: include/clang/AST/DeclBase.h include/clang/AST/DeclOpenMP.h include/clang/AST/RecursiveASTVisitor.h include/clang/Basic/Attr.td include/clang/Basic/DeclNodes.td include/clang/Basic/DiagnosticGroups.td include/clang/Basic/DiagnosticParseKinds.td include/clang/Basic/DiagnosticSemaKinds.td include/clang/Basic/OpenMPKinds.def include/clang/Parse/Parser.h include/clang/Sema/Sema.h include/clang/Serialization/ASTBitCodes.h lib/AST/ASTContext.cpp lib/AST/Decl.cpp lib/AST/DeclBase.cpp lib/AST/DeclOpenMP.cpp lib/AST/DeclPrinter.cpp lib/AST/ItaniumMangle.cpp lib/AST/MicrosoftMangle.cpp lib/Basic/OpenMPKinds.cpp lib/CodeGen/CGDecl.cpp lib/CodeGen/CodeGenModule.cpp lib/CodeGen/CodeGenModule.h lib/Parse/ParseDecl.cpp lib/Parse/ParseDeclCXX.cpp lib/Parse/ParseOpenMP.cpp lib/Parse/Parser.cpp lib/Sema/SemaDecl.cpp lib/Sema/SemaExpr.cpp lib/Sema/SemaLookup.cpp lib/Sema/SemaOpenMP.cpp lib/Sema/SemaTemplateInstantiate.cpp lib/Sema/SemaTemplateInstantiateDecl.cpp lib/Serialization/ASTCommon.cpp lib/Serialization/ASTCommon.h lib/Serialization/ASTReaderDecl.cpp lib/Serialization/ASTWriter.cpp lib/Serialization/ASTWriterDecl.cpp test/OpenMP/declare_target_ast_print.cpp test/OpenMP/declare_target_messages.cpp tools/libclang/CIndex.cpp
Index: tools/libclang/CIndex.cpp =================================================================== --- tools/libclang/CIndex.cpp +++ tools/libclang/CIndex.cpp @@ -5228,6 +5228,7 @@ case Decl::ClassScopeFunctionSpecialization: case Decl::Import: case Decl::OMPThreadPrivate: + case Decl::OMPDeclareTarget: case Decl::ObjCTypeParam: case Decl::BuiltinTemplate: return C; Index: test/OpenMP/declare_target_messages.cpp =================================================================== --- test/OpenMP/declare_target_messages.cpp +++ test/OpenMP/declare_target_messages.cpp @@ -0,0 +1,83 @@ +// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -fnoopenmp-use-tls -ferror-limit 100 -o - %s + +#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}} + +int a, b; // expected-warning 2 {{declaration is not declared in any declare target region}} +__thread int t; // expected-error {{threadprivate variables cannot be used in target constructs}} +#pragma omp declare target private(a) // expected-warning {{extra tokens at the end of '#pragma omp declare target' are ignored}} +void f(); +#pragma omp end declare target shared(a) // expected-warning {{extra tokens at the end of '#pragma omp end declare target' are ignored}} +void c(); // expected-warning {{declaration is not declared in any declare target region}} + +extern int b; + +struct NonT { + int a; +}; + +typedef int sint; + +#pragma omp declare target // expected-note {{to match this '#pragma omp declare target'}} +#pragma omp threadprivate(a) // expected-error {{threadprivate variables cannot be used in target constructs}} expected-note {{used here}} +extern int b; +int g; + +struct T { // expected-note {{mappable type cannot be polymorphic}} + int a; + virtual int method(); +}; + +class VC { // expected-note {{mappable type cannot be polymorphic}} + T member; + NonT member1; + public: + virtual int method() { T a; return 0; } // expected-error {{type 'T' is not mappable to target}} +}; + +struct C { + NonT a; + sint b; + int method(); + int method1(); +}; + +int C::method1() { + return 0; +} + +void foo() { + a = 0; // expected-note {{used here}} + b = 0; // expected-note {{used here}} + t = 1; // expected-note {{used here}} + C object; + VC object1; // expected-error {{type 'VC' is not mappable to target}} + g = object.method(); + g += object.method1(); + g += object1.method(); + f(); + c(); // expected-note {{used here}} +} +#pragma omp declare target // expected-error {{expected '#pragma omp end declare target'}} +void foo1() {} +#pragma omp end declare target +#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}} + +int C::method() { + return 0; +} + +struct S { +#pragma omp declare target // expected-error {{directive must be at file or namespace scope}} + int v; +#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}} +}; + +int main (int argc, char **argv) { +#pragma omp declare target // expected-error {{unexpected OpenMP directive '#pragma omp declare target'}} + int v; +#pragma omp end declare target // expected-error {{unexpected OpenMP directive '#pragma omp end declare target'}} + foo(); + return (0); +} + +#pragma omp declare target // expected-error {{expected '#pragma omp end declare target'}} expected-note {{to match this '#pragma omp declare target'}} Index: test/OpenMP/declare_target_ast_print.cpp =================================================================== --- test/OpenMP/declare_target_ast_print.cpp +++ test/OpenMP/declare_target_ast_print.cpp @@ -0,0 +1,47 @@ +// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s +// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s +// expected-no-diagnostics + +#ifndef HEADER +#define HEADER + +#pragma omp declare target +// CHECK: #pragma omp declare target + +void foo() {} +// CHECK-NEXT: void foo() + +#pragma omp end declare target +// CHECK: #pragma omp end declare target + +extern "C" { +#pragma omp declare target +// CHECK: #pragma omp declare target + +void foo_c() {} +// CHECK-NEXT: void foo_c() + +#pragma omp end declare target +// CHECK: #pragma omp end declare target +} + +extern "C++" { +#pragma omp declare target +// CHECK: #pragma omp declare target + +void foo_cpp() {} +// CHECK-NEXT: void foo_cpp() + +#pragma omp end declare target +// CHECK: #pragma omp end declare target +} + +int main (int argc, char **argv) { + foo(); + foo_c(); + foo_cpp(); + return (0); +} + +#endif Index: lib/Serialization/ASTWriterDecl.cpp =================================================================== --- lib/Serialization/ASTWriterDecl.cpp +++ lib/Serialization/ASTWriterDecl.cpp @@ -131,6 +131,7 @@ void VisitObjCPropertyDecl(ObjCPropertyDecl *D); void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); + void VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D); /// Add an Objective-C type parameter list to the given record. void AddObjCTypeParamList(ObjCTypeParamList *typeParams) { @@ -1617,6 +1618,11 @@ Code = serialization::DECL_OMP_THREADPRIVATE; } +void ASTDeclWriter::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) { + VisitDecl(D); + Code = serialization::DECL_OMP_DECLARETARGET; +} + //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// @@ -2071,8 +2077,8 @@ // An ObjCMethodDecl is never considered as "required" because its // implementation container always is. - // File scoped assembly or obj-c implementation must be seen. - if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D)) + // File scoped assembly or obj-c or OMP Declare target implementation must be seen. + if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D) || isa<OMPDeclareTargetDecl>(D)) return true; // ImportDecl is used by codegen to determine the set of imported modules to Index: lib/Serialization/ASTWriter.cpp =================================================================== --- lib/Serialization/ASTWriter.cpp +++ lib/Serialization/ASTWriter.cpp @@ -4697,6 +4697,11 @@ Record); break; + case UPD_DECL_MARKED_OPENMP_DECLARETARGET: + AddSourceRange(D->getAttr<OMPDeclareTargetDeclAttr>()->getRange(), + Record); + break; + case UPD_DECL_EXPORTED: Record.push_back(getSubmoduleID(Update.getModule())); break; Index: lib/Serialization/ASTReaderDecl.cpp =================================================================== --- lib/Serialization/ASTReaderDecl.cpp +++ lib/Serialization/ASTReaderDecl.cpp @@ -350,6 +350,7 @@ void VisitObjCPropertyDecl(ObjCPropertyDecl *D); void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D); void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); + void VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D); /// We've merged the definition \p MergedDef into the existing definition /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made @@ -2353,6 +2354,10 @@ D->setVars(Vars); } +void ASTDeclReader::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) { + VisitDecl(D); +} + //===----------------------------------------------------------------------===// // Attribute Reading //===----------------------------------------------------------------------===// @@ -2402,7 +2407,8 @@ isa<ObjCProtocolDecl>(D) || isa<ObjCImplDecl>(D) || isa<ImportDecl>(D) || - isa<OMPThreadPrivateDecl>(D)) + isa<OMPThreadPrivateDecl>(D) || + isa<OMPDeclareTargetDecl>(D) ) return true; if (VarDecl *Var = dyn_cast<VarDecl>(D)) return Var->isFileVarDecl() && @@ -2721,7 +2727,7 @@ if (needsAnonymousDeclarationNumber(New)) { setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(), AnonymousDeclNumber, New); - } else if (DC->isTranslationUnit() && Reader.SemaObj && + } else if (DC->isTranslationUnitOrDeclareTarget() && Reader.SemaObj && !Reader.getContext().getLangOpts().CPlusPlus) { if (Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, Name)) Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()] @@ -2826,7 +2832,7 @@ if (isSameEntity(Existing, D)) return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber, TypedefNameForLinkage); - } else if (DC->isTranslationUnit() && Reader.SemaObj && + } else if (DC->isTranslationUnitOrDeclareTarget() && Reader.SemaObj && !Reader.getContext().getLangOpts().CPlusPlus) { IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver; @@ -3298,6 +3304,9 @@ case DECL_OMP_THREADPRIVATE: D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]); break; + case DECL_OMP_DECLARETARGET: + D = OMPDeclareTargetDecl::CreateDeserialized(Context, ID); + break; case DECL_EMPTY: D = EmptyDecl::CreateDeserialized(Context, ID); break; @@ -3770,6 +3779,11 @@ case UPD_DECL_MARKED_OPENMP_THREADPRIVATE: D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit( + Reader.Context, ReadSourceRange(Record, Idx))); + break; + + case UPD_DECL_MARKED_OPENMP_DECLARETARGET: + D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit( Reader.Context, ReadSourceRange(Record, Idx))); break; Index: lib/Serialization/ASTCommon.h =================================================================== --- lib/Serialization/ASTCommon.h +++ lib/Serialization/ASTCommon.h @@ -36,6 +36,7 @@ UPD_MANGLING_NUMBER, UPD_STATIC_LOCAL_NUMBER, UPD_DECL_MARKED_OPENMP_THREADPRIVATE, + UPD_DECL_MARKED_OPENMP_DECLARETARGET, UPD_DECL_EXPORTED, UPD_ADDED_ATTR_TO_RECORD }; Index: lib/Serialization/ASTCommon.cpp =================================================================== --- lib/Serialization/ASTCommon.cpp +++ lib/Serialization/ASTCommon.cpp @@ -329,6 +329,7 @@ case Decl::ClassScopeFunctionSpecialization: case Decl::Import: case Decl::OMPThreadPrivate: + case Decl::OMPDeclareTarget: case Decl::BuiltinTemplate: return false; Index: lib/Sema/SemaTemplateInstantiateDecl.cpp =================================================================== --- lib/Sema/SemaTemplateInstantiateDecl.cpp +++ lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -2477,6 +2477,11 @@ return TD; } +Decl * +TemplateDeclInstantiator::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) { + llvm_unreachable("OpenMP declare target cannot be instantiated"); +} + Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D) { return VisitFunctionDecl(D, nullptr); } Index: lib/Sema/SemaTemplateInstantiate.cpp =================================================================== --- lib/Sema/SemaTemplateInstantiate.cpp +++ lib/Sema/SemaTemplateInstantiate.cpp @@ -96,7 +96,7 @@ // that will own this template template parameter. In this case, we // use empty template parameter lists for all of the outer templates // to avoid performing any substitutions. - if (Ctx->isTranslationUnit()) { + if (Ctx->isTranslationUnitOrDeclareTarget()) { if (TemplateTemplateParmDecl *TTP = dyn_cast<TemplateTemplateParmDecl>(D)) { for (unsigned I = 0, N = TTP->getDepth() + 1; I != N; ++I) Index: lib/Sema/SemaOpenMP.cpp =================================================================== --- lib/Sema/SemaOpenMP.cpp +++ lib/Sema/SemaOpenMP.cpp @@ -138,6 +138,13 @@ DSAVarData getDSA(StackTy::reverse_iterator Iter, VarDecl *D); + typedef llvm::DenseSet<Decl *> DeclaredTargetDeclsTy; + + DeclaredTargetDeclsTy DeclaredTargetDecls; + + OpenMPClauseKind getDSA(StackTy::reverse_iterator Iter, VarDecl *D, + OpenMPDirectiveKind &Kind, DeclRefExpr *&E); + /// \brief Checks if the variable is a local for OpenMP region. bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter); @@ -163,6 +170,8 @@ Stack.pop_back(); } + bool IsThreadprivate(VarDecl *D, DeclRefExpr *&E); + /// \brief If 'aligned' declaration for given variable \a D was not seen yet, /// add it and return NULL; otherwise return previous occurrence's expression /// for diagnostics. @@ -289,6 +298,10 @@ return Stack.back().CancelRegion; } + void addDeclareTargetDecl(Decl *D) { DeclaredTargetDecls.insert(D); } + + bool isDeclareTargetDecl(Decl *D) { return DeclaredTargetDecls.count(D); } + /// \brief Set collapse value for the region. void setCollapseNumber(unsigned Val) { Stack.back().CollapseNumber = Val; } /// \brief Return collapse value for region. @@ -536,9 +549,27 @@ bool RefersToCapture = false) { D->setReferenced(); D->markUsed(S.Context); - return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(), + DeclRefExpr *E; + + E = DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(), SourceLocation(), D, RefersToCapture, Loc, Ty, VK_LValue); + + if (S.IsDeclContextInOpenMPTarget(S.CurContext)) { + S.CheckDeclIsAllowedInOpenMPTarget(E, E->getDecl()); + } + return E; +} + +bool DSAStackTy::IsThreadprivate(VarDecl *D, DeclRefExpr *&E) { + E = 0; + if (D->getTLSKind() != VarDecl::TLS_None) + return true; + if (Stack[0].SharingMap.count(D)) { + E = Stack[0].SharingMap[D].RefExpr; + return true; + } + return false; } DSAStackTy::DSAVarData DSAStackTy::getTopDSA(VarDecl *D, bool FromParent) { @@ -742,6 +773,13 @@ VarDataSharingAttributesStack = new DSAStackTy(*this); } +bool Sema::IsDeclContextInOpenMPTarget(DeclContext *DC) { + while (DC && !isa<OMPDeclareTargetDecl>(DC)) { + DC = DC->getParent(); + } + return DC != 0; +} + #define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack) bool Sema::IsOpenMPCapturedByRef(VarDecl *VD, @@ -1036,8 +1074,10 @@ // OpenMP [2.9.2, Restrictions, C/C++, p.2] // A threadprivate directive for file-scope variables must appear outside // any definition or declaration. - if (CanonicalVD->getDeclContext()->isTranslationUnit() && - !getCurLexicalContext()->isTranslationUnit()) { + + if ((!getCurLexicalContext()->isFileContext() || + !VD->getDeclContext()->isFileContext()) && + !isDeclInScope(ND, getCurLexicalContext(), getCurScope())) { Diag(Id.getLoc(), diag::err_omp_var_scope) << getOpenMPDirectiveName(OMPD_threadprivate) << VD; bool IsDecl = @@ -1223,6 +1263,210 @@ return D; } +bool Sema::ActOnStartOpenMPDeclareTargetDirective(Scope *S, + SourceLocation Loc) { + if (CurContext && !CurContext->isFileContext() && + !CurContext->isExternCContext() && !CurContext->isExternCXXContext()) { + Diag(Loc, diag::err_omp_region_not_file_context); + return false; + } + OMPDeclareTargetDecl *DT = + OMPDeclareTargetDecl::Create(Context, CurContext, Loc); + DT->setAccess(AS_public); + CurContext->addDecl(DT); + if (CurScope) + PushDeclContext(S, DT); + else + CurContext = DT; + return true; +} + +void Sema::ActOnOpenMPDeclareTargetDecls(Sema::DeclGroupPtrTy Decls) { + if (!Decls) + return; + DeclGroupRef DGR = Decls.get(); + if (DGR.isNull()) + return; + for (DeclGroupRef::iterator I = DGR.begin(), E = DGR.end(); I != E; ++I) { + if (*I) + DSAStack->addDeclareTargetDecl(*I); + } +} + +Sema::DeclGroupPtrTy Sema::ActOnFinishOpenMPDeclareTargetDirective() { + if (CurContext && isa<OMPDeclareTargetDecl>(CurContext)) { + OMPDeclareTargetDecl *DT = cast<OMPDeclareTargetDecl>(CurContext); + PopDeclContext(); + return DeclGroupPtrTy::make(DeclGroupRef(DT)); + } + return DeclGroupPtrTy(); +} + +void Sema::ActOnOpenMPDeclareTargetDirectiveError() { + if (CurContext && isa<OMPDeclareTargetDecl>(CurContext)) { + PopDeclContext(); + } +} + +static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc, + DSAStackTy *Stack, CXXRecordDecl *RD) { + if (!RD || RD->isInvalidDecl()) + return true; + + auto QTy = SemaRef.Context.getRecordType(RD); + if (RD->isDynamicClass()) { + SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; + SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target); + return false; + } + auto *DC = RD; + bool IsCorrect = true; + for (auto *I : DC->decls()) { + if (I) { + if (auto *MD = dyn_cast<CXXMethodDecl>(I)) { + if (MD->isStatic()) { + SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; + SemaRef.Diag(MD->getLocation(), + diag::note_omp_static_member_in_target); + IsCorrect = false; + } + } else if (auto *VD = dyn_cast<VarDecl>(I)) { + if (VD->isStaticDataMember()) { + SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; + SemaRef.Diag(VD->getLocation(), + diag::note_omp_static_member_in_target); + IsCorrect = false; + } + } + } + } + + for (auto &I : RD->bases()) { + if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack, + I.getType()->getAsCXXRecordDecl())) + IsCorrect = false; + } + return IsCorrect; +} + +static void CheckDeclInTargetContext(SourceLocation SL, SourceRange SR, + Sema &SemaRef, DSAStackTy *Stack, + Decl *D) { + if (!D) + return; + Decl *LD = 0; + if (isa<TagDecl>(D)) { + LD = cast<TagDecl>(D)->getDefinition(); + } + else if (isa<VarDecl>(D)) { + LD = cast<VarDecl>(D)->getDefinition(); + + // If this is an implicit variable that is legal and we do not need to do + // anything + if (cast<VarDecl>(D)->isImplicit()) { + Stack->addDeclareTargetDecl(D); + return; + } + + } + else if (isa<FunctionDecl>(D)) { + const FunctionDecl *FD = 0; + if (cast<FunctionDecl>(D)->hasBody(FD)) + LD = const_cast<FunctionDecl *>(FD); + + // If the definition is associated with the current declaration in the + // target region (it can be e.g. a lambda) that is legal and we do not need + // to do anything else + if (LD == D) { + Stack->addDeclareTargetDecl(D); + return; + } + } + if (!LD) + LD = D; + if (LD) { + if (!Stack->isDeclareTargetDecl(LD)) { + // Outlined declaration is not declared target. + if (LD->isOutOfLine()) { + SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context); + SemaRef.Diag(SL, diag::note_used_here) << SR; + } + else { + DeclContext *DC = LD->getDeclContext(); + while (DC) { + if (isa<OMPDeclareTargetDecl>(DC)) + break; + DC = DC->getParent(); + } + // Is not declared in target context. + if (!DC) { + SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context); + SemaRef.Diag(SL, diag::note_used_here) << SR; + } + } + } + // Mark decl as declared to prevent further diagnostic. + if (isa<VarDecl>(LD) || isa<FunctionDecl>(LD)) + Stack->addDeclareTargetDecl(LD); + } +} + +static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef, + DSAStackTy *Stack, QualType QTy) { + NamedDecl *ND; + if (QTy->isIncompleteType(&ND)) { + SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR; + return false; + } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) { + if (!RD->isInvalidDecl() && + !IsCXXRecordForMappable(SemaRef, SL, Stack, RD)) + return false; + } + return true; +} + +static bool CheckValueDeclInTarget(SourceLocation SL, SourceRange SR, + Sema &SemaRef, DSAStackTy *Stack, + ValueDecl *VD) { + if (Stack->isDeclareTargetDecl(VD)) + return true; + if (!CheckTypeMappable(SL, SR, SemaRef, Stack, VD->getType())) { + return false; + } + return true; +} + +void Sema::CheckDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D) { + if (!D || D->isInvalidDecl()) + return; + SourceRange SR = E ? E->getSourceRange() : D->getSourceRange(); + SourceLocation SL = E ? E->getLocStart() : D->getLocation(); + if (VarDecl *VD = dyn_cast<VarDecl>(D)) { + DeclRefExpr *DRE; + if (DSAStack->IsThreadprivate(VD, DRE)) { + SourceLocation Loc = DRE ? DRE->getLocation() : VD->getLocation(); + Diag(Loc, diag::err_omp_threadprivate_in_target); + Diag(SL, diag::note_used_here) << SR; + D->setInvalidDecl(); + return; + } + } + if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) { + if (!CheckValueDeclInTarget(SL, SR, *this, DSAStack, VD)) { + VD->setInvalidDecl(); + return; + } + } + if (!E) { + // Checking declaration. + if (isa<VarDecl>(D) || isa<FunctionDecl>(D)) + DSAStack->addDeclareTargetDecl(D); + return; + } + CheckDeclInTargetContext(E->getExprLoc(), E->getSourceRange(), *this, + DSAStack, D); +} + static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack, const VarDecl *VD, DSAStackTy::DSAVarData DVar, bool IsLoopIterVar = false) { @@ -7771,61 +8015,6 @@ return nullptr; return new (Context) OMPDeviceClause(ValExpr, StartLoc, LParenLoc, EndLoc); -} - -static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc, - DSAStackTy *Stack, CXXRecordDecl *RD) { - if (!RD || RD->isInvalidDecl()) - return true; - - auto QTy = SemaRef.Context.getRecordType(RD); - if (RD->isDynamicClass()) { - SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; - SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target); - return false; - } - auto *DC = RD; - bool IsCorrect = true; - for (auto *I : DC->decls()) { - if (I) { - if (auto *MD = dyn_cast<CXXMethodDecl>(I)) { - if (MD->isStatic()) { - SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; - SemaRef.Diag(MD->getLocation(), - diag::note_omp_static_member_in_target); - IsCorrect = false; - } - } else if (auto *VD = dyn_cast<VarDecl>(I)) { - if (VD->isStaticDataMember()) { - SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; - SemaRef.Diag(VD->getLocation(), - diag::note_omp_static_member_in_target); - IsCorrect = false; - } - } - } - } - - for (auto &I : RD->bases()) { - if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack, - I.getType()->getAsCXXRecordDecl())) - IsCorrect = false; - } - return IsCorrect; -} - -static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef, - DSAStackTy *Stack, QualType QTy) { - NamedDecl *ND; - if (QTy->isIncompleteType(&ND)) { - SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR; - return false; - } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) { - if (!RD->isInvalidDecl() && - !IsCXXRecordForMappable(SemaRef, SL, Stack, RD)) - return false; - } - return true; } OMPClause *Sema::ActOnOpenMPMapClause( Index: lib/Sema/SemaLookup.cpp =================================================================== --- lib/Sema/SemaLookup.cpp +++ lib/Sema/SemaLookup.cpp @@ -828,7 +828,7 @@ } } - if (!Found && DC->isTranslationUnit() && LookupBuiltin(S, R)) + if (!Found && DC->isTranslationUnitOrDeclareTarget() && LookupBuiltin(S, R)) return true; if (R.getLookupName().getNameKind() Index: lib/Sema/SemaExpr.cpp =================================================================== --- lib/Sema/SemaExpr.cpp +++ lib/Sema/SemaExpr.cpp @@ -13563,6 +13563,9 @@ static void MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E, bool OdrUse) { + if (SemaRef.IsDeclContextInOpenMPTarget(SemaRef.CurContext)) + SemaRef.CheckDeclIsAllowedInOpenMPTarget(E, D); + if (VarDecl *Var = dyn_cast<VarDecl>(D)) { DoMarkVarDeclReferenced(SemaRef, Loc, Var, E); return; Index: lib/Sema/SemaDecl.cpp =================================================================== --- lib/Sema/SemaDecl.cpp +++ lib/Sema/SemaDecl.cpp @@ -4873,8 +4873,8 @@ R->isFunctionType())) { IsLinkageLookup = true; CreateBuiltins = - CurContext->getEnclosingNamespaceContext()->isTranslationUnit(); - } else if (CurContext->getRedeclContext()->isTranslationUnit() && + CurContext->getEnclosingNamespaceContext()->isTranslationUnitOrDeclareTarget(); + } else if (CurContext->getRedeclContext()->isTranslationUnitOrDeclareTarget() && D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) CreateBuiltins = true; @@ -4990,6 +4990,10 @@ CurContext->addHiddenDecl(New); } + if (IsDeclContextInOpenMPTarget(CurContext)) { + CheckDeclIsAllowedInOpenMPTarget(0, New); + } + return New; } @@ -5118,7 +5122,7 @@ void Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) { if (!getLangOpts().CPlusPlus && - ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit()) + ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) // Don't need to track declarations in the TU in C. return; @@ -5253,7 +5257,7 @@ // If this is the C FILE type, notify the AST context. if (IdentifierInfo *II = NewTD->getIdentifier()) if (!NewTD->isInvalidDecl() && - NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { + NewTD->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) { if (II->isStr("FILE")) Context.setFILEDecl(NewTD); else if (II->isStr("jmp_buf")) @@ -6454,7 +6458,7 @@ // In C, when declaring a global variable, look for a corresponding 'extern' // variable declared in function scope. We don't need this in C++, because // we find local extern decls in the surrounding file-scope DeclContext. - if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) { + if (ND->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) { if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) { Previous.clear(); Previous.addDecl(Prev); @@ -6466,7 +6470,7 @@ // A declaration in the translation unit can conflict with an extern "C" // declaration. - if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) + if (ND->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous); // An extern "C" declaration can conflict with a declaration in the @@ -8244,7 +8248,7 @@ if (getLangOpts().CUDA) if (IdentifierInfo *II = NewFD->getIdentifier()) if (!NewFD->isInvalidDecl() && - NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) { + NewFD->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) { if (II->isStr("cudaConfigureCall")) { if (!R->getAs<FunctionType>()->getReturnType()->isScalarType()) Diag(NewFD->getLocation(), diag::err_config_scalar_return); @@ -11462,7 +11466,7 @@ if (!Name) return; if ((!getLangOpts().CPlusPlus && - FD->getDeclContext()->isTranslationUnit()) || + FD->getDeclContext()->isTranslationUnitOrDeclareTarget()) || (isa<LinkageSpecDecl>(FD->getDeclContext()) && cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() == LinkageSpecDecl::lang_c)) { @@ -11737,7 +11741,7 @@ // translation unit scope, at which point we have a fully qualified NNS. SmallVector<IdentifierInfo *, 4> Namespaces; DeclContext *DC = ND->getDeclContext()->getRedeclContext(); - for (; !DC->isTranslationUnit(); DC = DC->getParent()) { + for (; !DC->isTranslationUnitOrDeclareTarget(); DC = DC->getParent()) { // This tag should be declared in a namespace, which can only be enclosed by // other namespaces. Bail if there's an anonymous namespace in the chain. NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC); @@ -11755,7 +11759,7 @@ // build an NNS. SmallString<64> Insertion; llvm::raw_svector_ostream OS(Insertion); - if (DC->isTranslationUnit()) + if (DC->isTranslationUnitOrDeclareTarget()) OS << "::"; std::reverse(Namespaces.begin(), Namespaces.end()); for (auto *II : Namespaces) @@ -12617,7 +12621,7 @@ // If this is the C FILE type, notify the AST context. if (IdentifierInfo *II = New->getIdentifier()) if (!New->isInvalidDecl() && - New->getDeclContext()->getRedeclContext()->isTranslationUnit() && + New->getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget() && II->isStr("FILE")) Context.setFILEDecl(New); Index: lib/Parse/Parser.cpp =================================================================== --- lib/Parse/Parser.cpp +++ lib/Parse/Parser.cpp @@ -658,7 +658,7 @@ HandlePragmaOpenCLExtension(); return DeclGroupPtrTy(); case tok::annot_pragma_openmp: - return ParseOpenMPDeclarativeDirective(); + return ParseOpenMPDeclarativeDirective(/*AS=*/AS_none); case tok::annot_pragma_ms_pointers_to_members: HandlePragmaMSPointersToMembers(); return DeclGroupPtrTy(); @@ -1045,7 +1045,7 @@ !TemplateInfo.TemplateParams && (Tok.is(tok::l_brace) || Tok.is(tok::kw_try) || Tok.is(tok::colon)) && - Actions.CurContext->isTranslationUnit()) { + Actions.CurContext->isTranslationUnitOrDeclareTarget()) { ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); Scope *ParentScope = getCurScope()->getParent(); Index: lib/Parse/ParseOpenMP.cpp =================================================================== --- lib/Parse/ParseOpenMP.cpp +++ lib/Parse/ParseOpenMP.cpp @@ -32,13 +32,17 @@ // TODO: add other combined directives in topological order. const OpenMPDirectiveKind F[][3] = { {OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/, - OMPD_cancellation_point}, - {OMPD_target, OMPD_unknown /*data*/, OMPD_target_data}, - {OMPD_for, OMPD_simd, OMPD_for_simd}, - {OMPD_parallel, OMPD_for, OMPD_parallel_for}, - {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd}, - {OMPD_parallel, OMPD_sections, OMPD_parallel_sections}, - {OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd}}; + OMPD_cancellation_point}, //0 + {OMPD_unknown /*declare*/, OMPD_target /*target*/, + OMPD_declare_target }, //1 + {OMPD_unknown /*end*/, OMPD_unknown /*declare*/, + OMPD_end_declare_target }, //2 + {OMPD_target, OMPD_unknown /*data*/, OMPD_target_data}, //3 + {OMPD_for, OMPD_simd, OMPD_for_simd}, //4 + {OMPD_parallel, OMPD_for, OMPD_parallel_for}, //5 + {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd}, //6 + {OMPD_parallel, OMPD_sections, OMPD_parallel_sections}, //7 + {OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd}}; //8 auto Tok = P.getCurToken(); auto DKind = Tok.isAnnotation() @@ -50,7 +54,13 @@ if (!Tok.isAnnotation() && DKind == OMPD_unknown) { TokenMatched = (i == 0) && - !P.getPreprocessor().getSpelling(Tok).compare("cancellation"); + !P.getPreprocessor().getSpelling(Tok).compare("cancellation") || + ((i == 1 || i == 3) && + !P.getPreprocessor().getSpelling(Tok).compare("declare")) || + ((i == 2) && + !P.getPreprocessor().getSpelling(Tok).compare("end")) || + ((i == 3) && + !P.getPreprocessor().getSpelling(Tok).compare("target")); } else { TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown; } @@ -67,7 +77,10 @@ TokenMatched = ((i == 0) && !P.getPreprocessor().getSpelling(Tok).compare("point")) || - ((i == 1) && !P.getPreprocessor().getSpelling(Tok).compare("data")); + ((i == 2) && + !P.getPreprocessor().getSpelling(Tok).compare("declare")) || + ((i == 3) && + !P.getPreprocessor().getSpelling(Tok).compare("data")); } else { TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown; } @@ -86,7 +99,7 @@ /// threadprivate-directive: /// annot_pragma_openmp 'threadprivate' simple-variable-list /// -Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() { +Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective(AccessSpecifier AS) { assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!"); ParenBraceBracketBalancer BalancerRAIIObj(*this); @@ -110,6 +123,59 @@ return Actions.ActOnOpenMPThreadprivateDirective(Loc, Identifiers); } break; + case OMPD_declare_target: { + SourceLocation DTLoc = ConsumeAnyToken(); + if (Tok.isNot(tok::annot_pragma_openmp_end)) { + Diag(Tok, diag::warn_omp_extra_tokens_at_eol) + << getOpenMPDirectiveName(OMPD_declare_target); + while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch)) + ; + } + // Skip the last annot_pragma_openmp_end. + ConsumeAnyToken(); + + ParseScope OMPDeclareTargetScope(this, Scope::DeclScope); + if (!Actions.ActOnStartOpenMPDeclareTargetDirective(getCurScope(), DTLoc)) + return DeclGroupPtrTy(); + + DKind = ParseOpenMPDirectiveKind(*this); + while (DKind != OMPD_end_declare_target && DKind != OMPD_declare_target && + Tok.isNot(tok::eof)) { + ParsedAttributesWithRange attrs(AttrFactory); + MaybeParseCXX11Attributes(attrs); + MaybeParseMicrosoftAttributes(attrs); + Actions.ActOnOpenMPDeclareTargetDecls(ParseExternalDeclaration(attrs)); + if (Tok.isAnnotation() && Tok.is(tok::annot_pragma_openmp)) { + TentativeParsingAction TPA(*this); + ConsumeToken(); + DKind = ParseOpenMPDirectiveKind(*this); + if (DKind != OMPD_end_declare_target) { + TPA.Revert(); + } + else { + TPA.Commit(); + } + } + } + if (DKind == OMPD_end_declare_target) { + // Skip the last annot_pragma_openmp_end. + ConsumeAnyToken(); + ConsumeAnyToken(); + if (Tok.isNot(tok::annot_pragma_openmp_end)) { + Diag(Tok, diag::warn_omp_extra_tokens_at_eol) + << getOpenMPDirectiveName(OMPD_end_declare_target); + while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch)) + ; + } + // Skip the last annot_pragma_openmp_end. + ConsumeAnyToken(); + return Actions.ActOnFinishOpenMPDeclareTargetDirective(); + } + Actions.ActOnOpenMPDeclareTargetDirectiveError(); + Diag(Tok, diag::err_expected_end_declare_target); + Diag(DTLoc, diag::note_matching) << "'#pragma omp declare target'"; + return DeclGroupPtrTy(); + } case OMPD_unknown: Diag(Tok, diag::err_omp_unknown_directive); break; @@ -140,11 +206,13 @@ case OMPD_target_data: case OMPD_taskloop: case OMPD_taskloop_simd: + case OMPD_end_declare_target: Diag(Tok, diag::err_omp_unexpected_directive) << getOpenMPDirectiveName(DKind); break; } - SkipUntil(tok::annot_pragma_openmp_end); + while (!SkipUntil(tok::annot_pragma_openmp_end)) + ; return DeclGroupPtrTy(); } @@ -312,11 +380,19 @@ OMPDirectiveScope.Exit(); break; } - case OMPD_unknown: - Diag(Tok, diag::err_omp_unknown_directive); - SkipUntil(tok::annot_pragma_openmp_end); + case OMPD_declare_target: + case OMPD_end_declare_target: + Diag(Tok, diag::err_omp_unexpected_directive) + << getOpenMPDirectiveName(DKind); + while (!SkipUntil(tok::annot_pragma_openmp_end)) + ; break; + case OMPD_unknown: + Diag(Tok, diag::err_omp_unknown_directive); + SkipUntil(tok::annot_pragma_openmp_end); + break; } + return Directive; } Index: lib/Parse/ParseDeclCXX.cpp =================================================================== --- lib/Parse/ParseDeclCXX.cpp +++ lib/Parse/ParseDeclCXX.cpp @@ -2902,7 +2902,7 @@ } if (Tok.is(tok::annot_pragma_openmp)) - return ParseOpenMPDeclarativeDirective(); + return ParseOpenMPDeclarativeDirective(AS); // Parse all the comma separated declarators. return ParseCXXClassMemberDeclaration(AS, AccessAttrs.getList()); Index: lib/Parse/ParseDecl.cpp =================================================================== --- lib/Parse/ParseDecl.cpp +++ lib/Parse/ParseDecl.cpp @@ -3618,7 +3618,7 @@ if (Tok.is(tok::annot_pragma_openmp)) { // Result can be ignored, because it must be always empty. - auto Res = ParseOpenMPDeclarativeDirective(); + auto Res = ParseOpenMPDeclarativeDirective(AS_public); assert(!Res); // Silence possible warnings. (void)Res; Index: lib/CodeGen/CodeGenModule.h =================================================================== --- lib/CodeGen/CodeGenModule.h +++ lib/CodeGen/CodeGenModule.h @@ -1097,6 +1097,10 @@ /// \param D Threadprivate declaration. void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D); + /// \brief Emit declare target decls. + /// + void EmitOMPDeclareTarget(const OMPDeclareTargetDecl *D); + /// Returns whether the given record is blacklisted from control flow /// integrity checks. bool IsCFIBlacklistedRecord(const CXXRecordDecl *RD); Index: lib/CodeGen/CodeGenModule.cpp =================================================================== --- lib/CodeGen/CodeGenModule.cpp +++ lib/CodeGen/CodeGenModule.cpp @@ -3567,6 +3567,10 @@ break; } + case Decl::OMPDeclareTarget: + EmitOMPDeclareTarget(cast<OMPDeclareTargetDecl>(D)); + break; + default: // Make sure we handled everything we should, every other kind is a // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind Index: lib/CodeGen/CGDecl.cpp =================================================================== --- lib/CodeGen/CGDecl.cpp +++ lib/CodeGen/CGDecl.cpp @@ -21,6 +21,7 @@ #include "clang/AST/CharUnits.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclObjC.h" +#include "clang/AST/DeclOpenMP.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" #include "clang/CodeGen/CGFunctionInfo.h" @@ -115,6 +116,9 @@ return EmitVarDecl(VD); } + case Decl::OMPDeclareTarget: + return CGM.EmitOMPDeclareTarget(cast<OMPDeclareTargetDecl>(&D)); + case Decl::Typedef: // typedef int X; case Decl::TypeAlias: { // using X = int; [C++0x] const TypedefNameDecl &TD = cast<TypedefNameDecl>(D); @@ -1861,3 +1865,18 @@ if (D.hasAttr<AnnotateAttr>()) EmitVarAnnotations(&D, DeclPtr.getPointer()); } + +void CodeGenModule::EmitOMPDeclareTarget(const OMPDeclareTargetDecl *D) { + + for (DeclContext::decl_iterator I = D->decls_begin(), E = D->decls_end(); + I != E; ++I) { + if (const VarDecl *VD = dyn_cast<VarDecl>(*I)) + if (VD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization && + VD->getTemplateSpecializationKind() != TSK_Undeclared) + continue; + + EmitTopLevelDecl(*I); + } + + +} \ No newline at end of file Index: lib/Basic/OpenMPKinds.cpp =================================================================== --- lib/Basic/OpenMPKinds.cpp +++ lib/Basic/OpenMPKinds.cpp @@ -432,6 +432,9 @@ break; } break; + // No clauses allowed for 'omp [end] declare target' constructs. + case OMPD_declare_target: + case OMPD_end_declare_target: case OMPD_unknown: case OMPD_threadprivate: case OMPD_section: Index: lib/AST/MicrosoftMangle.cpp =================================================================== --- lib/AST/MicrosoftMangle.cpp +++ lib/AST/MicrosoftMangle.cpp @@ -361,10 +361,10 @@ const DeclContext *DC = getEffectiveDeclContext(D); // Check for extern variable declared locally. if (DC->isFunctionOrMethod() && D->hasLinkage()) - while (!DC->isNamespace() && !DC->isTranslationUnit()) + while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget()) DC = getEffectiveParentContext(DC); - if (DC->isTranslationUnit() && D->getFormalLinkage() == InternalLinkage && + if (DC->isTranslationUnitOrDeclareTarget() && D->getFormalLinkage() == InternalLinkage && !isa<VarTemplateSpecializationDecl>(D) && D->getIdentifier() != nullptr) return false; @@ -864,7 +864,7 @@ // ::= <substitution> [<postfix>] const DeclContext *DC = getEffectiveDeclContext(ND); - while (!DC->isTranslationUnit()) { + while (!DC->isTranslationUnitOrDeclareTarget()) { if (isa<TagDecl>(ND) || isa<VarDecl>(ND)) { unsigned Disc; if (Context.getNextDiscriminator(ND, Disc)) { Index: lib/AST/ItaniumMangle.cpp =================================================================== --- lib/AST/ItaniumMangle.cpp +++ lib/AST/ItaniumMangle.cpp @@ -90,7 +90,7 @@ static const RecordDecl *GetLocalClassDecl(const Decl *D) { const DeclContext *DC = getEffectiveDeclContext(D); - while (!DC->isNamespace() && !DC->isTranslationUnit()) { + while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget()) { if (isLocalContainerContext(DC)) return dyn_cast<RecordDecl>(D); D = cast<Decl>(DC); @@ -444,9 +444,9 @@ const DeclContext *DC = getEffectiveDeclContext(D); // Check for extern variable declared locally. if (DC->isFunctionOrMethod() && D->hasLinkage()) - while (!DC->isNamespace() && !DC->isTranslationUnit()) + while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget()) DC = getEffectiveParentContext(DC); - if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage && + if (DC->isTranslationUnitOrDeclareTarget() && D->getFormalLinkage() != InternalLinkage && !isa<VarTemplateSpecializationDecl>(D)) return false; } @@ -537,7 +537,7 @@ /// Return whether a given namespace is the 'std' namespace. static bool isStd(const NamespaceDecl *NS) { if (!IgnoreLinkageSpecDecls(getEffectiveParentContext(NS)) - ->isTranslationUnit()) + ->isTranslationUnitOrDeclareTarget()) return false; const IdentifierInfo *II = NS->getOriginalNamespace()->getIdentifier(); @@ -593,16 +593,16 @@ // FIXME: This is a hack; extern variables declared locally should have // a proper semantic declaration context! if (isLocalContainerContext(DC) && ND->hasLinkage() && !isLambda(ND)) - while (!DC->isNamespace() && !DC->isTranslationUnit()) + while (!DC->isNamespace() && !DC->isTranslationUnitOrDeclareTarget()) DC = getEffectiveParentContext(DC); else if (GetLocalClassDecl(ND)) { mangleLocalName(ND); return; } DC = IgnoreLinkageSpecDecls(DC); - if (DC->isTranslationUnit() || isStdNamespace(DC)) { + if (DC->isTranslationUnitOrDeclareTarget() || isStdNamespace(DC)) { // Check if we have a template. const TemplateArgumentList *TemplateArgs = nullptr; if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) { @@ -627,7 +627,7 @@ unsigned NumTemplateArgs) { const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD)); - if (DC->isTranslationUnit() || isStdNamespace(DC)) { + if (DC->isTranslationUnitOrDeclareTarget() || isStdNamespace(DC)) { mangleUnscopedTemplateName(TD); mangleTemplateArgs(TemplateArgs, NumTemplateArgs); } else { @@ -1342,7 +1342,7 @@ DC = IgnoreLinkageSpecDecls(DC); - if (DC->isTranslationUnit()) + if (DC->isTranslationUnitOrDeclareTarget()) return; if (NoFunction && isLocalContainerContext(DC)) Index: lib/AST/DeclPrinter.cpp =================================================================== --- lib/AST/DeclPrinter.cpp +++ lib/AST/DeclPrinter.cpp @@ -92,6 +92,7 @@ void VisitUsingDecl(UsingDecl *D); void VisitUsingShadowDecl(UsingShadowDecl *D); void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D); + void VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D); void PrintTemplateParameters(const TemplateParameterList *Params, const TemplateArgumentList *Args = nullptr); @@ -333,7 +334,7 @@ // FIXME: Need to be able to tell the DeclPrinter when const char *Terminator = nullptr; - if (isa<OMPThreadPrivateDecl>(*D)) + if (isa<OMPThreadPrivateDecl>(*D) || isa<OMPDeclareTargetDecl>(*D)) Terminator = nullptr; else if (isa<FunctionDecl>(*D) && cast<FunctionDecl>(*D)->isThisDeclarationADefinition()) @@ -1305,6 +1306,12 @@ getAsString(Policy) << ' ' << *PDecl; if (Policy.PolishForDeclaration) Out << ';'; +} + +void DeclPrinter::VisitOMPDeclareTargetDecl(OMPDeclareTargetDecl *D) { + Out << "#pragma omp declare target\n"; + VisitDeclContext(D); + Out << "#pragma omp end declare target\n"; } void DeclPrinter::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *PID) { Index: lib/AST/DeclOpenMP.cpp =================================================================== --- lib/AST/DeclOpenMP.cpp +++ lib/AST/DeclOpenMP.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// /// \file -/// \brief This file implements OMPThreadPrivateDecl class. +/// \brief This file implements OMPThreadPrivateDecl, OMPDeclareTarget class. /// //===----------------------------------------------------------------------===// @@ -52,3 +52,24 @@ std::copy(VL.begin(), VL.end(), Vars); } + +//===----------------------------------------------------------------------===// +// OMPDeclareTargetDecl Implementation. +//===----------------------------------------------------------------------===// + +void OMPDeclareTargetDecl::anchor() {} + +OMPDeclareTargetDecl * +OMPDeclareTargetDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { + OMPDeclareTargetDecl *D = + new (C, DC) OMPDeclareTargetDecl(OMPDeclareTarget, DC, L); + return D; +} + +OMPDeclareTargetDecl *OMPDeclareTargetDecl::CreateDeserialized(ASTContext &C, + unsigned ID) { + // Realign + OMPDeclareTargetDecl *D = + new (C, ID) OMPDeclareTargetDecl(OMPDeclareTarget, 0, SourceLocation()); + return D; +} \ No newline at end of file Index: lib/AST/DeclBase.cpp =================================================================== --- lib/AST/DeclBase.cpp +++ lib/AST/DeclBase.cpp @@ -198,7 +198,7 @@ const DeclContext *Decl::getParentFunctionOrMethod() const { for (const DeclContext *DC = getDeclContext(); - DC && !DC->isTranslationUnit() && !DC->isNamespace(); + DC && !DC->isTranslationUnitOrDeclareTarget() && !DC->isNamespace(); DC = DC->getParent()) if (DC->isFunctionOrMethod()) return DC; @@ -650,6 +650,7 @@ case ObjCCategoryImpl: case Import: case OMPThreadPrivate: + case OMPDeclareTarget: case Empty: // Never looked up by name. return 0; @@ -869,7 +870,7 @@ return ND->getParent()->isStdNamespace(); } - if (!getParent()->getRedeclContext()->isTranslationUnit()) + if (!getParent()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) return false; const IdentifierInfo *II = ND->getIdentifier(); @@ -913,6 +914,8 @@ return !cast<EnumDecl>(this)->isScoped(); else if (DeclKind == Decl::LinkageSpec) return true; + else if (DeclKind == Decl::OMPDeclareTarget) + return true; return false; } @@ -952,6 +955,7 @@ case Decl::LinkageSpec: case Decl::Block: case Decl::Captured: + case Decl::OMPDeclareTarget: // There is only one DeclContext for these entities. return this; Index: lib/AST/Decl.cpp =================================================================== --- lib/AST/Decl.cpp +++ lib/AST/Decl.cpp @@ -1813,12 +1813,12 @@ VarDecl::TLSKind VarDecl::getTLSKind() const { switch (VarDeclBits.TSCSpec) { case TSCS_unspecified: - if (!hasAttr<ThreadAttr>() && - !(getASTContext().getLangOpts().OpenMPUseTLS && - getASTContext().getTargetInfo().isTLSSupported() && - hasAttr<OMPThreadPrivateDeclAttr>())) - return TLS_None; - return ((getASTContext().getLangOpts().isCompatibleWithMSVC( + if (!hasAttr<ThreadAttr>() && + !(getASTContext().getLangOpts().OpenMPUseTLS && + getASTContext().getTargetInfo().isTLSSupported() && + hasAttr<OMPThreadPrivateDeclAttr>())) + return TLS_None; + return ((getASTContext().getLangOpts().isCompatibleWithMSVC( LangOptions::MSVC2015)) || hasAttr<OMPThreadPrivateDeclAttr>()) ? TLS_Dynamic @@ -2481,7 +2481,7 @@ getDeclName().getCXXOverloadedOperator() == OO_Array_New || getDeclName().getCXXOverloadedOperator() == OO_Array_Delete); - if (!getDeclContext()->getRedeclContext()->isTranslationUnit()) + if (!getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) return false; const auto *proto = getType()->castAs<FunctionProtoType>(); @@ -2510,7 +2510,7 @@ return false; // This can only fail for an invalid 'operator new' declaration. - if (!getDeclContext()->getRedeclContext()->isTranslationUnit()) + if (!getDeclContext()->getRedeclContext()->isTranslationUnitOrDeclareTarget()) return false; const auto *FPT = getType()->castAs<FunctionProtoType>(); @@ -2745,7 +2745,7 @@ static bool RedeclForcesDefC99(const FunctionDecl *Redecl) { // Only consider file-scope declarations in this test. - if (!Redecl->getLexicalDeclContext()->isTranslationUnit()) + if (!Redecl->getLexicalDeclContext()->isTranslationUnitOrDeclareTarget()) return false; // Only consider explicit declarations; the presence of a builtin for a Index: lib/AST/ASTContext.cpp =================================================================== --- lib/AST/ASTContext.cpp +++ lib/AST/ASTContext.cpp @@ -8400,7 +8400,7 @@ // We never need to emit an uninstantiated function template. if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate) return false; - } else if (isa<OMPThreadPrivateDecl>(D)) + } else if (isa<OMPThreadPrivateDecl>(D) || isa<OMPDeclareTargetDecl>(D)) return true; else return false; Index: include/clang/Serialization/ASTBitCodes.h =================================================================== --- include/clang/Serialization/ASTBitCodes.h +++ include/clang/Serialization/ASTBitCodes.h @@ -1152,6 +1152,8 @@ DECL_EMPTY, /// \brief An ObjCTypeParamDecl record. DECL_OBJC_TYPE_PARAM, + /// \brief An OMPDeclareTargetDecl record. + DECL_OMP_DECLARETARGET, }; /// \brief Record codes for each kind of statement or expression. Index: include/clang/Sema/Sema.h =================================================================== --- include/clang/Sema/Sema.h +++ include/clang/Sema/Sema.h @@ -145,6 +145,7 @@ class ObjCProtocolDecl; class OMPThreadPrivateDecl; class OMPClause; + class OMPDeclareTargetDecl; struct OverloadCandidate; class OverloadCandidateSet; class OverloadExpr; @@ -7814,6 +7815,13 @@ OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl( SourceLocation Loc, ArrayRef<Expr *> VarList); + + bool ActOnStartOpenMPDeclareTargetDirective(Scope *S, SourceLocation Loc); + void ActOnOpenMPDeclareTargetDecls(DeclGroupPtrTy Decls); + DeclGroupPtrTy ActOnFinishOpenMPDeclareTargetDirective(); + void ActOnOpenMPDeclareTargetDirectiveError(); + void CheckDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D); + bool IsDeclContextInOpenMPTarget(DeclContext *DC); /// \brief Initialization of captured region for OpenMP region. void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope); Index: include/clang/Parse/Parser.h =================================================================== --- include/clang/Parse/Parser.h +++ include/clang/Parse/Parser.h @@ -2426,7 +2426,7 @@ //===--------------------------------------------------------------------===// // OpenMP: Directives and clauses. /// \brief Parses declarative OpenMP directives. - DeclGroupPtrTy ParseOpenMPDeclarativeDirective(); + DeclGroupPtrTy ParseOpenMPDeclarativeDirective(AccessSpecifier AS); /// \brief Parses simple list of variables. /// /// \param Kind Kind of the directive. Index: include/clang/Basic/OpenMPKinds.def =================================================================== --- include/clang/Basic/OpenMPKinds.def +++ include/clang/Basic/OpenMPKinds.def @@ -123,6 +123,8 @@ OPENMP_DIRECTIVE_EXT(cancellation_point, "cancellation point") OPENMP_DIRECTIVE(taskloop) OPENMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd") +OPENMP_DIRECTIVE_EXT(declare_target, "declare target") +OPENMP_DIRECTIVE_EXT(end_declare_target, "end declare target") // OpenMP clauses. OPENMP_CLAUSE(if, OMPIfClause) Index: include/clang/Basic/DiagnosticSemaKinds.td =================================================================== --- include/clang/Basic/DiagnosticSemaKinds.td +++ include/clang/Basic/DiagnosticSemaKinds.td @@ -7659,6 +7659,8 @@ "arguments of '#pragma omp %0' must have %select{global storage|static storage duration}1">; def err_omp_ref_type_arg : Error< "arguments of '#pragma omp %0' cannot be of reference type %1">; +def err_omp_region_not_file_context : Error< + "directive must be at file or namespace scope">; def err_omp_var_scope : Error< "'#pragma omp %0' must appear in the scope of the %q1 variable declaration">; def err_omp_var_used : Error< @@ -7716,6 +7718,8 @@ def err_omp_not_integral : Error< "expression must have integral or unscoped enumeration " "type, not %0">; +def err_omp_threadprivate_in_target : Error< + "threadprivate variables cannot be used in target constructs">; def err_omp_incomplete_type : Error< "expression has incomplete class type %0">; def err_omp_explicit_conversion : Error< @@ -7742,6 +7746,9 @@ def warn_omp_alignment_not_power_of_two : Warning< "aligned clause will be ignored because the requested alignment is not a power of 2">, InGroup<OpenMPClauses>; +def warn_omp_not_in_target_context : Warning< + "declaration is not declared in any declare target region">, + InGroup<OpenMPTarget>; def err_omp_aligned_expected_array_or_ptr : Error< "argument of aligned clause should be array" "%select{ or pointer|, pointer, reference to array or reference to pointer}1" Index: include/clang/Basic/DiagnosticParseKinds.td =================================================================== --- include/clang/Basic/DiagnosticParseKinds.td +++ include/clang/Basic/DiagnosticParseKinds.td @@ -928,6 +928,8 @@ "'#pragma omp %0' cannot be an immediate substatement">; def err_omp_expected_identifier_for_critical : Error< "expected identifier specifying the name of the 'omp critical' directive">; +def err_expected_end_declare_target : Error< + "expected '#pragma omp end declare target'">; def err_omp_unknown_map_type : Error< "incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'">; def err_omp_unknown_map_type_modifier : Error< Index: include/clang/Basic/DiagnosticGroups.td =================================================================== --- include/clang/Basic/DiagnosticGroups.td +++ include/clang/Basic/DiagnosticGroups.td @@ -809,6 +809,7 @@ def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">; def OpenMPClauses : DiagGroup<"openmp-clauses">; def OpenMPLoopForm : DiagGroup<"openmp-loop-form">; +def OpenMPTarget : DiagGroup<"openmp-target">; // Backend warnings. def BackendInlineAsm : DiagGroup<"inline-asm">; Index: include/clang/Basic/DeclNodes.td =================================================================== --- include/clang/Basic/DeclNodes.td +++ include/clang/Basic/DeclNodes.td @@ -84,5 +84,6 @@ def ClassScopeFunctionSpecialization : Decl; def Import : Decl; def OMPThreadPrivate : Decl; +def OMPDeclareTarget : Decl, DeclContext; def Empty : Decl; Index: include/clang/Basic/Attr.td =================================================================== --- include/clang/Basic/Attr.td +++ include/clang/Basic/Attr.td @@ -2165,6 +2165,13 @@ let Documentation = [Undocumented]; } +def OMPDeclareTargetDecl : InheritableAttr { + // This attribute has no spellings as it is only ever created implicitly. + let Spellings = []; + let SemaHandler = 0; + let Documentation = [Undocumented]; +} + def InternalLinkage : InheritableAttr { let Spellings = [GNU<"internal_linkage">, CXX11<"clang", "internal_linkage">]; let Subjects = SubjectList<[Var, Function, CXXRecord]>; Index: include/clang/AST/RecursiveASTVisitor.h =================================================================== --- include/clang/AST/RecursiveASTVisitor.h +++ include/clang/AST/RecursiveASTVisitor.h @@ -1425,6 +1425,8 @@ } }) +DEF_TRAVERSE_DECL(OMPDeclareTargetDecl, {}) + // A helper method for TemplateDecl's children. template <typename Derived> bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper( Index: include/clang/AST/DeclOpenMP.h =================================================================== --- include/clang/AST/DeclOpenMP.h +++ include/clang/AST/DeclOpenMP.h @@ -15,7 +15,7 @@ #ifndef LLVM_CLANG_AST_DECLOPENMP_H #define LLVM_CLANG_AST_DECLOPENMP_H -#include "clang/AST/DeclBase.h" +#include "clang/AST/Decl.h" #include "llvm/ADT/ArrayRef.h" namespace clang { @@ -83,6 +83,39 @@ static bool classof(const Decl *D) { return classofKind(D->getKind()); } static bool classofKind(Kind K) { return K == OMPThreadPrivate; } +}; + +/// For example, in the following, declared target variable 'foo': +/// +/// \code +/// #pragma omp declare target +/// int foo; +/// #pragma omp end declare target +/// \endcode +/// +class OMPDeclareTargetDecl : public Decl, public DeclContext { + friend class ASTDeclReader; + + virtual void anchor(); + + OMPDeclareTargetDecl(Kind DK, DeclContext *DC, SourceLocation L) + : Decl(DK, DC, L), DeclContext(DK) { + setModulePrivate(); + } + +public: + static OMPDeclareTargetDecl *Create(ASTContext &C, DeclContext *DC, + SourceLocation L); + static OMPDeclareTargetDecl *CreateDeserialized(ASTContext &C, unsigned ID); + + static bool classof(const Decl *D) { return classofKind(D->getKind()); } + static bool classofKind(Kind K) { return K == OMPDeclareTarget; } + static DeclContext *castToDeclContext(const OMPDeclareTargetDecl *D) { + return static_cast<DeclContext *>(const_cast<OMPDeclareTargetDecl *>(D)); + } + static OMPDeclareTargetDecl *castFromDeclContext(const DeclContext *DC) { + return static_cast<OMPDeclareTargetDecl *>(const_cast<DeclContext *>(DC)); + } }; } // end namespace clang Index: include/clang/AST/DeclBase.h =================================================================== --- include/clang/AST/DeclBase.h +++ include/clang/AST/DeclBase.h @@ -1265,6 +1265,12 @@ return DeclKind == Decl::TranslationUnit; } + bool isOMPDeclareTarget() const { return DeclKind == Decl::OMPDeclareTarget; } + + bool isTranslationUnitOrDeclareTarget() const { + return isOMPDeclareTarget() || isTranslationUnit(); + } + bool isRecord() const { return DeclKind >= Decl::firstRecord && DeclKind <= Decl::lastRecord; }
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits