SemaOpenMP.cpp revision 263508
1//===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9/// \file 10/// \brief This file implements semantic analysis for OpenMP directives and 11/// clauses. 12/// 13//===----------------------------------------------------------------------===// 14 15#include "clang/Basic/OpenMPKinds.h" 16#include "clang/AST/Decl.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/DeclOpenMP.h" 19#include "clang/AST/StmtCXX.h" 20#include "clang/AST/StmtOpenMP.h" 21#include "clang/AST/StmtVisitor.h" 22#include "clang/Lex/Preprocessor.h" 23#include "clang/Sema/Initialization.h" 24#include "clang/Sema/SemaInternal.h" 25#include "clang/Sema/Lookup.h" 26#include "clang/Sema/Scope.h" 27#include "clang/Sema/ScopeInfo.h" 28using namespace clang; 29 30//===----------------------------------------------------------------------===// 31// Stack of data-sharing attributes for variables 32//===----------------------------------------------------------------------===// 33 34namespace { 35/// \brief Default data sharing attributes, which can be applied to directive. 36enum DefaultDataSharingAttributes { 37 DSA_unspecified = 0, /// \brief Data sharing attribute not specified. 38 DSA_none = 1 << 0, /// \brief Default data sharing attribute 'none'. 39 DSA_shared = 1 << 1 /// \brief Default data sharing attribute 'shared'. 40}; 41 42/// \brief Stack for tracking declarations used in OpenMP directives and 43/// clauses and their data-sharing attributes. 44class DSAStackTy { 45public: 46 struct DSAVarData { 47 OpenMPDirectiveKind DKind; 48 OpenMPClauseKind CKind; 49 DeclRefExpr *RefExpr; 50 DSAVarData() : DKind(OMPD_unknown), CKind(OMPC_unknown), RefExpr(0) { } 51 }; 52private: 53 struct DSAInfo { 54 OpenMPClauseKind Attributes; 55 DeclRefExpr *RefExpr; 56 }; 57 typedef llvm::SmallDenseMap<VarDecl *, DSAInfo, 64> DeclSAMapTy; 58 59 struct SharingMapTy { 60 DeclSAMapTy SharingMap; 61 DefaultDataSharingAttributes DefaultAttr; 62 OpenMPDirectiveKind Directive; 63 DeclarationNameInfo DirectiveName; 64 Scope *CurScope; 65 SharingMapTy(OpenMPDirectiveKind DKind, 66 const DeclarationNameInfo &Name, 67 Scope *CurScope) 68 : SharingMap(), DefaultAttr(DSA_unspecified), Directive(DKind), 69 DirectiveName(Name), CurScope(CurScope) { } 70 SharingMapTy() 71 : SharingMap(), DefaultAttr(DSA_unspecified), 72 Directive(OMPD_unknown), DirectiveName(), 73 CurScope(0) { } 74 }; 75 76 typedef SmallVector<SharingMapTy, 64> StackTy; 77 78 /// \brief Stack of used declaration and their data-sharing attributes. 79 StackTy Stack; 80 Sema &Actions; 81 82 typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator; 83 84 DSAVarData getDSA(StackTy::reverse_iterator Iter, VarDecl *D); 85public: 86 explicit DSAStackTy(Sema &S) : Stack(1), Actions(S) { } 87 88 void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName, 89 Scope *CurScope) { 90 Stack.push_back(SharingMapTy(DKind, DirName, CurScope)); 91 } 92 93 void pop() { 94 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty!"); 95 Stack.pop_back(); 96 } 97 98 /// \brief Adds explicit data sharing attribute to the specified declaration. 99 void addDSA(VarDecl *D, DeclRefExpr *E, OpenMPClauseKind A); 100 101 /// \brief Checks if the variable is a local for OpenMP region. 102 bool isOpenMPLocal(VarDecl *D); 103 104 /// \brief Returns data sharing attributes from top of the stack for the 105 /// specified declaration. 106 DSAVarData getTopDSA(VarDecl *D); 107 /// \brief Returns data-sharing attributes for the specified declaration. 108 DSAVarData getImplicitDSA(VarDecl *D); 109 /// \brief Checks if the specified variables has \a CKind data-sharing 110 /// attribute in \a DKind directive. 111 DSAVarData hasDSA(VarDecl *D, OpenMPClauseKind CKind, 112 OpenMPDirectiveKind DKind = OMPD_unknown); 113 114 115 /// \brief Returns currently analyzed directive. 116 OpenMPDirectiveKind getCurrentDirective() const { 117 return Stack.back().Directive; 118 } 119 120 /// \brief Set default data sharing attribute to none. 121 void setDefaultDSANone() { Stack.back().DefaultAttr = DSA_none; } 122 /// \brief Set default data sharing attribute to shared. 123 void setDefaultDSAShared() { Stack.back().DefaultAttr = DSA_shared; } 124 125 DefaultDataSharingAttributes getDefaultDSA() const { 126 return Stack.back().DefaultAttr; 127 } 128 129 Scope *getCurScope() { return Stack.back().CurScope; } 130}; 131} // end anonymous namespace. 132 133DSAStackTy::DSAVarData DSAStackTy::getDSA(StackTy::reverse_iterator Iter, 134 VarDecl *D) { 135 DSAVarData DVar; 136 if (Iter == Stack.rend() - 1) { 137 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 138 // in a region but not in construct] 139 // File-scope or namespace-scope variables referenced in called routines 140 // in the region are shared unless they appear in a threadprivate 141 // directive. 142 // TODO 143 if (!D->isFunctionOrMethodVarDecl()) 144 DVar.CKind = OMPC_shared; 145 146 // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced 147 // in a region but not in construct] 148 // Variables with static storage duration that are declared in called 149 // routines in the region are shared. 150 if (D->hasGlobalStorage()) 151 DVar.CKind = OMPC_shared; 152 153 return DVar; 154 } 155 DVar.DKind = Iter->Directive; 156 // Explicitly specified attributes and local variables with predetermined 157 // attributes. 158 if (Iter->SharingMap.count(D)) { 159 DVar.RefExpr = Iter->SharingMap[D].RefExpr; 160 DVar.CKind = Iter->SharingMap[D].Attributes; 161 return DVar; 162 } 163 164 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 165 // in a Construct, C/C++, implicitly determined, p.1] 166 // In a parallel or task construct, the data-sharing attributes of these 167 // variables are determined by the default clause, if present. 168 switch (Iter->DefaultAttr) { 169 case DSA_shared: 170 DVar.CKind = OMPC_shared; 171 return DVar; 172 case DSA_none: 173 return DVar; 174 case DSA_unspecified: 175 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 176 // in a Construct, implicitly determined, p.2] 177 // In a parallel construct, if no default clause is present, these 178 // variables are shared. 179 if (DVar.DKind == OMPD_parallel) { 180 DVar.CKind = OMPC_shared; 181 return DVar; 182 } 183 184 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 185 // in a Construct, implicitly determined, p.4] 186 // In a task construct, if no default clause is present, a variable that in 187 // the enclosing context is determined to be shared by all implicit tasks 188 // bound to the current team is shared. 189 // TODO 190 if (DVar.DKind == OMPD_task) { 191 DSAVarData DVarTemp; 192 for (StackTy::reverse_iterator I = Iter + 1, 193 EE = Stack.rend() - 1; 194 I != EE; ++I) { 195 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 196 // in a Construct, implicitly determined, p.6] 197 // In a task construct, if no default clause is present, a variable 198 // whose data-sharing attribute is not determined by the rules above is 199 // firstprivate. 200 DVarTemp = getDSA(I, D); 201 if (DVarTemp.CKind != OMPC_shared) { 202 DVar.RefExpr = 0; 203 DVar.DKind = OMPD_task; 204 DVar.CKind = OMPC_firstprivate; 205 return DVar; 206 } 207 if (I->Directive == OMPD_parallel) break; 208 } 209 DVar.DKind = OMPD_task; 210 DVar.CKind = 211 (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared; 212 return DVar; 213 } 214 } 215 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 216 // in a Construct, implicitly determined, p.3] 217 // For constructs other than task, if no default clause is present, these 218 // variables inherit their data-sharing attributes from the enclosing 219 // context. 220 return getDSA(Iter + 1, D); 221} 222 223void DSAStackTy::addDSA(VarDecl *D, DeclRefExpr *E, OpenMPClauseKind A) { 224 if (A == OMPC_threadprivate) { 225 Stack[0].SharingMap[D].Attributes = A; 226 Stack[0].SharingMap[D].RefExpr = E; 227 } else { 228 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty"); 229 Stack.back().SharingMap[D].Attributes = A; 230 Stack.back().SharingMap[D].RefExpr = E; 231 } 232} 233 234bool DSAStackTy::isOpenMPLocal(VarDecl *D) { 235 Scope *CurScope = getCurScope(); 236 while (CurScope && !CurScope->isDeclScope(D)) 237 CurScope = CurScope->getParent(); 238 while (CurScope && !CurScope->isOpenMPDirectiveScope()) 239 CurScope = CurScope->getParent(); 240 bool isOpenMPLocal = !!CurScope; 241 if (!isOpenMPLocal) { 242 CurScope = getCurScope(); 243 while (CurScope && !CurScope->isOpenMPDirectiveScope()) 244 CurScope = CurScope->getParent(); 245 isOpenMPLocal = 246 CurScope && 247 isa<CapturedDecl>(D->getDeclContext()) && 248 CurScope->getFnParent()->getEntity()->Encloses(D->getDeclContext()); 249 } 250 return isOpenMPLocal; 251} 252 253DSAStackTy::DSAVarData DSAStackTy::getTopDSA(VarDecl *D) { 254 DSAVarData DVar; 255 256 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 257 // in a Construct, C/C++, predetermined, p.1] 258 // Variables appearing in threadprivate directives are threadprivate. 259 if (D->getTLSKind() != VarDecl::TLS_None) { 260 DVar.CKind = OMPC_threadprivate; 261 return DVar; 262 } 263 if (Stack[0].SharingMap.count(D)) { 264 DVar.RefExpr = Stack[0].SharingMap[D].RefExpr; 265 DVar.CKind = OMPC_threadprivate; 266 return DVar; 267 } 268 269 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 270 // in a Construct, C/C++, predetermined, p.1] 271 // Variables with automatic storage duration that are declared in a scope 272 // inside the construct are private. 273 if (isOpenMPLocal(D) && D->isLocalVarDecl() && 274 (D->getStorageClass() == SC_Auto || 275 D->getStorageClass() == SC_None)) { 276 DVar.CKind = OMPC_private; 277 return DVar; 278 } 279 280 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 281 // in a Construct, C/C++, predetermined, p.4] 282 // Static data memebers are shared. 283 if (D->isStaticDataMember()) { 284 // Variables with const-qualified type having no mutable member may be listed 285 // in a firstprivate clause, even if they are static data members. 286 DSAVarData DVarTemp = hasDSA(D, OMPC_firstprivate); 287 if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr) 288 return DVar; 289 290 DVar.CKind = OMPC_shared; 291 return DVar; 292 } 293 294 QualType Type = D->getType().getNonReferenceType().getCanonicalType(); 295 bool IsConstant = Type.isConstant(Actions.getASTContext()); 296 while (Type->isArrayType()) { 297 QualType ElemType = cast<ArrayType>(Type.getTypePtr())->getElementType(); 298 Type = ElemType.getNonReferenceType().getCanonicalType(); 299 } 300 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 301 // in a Construct, C/C++, predetermined, p.6] 302 // Variables with const qualified type having no mutable member are 303 // shared. 304 CXXRecordDecl *RD = Actions.getLangOpts().CPlusPlus ? 305 Type->getAsCXXRecordDecl() : 0; 306 if (IsConstant && 307 !(Actions.getLangOpts().CPlusPlus && RD && RD->hasMutableFields())) { 308 // Variables with const-qualified type having no mutable member may be 309 // listed in a firstprivate clause, even if they are static data members. 310 DSAVarData DVarTemp = hasDSA(D, OMPC_firstprivate); 311 if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr) 312 return DVar; 313 314 DVar.CKind = OMPC_shared; 315 return DVar; 316 } 317 318 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 319 // in a Construct, C/C++, predetermined, p.7] 320 // Variables with static storage duration that are declared in a scope 321 // inside the construct are shared. 322 if (isOpenMPLocal(D) && D->isStaticLocal()) { 323 DVar.CKind = OMPC_shared; 324 return DVar; 325 } 326 327 // Explicitly specified attributes and local variables with predetermined 328 // attributes. 329 if (Stack.back().SharingMap.count(D)) { 330 DVar.RefExpr = Stack.back().SharingMap[D].RefExpr; 331 DVar.CKind = Stack.back().SharingMap[D].Attributes; 332 } 333 334 return DVar; 335} 336 337DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(VarDecl *D) { 338 return getDSA(Stack.rbegin() + 1, D); 339} 340 341DSAStackTy::DSAVarData DSAStackTy::hasDSA(VarDecl *D, OpenMPClauseKind CKind, 342 OpenMPDirectiveKind DKind) { 343 for (StackTy::reverse_iterator I = Stack.rbegin() + 1, 344 E = Stack.rend() - 1; 345 I != E; ++I) { 346 if (DKind != OMPD_unknown && DKind != I->Directive) continue; 347 DSAVarData DVar = getDSA(I, D); 348 if (DVar.CKind == CKind) 349 return DVar; 350 } 351 return DSAVarData(); 352} 353 354void Sema::InitDataSharingAttributesStack() { 355 VarDataSharingAttributesStack = new DSAStackTy(*this); 356} 357 358#define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack) 359 360void Sema::DestroyDataSharingAttributesStack() { 361 delete DSAStack; 362} 363 364void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind, 365 const DeclarationNameInfo &DirName, 366 Scope *CurScope) { 367 DSAStack->push(DKind, DirName, CurScope); 368 PushExpressionEvaluationContext(PotentiallyEvaluated); 369} 370 371void Sema::EndOpenMPDSABlock(Stmt *CurDirective) { 372 DSAStack->pop(); 373 DiscardCleanupsInEvaluationContext(); 374 PopExpressionEvaluationContext(); 375} 376 377namespace { 378 379class VarDeclFilterCCC : public CorrectionCandidateCallback { 380private: 381 Sema &Actions; 382public: 383 VarDeclFilterCCC(Sema &S) : Actions(S) { } 384 virtual bool ValidateCandidate(const TypoCorrection &Candidate) { 385 NamedDecl *ND = Candidate.getCorrectionDecl(); 386 if (VarDecl *VD = dyn_cast_or_null<VarDecl>(ND)) { 387 return VD->hasGlobalStorage() && 388 Actions.isDeclInScope(ND, Actions.getCurLexicalContext(), 389 Actions.getCurScope()); 390 } 391 return false; 392 } 393}; 394} 395 396ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope, 397 CXXScopeSpec &ScopeSpec, 398 const DeclarationNameInfo &Id) { 399 LookupResult Lookup(*this, Id, LookupOrdinaryName); 400 LookupParsedName(Lookup, CurScope, &ScopeSpec, true); 401 402 if (Lookup.isAmbiguous()) 403 return ExprError(); 404 405 VarDecl *VD; 406 if (!Lookup.isSingleResult()) { 407 VarDeclFilterCCC Validator(*this); 408 if (TypoCorrection Corrected = CorrectTypo(Id, LookupOrdinaryName, CurScope, 409 0, Validator)) { 410 diagnoseTypo(Corrected, 411 PDiag(Lookup.empty()? diag::err_undeclared_var_use_suggest 412 : diag::err_omp_expected_var_arg_suggest) 413 << Id.getName()); 414 VD = Corrected.getCorrectionDeclAs<VarDecl>(); 415 } else { 416 Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use 417 : diag::err_omp_expected_var_arg) 418 << Id.getName(); 419 return ExprError(); 420 } 421 } else { 422 if (!(VD = Lookup.getAsSingle<VarDecl>())) { 423 Diag(Id.getLoc(), diag::err_omp_expected_var_arg) 424 << Id.getName(); 425 Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at); 426 return ExprError(); 427 } 428 } 429 Lookup.suppressDiagnostics(); 430 431 // OpenMP [2.9.2, Syntax, C/C++] 432 // Variables must be file-scope, namespace-scope, or static block-scope. 433 if (!VD->hasGlobalStorage()) { 434 Diag(Id.getLoc(), diag::err_omp_global_var_arg) 435 << getOpenMPDirectiveName(OMPD_threadprivate) 436 << !VD->isStaticLocal(); 437 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 438 VarDecl::DeclarationOnly; 439 Diag(VD->getLocation(), 440 IsDecl ? diag::note_previous_decl : diag::note_defined_here) << VD; 441 return ExprError(); 442 } 443 444 VarDecl *CanonicalVD = VD->getCanonicalDecl(); 445 NamedDecl *ND = cast<NamedDecl>(CanonicalVD); 446 // OpenMP [2.9.2, Restrictions, C/C++, p.2] 447 // A threadprivate directive for file-scope variables must appear outside 448 // any definition or declaration. 449 if (CanonicalVD->getDeclContext()->isTranslationUnit() && 450 !getCurLexicalContext()->isTranslationUnit()) { 451 Diag(Id.getLoc(), diag::err_omp_var_scope) 452 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 453 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 454 VarDecl::DeclarationOnly; 455 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 456 diag::note_defined_here) << VD; 457 return ExprError(); 458 } 459 // OpenMP [2.9.2, Restrictions, C/C++, p.3] 460 // A threadprivate directive for static class member variables must appear 461 // in the class definition, in the same scope in which the member 462 // variables are declared. 463 if (CanonicalVD->isStaticDataMember() && 464 !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) { 465 Diag(Id.getLoc(), diag::err_omp_var_scope) 466 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 467 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 468 VarDecl::DeclarationOnly; 469 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 470 diag::note_defined_here) << VD; 471 return ExprError(); 472 } 473 // OpenMP [2.9.2, Restrictions, C/C++, p.4] 474 // A threadprivate directive for namespace-scope variables must appear 475 // outside any definition or declaration other than the namespace 476 // definition itself. 477 if (CanonicalVD->getDeclContext()->isNamespace() && 478 (!getCurLexicalContext()->isFileContext() || 479 !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) { 480 Diag(Id.getLoc(), diag::err_omp_var_scope) 481 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 482 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 483 VarDecl::DeclarationOnly; 484 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 485 diag::note_defined_here) << VD; 486 return ExprError(); 487 } 488 // OpenMP [2.9.2, Restrictions, C/C++, p.6] 489 // A threadprivate directive for static block-scope variables must appear 490 // in the scope of the variable and not in a nested scope. 491 if (CanonicalVD->isStaticLocal() && CurScope && 492 !isDeclInScope(ND, getCurLexicalContext(), CurScope)) { 493 Diag(Id.getLoc(), diag::err_omp_var_scope) 494 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 495 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 496 VarDecl::DeclarationOnly; 497 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 498 diag::note_defined_here) << VD; 499 return ExprError(); 500 } 501 502 // OpenMP [2.9.2, Restrictions, C/C++, p.2-6] 503 // A threadprivate directive must lexically precede all references to any 504 // of the variables in its list. 505 if (VD->isUsed()) { 506 Diag(Id.getLoc(), diag::err_omp_var_used) 507 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 508 return ExprError(); 509 } 510 511 QualType ExprType = VD->getType().getNonReferenceType(); 512 ExprResult DE = BuildDeclRefExpr(VD, ExprType, VK_RValue, Id.getLoc()); 513 DSAStack->addDSA(VD, cast<DeclRefExpr>(DE.get()), OMPC_threadprivate); 514 return DE; 515} 516 517Sema::DeclGroupPtrTy Sema::ActOnOpenMPThreadprivateDirective( 518 SourceLocation Loc, 519 ArrayRef<Expr *> VarList) { 520 if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) { 521 CurContext->addDecl(D); 522 return DeclGroupPtrTy::make(DeclGroupRef(D)); 523 } 524 return DeclGroupPtrTy(); 525} 526 527OMPThreadPrivateDecl *Sema::CheckOMPThreadPrivateDecl( 528 SourceLocation Loc, 529 ArrayRef<Expr *> VarList) { 530 SmallVector<Expr *, 8> Vars; 531 for (ArrayRef<Expr *>::iterator I = VarList.begin(), 532 E = VarList.end(); 533 I != E; ++I) { 534 DeclRefExpr *DE = cast<DeclRefExpr>(*I); 535 VarDecl *VD = cast<VarDecl>(DE->getDecl()); 536 SourceLocation ILoc = DE->getExprLoc(); 537 538 // OpenMP [2.9.2, Restrictions, C/C++, p.10] 539 // A threadprivate variable must not have an incomplete type. 540 if (RequireCompleteType(ILoc, VD->getType(), 541 diag::err_omp_threadprivate_incomplete_type)) { 542 continue; 543 } 544 545 // OpenMP [2.9.2, Restrictions, C/C++, p.10] 546 // A threadprivate variable must not have a reference type. 547 if (VD->getType()->isReferenceType()) { 548 Diag(ILoc, diag::err_omp_ref_type_arg) 549 << getOpenMPDirectiveName(OMPD_threadprivate) 550 << VD->getType(); 551 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 552 VarDecl::DeclarationOnly; 553 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 554 diag::note_defined_here) << VD; 555 continue; 556 } 557 558 // Check if this is a TLS variable. 559 if (VD->getTLSKind()) { 560 Diag(ILoc, diag::err_omp_var_thread_local) << VD; 561 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 562 VarDecl::DeclarationOnly; 563 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 564 diag::note_defined_here) << VD; 565 continue; 566 } 567 568 Vars.push_back(*I); 569 } 570 return Vars.empty() ? 571 0 : OMPThreadPrivateDecl::Create(Context, 572 getCurLexicalContext(), 573 Loc, Vars); 574} 575 576namespace { 577class DSAAttrChecker : public StmtVisitor<DSAAttrChecker, void> { 578 DSAStackTy *Stack; 579 Sema &Actions; 580 bool ErrorFound; 581 CapturedStmt *CS; 582 llvm::SmallVector<Expr *, 8> ImplicitFirstprivate; 583public: 584 void VisitDeclRefExpr(DeclRefExpr *E) { 585 if(VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) { 586 // Skip internally declared variables. 587 if (VD->isLocalVarDecl() && !CS->capturesVariable(VD)) return; 588 589 SourceLocation ELoc = E->getExprLoc(); 590 591 OpenMPDirectiveKind DKind = Stack->getCurrentDirective(); 592 DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD); 593 if (DVar.CKind != OMPC_unknown) { 594 if (DKind == OMPD_task && DVar.CKind != OMPC_shared && 595 DVar.CKind != OMPC_threadprivate && !DVar.RefExpr) 596 ImplicitFirstprivate.push_back(DVar.RefExpr); 597 return; 598 } 599 // The default(none) clause requires that each variable that is referenced 600 // in the construct, and does not have a predetermined data-sharing 601 // attribute, must have its data-sharing attribute explicitly determined 602 // by being listed in a data-sharing attribute clause. 603 if (DVar.CKind == OMPC_unknown && Stack->getDefaultDSA() == DSA_none && 604 (DKind == OMPD_parallel || DKind == OMPD_task)) { 605 ErrorFound = true; 606 Actions.Diag(ELoc, diag::err_omp_no_dsa_for_variable) << VD; 607 return; 608 } 609 610 // OpenMP [2.9.3.6, Restrictions, p.2] 611 // A list item that appears in a reduction clause of the innermost 612 // enclosing worksharing or parallel construct may not be accessed in an 613 // explicit task. 614 // TODO: 615 616 // Define implicit data-sharing attributes for task. 617 DVar = Stack->getImplicitDSA(VD); 618 if (DKind == OMPD_task && DVar.CKind != OMPC_shared) 619 ImplicitFirstprivate.push_back(DVar.RefExpr); 620 } 621 } 622 void VisitOMPExecutableDirective(OMPExecutableDirective *S) { 623 for (ArrayRef<OMPClause *>::iterator I = S->clauses().begin(), 624 E = S->clauses().end(); 625 I != E; ++I) 626 if (OMPClause *C = *I) 627 for (StmtRange R = C->children(); R; ++R) 628 if (Stmt *Child = *R) 629 Visit(Child); 630 } 631 void VisitStmt(Stmt *S) { 632 for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); 633 I != E; ++I) 634 if (Stmt *Child = *I) 635 if (!isa<OMPExecutableDirective>(Child)) 636 Visit(Child); 637 } 638 639 bool isErrorFound() { return ErrorFound; } 640 ArrayRef<Expr *> getImplicitFirstprivate() { return ImplicitFirstprivate; } 641 642 DSAAttrChecker(DSAStackTy *S, Sema &Actions, CapturedStmt *CS) 643 : Stack(S), Actions(Actions), ErrorFound(false), CS(CS) { } 644}; 645} 646 647StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, 648 ArrayRef<OMPClause *> Clauses, 649 Stmt *AStmt, 650 SourceLocation StartLoc, 651 SourceLocation EndLoc) { 652 assert(AStmt && isa<CapturedStmt>(AStmt) && "Captured statement expected"); 653 654 StmtResult Res = StmtError(); 655 656 // Check default data sharing attributes for referenced variables. 657 DSAAttrChecker DSAChecker(DSAStack, *this, cast<CapturedStmt>(AStmt)); 658 DSAChecker.Visit(cast<CapturedStmt>(AStmt)->getCapturedStmt()); 659 if (DSAChecker.isErrorFound()) 660 return StmtError(); 661 // Generate list of implicitly defined firstprivate variables. 662 llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit; 663 ClausesWithImplicit.append(Clauses.begin(), Clauses.end()); 664 665 bool ErrorFound = false; 666 if (!DSAChecker.getImplicitFirstprivate().empty()) { 667 if (OMPClause *Implicit = 668 ActOnOpenMPFirstprivateClause(DSAChecker.getImplicitFirstprivate(), 669 SourceLocation(), SourceLocation(), 670 SourceLocation())) { 671 ClausesWithImplicit.push_back(Implicit); 672 ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() != 673 DSAChecker.getImplicitFirstprivate().size(); 674 } else 675 ErrorFound = true; 676 } 677 678 switch (Kind) { 679 case OMPD_parallel: 680 Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, 681 StartLoc, EndLoc); 682 break; 683 case OMPD_threadprivate: 684 case OMPD_task: 685 llvm_unreachable("OpenMP Directive is not allowed"); 686 case OMPD_unknown: 687 case NUM_OPENMP_DIRECTIVES: 688 llvm_unreachable("Unknown OpenMP directive"); 689 } 690 691 if (ErrorFound) return StmtError(); 692 return Res; 693} 694 695StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses, 696 Stmt *AStmt, 697 SourceLocation StartLoc, 698 SourceLocation EndLoc) { 699 getCurFunction()->setHasBranchProtectedScope(); 700 701 return Owned(OMPParallelDirective::Create(Context, StartLoc, EndLoc, 702 Clauses, AStmt)); 703} 704 705OMPClause *Sema::ActOnOpenMPSimpleClause(OpenMPClauseKind Kind, 706 unsigned Argument, 707 SourceLocation ArgumentLoc, 708 SourceLocation StartLoc, 709 SourceLocation LParenLoc, 710 SourceLocation EndLoc) { 711 OMPClause *Res = 0; 712 switch (Kind) { 713 case OMPC_default: 714 Res = 715 ActOnOpenMPDefaultClause(static_cast<OpenMPDefaultClauseKind>(Argument), 716 ArgumentLoc, StartLoc, LParenLoc, EndLoc); 717 break; 718 case OMPC_private: 719 case OMPC_firstprivate: 720 case OMPC_shared: 721 case OMPC_threadprivate: 722 case OMPC_unknown: 723 case NUM_OPENMP_CLAUSES: 724 llvm_unreachable("Clause is not allowed."); 725 } 726 return Res; 727} 728 729OMPClause *Sema::ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind, 730 SourceLocation KindKwLoc, 731 SourceLocation StartLoc, 732 SourceLocation LParenLoc, 733 SourceLocation EndLoc) { 734 if (Kind == OMPC_DEFAULT_unknown) { 735 std::string Values; 736 std::string Sep(NUM_OPENMP_DEFAULT_KINDS > 1 ? ", " : ""); 737 for (unsigned i = OMPC_DEFAULT_unknown + 1; 738 i < NUM_OPENMP_DEFAULT_KINDS; ++i) { 739 Values += "'"; 740 Values += getOpenMPSimpleClauseTypeName(OMPC_default, i); 741 Values += "'"; 742 switch (i) { 743 case NUM_OPENMP_DEFAULT_KINDS - 2: 744 Values += " or "; 745 break; 746 case NUM_OPENMP_DEFAULT_KINDS - 1: 747 break; 748 default: 749 Values += Sep; 750 break; 751 } 752 } 753 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value) 754 << Values << getOpenMPClauseName(OMPC_default); 755 return 0; 756 } 757 switch (Kind) { 758 case OMPC_DEFAULT_none: 759 DSAStack->setDefaultDSANone(); 760 break; 761 case OMPC_DEFAULT_shared: 762 DSAStack->setDefaultDSAShared(); 763 break; 764 default: 765 break; 766 } 767 return new (Context) OMPDefaultClause(Kind, KindKwLoc, StartLoc, LParenLoc, 768 EndLoc); 769} 770 771OMPClause *Sema::ActOnOpenMPVarListClause(OpenMPClauseKind Kind, 772 ArrayRef<Expr *> VarList, 773 SourceLocation StartLoc, 774 SourceLocation LParenLoc, 775 SourceLocation EndLoc) { 776 OMPClause *Res = 0; 777 switch (Kind) { 778 case OMPC_private: 779 Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc); 780 break; 781 case OMPC_firstprivate: 782 Res = ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, EndLoc); 783 break; 784 case OMPC_shared: 785 Res = ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, EndLoc); 786 break; 787 case OMPC_default: 788 case OMPC_threadprivate: 789 case OMPC_unknown: 790 case NUM_OPENMP_CLAUSES: 791 llvm_unreachable("Clause is not allowed."); 792 } 793 return Res; 794} 795 796OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList, 797 SourceLocation StartLoc, 798 SourceLocation LParenLoc, 799 SourceLocation EndLoc) { 800 SmallVector<Expr *, 8> Vars; 801 for (ArrayRef<Expr *>::iterator I = VarList.begin(), E = VarList.end(); 802 I != E; ++I) { 803 assert(*I && "NULL expr in OpenMP private clause."); 804 if (isa<DependentScopeDeclRefExpr>(*I)) { 805 // It will be analyzed later. 806 Vars.push_back(*I); 807 continue; 808 } 809 810 SourceLocation ELoc = (*I)->getExprLoc(); 811 // OpenMP [2.1, C/C++] 812 // A list item is a variable name. 813 // OpenMP [2.9.3.3, Restrictions, p.1] 814 // A variable that is part of another variable (as an array or 815 // structure element) cannot appear in a private clause. 816 DeclRefExpr *DE = dyn_cast_or_null<DeclRefExpr>(*I); 817 if (!DE || !isa<VarDecl>(DE->getDecl())) { 818 Diag(ELoc, diag::err_omp_expected_var_name) 819 << (*I)->getSourceRange(); 820 continue; 821 } 822 Decl *D = DE->getDecl(); 823 VarDecl *VD = cast<VarDecl>(D); 824 825 QualType Type = VD->getType(); 826 if (Type->isDependentType() || Type->isInstantiationDependentType()) { 827 // It will be analyzed later. 828 Vars.push_back(DE); 829 continue; 830 } 831 832 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3] 833 // A variable that appears in a private clause must not have an incomplete 834 // type or a reference type. 835 if (RequireCompleteType(ELoc, Type, 836 diag::err_omp_private_incomplete_type)) { 837 continue; 838 } 839 if (Type->isReferenceType()) { 840 Diag(ELoc, diag::err_omp_clause_ref_type_arg) 841 << getOpenMPClauseName(OMPC_private) << Type; 842 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 843 VarDecl::DeclarationOnly; 844 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 845 diag::note_defined_here) << VD; 846 continue; 847 } 848 849 // OpenMP [2.9.3.3, Restrictions, C/C++, p.1] 850 // A variable of class type (or array thereof) that appears in a private 851 // clause requires an accesible, unambiguous default constructor for the 852 // class type. 853 while (Type.getNonReferenceType()->isArrayType()) { 854 Type = cast<ArrayType>( 855 Type.getNonReferenceType().getTypePtr())->getElementType(); 856 } 857 CXXRecordDecl *RD = getLangOpts().CPlusPlus ? 858 Type.getNonReferenceType()->getAsCXXRecordDecl() : 0; 859 if (RD) { 860 CXXConstructorDecl *CD = LookupDefaultConstructor(RD); 861 PartialDiagnostic PD = 862 PartialDiagnostic(PartialDiagnostic::NullDiagnostic()); 863 if (!CD || 864 CheckConstructorAccess(ELoc, CD, 865 InitializedEntity::InitializeTemporary(Type), 866 CD->getAccess(), PD) == AR_inaccessible || 867 CD->isDeleted()) { 868 Diag(ELoc, diag::err_omp_required_method) 869 << getOpenMPClauseName(OMPC_private) << 0; 870 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 871 VarDecl::DeclarationOnly; 872 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 873 diag::note_defined_here) << VD; 874 Diag(RD->getLocation(), diag::note_previous_decl) << RD; 875 continue; 876 } 877 MarkFunctionReferenced(ELoc, CD); 878 DiagnoseUseOfDecl(CD, ELoc); 879 880 CXXDestructorDecl *DD = RD->getDestructor(); 881 if (DD) { 882 if (CheckDestructorAccess(ELoc, DD, PD) == AR_inaccessible || 883 DD->isDeleted()) { 884 Diag(ELoc, diag::err_omp_required_method) 885 << getOpenMPClauseName(OMPC_private) << 4; 886 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 887 VarDecl::DeclarationOnly; 888 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 889 diag::note_defined_here) << VD; 890 Diag(RD->getLocation(), diag::note_previous_decl) << RD; 891 continue; 892 } 893 MarkFunctionReferenced(ELoc, DD); 894 DiagnoseUseOfDecl(DD, ELoc); 895 } 896 } 897 898 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 899 // in a Construct] 900 // Variables with the predetermined data-sharing attributes may not be 901 // listed in data-sharing attributes clauses, except for the cases 902 // listed below. For these exceptions only, listing a predetermined 903 // variable in a data-sharing attribute clause is allowed and overrides 904 // the variable's predetermined data-sharing attributes. 905 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(VD); 906 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_private) { 907 Diag(ELoc, diag::err_omp_wrong_dsa) 908 << getOpenMPClauseName(DVar.CKind) 909 << getOpenMPClauseName(OMPC_private); 910 if (DVar.RefExpr) { 911 Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa) 912 << getOpenMPClauseName(DVar.CKind); 913 } else { 914 Diag(VD->getLocation(), diag::note_omp_predetermined_dsa) 915 << getOpenMPClauseName(DVar.CKind); 916 } 917 continue; 918 } 919 920 DSAStack->addDSA(VD, DE, OMPC_private); 921 Vars.push_back(DE); 922 } 923 924 if (Vars.empty()) return 0; 925 926 return OMPPrivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars); 927} 928 929OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList, 930 SourceLocation StartLoc, 931 SourceLocation LParenLoc, 932 SourceLocation EndLoc) { 933 SmallVector<Expr *, 8> Vars; 934 for (ArrayRef<Expr *>::iterator I = VarList.begin(), E = VarList.end(); 935 I != E; ++I) { 936 assert(*I && "NULL expr in OpenMP firstprivate clause."); 937 if (isa<DependentScopeDeclRefExpr>(*I)) { 938 // It will be analyzed later. 939 Vars.push_back(*I); 940 continue; 941 } 942 943 SourceLocation ELoc = (*I)->getExprLoc(); 944 // OpenMP [2.1, C/C++] 945 // A list item is a variable name. 946 // OpenMP [2.9.3.3, Restrictions, p.1] 947 // A variable that is part of another variable (as an array or 948 // structure element) cannot appear in a private clause. 949 DeclRefExpr *DE = dyn_cast_or_null<DeclRefExpr>(*I); 950 if (!DE || !isa<VarDecl>(DE->getDecl())) { 951 Diag(ELoc, diag::err_omp_expected_var_name) 952 << (*I)->getSourceRange(); 953 continue; 954 } 955 Decl *D = DE->getDecl(); 956 VarDecl *VD = cast<VarDecl>(D); 957 958 QualType Type = VD->getType(); 959 if (Type->isDependentType() || Type->isInstantiationDependentType()) { 960 // It will be analyzed later. 961 Vars.push_back(DE); 962 continue; 963 } 964 965 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3] 966 // A variable that appears in a private clause must not have an incomplete 967 // type or a reference type. 968 if (RequireCompleteType(ELoc, Type, 969 diag::err_omp_firstprivate_incomplete_type)) { 970 continue; 971 } 972 if (Type->isReferenceType()) { 973 Diag(ELoc, diag::err_omp_clause_ref_type_arg) 974 << getOpenMPClauseName(OMPC_firstprivate) << Type; 975 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 976 VarDecl::DeclarationOnly; 977 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 978 diag::note_defined_here) << VD; 979 continue; 980 } 981 982 // OpenMP [2.9.3.4, Restrictions, C/C++, p.1] 983 // A variable of class type (or array thereof) that appears in a private 984 // clause requires an accesible, unambiguous copy constructor for the 985 // class type. 986 Type = Context.getBaseElementType(Type); 987 CXXRecordDecl *RD = getLangOpts().CPlusPlus ? 988 Type.getNonReferenceType()->getAsCXXRecordDecl() : 0; 989 if (RD) { 990 CXXConstructorDecl *CD = LookupCopyingConstructor(RD, 0); 991 PartialDiagnostic PD = 992 PartialDiagnostic(PartialDiagnostic::NullDiagnostic()); 993 if (!CD || 994 CheckConstructorAccess(ELoc, CD, 995 InitializedEntity::InitializeTemporary(Type), 996 CD->getAccess(), PD) == AR_inaccessible || 997 CD->isDeleted()) { 998 Diag(ELoc, diag::err_omp_required_method) 999 << getOpenMPClauseName(OMPC_firstprivate) << 1; 1000 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 1001 VarDecl::DeclarationOnly; 1002 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 1003 diag::note_defined_here) << VD; 1004 Diag(RD->getLocation(), diag::note_previous_decl) << RD; 1005 continue; 1006 } 1007 MarkFunctionReferenced(ELoc, CD); 1008 DiagnoseUseOfDecl(CD, ELoc); 1009 1010 CXXDestructorDecl *DD = RD->getDestructor(); 1011 if (DD) { 1012 if (CheckDestructorAccess(ELoc, DD, PD) == AR_inaccessible || 1013 DD->isDeleted()) { 1014 Diag(ELoc, diag::err_omp_required_method) 1015 << getOpenMPClauseName(OMPC_firstprivate) << 4; 1016 bool IsDecl = VD->isThisDeclarationADefinition(Context) == 1017 VarDecl::DeclarationOnly; 1018 Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl : 1019 diag::note_defined_here) << VD; 1020 Diag(RD->getLocation(), diag::note_previous_decl) << RD; 1021 continue; 1022 } 1023 MarkFunctionReferenced(ELoc, DD); 1024 DiagnoseUseOfDecl(DD, ELoc); 1025 } 1026 } 1027 1028 // If StartLoc and EndLoc are invalid - this is an implicit firstprivate 1029 // variable and it was checked already. 1030 if (StartLoc.isValid() && EndLoc.isValid()) { 1031 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(VD); 1032 Type = Type.getNonReferenceType().getCanonicalType(); 1033 bool IsConstant = Type.isConstant(Context); 1034 Type = Context.getBaseElementType(Type); 1035 // OpenMP [2.4.13, Data-sharing Attribute Clauses] 1036 // A list item that specifies a given variable may not appear in more 1037 // than one clause on the same directive, except that a variable may be 1038 // specified in both firstprivate and lastprivate clauses. 1039 // TODO: add processing for lastprivate. 1040 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_firstprivate && 1041 DVar.RefExpr) { 1042 Diag(ELoc, diag::err_omp_wrong_dsa) 1043 << getOpenMPClauseName(DVar.CKind) 1044 << getOpenMPClauseName(OMPC_firstprivate); 1045 Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa) 1046 << getOpenMPClauseName(DVar.CKind); 1047 continue; 1048 } 1049 1050 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 1051 // in a Construct] 1052 // Variables with the predetermined data-sharing attributes may not be 1053 // listed in data-sharing attributes clauses, except for the cases 1054 // listed below. For these exceptions only, listing a predetermined 1055 // variable in a data-sharing attribute clause is allowed and overrides 1056 // the variable's predetermined data-sharing attributes. 1057 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 1058 // in a Construct, C/C++, p.2] 1059 // Variables with const-qualified type having no mutable member may be 1060 // listed in a firstprivate clause, even if they are static data members. 1061 if (!(IsConstant || VD->isStaticDataMember()) && !DVar.RefExpr && 1062 DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared) { 1063 Diag(ELoc, diag::err_omp_wrong_dsa) 1064 << getOpenMPClauseName(DVar.CKind) 1065 << getOpenMPClauseName(OMPC_firstprivate); 1066 Diag(VD->getLocation(), diag::note_omp_predetermined_dsa) 1067 << getOpenMPClauseName(DVar.CKind); 1068 continue; 1069 } 1070 1071 // OpenMP [2.9.3.4, Restrictions, p.2] 1072 // A list item that is private within a parallel region must not appear 1073 // in a firstprivate clause on a worksharing construct if any of the 1074 // worksharing regions arising from the worksharing construct ever bind 1075 // to any of the parallel regions arising from the parallel construct. 1076 // OpenMP [2.9.3.4, Restrictions, p.3] 1077 // A list item that appears in a reduction clause of a parallel construct 1078 // must not appear in a firstprivate clause on a worksharing or task 1079 // construct if any of the worksharing or task regions arising from the 1080 // worksharing or task construct ever bind to any of the parallel regions 1081 // arising from the parallel construct. 1082 // OpenMP [2.9.3.4, Restrictions, p.4] 1083 // A list item that appears in a reduction clause in worksharing 1084 // construct must not appear in a firstprivate clause in a task construct 1085 // encountered during execution of any of the worksharing regions arising 1086 // from the worksharing construct. 1087 // TODO: 1088 } 1089 1090 DSAStack->addDSA(VD, DE, OMPC_firstprivate); 1091 Vars.push_back(DE); 1092 } 1093 1094 if (Vars.empty()) return 0; 1095 1096 return OMPFirstprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, 1097 Vars); 1098} 1099 1100OMPClause *Sema::ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList, 1101 SourceLocation StartLoc, 1102 SourceLocation LParenLoc, 1103 SourceLocation EndLoc) { 1104 SmallVector<Expr *, 8> Vars; 1105 for (ArrayRef<Expr *>::iterator I = VarList.begin(), E = VarList.end(); 1106 I != E; ++I) { 1107 assert(*I && "NULL expr in OpenMP shared clause."); 1108 if (isa<DependentScopeDeclRefExpr>(*I)) { 1109 // It will be analyzed later. 1110 Vars.push_back(*I); 1111 continue; 1112 } 1113 1114 SourceLocation ELoc = (*I)->getExprLoc(); 1115 // OpenMP [2.1, C/C++] 1116 // A list item is a variable name. 1117 // OpenMP [2.9.3.4, Restrictions, p.1] 1118 // A variable that is part of another variable (as an array or 1119 // structure element) cannot appear in a private clause. 1120 DeclRefExpr *DE = dyn_cast<DeclRefExpr>(*I); 1121 if (!DE || !isa<VarDecl>(DE->getDecl())) { 1122 Diag(ELoc, diag::err_omp_expected_var_name) 1123 << (*I)->getSourceRange(); 1124 continue; 1125 } 1126 Decl *D = DE->getDecl(); 1127 VarDecl *VD = cast<VarDecl>(D); 1128 1129 QualType Type = VD->getType(); 1130 if (Type->isDependentType() || Type->isInstantiationDependentType()) { 1131 // It will be analyzed later. 1132 Vars.push_back(DE); 1133 continue; 1134 } 1135 1136 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 1137 // in a Construct] 1138 // Variables with the predetermined data-sharing attributes may not be 1139 // listed in data-sharing attributes clauses, except for the cases 1140 // listed below. For these exceptions only, listing a predetermined 1141 // variable in a data-sharing attribute clause is allowed and overrides 1142 // the variable's predetermined data-sharing attributes. 1143 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(VD); 1144 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared && DVar.RefExpr) { 1145 Diag(ELoc, diag::err_omp_wrong_dsa) 1146 << getOpenMPClauseName(DVar.CKind) 1147 << getOpenMPClauseName(OMPC_shared); 1148 Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa) 1149 << getOpenMPClauseName(DVar.CKind); 1150 continue; 1151 } 1152 1153 DSAStack->addDSA(VD, DE, OMPC_shared); 1154 Vars.push_back(DE); 1155 } 1156 1157 if (Vars.empty()) return 0; 1158 1159 return OMPSharedClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars); 1160} 1161 1162#undef DSAStack 1163