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 "TreeTransform.h" 16 #include "clang/AST/ASTContext.h" 17 #include "clang/AST/ASTMutationListener.h" 18 #include "clang/AST/CXXInheritance.h" 19 #include "clang/AST/Decl.h" 20 #include "clang/AST/DeclCXX.h" 21 #include "clang/AST/DeclOpenMP.h" 22 #include "clang/AST/StmtCXX.h" 23 #include "clang/AST/StmtOpenMP.h" 24 #include "clang/AST/StmtVisitor.h" 25 #include "clang/AST/TypeOrdering.h" 26 #include "clang/Basic/OpenMPKinds.h" 27 #include "clang/Basic/TargetInfo.h" 28 #include "clang/Lex/Preprocessor.h" 29 #include "clang/Sema/Initialization.h" 30 #include "clang/Sema/Lookup.h" 31 #include "clang/Sema/Scope.h" 32 #include "clang/Sema/ScopeInfo.h" 33 #include "clang/Sema/SemaInternal.h" 34 using namespace clang; 35 36 //===----------------------------------------------------------------------===// 37 // Stack of data-sharing attributes for variables 38 //===----------------------------------------------------------------------===// 39 40 namespace { 41 /// \brief Default data sharing attributes, which can be applied to directive. 42 enum DefaultDataSharingAttributes { 43 DSA_unspecified = 0, /// \brief Data sharing attribute not specified. 44 DSA_none = 1 << 0, /// \brief Default data sharing attribute 'none'. 45 DSA_shared = 1 << 1 /// \brief Default data sharing attribute 'shared'. 46 }; 47 48 /// \brief Stack for tracking declarations used in OpenMP directives and 49 /// clauses and their data-sharing attributes. 50 class DSAStackTy final { 51 public: 52 struct DSAVarData final { 53 OpenMPDirectiveKind DKind = OMPD_unknown; 54 OpenMPClauseKind CKind = OMPC_unknown; 55 Expr *RefExpr = nullptr; 56 DeclRefExpr *PrivateCopy = nullptr; 57 SourceLocation ImplicitDSALoc; 58 DSAVarData() {} 59 }; 60 typedef llvm::SmallVector<std::pair<Expr *, OverloadedOperatorKind>, 4> 61 OperatorOffsetTy; 62 63 private: 64 struct DSAInfo final { 65 OpenMPClauseKind Attributes = OMPC_unknown; 66 /// Pointer to a reference expression and a flag which shows that the 67 /// variable is marked as lastprivate(true) or not (false). 68 llvm::PointerIntPair<Expr *, 1, bool> RefExpr; 69 DeclRefExpr *PrivateCopy = nullptr; 70 }; 71 typedef llvm::DenseMap<ValueDecl *, DSAInfo> DeclSAMapTy; 72 typedef llvm::DenseMap<ValueDecl *, Expr *> AlignedMapTy; 73 typedef std::pair<unsigned, VarDecl *> LCDeclInfo; 74 typedef llvm::DenseMap<ValueDecl *, LCDeclInfo> LoopControlVariablesMapTy; 75 typedef llvm::DenseMap< 76 ValueDecl *, OMPClauseMappableExprCommon::MappableExprComponentLists> 77 MappedExprComponentsTy; 78 typedef llvm::StringMap<std::pair<OMPCriticalDirective *, llvm::APSInt>> 79 CriticalsWithHintsTy; 80 typedef llvm::DenseMap<OMPDependClause *, OperatorOffsetTy> 81 DoacrossDependMapTy; 82 83 struct SharingMapTy final { 84 DeclSAMapTy SharingMap; 85 AlignedMapTy AlignedMap; 86 MappedExprComponentsTy MappedExprComponents; 87 LoopControlVariablesMapTy LCVMap; 88 DefaultDataSharingAttributes DefaultAttr = DSA_unspecified; 89 SourceLocation DefaultAttrLoc; 90 OpenMPDirectiveKind Directive = OMPD_unknown; 91 DeclarationNameInfo DirectiveName; 92 Scope *CurScope = nullptr; 93 SourceLocation ConstructLoc; 94 /// Set of 'depend' clauses with 'sink|source' dependence kind. Required to 95 /// get the data (loop counters etc.) about enclosing loop-based construct. 96 /// This data is required during codegen. 97 DoacrossDependMapTy DoacrossDepends; 98 /// \brief first argument (Expr *) contains optional argument of the 99 /// 'ordered' clause, the second one is true if the regions has 'ordered' 100 /// clause, false otherwise. 101 llvm::PointerIntPair<Expr *, 1, bool> OrderedRegion; 102 bool NowaitRegion = false; 103 bool CancelRegion = false; 104 unsigned AssociatedLoops = 1; 105 SourceLocation InnerTeamsRegionLoc; 106 SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name, 107 Scope *CurScope, SourceLocation Loc) 108 : Directive(DKind), DirectiveName(Name), CurScope(CurScope), 109 ConstructLoc(Loc) {} 110 SharingMapTy() {} 111 }; 112 113 typedef SmallVector<SharingMapTy, 4> StackTy; 114 115 /// \brief Stack of used declaration and their data-sharing attributes. 116 StackTy Stack; 117 /// \brief true, if check for DSA must be from parent directive, false, if 118 /// from current directive. 119 OpenMPClauseKind ClauseKindMode = OMPC_unknown; 120 Sema &SemaRef; 121 bool ForceCapturing = false; 122 CriticalsWithHintsTy Criticals; 123 124 typedef SmallVector<SharingMapTy, 8>::reverse_iterator reverse_iterator; 125 126 DSAVarData getDSA(StackTy::reverse_iterator& Iter, ValueDecl *D); 127 128 /// \brief Checks if the variable is a local for OpenMP region. 129 bool isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter); 130 131 public: 132 explicit DSAStackTy(Sema &S) : Stack(1), SemaRef(S) {} 133 134 bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; } 135 void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; } 136 137 bool isForceVarCapturing() const { return ForceCapturing; } 138 void setForceVarCapturing(bool V) { ForceCapturing = V; } 139 140 void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName, 141 Scope *CurScope, SourceLocation Loc) { 142 Stack.push_back(SharingMapTy(DKind, DirName, CurScope, Loc)); 143 Stack.back().DefaultAttrLoc = Loc; 144 } 145 146 void pop() { 147 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty!"); 148 Stack.pop_back(); 149 } 150 151 void addCriticalWithHint(OMPCriticalDirective *D, llvm::APSInt Hint) { 152 Criticals[D->getDirectiveName().getAsString()] = std::make_pair(D, Hint); 153 } 154 const std::pair<OMPCriticalDirective *, llvm::APSInt> 155 getCriticalWithHint(const DeclarationNameInfo &Name) const { 156 auto I = Criticals.find(Name.getAsString()); 157 if (I != Criticals.end()) 158 return I->second; 159 return std::make_pair(nullptr, llvm::APSInt()); 160 } 161 /// \brief If 'aligned' declaration for given variable \a D was not seen yet, 162 /// add it and return NULL; otherwise return previous occurrence's expression 163 /// for diagnostics. 164 Expr *addUniqueAligned(ValueDecl *D, Expr *NewDE); 165 166 /// \brief Register specified variable as loop control variable. 167 void addLoopControlVariable(ValueDecl *D, VarDecl *Capture); 168 /// \brief Check if the specified variable is a loop control variable for 169 /// current region. 170 /// \return The index of the loop control variable in the list of associated 171 /// for-loops (from outer to inner). 172 LCDeclInfo isLoopControlVariable(ValueDecl *D); 173 /// \brief Check if the specified variable is a loop control variable for 174 /// parent region. 175 /// \return The index of the loop control variable in the list of associated 176 /// for-loops (from outer to inner). 177 LCDeclInfo isParentLoopControlVariable(ValueDecl *D); 178 /// \brief Get the loop control variable for the I-th loop (or nullptr) in 179 /// parent directive. 180 ValueDecl *getParentLoopControlVariable(unsigned I); 181 182 /// \brief Adds explicit data sharing attribute to the specified declaration. 183 void addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A, 184 DeclRefExpr *PrivateCopy = nullptr); 185 186 /// \brief Returns data sharing attributes from top of the stack for the 187 /// specified declaration. 188 DSAVarData getTopDSA(ValueDecl *D, bool FromParent); 189 /// \brief Returns data-sharing attributes for the specified declaration. 190 DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent); 191 /// \brief Checks if the specified variables has data-sharing attributes which 192 /// match specified \a CPred predicate in any directive which matches \a DPred 193 /// predicate. 194 DSAVarData hasDSA(ValueDecl *D, 195 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, 196 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred, 197 bool FromParent); 198 /// \brief Checks if the specified variables has data-sharing attributes which 199 /// match specified \a CPred predicate in any innermost directive which 200 /// matches \a DPred predicate. 201 DSAVarData 202 hasInnermostDSA(ValueDecl *D, 203 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, 204 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred, 205 bool FromParent); 206 /// \brief Checks if the specified variables has explicit data-sharing 207 /// attributes which match specified \a CPred predicate at the specified 208 /// OpenMP region. 209 bool hasExplicitDSA(ValueDecl *D, 210 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, 211 unsigned Level, bool NotLastprivate = false); 212 213 /// \brief Returns true if the directive at level \Level matches in the 214 /// specified \a DPred predicate. 215 bool hasExplicitDirective( 216 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred, 217 unsigned Level); 218 219 /// \brief Finds a directive which matches specified \a DPred predicate. 220 bool hasDirective(const llvm::function_ref<bool(OpenMPDirectiveKind, 221 const DeclarationNameInfo &, 222 SourceLocation)> &DPred, 223 bool FromParent); 224 225 /// \brief Returns currently analyzed directive. 226 OpenMPDirectiveKind getCurrentDirective() const { 227 return Stack.back().Directive; 228 } 229 /// \brief Returns parent directive. 230 OpenMPDirectiveKind getParentDirective() const { 231 if (Stack.size() > 2) 232 return Stack[Stack.size() - 2].Directive; 233 return OMPD_unknown; 234 } 235 236 /// \brief Set default data sharing attribute to none. 237 void setDefaultDSANone(SourceLocation Loc) { 238 Stack.back().DefaultAttr = DSA_none; 239 Stack.back().DefaultAttrLoc = Loc; 240 } 241 /// \brief Set default data sharing attribute to shared. 242 void setDefaultDSAShared(SourceLocation Loc) { 243 Stack.back().DefaultAttr = DSA_shared; 244 Stack.back().DefaultAttrLoc = Loc; 245 } 246 247 DefaultDataSharingAttributes getDefaultDSA() const { 248 return Stack.back().DefaultAttr; 249 } 250 SourceLocation getDefaultDSALocation() const { 251 return Stack.back().DefaultAttrLoc; 252 } 253 254 /// \brief Checks if the specified variable is a threadprivate. 255 bool isThreadPrivate(VarDecl *D) { 256 DSAVarData DVar = getTopDSA(D, false); 257 return isOpenMPThreadPrivate(DVar.CKind); 258 } 259 260 /// \brief Marks current region as ordered (it has an 'ordered' clause). 261 void setOrderedRegion(bool IsOrdered, Expr *Param) { 262 Stack.back().OrderedRegion.setInt(IsOrdered); 263 Stack.back().OrderedRegion.setPointer(Param); 264 } 265 /// \brief Returns true, if parent region is ordered (has associated 266 /// 'ordered' clause), false - otherwise. 267 bool isParentOrderedRegion() const { 268 if (Stack.size() > 2) 269 return Stack[Stack.size() - 2].OrderedRegion.getInt(); 270 return false; 271 } 272 /// \brief Returns optional parameter for the ordered region. 273 Expr *getParentOrderedRegionParam() const { 274 if (Stack.size() > 2) 275 return Stack[Stack.size() - 2].OrderedRegion.getPointer(); 276 return nullptr; 277 } 278 /// \brief Marks current region as nowait (it has a 'nowait' clause). 279 void setNowaitRegion(bool IsNowait = true) { 280 Stack.back().NowaitRegion = IsNowait; 281 } 282 /// \brief Returns true, if parent region is nowait (has associated 283 /// 'nowait' clause), false - otherwise. 284 bool isParentNowaitRegion() const { 285 if (Stack.size() > 2) 286 return Stack[Stack.size() - 2].NowaitRegion; 287 return false; 288 } 289 /// \brief Marks parent region as cancel region. 290 void setParentCancelRegion(bool Cancel = true) { 291 if (Stack.size() > 2) 292 Stack[Stack.size() - 2].CancelRegion = 293 Stack[Stack.size() - 2].CancelRegion || Cancel; 294 } 295 /// \brief Return true if current region has inner cancel construct. 296 bool isCancelRegion() const { 297 return Stack.back().CancelRegion; 298 } 299 300 /// \brief Set collapse value for the region. 301 void setAssociatedLoops(unsigned Val) { Stack.back().AssociatedLoops = Val; } 302 /// \brief Return collapse value for region. 303 unsigned getAssociatedLoops() const { return Stack.back().AssociatedLoops; } 304 305 /// \brief Marks current target region as one with closely nested teams 306 /// region. 307 void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) { 308 if (Stack.size() > 2) 309 Stack[Stack.size() - 2].InnerTeamsRegionLoc = TeamsRegionLoc; 310 } 311 /// \brief Returns true, if current region has closely nested teams region. 312 bool hasInnerTeamsRegion() const { 313 return getInnerTeamsRegionLoc().isValid(); 314 } 315 /// \brief Returns location of the nested teams region (if any). 316 SourceLocation getInnerTeamsRegionLoc() const { 317 if (Stack.size() > 1) 318 return Stack.back().InnerTeamsRegionLoc; 319 return SourceLocation(); 320 } 321 322 Scope *getCurScope() const { return Stack.back().CurScope; } 323 Scope *getCurScope() { return Stack.back().CurScope; } 324 SourceLocation getConstructLoc() { return Stack.back().ConstructLoc; } 325 326 // Do the check specified in \a Check to all component lists and return true 327 // if any issue is found. 328 bool checkMappableExprComponentListsForDecl( 329 ValueDecl *VD, bool CurrentRegionOnly, 330 const llvm::function_ref<bool( 331 OMPClauseMappableExprCommon::MappableExprComponentListRef)> &Check) { 332 auto SI = Stack.rbegin(); 333 auto SE = Stack.rend(); 334 335 if (SI == SE) 336 return false; 337 338 if (CurrentRegionOnly) { 339 SE = std::next(SI); 340 } else { 341 ++SI; 342 } 343 344 for (; SI != SE; ++SI) { 345 auto MI = SI->MappedExprComponents.find(VD); 346 if (MI != SI->MappedExprComponents.end()) 347 for (auto &L : MI->second) 348 if (Check(L)) 349 return true; 350 } 351 return false; 352 } 353 354 // Create a new mappable expression component list associated with a given 355 // declaration and initialize it with the provided list of components. 356 void addMappableExpressionComponents( 357 ValueDecl *VD, 358 OMPClauseMappableExprCommon::MappableExprComponentListRef Components) { 359 assert(Stack.size() > 1 && 360 "Not expecting to retrieve components from a empty stack!"); 361 auto &MEC = Stack.back().MappedExprComponents[VD]; 362 // Create new entry and append the new components there. 363 MEC.resize(MEC.size() + 1); 364 MEC.back().append(Components.begin(), Components.end()); 365 } 366 367 unsigned getNestingLevel() const { 368 assert(Stack.size() > 1); 369 return Stack.size() - 2; 370 } 371 void addDoacrossDependClause(OMPDependClause *C, OperatorOffsetTy &OpsOffs) { 372 assert(Stack.size() > 2); 373 assert(isOpenMPWorksharingDirective(Stack[Stack.size() - 2].Directive)); 374 Stack[Stack.size() - 2].DoacrossDepends.insert({C, OpsOffs}); 375 } 376 llvm::iterator_range<DoacrossDependMapTy::const_iterator> 377 getDoacrossDependClauses() const { 378 assert(Stack.size() > 1); 379 if (isOpenMPWorksharingDirective(Stack[Stack.size() - 1].Directive)) { 380 auto &Ref = Stack[Stack.size() - 1].DoacrossDepends; 381 return llvm::make_range(Ref.begin(), Ref.end()); 382 } 383 return llvm::make_range(Stack[0].DoacrossDepends.end(), 384 Stack[0].DoacrossDepends.end()); 385 } 386 }; 387 bool isParallelOrTaskRegion(OpenMPDirectiveKind DKind) { 388 return isOpenMPParallelDirective(DKind) || isOpenMPTaskingDirective(DKind) || 389 isOpenMPTeamsDirective(DKind) || DKind == OMPD_unknown; 390 } 391 } // namespace 392 393 static ValueDecl *getCanonicalDecl(ValueDecl *D) { 394 auto *VD = dyn_cast<VarDecl>(D); 395 auto *FD = dyn_cast<FieldDecl>(D); 396 if (VD != nullptr) { 397 VD = VD->getCanonicalDecl(); 398 D = VD; 399 } else { 400 assert(FD); 401 FD = FD->getCanonicalDecl(); 402 D = FD; 403 } 404 return D; 405 } 406 407 DSAStackTy::DSAVarData DSAStackTy::getDSA(StackTy::reverse_iterator& Iter, 408 ValueDecl *D) { 409 D = getCanonicalDecl(D); 410 auto *VD = dyn_cast<VarDecl>(D); 411 auto *FD = dyn_cast<FieldDecl>(D); 412 DSAVarData DVar; 413 if (Iter == std::prev(Stack.rend())) { 414 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 415 // in a region but not in construct] 416 // File-scope or namespace-scope variables referenced in called routines 417 // in the region are shared unless they appear in a threadprivate 418 // directive. 419 if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(D)) 420 DVar.CKind = OMPC_shared; 421 422 // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced 423 // in a region but not in construct] 424 // Variables with static storage duration that are declared in called 425 // routines in the region are shared. 426 if (VD && VD->hasGlobalStorage()) 427 DVar.CKind = OMPC_shared; 428 429 // Non-static data members are shared by default. 430 if (FD) 431 DVar.CKind = OMPC_shared; 432 433 return DVar; 434 } 435 436 DVar.DKind = Iter->Directive; 437 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 438 // in a Construct, C/C++, predetermined, p.1] 439 // Variables with automatic storage duration that are declared in a scope 440 // inside the construct are private. 441 if (VD && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() && 442 (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) { 443 DVar.CKind = OMPC_private; 444 return DVar; 445 } 446 447 // Explicitly specified attributes and local variables with predetermined 448 // attributes. 449 if (Iter->SharingMap.count(D)) { 450 DVar.RefExpr = Iter->SharingMap[D].RefExpr.getPointer(); 451 DVar.PrivateCopy = Iter->SharingMap[D].PrivateCopy; 452 DVar.CKind = Iter->SharingMap[D].Attributes; 453 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc; 454 return DVar; 455 } 456 457 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 458 // in a Construct, C/C++, implicitly determined, p.1] 459 // In a parallel or task construct, the data-sharing attributes of these 460 // variables are determined by the default clause, if present. 461 switch (Iter->DefaultAttr) { 462 case DSA_shared: 463 DVar.CKind = OMPC_shared; 464 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc; 465 return DVar; 466 case DSA_none: 467 return DVar; 468 case DSA_unspecified: 469 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 470 // in a Construct, implicitly determined, p.2] 471 // In a parallel construct, if no default clause is present, these 472 // variables are shared. 473 DVar.ImplicitDSALoc = Iter->DefaultAttrLoc; 474 if (isOpenMPParallelDirective(DVar.DKind) || 475 isOpenMPTeamsDirective(DVar.DKind)) { 476 DVar.CKind = OMPC_shared; 477 return DVar; 478 } 479 480 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 481 // in a Construct, implicitly determined, p.4] 482 // In a task construct, if no default clause is present, a variable that in 483 // the enclosing context is determined to be shared by all implicit tasks 484 // bound to the current team is shared. 485 if (isOpenMPTaskingDirective(DVar.DKind)) { 486 DSAVarData DVarTemp; 487 for (StackTy::reverse_iterator I = std::next(Iter), EE = Stack.rend(); 488 I != EE; ++I) { 489 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables 490 // Referenced in a Construct, implicitly determined, p.6] 491 // In a task construct, if no default clause is present, a variable 492 // whose data-sharing attribute is not determined by the rules above is 493 // firstprivate. 494 DVarTemp = getDSA(I, D); 495 if (DVarTemp.CKind != OMPC_shared) { 496 DVar.RefExpr = nullptr; 497 DVar.CKind = OMPC_firstprivate; 498 return DVar; 499 } 500 if (isParallelOrTaskRegion(I->Directive)) 501 break; 502 } 503 DVar.CKind = 504 (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared; 505 return DVar; 506 } 507 } 508 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 509 // in a Construct, implicitly determined, p.3] 510 // For constructs other than task, if no default clause is present, these 511 // variables inherit their data-sharing attributes from the enclosing 512 // context. 513 return getDSA(++Iter, D); 514 } 515 516 Expr *DSAStackTy::addUniqueAligned(ValueDecl *D, Expr *NewDE) { 517 assert(Stack.size() > 1 && "Data sharing attributes stack is empty"); 518 D = getCanonicalDecl(D); 519 auto It = Stack.back().AlignedMap.find(D); 520 if (It == Stack.back().AlignedMap.end()) { 521 assert(NewDE && "Unexpected nullptr expr to be added into aligned map"); 522 Stack.back().AlignedMap[D] = NewDE; 523 return nullptr; 524 } else { 525 assert(It->second && "Unexpected nullptr expr in the aligned map"); 526 return It->second; 527 } 528 return nullptr; 529 } 530 531 void DSAStackTy::addLoopControlVariable(ValueDecl *D, VarDecl *Capture) { 532 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty"); 533 D = getCanonicalDecl(D); 534 Stack.back().LCVMap.insert( 535 std::make_pair(D, LCDeclInfo(Stack.back().LCVMap.size() + 1, Capture))); 536 } 537 538 DSAStackTy::LCDeclInfo DSAStackTy::isLoopControlVariable(ValueDecl *D) { 539 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty"); 540 D = getCanonicalDecl(D); 541 return Stack.back().LCVMap.count(D) > 0 ? Stack.back().LCVMap[D] 542 : LCDeclInfo(0, nullptr); 543 } 544 545 DSAStackTy::LCDeclInfo DSAStackTy::isParentLoopControlVariable(ValueDecl *D) { 546 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty"); 547 D = getCanonicalDecl(D); 548 return Stack[Stack.size() - 2].LCVMap.count(D) > 0 549 ? Stack[Stack.size() - 2].LCVMap[D] 550 : LCDeclInfo(0, nullptr); 551 } 552 553 ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) { 554 assert(Stack.size() > 2 && "Data-sharing attributes stack is empty"); 555 if (Stack[Stack.size() - 2].LCVMap.size() < I) 556 return nullptr; 557 for (auto &Pair : Stack[Stack.size() - 2].LCVMap) { 558 if (Pair.second.first == I) 559 return Pair.first; 560 } 561 return nullptr; 562 } 563 564 void DSAStackTy::addDSA(ValueDecl *D, Expr *E, OpenMPClauseKind A, 565 DeclRefExpr *PrivateCopy) { 566 D = getCanonicalDecl(D); 567 if (A == OMPC_threadprivate) { 568 auto &Data = Stack[0].SharingMap[D]; 569 Data.Attributes = A; 570 Data.RefExpr.setPointer(E); 571 Data.PrivateCopy = nullptr; 572 } else { 573 assert(Stack.size() > 1 && "Data-sharing attributes stack is empty"); 574 auto &Data = Stack.back().SharingMap[D]; 575 assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) || 576 (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) || 577 (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) || 578 (isLoopControlVariable(D).first && A == OMPC_private)); 579 if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) { 580 Data.RefExpr.setInt(/*IntVal=*/true); 581 return; 582 } 583 const bool IsLastprivate = 584 A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate; 585 Data.Attributes = A; 586 Data.RefExpr.setPointerAndInt(E, IsLastprivate); 587 Data.PrivateCopy = PrivateCopy; 588 if (PrivateCopy) { 589 auto &Data = Stack.back().SharingMap[PrivateCopy->getDecl()]; 590 Data.Attributes = A; 591 Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate); 592 Data.PrivateCopy = nullptr; 593 } 594 } 595 } 596 597 bool DSAStackTy::isOpenMPLocal(VarDecl *D, StackTy::reverse_iterator Iter) { 598 D = D->getCanonicalDecl(); 599 if (Stack.size() > 2) { 600 reverse_iterator I = Iter, E = std::prev(Stack.rend()); 601 Scope *TopScope = nullptr; 602 while (I != E && !isParallelOrTaskRegion(I->Directive)) { 603 ++I; 604 } 605 if (I == E) 606 return false; 607 TopScope = I->CurScope ? I->CurScope->getParent() : nullptr; 608 Scope *CurScope = getCurScope(); 609 while (CurScope != TopScope && !CurScope->isDeclScope(D)) { 610 CurScope = CurScope->getParent(); 611 } 612 return CurScope != TopScope; 613 } 614 return false; 615 } 616 617 /// \brief Build a variable declaration for OpenMP loop iteration variable. 618 static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type, 619 StringRef Name, const AttrVec *Attrs = nullptr) { 620 DeclContext *DC = SemaRef.CurContext; 621 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name); 622 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc); 623 VarDecl *Decl = 624 VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None); 625 if (Attrs) { 626 for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end()); 627 I != E; ++I) 628 Decl->addAttr(*I); 629 } 630 Decl->setImplicit(); 631 return Decl; 632 } 633 634 static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty, 635 SourceLocation Loc, 636 bool RefersToCapture = false) { 637 D->setReferenced(); 638 D->markUsed(S.Context); 639 return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(), 640 SourceLocation(), D, RefersToCapture, Loc, Ty, 641 VK_LValue); 642 } 643 644 DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D, bool FromParent) { 645 D = getCanonicalDecl(D); 646 DSAVarData DVar; 647 648 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 649 // in a Construct, C/C++, predetermined, p.1] 650 // Variables appearing in threadprivate directives are threadprivate. 651 auto *VD = dyn_cast<VarDecl>(D); 652 if ((VD && VD->getTLSKind() != VarDecl::TLS_None && 653 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() && 654 SemaRef.getLangOpts().OpenMPUseTLS && 655 SemaRef.getASTContext().getTargetInfo().isTLSSupported())) || 656 (VD && VD->getStorageClass() == SC_Register && 657 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) { 658 addDSA(D, buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(), 659 D->getLocation()), 660 OMPC_threadprivate); 661 } 662 if (Stack[0].SharingMap.count(D)) { 663 DVar.RefExpr = Stack[0].SharingMap[D].RefExpr.getPointer(); 664 DVar.CKind = OMPC_threadprivate; 665 return DVar; 666 } 667 668 if (Stack.size() == 1) { 669 // Not in OpenMP execution region and top scope was already checked. 670 return DVar; 671 } 672 673 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 674 // in a Construct, C/C++, predetermined, p.4] 675 // Static data members are shared. 676 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 677 // in a Construct, C/C++, predetermined, p.7] 678 // Variables with static storage duration that are declared in a scope 679 // inside the construct are shared. 680 auto &&MatchesAlways = [](OpenMPDirectiveKind) -> bool { return true; }; 681 if (VD && VD->isStaticDataMember()) { 682 DSAVarData DVarTemp = hasDSA(D, isOpenMPPrivate, MatchesAlways, FromParent); 683 if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr) 684 return DVar; 685 686 DVar.CKind = OMPC_shared; 687 return DVar; 688 } 689 690 QualType Type = D->getType().getNonReferenceType().getCanonicalType(); 691 bool IsConstant = Type.isConstant(SemaRef.getASTContext()); 692 Type = SemaRef.getASTContext().getBaseElementType(Type); 693 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 694 // in a Construct, C/C++, predetermined, p.6] 695 // Variables with const qualified type having no mutable member are 696 // shared. 697 CXXRecordDecl *RD = 698 SemaRef.getLangOpts().CPlusPlus ? Type->getAsCXXRecordDecl() : nullptr; 699 if (auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD)) 700 if (auto *CTD = CTSD->getSpecializedTemplate()) 701 RD = CTD->getTemplatedDecl(); 702 if (IsConstant && 703 !(SemaRef.getLangOpts().CPlusPlus && RD && RD->hasDefinition() && 704 RD->hasMutableFields())) { 705 // Variables with const-qualified type having no mutable member may be 706 // listed in a firstprivate clause, even if they are static data members. 707 DSAVarData DVarTemp = hasDSA( 708 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_firstprivate; }, 709 MatchesAlways, FromParent); 710 if (DVarTemp.CKind == OMPC_firstprivate && DVarTemp.RefExpr) 711 return DVar; 712 713 DVar.CKind = OMPC_shared; 714 return DVar; 715 } 716 717 // Explicitly specified attributes and local variables with predetermined 718 // attributes. 719 auto StartI = std::next(Stack.rbegin()); 720 auto EndI = std::prev(Stack.rend()); 721 if (FromParent && StartI != EndI) { 722 StartI = std::next(StartI); 723 } 724 auto I = std::prev(StartI); 725 if (I->SharingMap.count(D)) { 726 DVar.RefExpr = I->SharingMap[D].RefExpr.getPointer(); 727 DVar.PrivateCopy = I->SharingMap[D].PrivateCopy; 728 DVar.CKind = I->SharingMap[D].Attributes; 729 DVar.ImplicitDSALoc = I->DefaultAttrLoc; 730 } 731 732 return DVar; 733 } 734 735 DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D, 736 bool FromParent) { 737 D = getCanonicalDecl(D); 738 auto StartI = Stack.rbegin(); 739 auto EndI = std::prev(Stack.rend()); 740 if (FromParent && StartI != EndI) { 741 StartI = std::next(StartI); 742 } 743 return getDSA(StartI, D); 744 } 745 746 DSAStackTy::DSAVarData 747 DSAStackTy::hasDSA(ValueDecl *D, 748 const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, 749 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred, 750 bool FromParent) { 751 D = getCanonicalDecl(D); 752 auto StartI = std::next(Stack.rbegin()); 753 auto EndI = Stack.rend(); 754 if (FromParent && StartI != EndI) { 755 StartI = std::next(StartI); 756 } 757 for (auto I = StartI, EE = EndI; I != EE; ++I) { 758 if (!DPred(I->Directive) && !isParallelOrTaskRegion(I->Directive)) 759 continue; 760 DSAVarData DVar = getDSA(I, D); 761 if (CPred(DVar.CKind)) 762 return DVar; 763 } 764 return DSAVarData(); 765 } 766 767 DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA( 768 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, 769 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred, 770 bool FromParent) { 771 D = getCanonicalDecl(D); 772 auto StartI = std::next(Stack.rbegin()); 773 auto EndI = Stack.rend(); 774 if (FromParent && StartI != EndI) { 775 StartI = std::next(StartI); 776 } 777 for (auto I = StartI, EE = EndI; I != EE; ++I) { 778 if (!DPred(I->Directive)) 779 break; 780 DSAVarData DVar = getDSA(I, D); 781 if (CPred(DVar.CKind)) 782 return DVar; 783 return DSAVarData(); 784 } 785 return DSAVarData(); 786 } 787 788 bool DSAStackTy::hasExplicitDSA( 789 ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind)> &CPred, 790 unsigned Level, bool NotLastprivate) { 791 if (CPred(ClauseKindMode)) 792 return true; 793 D = getCanonicalDecl(D); 794 auto StartI = std::next(Stack.begin()); 795 auto EndI = Stack.end(); 796 if (std::distance(StartI, EndI) <= (int)Level) 797 return false; 798 std::advance(StartI, Level); 799 return (StartI->SharingMap.count(D) > 0) && 800 StartI->SharingMap[D].RefExpr.getPointer() && 801 CPred(StartI->SharingMap[D].Attributes) && 802 (!NotLastprivate || !StartI->SharingMap[D].RefExpr.getInt()); 803 } 804 805 bool DSAStackTy::hasExplicitDirective( 806 const llvm::function_ref<bool(OpenMPDirectiveKind)> &DPred, 807 unsigned Level) { 808 auto StartI = std::next(Stack.begin()); 809 auto EndI = Stack.end(); 810 if (std::distance(StartI, EndI) <= (int)Level) 811 return false; 812 std::advance(StartI, Level); 813 return DPred(StartI->Directive); 814 } 815 816 bool DSAStackTy::hasDirective( 817 const llvm::function_ref<bool(OpenMPDirectiveKind, 818 const DeclarationNameInfo &, SourceLocation)> 819 &DPred, 820 bool FromParent) { 821 // We look only in the enclosing region. 822 if (Stack.size() < 2) 823 return false; 824 auto StartI = std::next(Stack.rbegin()); 825 auto EndI = std::prev(Stack.rend()); 826 if (FromParent && StartI != EndI) { 827 StartI = std::next(StartI); 828 } 829 for (auto I = StartI, EE = EndI; I != EE; ++I) { 830 if (DPred(I->Directive, I->DirectiveName, I->ConstructLoc)) 831 return true; 832 } 833 return false; 834 } 835 836 void Sema::InitDataSharingAttributesStack() { 837 VarDataSharingAttributesStack = new DSAStackTy(*this); 838 } 839 840 #define DSAStack static_cast<DSAStackTy *>(VarDataSharingAttributesStack) 841 842 bool Sema::IsOpenMPCapturedByRef(ValueDecl *D, unsigned Level) { 843 assert(LangOpts.OpenMP && "OpenMP is not allowed"); 844 845 auto &Ctx = getASTContext(); 846 bool IsByRef = true; 847 848 // Find the directive that is associated with the provided scope. 849 auto Ty = D->getType(); 850 851 if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level)) { 852 // This table summarizes how a given variable should be passed to the device 853 // given its type and the clauses where it appears. This table is based on 854 // the description in OpenMP 4.5 [2.10.4, target Construct] and 855 // OpenMP 4.5 [2.15.5, Data-mapping Attribute Rules and Clauses]. 856 // 857 // ========================================================================= 858 // | type | defaultmap | pvt | first | is_device_ptr | map | res. | 859 // | |(tofrom:scalar)| | pvt | | | | 860 // ========================================================================= 861 // | scl | | | | - | | bycopy| 862 // | scl | | - | x | - | - | bycopy| 863 // | scl | | x | - | - | - | null | 864 // | scl | x | | | - | | byref | 865 // | scl | x | - | x | - | - | bycopy| 866 // | scl | x | x | - | - | - | null | 867 // | scl | | - | - | - | x | byref | 868 // | scl | x | - | - | - | x | byref | 869 // 870 // | agg | n.a. | | | - | | byref | 871 // | agg | n.a. | - | x | - | - | byref | 872 // | agg | n.a. | x | - | - | - | null | 873 // | agg | n.a. | - | - | - | x | byref | 874 // | agg | n.a. | - | - | - | x[] | byref | 875 // 876 // | ptr | n.a. | | | - | | bycopy| 877 // | ptr | n.a. | - | x | - | - | bycopy| 878 // | ptr | n.a. | x | - | - | - | null | 879 // | ptr | n.a. | - | - | - | x | byref | 880 // | ptr | n.a. | - | - | - | x[] | bycopy| 881 // | ptr | n.a. | - | - | x | | bycopy| 882 // | ptr | n.a. | - | - | x | x | bycopy| 883 // | ptr | n.a. | - | - | x | x[] | bycopy| 884 // ========================================================================= 885 // Legend: 886 // scl - scalar 887 // ptr - pointer 888 // agg - aggregate 889 // x - applies 890 // - - invalid in this combination 891 // [] - mapped with an array section 892 // byref - should be mapped by reference 893 // byval - should be mapped by value 894 // null - initialize a local variable to null on the device 895 // 896 // Observations: 897 // - All scalar declarations that show up in a map clause have to be passed 898 // by reference, because they may have been mapped in the enclosing data 899 // environment. 900 // - If the scalar value does not fit the size of uintptr, it has to be 901 // passed by reference, regardless the result in the table above. 902 // - For pointers mapped by value that have either an implicit map or an 903 // array section, the runtime library may pass the NULL value to the 904 // device instead of the value passed to it by the compiler. 905 906 907 if (Ty->isReferenceType()) 908 Ty = Ty->castAs<ReferenceType>()->getPointeeType(); 909 910 // Locate map clauses and see if the variable being captured is referred to 911 // in any of those clauses. Here we only care about variables, not fields, 912 // because fields are part of aggregates. 913 bool IsVariableUsedInMapClause = false; 914 bool IsVariableAssociatedWithSection = false; 915 916 DSAStack->checkMappableExprComponentListsForDecl( 917 D, /*CurrentRegionOnly=*/true, 918 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef 919 MapExprComponents) { 920 921 auto EI = MapExprComponents.rbegin(); 922 auto EE = MapExprComponents.rend(); 923 924 assert(EI != EE && "Invalid map expression!"); 925 926 if (isa<DeclRefExpr>(EI->getAssociatedExpression())) 927 IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D; 928 929 ++EI; 930 if (EI == EE) 931 return false; 932 933 if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) || 934 isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) || 935 isa<MemberExpr>(EI->getAssociatedExpression())) { 936 IsVariableAssociatedWithSection = true; 937 // There is nothing more we need to know about this variable. 938 return true; 939 } 940 941 // Keep looking for more map info. 942 return false; 943 }); 944 945 if (IsVariableUsedInMapClause) { 946 // If variable is identified in a map clause it is always captured by 947 // reference except if it is a pointer that is dereferenced somehow. 948 IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection); 949 } else { 950 // By default, all the data that has a scalar type is mapped by copy. 951 IsByRef = !Ty->isScalarType(); 952 } 953 } 954 955 if (IsByRef && Ty.getNonReferenceType()->isScalarType()) { 956 IsByRef = !DSAStack->hasExplicitDSA( 957 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_firstprivate; }, 958 Level, /*NotLastprivate=*/true); 959 } 960 961 // When passing data by copy, we need to make sure it fits the uintptr size 962 // and alignment, because the runtime library only deals with uintptr types. 963 // If it does not fit the uintptr size, we need to pass the data by reference 964 // instead. 965 if (!IsByRef && 966 (Ctx.getTypeSizeInChars(Ty) > 967 Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) || 968 Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) { 969 IsByRef = true; 970 } 971 972 return IsByRef; 973 } 974 975 unsigned Sema::getOpenMPNestingLevel() const { 976 assert(getLangOpts().OpenMP); 977 return DSAStack->getNestingLevel(); 978 } 979 980 VarDecl *Sema::IsOpenMPCapturedDecl(ValueDecl *D) { 981 assert(LangOpts.OpenMP && "OpenMP is not allowed"); 982 D = getCanonicalDecl(D); 983 984 // If we are attempting to capture a global variable in a directive with 985 // 'target' we return true so that this global is also mapped to the device. 986 // 987 // FIXME: If the declaration is enclosed in a 'declare target' directive, 988 // then it should not be captured. Therefore, an extra check has to be 989 // inserted here once support for 'declare target' is added. 990 // 991 auto *VD = dyn_cast<VarDecl>(D); 992 if (VD && !VD->hasLocalStorage()) { 993 if (DSAStack->getCurrentDirective() == OMPD_target && 994 !DSAStack->isClauseParsingMode()) 995 return VD; 996 if (DSAStack->hasDirective( 997 [](OpenMPDirectiveKind K, const DeclarationNameInfo &, 998 SourceLocation) -> bool { 999 return isOpenMPTargetExecutionDirective(K); 1000 }, 1001 false)) 1002 return VD; 1003 } 1004 1005 if (DSAStack->getCurrentDirective() != OMPD_unknown && 1006 (!DSAStack->isClauseParsingMode() || 1007 DSAStack->getParentDirective() != OMPD_unknown)) { 1008 auto &&Info = DSAStack->isLoopControlVariable(D); 1009 if (Info.first || 1010 (VD && VD->hasLocalStorage() && 1011 isParallelOrTaskRegion(DSAStack->getCurrentDirective())) || 1012 (VD && DSAStack->isForceVarCapturing())) 1013 return VD ? VD : Info.second; 1014 auto DVarPrivate = DSAStack->getTopDSA(D, DSAStack->isClauseParsingMode()); 1015 if (DVarPrivate.CKind != OMPC_unknown && isOpenMPPrivate(DVarPrivate.CKind)) 1016 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl()); 1017 DVarPrivate = DSAStack->hasDSA( 1018 D, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; }, 1019 DSAStack->isClauseParsingMode()); 1020 if (DVarPrivate.CKind != OMPC_unknown) 1021 return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl()); 1022 } 1023 return nullptr; 1024 } 1025 1026 bool Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level) { 1027 assert(LangOpts.OpenMP && "OpenMP is not allowed"); 1028 return DSAStack->hasExplicitDSA( 1029 D, [](OpenMPClauseKind K) -> bool { return K == OMPC_private; }, Level); 1030 } 1031 1032 bool Sema::isOpenMPTargetCapturedDecl(ValueDecl *D, unsigned Level) { 1033 assert(LangOpts.OpenMP && "OpenMP is not allowed"); 1034 // Return true if the current level is no longer enclosed in a target region. 1035 1036 auto *VD = dyn_cast<VarDecl>(D); 1037 return VD && !VD->hasLocalStorage() && 1038 DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective, 1039 Level); 1040 } 1041 1042 void Sema::DestroyDataSharingAttributesStack() { delete DSAStack; } 1043 1044 void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind, 1045 const DeclarationNameInfo &DirName, 1046 Scope *CurScope, SourceLocation Loc) { 1047 DSAStack->push(DKind, DirName, CurScope, Loc); 1048 PushExpressionEvaluationContext(PotentiallyEvaluated); 1049 } 1050 1051 void Sema::StartOpenMPClause(OpenMPClauseKind K) { 1052 DSAStack->setClauseParsingMode(K); 1053 } 1054 1055 void Sema::EndOpenMPClause() { 1056 DSAStack->setClauseParsingMode(/*K=*/OMPC_unknown); 1057 } 1058 1059 void Sema::EndOpenMPDSABlock(Stmt *CurDirective) { 1060 // OpenMP [2.14.3.5, Restrictions, C/C++, p.1] 1061 // A variable of class type (or array thereof) that appears in a lastprivate 1062 // clause requires an accessible, unambiguous default constructor for the 1063 // class type, unless the list item is also specified in a firstprivate 1064 // clause. 1065 if (auto D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) { 1066 for (auto *C : D->clauses()) { 1067 if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) { 1068 SmallVector<Expr *, 8> PrivateCopies; 1069 for (auto *DE : Clause->varlists()) { 1070 if (DE->isValueDependent() || DE->isTypeDependent()) { 1071 PrivateCopies.push_back(nullptr); 1072 continue; 1073 } 1074 auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens()); 1075 VarDecl *VD = cast<VarDecl>(DRE->getDecl()); 1076 QualType Type = VD->getType().getNonReferenceType(); 1077 auto DVar = DSAStack->getTopDSA(VD, false); 1078 if (DVar.CKind == OMPC_lastprivate) { 1079 // Generate helper private variable and initialize it with the 1080 // default value. The address of the original variable is replaced 1081 // by the address of the new private variable in CodeGen. This new 1082 // variable is not added to IdResolver, so the code in the OpenMP 1083 // region uses original variable for proper diagnostics. 1084 auto *VDPrivate = buildVarDecl( 1085 *this, DE->getExprLoc(), Type.getUnqualifiedType(), 1086 VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr); 1087 ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false); 1088 if (VDPrivate->isInvalidDecl()) 1089 continue; 1090 PrivateCopies.push_back(buildDeclRefExpr( 1091 *this, VDPrivate, DE->getType(), DE->getExprLoc())); 1092 } else { 1093 // The variable is also a firstprivate, so initialization sequence 1094 // for private copy is generated already. 1095 PrivateCopies.push_back(nullptr); 1096 } 1097 } 1098 // Set initializers to private copies if no errors were found. 1099 if (PrivateCopies.size() == Clause->varlist_size()) 1100 Clause->setPrivateCopies(PrivateCopies); 1101 } 1102 } 1103 } 1104 1105 DSAStack->pop(); 1106 DiscardCleanupsInEvaluationContext(); 1107 PopExpressionEvaluationContext(); 1108 } 1109 1110 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV, 1111 Expr *NumIterations, Sema &SemaRef, 1112 Scope *S, DSAStackTy *Stack); 1113 1114 namespace { 1115 1116 class VarDeclFilterCCC : public CorrectionCandidateCallback { 1117 private: 1118 Sema &SemaRef; 1119 1120 public: 1121 explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {} 1122 bool ValidateCandidate(const TypoCorrection &Candidate) override { 1123 NamedDecl *ND = Candidate.getCorrectionDecl(); 1124 if (VarDecl *VD = dyn_cast_or_null<VarDecl>(ND)) { 1125 return VD->hasGlobalStorage() && 1126 SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(), 1127 SemaRef.getCurScope()); 1128 } 1129 return false; 1130 } 1131 }; 1132 1133 class VarOrFuncDeclFilterCCC : public CorrectionCandidateCallback { 1134 private: 1135 Sema &SemaRef; 1136 1137 public: 1138 explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {} 1139 bool ValidateCandidate(const TypoCorrection &Candidate) override { 1140 NamedDecl *ND = Candidate.getCorrectionDecl(); 1141 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) { 1142 return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(), 1143 SemaRef.getCurScope()); 1144 } 1145 return false; 1146 } 1147 }; 1148 1149 } // namespace 1150 1151 ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope, 1152 CXXScopeSpec &ScopeSpec, 1153 const DeclarationNameInfo &Id) { 1154 LookupResult Lookup(*this, Id, LookupOrdinaryName); 1155 LookupParsedName(Lookup, CurScope, &ScopeSpec, true); 1156 1157 if (Lookup.isAmbiguous()) 1158 return ExprError(); 1159 1160 VarDecl *VD; 1161 if (!Lookup.isSingleResult()) { 1162 if (TypoCorrection Corrected = CorrectTypo( 1163 Id, LookupOrdinaryName, CurScope, nullptr, 1164 llvm::make_unique<VarDeclFilterCCC>(*this), CTK_ErrorRecovery)) { 1165 diagnoseTypo(Corrected, 1166 PDiag(Lookup.empty() 1167 ? diag::err_undeclared_var_use_suggest 1168 : diag::err_omp_expected_var_arg_suggest) 1169 << Id.getName()); 1170 VD = Corrected.getCorrectionDeclAs<VarDecl>(); 1171 } else { 1172 Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use 1173 : diag::err_omp_expected_var_arg) 1174 << Id.getName(); 1175 return ExprError(); 1176 } 1177 } else { 1178 if (!(VD = Lookup.getAsSingle<VarDecl>())) { 1179 Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName(); 1180 Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at); 1181 return ExprError(); 1182 } 1183 } 1184 Lookup.suppressDiagnostics(); 1185 1186 // OpenMP [2.9.2, Syntax, C/C++] 1187 // Variables must be file-scope, namespace-scope, or static block-scope. 1188 if (!VD->hasGlobalStorage()) { 1189 Diag(Id.getLoc(), diag::err_omp_global_var_arg) 1190 << getOpenMPDirectiveName(OMPD_threadprivate) << !VD->isStaticLocal(); 1191 bool IsDecl = 1192 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 1193 Diag(VD->getLocation(), 1194 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 1195 << VD; 1196 return ExprError(); 1197 } 1198 1199 VarDecl *CanonicalVD = VD->getCanonicalDecl(); 1200 NamedDecl *ND = cast<NamedDecl>(CanonicalVD); 1201 // OpenMP [2.9.2, Restrictions, C/C++, p.2] 1202 // A threadprivate directive for file-scope variables must appear outside 1203 // any definition or declaration. 1204 if (CanonicalVD->getDeclContext()->isTranslationUnit() && 1205 !getCurLexicalContext()->isTranslationUnit()) { 1206 Diag(Id.getLoc(), diag::err_omp_var_scope) 1207 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 1208 bool IsDecl = 1209 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 1210 Diag(VD->getLocation(), 1211 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 1212 << VD; 1213 return ExprError(); 1214 } 1215 // OpenMP [2.9.2, Restrictions, C/C++, p.3] 1216 // A threadprivate directive for static class member variables must appear 1217 // in the class definition, in the same scope in which the member 1218 // variables are declared. 1219 if (CanonicalVD->isStaticDataMember() && 1220 !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) { 1221 Diag(Id.getLoc(), diag::err_omp_var_scope) 1222 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 1223 bool IsDecl = 1224 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 1225 Diag(VD->getLocation(), 1226 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 1227 << VD; 1228 return ExprError(); 1229 } 1230 // OpenMP [2.9.2, Restrictions, C/C++, p.4] 1231 // A threadprivate directive for namespace-scope variables must appear 1232 // outside any definition or declaration other than the namespace 1233 // definition itself. 1234 if (CanonicalVD->getDeclContext()->isNamespace() && 1235 (!getCurLexicalContext()->isFileContext() || 1236 !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) { 1237 Diag(Id.getLoc(), diag::err_omp_var_scope) 1238 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 1239 bool IsDecl = 1240 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 1241 Diag(VD->getLocation(), 1242 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 1243 << VD; 1244 return ExprError(); 1245 } 1246 // OpenMP [2.9.2, Restrictions, C/C++, p.6] 1247 // A threadprivate directive for static block-scope variables must appear 1248 // in the scope of the variable and not in a nested scope. 1249 if (CanonicalVD->isStaticLocal() && CurScope && 1250 !isDeclInScope(ND, getCurLexicalContext(), CurScope)) { 1251 Diag(Id.getLoc(), diag::err_omp_var_scope) 1252 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 1253 bool IsDecl = 1254 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 1255 Diag(VD->getLocation(), 1256 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 1257 << VD; 1258 return ExprError(); 1259 } 1260 1261 // OpenMP [2.9.2, Restrictions, C/C++, p.2-6] 1262 // A threadprivate directive must lexically precede all references to any 1263 // of the variables in its list. 1264 if (VD->isUsed() && !DSAStack->isThreadPrivate(VD)) { 1265 Diag(Id.getLoc(), diag::err_omp_var_used) 1266 << getOpenMPDirectiveName(OMPD_threadprivate) << VD; 1267 return ExprError(); 1268 } 1269 1270 QualType ExprType = VD->getType().getNonReferenceType(); 1271 return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(), 1272 SourceLocation(), VD, 1273 /*RefersToEnclosingVariableOrCapture=*/false, 1274 Id.getLoc(), ExprType, VK_LValue); 1275 } 1276 1277 Sema::DeclGroupPtrTy 1278 Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc, 1279 ArrayRef<Expr *> VarList) { 1280 if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) { 1281 CurContext->addDecl(D); 1282 return DeclGroupPtrTy::make(DeclGroupRef(D)); 1283 } 1284 return nullptr; 1285 } 1286 1287 namespace { 1288 class LocalVarRefChecker : public ConstStmtVisitor<LocalVarRefChecker, bool> { 1289 Sema &SemaRef; 1290 1291 public: 1292 bool VisitDeclRefExpr(const DeclRefExpr *E) { 1293 if (auto VD = dyn_cast<VarDecl>(E->getDecl())) { 1294 if (VD->hasLocalStorage()) { 1295 SemaRef.Diag(E->getLocStart(), 1296 diag::err_omp_local_var_in_threadprivate_init) 1297 << E->getSourceRange(); 1298 SemaRef.Diag(VD->getLocation(), diag::note_defined_here) 1299 << VD << VD->getSourceRange(); 1300 return true; 1301 } 1302 } 1303 return false; 1304 } 1305 bool VisitStmt(const Stmt *S) { 1306 for (auto Child : S->children()) { 1307 if (Child && Visit(Child)) 1308 return true; 1309 } 1310 return false; 1311 } 1312 explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {} 1313 }; 1314 } // namespace 1315 1316 OMPThreadPrivateDecl * 1317 Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) { 1318 SmallVector<Expr *, 8> Vars; 1319 for (auto &RefExpr : VarList) { 1320 DeclRefExpr *DE = cast<DeclRefExpr>(RefExpr); 1321 VarDecl *VD = cast<VarDecl>(DE->getDecl()); 1322 SourceLocation ILoc = DE->getExprLoc(); 1323 1324 // Mark variable as used. 1325 VD->setReferenced(); 1326 VD->markUsed(Context); 1327 1328 QualType QType = VD->getType(); 1329 if (QType->isDependentType() || QType->isInstantiationDependentType()) { 1330 // It will be analyzed later. 1331 Vars.push_back(DE); 1332 continue; 1333 } 1334 1335 // OpenMP [2.9.2, Restrictions, C/C++, p.10] 1336 // A threadprivate variable must not have an incomplete type. 1337 if (RequireCompleteType(ILoc, VD->getType(), 1338 diag::err_omp_threadprivate_incomplete_type)) { 1339 continue; 1340 } 1341 1342 // OpenMP [2.9.2, Restrictions, C/C++, p.10] 1343 // A threadprivate variable must not have a reference type. 1344 if (VD->getType()->isReferenceType()) { 1345 Diag(ILoc, diag::err_omp_ref_type_arg) 1346 << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType(); 1347 bool IsDecl = 1348 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 1349 Diag(VD->getLocation(), 1350 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 1351 << VD; 1352 continue; 1353 } 1354 1355 // Check if this is a TLS variable. If TLS is not being supported, produce 1356 // the corresponding diagnostic. 1357 if ((VD->getTLSKind() != VarDecl::TLS_None && 1358 !(VD->hasAttr<OMPThreadPrivateDeclAttr>() && 1359 getLangOpts().OpenMPUseTLS && 1360 getASTContext().getTargetInfo().isTLSSupported())) || 1361 (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() && 1362 !VD->isLocalVarDecl())) { 1363 Diag(ILoc, diag::err_omp_var_thread_local) 1364 << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1); 1365 bool IsDecl = 1366 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 1367 Diag(VD->getLocation(), 1368 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 1369 << VD; 1370 continue; 1371 } 1372 1373 // Check if initial value of threadprivate variable reference variable with 1374 // local storage (it is not supported by runtime). 1375 if (auto Init = VD->getAnyInitializer()) { 1376 LocalVarRefChecker Checker(*this); 1377 if (Checker.Visit(Init)) 1378 continue; 1379 } 1380 1381 Vars.push_back(RefExpr); 1382 DSAStack->addDSA(VD, DE, OMPC_threadprivate); 1383 VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit( 1384 Context, SourceRange(Loc, Loc))); 1385 if (auto *ML = Context.getASTMutationListener()) 1386 ML->DeclarationMarkedOpenMPThreadPrivate(VD); 1387 } 1388 OMPThreadPrivateDecl *D = nullptr; 1389 if (!Vars.empty()) { 1390 D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc, 1391 Vars); 1392 D->setAccess(AS_public); 1393 } 1394 return D; 1395 } 1396 1397 static void ReportOriginalDSA(Sema &SemaRef, DSAStackTy *Stack, 1398 const ValueDecl *D, DSAStackTy::DSAVarData DVar, 1399 bool IsLoopIterVar = false) { 1400 if (DVar.RefExpr) { 1401 SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa) 1402 << getOpenMPClauseName(DVar.CKind); 1403 return; 1404 } 1405 enum { 1406 PDSA_StaticMemberShared, 1407 PDSA_StaticLocalVarShared, 1408 PDSA_LoopIterVarPrivate, 1409 PDSA_LoopIterVarLinear, 1410 PDSA_LoopIterVarLastprivate, 1411 PDSA_ConstVarShared, 1412 PDSA_GlobalVarShared, 1413 PDSA_TaskVarFirstprivate, 1414 PDSA_LocalVarPrivate, 1415 PDSA_Implicit 1416 } Reason = PDSA_Implicit; 1417 bool ReportHint = false; 1418 auto ReportLoc = D->getLocation(); 1419 auto *VD = dyn_cast<VarDecl>(D); 1420 if (IsLoopIterVar) { 1421 if (DVar.CKind == OMPC_private) 1422 Reason = PDSA_LoopIterVarPrivate; 1423 else if (DVar.CKind == OMPC_lastprivate) 1424 Reason = PDSA_LoopIterVarLastprivate; 1425 else 1426 Reason = PDSA_LoopIterVarLinear; 1427 } else if (isOpenMPTaskingDirective(DVar.DKind) && 1428 DVar.CKind == OMPC_firstprivate) { 1429 Reason = PDSA_TaskVarFirstprivate; 1430 ReportLoc = DVar.ImplicitDSALoc; 1431 } else if (VD && VD->isStaticLocal()) 1432 Reason = PDSA_StaticLocalVarShared; 1433 else if (VD && VD->isStaticDataMember()) 1434 Reason = PDSA_StaticMemberShared; 1435 else if (VD && VD->isFileVarDecl()) 1436 Reason = PDSA_GlobalVarShared; 1437 else if (D->getType().isConstant(SemaRef.getASTContext())) 1438 Reason = PDSA_ConstVarShared; 1439 else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) { 1440 ReportHint = true; 1441 Reason = PDSA_LocalVarPrivate; 1442 } 1443 if (Reason != PDSA_Implicit) { 1444 SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa) 1445 << Reason << ReportHint 1446 << getOpenMPDirectiveName(Stack->getCurrentDirective()); 1447 } else if (DVar.ImplicitDSALoc.isValid()) { 1448 SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa) 1449 << getOpenMPClauseName(DVar.CKind); 1450 } 1451 } 1452 1453 namespace { 1454 class DSAAttrChecker : public StmtVisitor<DSAAttrChecker, void> { 1455 DSAStackTy *Stack; 1456 Sema &SemaRef; 1457 bool ErrorFound; 1458 CapturedStmt *CS; 1459 llvm::SmallVector<Expr *, 8> ImplicitFirstprivate; 1460 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA; 1461 1462 public: 1463 void VisitDeclRefExpr(DeclRefExpr *E) { 1464 if (E->isTypeDependent() || E->isValueDependent() || 1465 E->containsUnexpandedParameterPack() || E->isInstantiationDependent()) 1466 return; 1467 if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) { 1468 // Skip internally declared variables. 1469 if (VD->isLocalVarDecl() && !CS->capturesVariable(VD)) 1470 return; 1471 1472 auto DVar = Stack->getTopDSA(VD, false); 1473 // Check if the variable has explicit DSA set and stop analysis if it so. 1474 if (DVar.RefExpr) return; 1475 1476 auto ELoc = E->getExprLoc(); 1477 auto DKind = Stack->getCurrentDirective(); 1478 // The default(none) clause requires that each variable that is referenced 1479 // in the construct, and does not have a predetermined data-sharing 1480 // attribute, must have its data-sharing attribute explicitly determined 1481 // by being listed in a data-sharing attribute clause. 1482 if (DVar.CKind == OMPC_unknown && Stack->getDefaultDSA() == DSA_none && 1483 isParallelOrTaskRegion(DKind) && 1484 VarsWithInheritedDSA.count(VD) == 0) { 1485 VarsWithInheritedDSA[VD] = E; 1486 return; 1487 } 1488 1489 // OpenMP [2.9.3.6, Restrictions, p.2] 1490 // A list item that appears in a reduction clause of the innermost 1491 // enclosing worksharing or parallel construct may not be accessed in an 1492 // explicit task. 1493 DVar = Stack->hasInnermostDSA( 1494 VD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; }, 1495 [](OpenMPDirectiveKind K) -> bool { 1496 return isOpenMPParallelDirective(K) || 1497 isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K); 1498 }, 1499 false); 1500 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) { 1501 ErrorFound = true; 1502 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task); 1503 ReportOriginalDSA(SemaRef, Stack, VD, DVar); 1504 return; 1505 } 1506 1507 // Define implicit data-sharing attributes for task. 1508 DVar = Stack->getImplicitDSA(VD, false); 1509 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared && 1510 !Stack->isLoopControlVariable(VD).first) 1511 ImplicitFirstprivate.push_back(E); 1512 } 1513 } 1514 void VisitMemberExpr(MemberExpr *E) { 1515 if (E->isTypeDependent() || E->isValueDependent() || 1516 E->containsUnexpandedParameterPack() || E->isInstantiationDependent()) 1517 return; 1518 if (isa<CXXThisExpr>(E->getBase()->IgnoreParens())) { 1519 if (auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) { 1520 auto DVar = Stack->getTopDSA(FD, false); 1521 // Check if the variable has explicit DSA set and stop analysis if it 1522 // so. 1523 if (DVar.RefExpr) 1524 return; 1525 1526 auto ELoc = E->getExprLoc(); 1527 auto DKind = Stack->getCurrentDirective(); 1528 // OpenMP [2.9.3.6, Restrictions, p.2] 1529 // A list item that appears in a reduction clause of the innermost 1530 // enclosing worksharing or parallel construct may not be accessed in 1531 // an explicit task. 1532 DVar = Stack->hasInnermostDSA( 1533 FD, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; }, 1534 [](OpenMPDirectiveKind K) -> bool { 1535 return isOpenMPParallelDirective(K) || 1536 isOpenMPWorksharingDirective(K) || 1537 isOpenMPTeamsDirective(K); 1538 }, 1539 false); 1540 if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) { 1541 ErrorFound = true; 1542 SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task); 1543 ReportOriginalDSA(SemaRef, Stack, FD, DVar); 1544 return; 1545 } 1546 1547 // Define implicit data-sharing attributes for task. 1548 DVar = Stack->getImplicitDSA(FD, false); 1549 if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared && 1550 !Stack->isLoopControlVariable(FD).first) 1551 ImplicitFirstprivate.push_back(E); 1552 } 1553 } 1554 } 1555 void VisitOMPExecutableDirective(OMPExecutableDirective *S) { 1556 for (auto *C : S->clauses()) { 1557 // Skip analysis of arguments of implicitly defined firstprivate clause 1558 // for task directives. 1559 if (C && (!isa<OMPFirstprivateClause>(C) || C->getLocStart().isValid())) 1560 for (auto *CC : C->children()) { 1561 if (CC) 1562 Visit(CC); 1563 } 1564 } 1565 } 1566 void VisitStmt(Stmt *S) { 1567 for (auto *C : S->children()) { 1568 if (C && !isa<OMPExecutableDirective>(C)) 1569 Visit(C); 1570 } 1571 } 1572 1573 bool isErrorFound() { return ErrorFound; } 1574 ArrayRef<Expr *> getImplicitFirstprivate() { return ImplicitFirstprivate; } 1575 llvm::DenseMap<ValueDecl *, Expr *> &getVarsWithInheritedDSA() { 1576 return VarsWithInheritedDSA; 1577 } 1578 1579 DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS) 1580 : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {} 1581 }; 1582 } // namespace 1583 1584 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) { 1585 switch (DKind) { 1586 case OMPD_parallel: 1587 case OMPD_parallel_for: 1588 case OMPD_parallel_for_simd: 1589 case OMPD_parallel_sections: 1590 case OMPD_teams: { 1591 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1); 1592 QualType KmpInt32PtrTy = 1593 Context.getPointerType(KmpInt32Ty).withConst().withRestrict(); 1594 Sema::CapturedParamNameType Params[] = { 1595 std::make_pair(".global_tid.", KmpInt32PtrTy), 1596 std::make_pair(".bound_tid.", KmpInt32PtrTy), 1597 std::make_pair(StringRef(), QualType()) // __context with shared vars 1598 }; 1599 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP, 1600 Params); 1601 break; 1602 } 1603 case OMPD_simd: 1604 case OMPD_for: 1605 case OMPD_for_simd: 1606 case OMPD_sections: 1607 case OMPD_section: 1608 case OMPD_single: 1609 case OMPD_master: 1610 case OMPD_critical: 1611 case OMPD_taskgroup: 1612 case OMPD_distribute: 1613 case OMPD_ordered: 1614 case OMPD_atomic: 1615 case OMPD_target_data: 1616 case OMPD_target: 1617 case OMPD_target_parallel: 1618 case OMPD_target_parallel_for: 1619 case OMPD_target_parallel_for_simd: { 1620 Sema::CapturedParamNameType Params[] = { 1621 std::make_pair(StringRef(), QualType()) // __context with shared vars 1622 }; 1623 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP, 1624 Params); 1625 break; 1626 } 1627 case OMPD_task: { 1628 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1); 1629 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()}; 1630 FunctionProtoType::ExtProtoInfo EPI; 1631 EPI.Variadic = true; 1632 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI); 1633 Sema::CapturedParamNameType Params[] = { 1634 std::make_pair(".global_tid.", KmpInt32Ty), 1635 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)), 1636 std::make_pair(".privates.", Context.VoidPtrTy.withConst()), 1637 std::make_pair(".copy_fn.", 1638 Context.getPointerType(CopyFnType).withConst()), 1639 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()), 1640 std::make_pair(StringRef(), QualType()) // __context with shared vars 1641 }; 1642 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP, 1643 Params); 1644 // Mark this captured region as inlined, because we don't use outlined 1645 // function directly. 1646 getCurCapturedRegion()->TheCapturedDecl->addAttr( 1647 AlwaysInlineAttr::CreateImplicit( 1648 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange())); 1649 break; 1650 } 1651 case OMPD_taskloop: 1652 case OMPD_taskloop_simd: { 1653 QualType KmpInt32Ty = 1654 Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1); 1655 QualType KmpUInt64Ty = 1656 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0); 1657 QualType KmpInt64Ty = 1658 Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1); 1659 QualType Args[] = {Context.VoidPtrTy.withConst().withRestrict()}; 1660 FunctionProtoType::ExtProtoInfo EPI; 1661 EPI.Variadic = true; 1662 QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI); 1663 Sema::CapturedParamNameType Params[] = { 1664 std::make_pair(".global_tid.", KmpInt32Ty), 1665 std::make_pair(".part_id.", Context.getPointerType(KmpInt32Ty)), 1666 std::make_pair(".privates.", 1667 Context.VoidPtrTy.withConst().withRestrict()), 1668 std::make_pair( 1669 ".copy_fn.", 1670 Context.getPointerType(CopyFnType).withConst().withRestrict()), 1671 std::make_pair(".task_t.", Context.VoidPtrTy.withConst()), 1672 std::make_pair(".lb.", KmpUInt64Ty), 1673 std::make_pair(".ub.", KmpUInt64Ty), std::make_pair(".st.", KmpInt64Ty), 1674 std::make_pair(".liter.", KmpInt32Ty), 1675 std::make_pair(StringRef(), QualType()) // __context with shared vars 1676 }; 1677 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP, 1678 Params); 1679 // Mark this captured region as inlined, because we don't use outlined 1680 // function directly. 1681 getCurCapturedRegion()->TheCapturedDecl->addAttr( 1682 AlwaysInlineAttr::CreateImplicit( 1683 Context, AlwaysInlineAttr::Keyword_forceinline, SourceRange())); 1684 break; 1685 } 1686 case OMPD_distribute_parallel_for_simd: 1687 case OMPD_distribute_simd: 1688 case OMPD_distribute_parallel_for: { 1689 QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1); 1690 QualType KmpInt32PtrTy = 1691 Context.getPointerType(KmpInt32Ty).withConst().withRestrict(); 1692 Sema::CapturedParamNameType Params[] = { 1693 std::make_pair(".global_tid.", KmpInt32PtrTy), 1694 std::make_pair(".bound_tid.", KmpInt32PtrTy), 1695 std::make_pair(".previous.lb.", Context.getSizeType()), 1696 std::make_pair(".previous.ub.", Context.getSizeType()), 1697 std::make_pair(StringRef(), QualType()) // __context with shared vars 1698 }; 1699 ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP, 1700 Params); 1701 break; 1702 } 1703 case OMPD_threadprivate: 1704 case OMPD_taskyield: 1705 case OMPD_barrier: 1706 case OMPD_taskwait: 1707 case OMPD_cancellation_point: 1708 case OMPD_cancel: 1709 case OMPD_flush: 1710 case OMPD_target_enter_data: 1711 case OMPD_target_exit_data: 1712 case OMPD_declare_reduction: 1713 case OMPD_declare_simd: 1714 case OMPD_declare_target: 1715 case OMPD_end_declare_target: 1716 case OMPD_target_update: 1717 llvm_unreachable("OpenMP Directive is not allowed"); 1718 case OMPD_unknown: 1719 llvm_unreachable("Unknown OpenMP directive"); 1720 } 1721 } 1722 1723 static OMPCapturedExprDecl *buildCaptureDecl(Sema &S, IdentifierInfo *Id, 1724 Expr *CaptureExpr, bool WithInit, 1725 bool AsExpression) { 1726 assert(CaptureExpr); 1727 ASTContext &C = S.getASTContext(); 1728 Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts(); 1729 QualType Ty = Init->getType(); 1730 if (CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue()) { 1731 if (S.getLangOpts().CPlusPlus) 1732 Ty = C.getLValueReferenceType(Ty); 1733 else { 1734 Ty = C.getPointerType(Ty); 1735 ExprResult Res = 1736 S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_AddrOf, Init); 1737 if (!Res.isUsable()) 1738 return nullptr; 1739 Init = Res.get(); 1740 } 1741 WithInit = true; 1742 } 1743 auto *CED = OMPCapturedExprDecl::Create(C, S.CurContext, Id, Ty); 1744 if (!WithInit) 1745 CED->addAttr(OMPCaptureNoInitAttr::CreateImplicit(C, SourceRange())); 1746 S.CurContext->addHiddenDecl(CED); 1747 S.AddInitializerToDecl(CED, Init, /*DirectInit=*/false, 1748 /*TypeMayContainAuto=*/true); 1749 return CED; 1750 } 1751 1752 static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr, 1753 bool WithInit) { 1754 OMPCapturedExprDecl *CD; 1755 if (auto *VD = S.IsOpenMPCapturedDecl(D)) 1756 CD = cast<OMPCapturedExprDecl>(VD); 1757 else 1758 CD = buildCaptureDecl(S, D->getIdentifier(), CaptureExpr, WithInit, 1759 /*AsExpression=*/false); 1760 return buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(), 1761 CaptureExpr->getExprLoc()); 1762 } 1763 1764 static ExprResult buildCapture(Sema &S, Expr *CaptureExpr, DeclRefExpr *&Ref) { 1765 if (!Ref) { 1766 auto *CD = 1767 buildCaptureDecl(S, &S.getASTContext().Idents.get(".capture_expr."), 1768 CaptureExpr, /*WithInit=*/true, /*AsExpression=*/true); 1769 Ref = buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(), 1770 CaptureExpr->getExprLoc()); 1771 } 1772 ExprResult Res = Ref; 1773 if (!S.getLangOpts().CPlusPlus && 1774 CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue() && 1775 Ref->getType()->isPointerType()) 1776 Res = S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_Deref, Ref); 1777 if (!Res.isUsable()) 1778 return ExprError(); 1779 return CaptureExpr->isGLValue() ? Res : S.DefaultLvalueConversion(Res.get()); 1780 } 1781 1782 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S, 1783 ArrayRef<OMPClause *> Clauses) { 1784 if (!S.isUsable()) { 1785 ActOnCapturedRegionError(); 1786 return StmtError(); 1787 } 1788 1789 OMPOrderedClause *OC = nullptr; 1790 OMPScheduleClause *SC = nullptr; 1791 SmallVector<OMPLinearClause *, 4> LCs; 1792 // This is required for proper codegen. 1793 for (auto *Clause : Clauses) { 1794 if (isOpenMPPrivate(Clause->getClauseKind()) || 1795 Clause->getClauseKind() == OMPC_copyprivate || 1796 (getLangOpts().OpenMPUseTLS && 1797 getASTContext().getTargetInfo().isTLSSupported() && 1798 Clause->getClauseKind() == OMPC_copyin)) { 1799 DSAStack->setForceVarCapturing(Clause->getClauseKind() == OMPC_copyin); 1800 // Mark all variables in private list clauses as used in inner region. 1801 for (auto *VarRef : Clause->children()) { 1802 if (auto *E = cast_or_null<Expr>(VarRef)) { 1803 MarkDeclarationsReferencedInExpr(E); 1804 } 1805 } 1806 DSAStack->setForceVarCapturing(/*V=*/false); 1807 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective())) { 1808 // Mark all variables in private list clauses as used in inner region. 1809 // Required for proper codegen of combined directives. 1810 // TODO: add processing for other clauses. 1811 if (auto *C = OMPClauseWithPreInit::get(Clause)) { 1812 if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) { 1813 for (auto *D : DS->decls()) 1814 MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D)); 1815 } 1816 } 1817 if (auto *C = OMPClauseWithPostUpdate::get(Clause)) { 1818 if (auto *E = C->getPostUpdateExpr()) 1819 MarkDeclarationsReferencedInExpr(E); 1820 } 1821 } 1822 if (Clause->getClauseKind() == OMPC_schedule) 1823 SC = cast<OMPScheduleClause>(Clause); 1824 else if (Clause->getClauseKind() == OMPC_ordered) 1825 OC = cast<OMPOrderedClause>(Clause); 1826 else if (Clause->getClauseKind() == OMPC_linear) 1827 LCs.push_back(cast<OMPLinearClause>(Clause)); 1828 } 1829 bool ErrorFound = false; 1830 // OpenMP, 2.7.1 Loop Construct, Restrictions 1831 // The nonmonotonic modifier cannot be specified if an ordered clause is 1832 // specified. 1833 if (SC && 1834 (SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic || 1835 SC->getSecondScheduleModifier() == 1836 OMPC_SCHEDULE_MODIFIER_nonmonotonic) && 1837 OC) { 1838 Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic 1839 ? SC->getFirstScheduleModifierLoc() 1840 : SC->getSecondScheduleModifierLoc(), 1841 diag::err_omp_schedule_nonmonotonic_ordered) 1842 << SourceRange(OC->getLocStart(), OC->getLocEnd()); 1843 ErrorFound = true; 1844 } 1845 if (!LCs.empty() && OC && OC->getNumForLoops()) { 1846 for (auto *C : LCs) { 1847 Diag(C->getLocStart(), diag::err_omp_linear_ordered) 1848 << SourceRange(OC->getLocStart(), OC->getLocEnd()); 1849 } 1850 ErrorFound = true; 1851 } 1852 if (isOpenMPWorksharingDirective(DSAStack->getCurrentDirective()) && 1853 isOpenMPSimdDirective(DSAStack->getCurrentDirective()) && OC && 1854 OC->getNumForLoops()) { 1855 Diag(OC->getLocStart(), diag::err_omp_ordered_simd) 1856 << getOpenMPDirectiveName(DSAStack->getCurrentDirective()); 1857 ErrorFound = true; 1858 } 1859 if (ErrorFound) { 1860 ActOnCapturedRegionError(); 1861 return StmtError(); 1862 } 1863 return ActOnCapturedRegionEnd(S.get()); 1864 } 1865 1866 static bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, 1867 OpenMPDirectiveKind CurrentRegion, 1868 const DeclarationNameInfo &CurrentName, 1869 OpenMPDirectiveKind CancelRegion, 1870 SourceLocation StartLoc) { 1871 // Allowed nesting of constructs 1872 // +------------------+-----------------+------------------------------------+ 1873 // | Parent directive | Child directive | Closely (!), No-Closely(+), Both(*)| 1874 // +------------------+-----------------+------------------------------------+ 1875 // | parallel | parallel | * | 1876 // | parallel | for | * | 1877 // | parallel | for simd | * | 1878 // | parallel | master | * | 1879 // | parallel | critical | * | 1880 // | parallel | simd | * | 1881 // | parallel | sections | * | 1882 // | parallel | section | + | 1883 // | parallel | single | * | 1884 // | parallel | parallel for | * | 1885 // | parallel |parallel for simd| * | 1886 // | parallel |parallel sections| * | 1887 // | parallel | task | * | 1888 // | parallel | taskyield | * | 1889 // | parallel | barrier | * | 1890 // | parallel | taskwait | * | 1891 // | parallel | taskgroup | * | 1892 // | parallel | flush | * | 1893 // | parallel | ordered | + | 1894 // | parallel | atomic | * | 1895 // | parallel | target | * | 1896 // | parallel | target parallel | * | 1897 // | parallel | target parallel | * | 1898 // | | for | | 1899 // | parallel | target enter | * | 1900 // | | data | | 1901 // | parallel | target exit | * | 1902 // | | data | | 1903 // | parallel | teams | + | 1904 // | parallel | cancellation | | 1905 // | | point | ! | 1906 // | parallel | cancel | ! | 1907 // | parallel | taskloop | * | 1908 // | parallel | taskloop simd | * | 1909 // | parallel | distribute | + | 1910 // | parallel | distribute | + | 1911 // | | parallel for | | 1912 // | parallel | distribute | + | 1913 // | |parallel for simd| | 1914 // | parallel | distribute simd | + | 1915 // +------------------+-----------------+------------------------------------+ 1916 // | for | parallel | * | 1917 // | for | for | + | 1918 // | for | for simd | + | 1919 // | for | master | + | 1920 // | for | critical | * | 1921 // | for | simd | * | 1922 // | for | sections | + | 1923 // | for | section | + | 1924 // | for | single | + | 1925 // | for | parallel for | * | 1926 // | for |parallel for simd| * | 1927 // | for |parallel sections| * | 1928 // | for | task | * | 1929 // | for | taskyield | * | 1930 // | for | barrier | + | 1931 // | for | taskwait | * | 1932 // | for | taskgroup | * | 1933 // | for | flush | * | 1934 // | for | ordered | * (if construct is ordered) | 1935 // | for | atomic | * | 1936 // | for | target | * | 1937 // | for | target parallel | * | 1938 // | for | target parallel | * | 1939 // | | for | | 1940 // | for | target enter | * | 1941 // | | data | | 1942 // | for | target exit | * | 1943 // | | data | | 1944 // | for | teams | + | 1945 // | for | cancellation | | 1946 // | | point | ! | 1947 // | for | cancel | ! | 1948 // | for | taskloop | * | 1949 // | for | taskloop simd | * | 1950 // | for | distribute | + | 1951 // | for | distribute | + | 1952 // | | parallel for | | 1953 // | for | distribute | + | 1954 // | |parallel for simd| | 1955 // | for | distribute simd | + | 1956 // | for | target parallel | + | 1957 // | | for simd | | 1958 // +------------------+-----------------+------------------------------------+ 1959 // | master | parallel | * | 1960 // | master | for | + | 1961 // | master | for simd | + | 1962 // | master | master | * | 1963 // | master | critical | * | 1964 // | master | simd | * | 1965 // | master | sections | + | 1966 // | master | section | + | 1967 // | master | single | + | 1968 // | master | parallel for | * | 1969 // | master |parallel for simd| * | 1970 // | master |parallel sections| * | 1971 // | master | task | * | 1972 // | master | taskyield | * | 1973 // | master | barrier | + | 1974 // | master | taskwait | * | 1975 // | master | taskgroup | * | 1976 // | master | flush | * | 1977 // | master | ordered | + | 1978 // | master | atomic | * | 1979 // | master | target | * | 1980 // | master | target parallel | * | 1981 // | master | target parallel | * | 1982 // | | for | | 1983 // | master | target enter | * | 1984 // | | data | | 1985 // | master | target exit | * | 1986 // | | data | | 1987 // | master | teams | + | 1988 // | master | cancellation | | 1989 // | | point | | 1990 // | master | cancel | | 1991 // | master | taskloop | * | 1992 // | master | taskloop simd | * | 1993 // | master | distribute | + | 1994 // | master | distribute | + | 1995 // | | parallel for | | 1996 // | master | distribute | + | 1997 // | |parallel for simd| | 1998 // | master | distribute simd | + | 1999 // | master | target parallel | + | 2000 // | | for simd | | 2001 // +------------------+-----------------+------------------------------------+ 2002 // | critical | parallel | * | 2003 // | critical | for | + | 2004 // | critical | for simd | + | 2005 // | critical | master | * | 2006 // | critical | critical | * (should have different names) | 2007 // | critical | simd | * | 2008 // | critical | sections | + | 2009 // | critical | section | + | 2010 // | critical | single | + | 2011 // | critical | parallel for | * | 2012 // | critical |parallel for simd| * | 2013 // | critical |parallel sections| * | 2014 // | critical | task | * | 2015 // | critical | taskyield | * | 2016 // | critical | barrier | + | 2017 // | critical | taskwait | * | 2018 // | critical | taskgroup | * | 2019 // | critical | ordered | + | 2020 // | critical | atomic | * | 2021 // | critical | target | * | 2022 // | critical | target parallel | * | 2023 // | critical | target parallel | * | 2024 // | | for | | 2025 // | critical | target enter | * | 2026 // | | data | | 2027 // | critical | target exit | * | 2028 // | | data | | 2029 // | critical | teams | + | 2030 // | critical | cancellation | | 2031 // | | point | | 2032 // | critical | cancel | | 2033 // | critical | taskloop | * | 2034 // | critical | taskloop simd | * | 2035 // | critical | distribute | + | 2036 // | critical | distribute | + | 2037 // | | parallel for | | 2038 // | critical | distribute | + | 2039 // | |parallel for simd| | 2040 // | critical | distribute simd | + | 2041 // | critical | target parallel | + | 2042 // | | for simd | | 2043 // +------------------+-----------------+------------------------------------+ 2044 // | simd | parallel | | 2045 // | simd | for | | 2046 // | simd | for simd | | 2047 // | simd | master | | 2048 // | simd | critical | | 2049 // | simd | simd | * | 2050 // | simd | sections | | 2051 // | simd | section | | 2052 // | simd | single | | 2053 // | simd | parallel for | | 2054 // | simd |parallel for simd| | 2055 // | simd |parallel sections| | 2056 // | simd | task | | 2057 // | simd | taskyield | | 2058 // | simd | barrier | | 2059 // | simd | taskwait | | 2060 // | simd | taskgroup | | 2061 // | simd | flush | | 2062 // | simd | ordered | + (with simd clause) | 2063 // | simd | atomic | | 2064 // | simd | target | | 2065 // | simd | target parallel | | 2066 // | simd | target parallel | | 2067 // | | for | | 2068 // | simd | target enter | | 2069 // | | data | | 2070 // | simd | target exit | | 2071 // | | data | | 2072 // | simd | teams | | 2073 // | simd | cancellation | | 2074 // | | point | | 2075 // | simd | cancel | | 2076 // | simd | taskloop | | 2077 // | simd | taskloop simd | | 2078 // | simd | distribute | | 2079 // | simd | distribute | | 2080 // | | parallel for | | 2081 // | simd | distribute | | 2082 // | |parallel for simd| | 2083 // | simd | distribute simd | | 2084 // | simd | target parallel | | 2085 // | | for simd | | 2086 // +------------------+-----------------+------------------------------------+ 2087 // | for simd | parallel | | 2088 // | for simd | for | | 2089 // | for simd | for simd | | 2090 // | for simd | master | | 2091 // | for simd | critical | | 2092 // | for simd | simd | * | 2093 // | for simd | sections | | 2094 // | for simd | section | | 2095 // | for simd | single | | 2096 // | for simd | parallel for | | 2097 // | for simd |parallel for simd| | 2098 // | for simd |parallel sections| | 2099 // | for simd | task | | 2100 // | for simd | taskyield | | 2101 // | for simd | barrier | | 2102 // | for simd | taskwait | | 2103 // | for simd | taskgroup | | 2104 // | for simd | flush | | 2105 // | for simd | ordered | + (with simd clause) | 2106 // | for simd | atomic | | 2107 // | for simd | target | | 2108 // | for simd | target parallel | | 2109 // | for simd | target parallel | | 2110 // | | for | | 2111 // | for simd | target enter | | 2112 // | | data | | 2113 // | for simd | target exit | | 2114 // | | data | | 2115 // | for simd | teams | | 2116 // | for simd | cancellation | | 2117 // | | point | | 2118 // | for simd | cancel | | 2119 // | for simd | taskloop | | 2120 // | for simd | taskloop simd | | 2121 // | for simd | distribute | | 2122 // | for simd | distribute | | 2123 // | | parallel for | | 2124 // | for simd | distribute | | 2125 // | |parallel for simd| | 2126 // | for simd | distribute simd | | 2127 // | for simd | target parallel | | 2128 // | | for simd | | 2129 // +------------------+-----------------+------------------------------------+ 2130 // | parallel for simd| parallel | | 2131 // | parallel for simd| for | | 2132 // | parallel for simd| for simd | | 2133 // | parallel for simd| master | | 2134 // | parallel for simd| critical | | 2135 // | parallel for simd| simd | * | 2136 // | parallel for simd| sections | | 2137 // | parallel for simd| section | | 2138 // | parallel for simd| single | | 2139 // | parallel for simd| parallel for | | 2140 // | parallel for simd|parallel for simd| | 2141 // | parallel for simd|parallel sections| | 2142 // | parallel for simd| task | | 2143 // | parallel for simd| taskyield | | 2144 // | parallel for simd| barrier | | 2145 // | parallel for simd| taskwait | | 2146 // | parallel for simd| taskgroup | | 2147 // | parallel for simd| flush | | 2148 // | parallel for simd| ordered | + (with simd clause) | 2149 // | parallel for simd| atomic | | 2150 // | parallel for simd| target | | 2151 // | parallel for simd| target parallel | | 2152 // | parallel for simd| target parallel | | 2153 // | | for | | 2154 // | parallel for simd| target enter | | 2155 // | | data | | 2156 // | parallel for simd| target exit | | 2157 // | | data | | 2158 // | parallel for simd| teams | | 2159 // | parallel for simd| cancellation | | 2160 // | | point | | 2161 // | parallel for simd| cancel | | 2162 // | parallel for simd| taskloop | | 2163 // | parallel for simd| taskloop simd | | 2164 // | parallel for simd| distribute | | 2165 // | parallel for simd| distribute | | 2166 // | | parallel for | | 2167 // | parallel for simd| distribute | | 2168 // | |parallel for simd| | 2169 // | parallel for simd| distribute simd | | 2170 // | | for simd | | 2171 // +------------------+-----------------+------------------------------------+ 2172 // | sections | parallel | * | 2173 // | sections | for | + | 2174 // | sections | for simd | + | 2175 // | sections | master | + | 2176 // | sections | critical | * | 2177 // | sections | simd | * | 2178 // | sections | sections | + | 2179 // | sections | section | * | 2180 // | sections | single | + | 2181 // | sections | parallel for | * | 2182 // | sections |parallel for simd| * | 2183 // | sections |parallel sections| * | 2184 // | sections | task | * | 2185 // | sections | taskyield | * | 2186 // | sections | barrier | + | 2187 // | sections | taskwait | * | 2188 // | sections | taskgroup | * | 2189 // | sections | flush | * | 2190 // | sections | ordered | + | 2191 // | sections | atomic | * | 2192 // | sections | target | * | 2193 // | sections | target parallel | * | 2194 // | sections | target parallel | * | 2195 // | | for | | 2196 // | sections | target enter | * | 2197 // | | data | | 2198 // | sections | target exit | * | 2199 // | | data | | 2200 // | sections | teams | + | 2201 // | sections | cancellation | | 2202 // | | point | ! | 2203 // | sections | cancel | ! | 2204 // | sections | taskloop | * | 2205 // | sections | taskloop simd | * | 2206 // | sections | distribute | + | 2207 // | sections | distribute | + | 2208 // | | parallel for | | 2209 // | sections | distribute | + | 2210 // | |parallel for simd| | 2211 // | sections | distribute simd | + | 2212 // | sections | target parallel | + | 2213 // | | for simd | | 2214 // +------------------+-----------------+------------------------------------+ 2215 // | section | parallel | * | 2216 // | section | for | + | 2217 // | section | for simd | + | 2218 // | section | master | + | 2219 // | section | critical | * | 2220 // | section | simd | * | 2221 // | section | sections | + | 2222 // | section | section | + | 2223 // | section | single | + | 2224 // | section | parallel for | * | 2225 // | section |parallel for simd| * | 2226 // | section |parallel sections| * | 2227 // | section | task | * | 2228 // | section | taskyield | * | 2229 // | section | barrier | + | 2230 // | section | taskwait | * | 2231 // | section | taskgroup | * | 2232 // | section | flush | * | 2233 // | section | ordered | + | 2234 // | section | atomic | * | 2235 // | section | target | * | 2236 // | section | target parallel | * | 2237 // | section | target parallel | * | 2238 // | | for | | 2239 // | section | target enter | * | 2240 // | | data | | 2241 // | section | target exit | * | 2242 // | | data | | 2243 // | section | teams | + | 2244 // | section | cancellation | | 2245 // | | point | ! | 2246 // | section | cancel | ! | 2247 // | section | taskloop | * | 2248 // | section | taskloop simd | * | 2249 // | section | distribute | + | 2250 // | section | distribute | + | 2251 // | | parallel for | | 2252 // | section | distribute | + | 2253 // | |parallel for simd| | 2254 // | section | distribute simd | + | 2255 // | section | target parallel | + | 2256 // | | for simd | | 2257 // +------------------+-----------------+------------------------------------+ 2258 // | single | parallel | * | 2259 // | single | for | + | 2260 // | single | for simd | + | 2261 // | single | master | + | 2262 // | single | critical | * | 2263 // | single | simd | * | 2264 // | single | sections | + | 2265 // | single | section | + | 2266 // | single | single | + | 2267 // | single | parallel for | * | 2268 // | single |parallel for simd| * | 2269 // | single |parallel sections| * | 2270 // | single | task | * | 2271 // | single | taskyield | * | 2272 // | single | barrier | + | 2273 // | single | taskwait | * | 2274 // | single | taskgroup | * | 2275 // | single | flush | * | 2276 // | single | ordered | + | 2277 // | single | atomic | * | 2278 // | single | target | * | 2279 // | single | target parallel | * | 2280 // | single | target parallel | * | 2281 // | | for | | 2282 // | single | target enter | * | 2283 // | | data | | 2284 // | single | target exit | * | 2285 // | | data | | 2286 // | single | teams | + | 2287 // | single | cancellation | | 2288 // | | point | | 2289 // | single | cancel | | 2290 // | single | taskloop | * | 2291 // | single | taskloop simd | * | 2292 // | single | distribute | + | 2293 // | single | distribute | + | 2294 // | | parallel for | | 2295 // | single | distribute | + | 2296 // | |parallel for simd| | 2297 // | single | distribute simd | + | 2298 // | single | target parallel | + | 2299 // | | for simd | | 2300 // +------------------+-----------------+------------------------------------+ 2301 // | parallel for | parallel | * | 2302 // | parallel for | for | + | 2303 // | parallel for | for simd | + | 2304 // | parallel for | master | + | 2305 // | parallel for | critical | * | 2306 // | parallel for | simd | * | 2307 // | parallel for | sections | + | 2308 // | parallel for | section | + | 2309 // | parallel for | single | + | 2310 // | parallel for | parallel for | * | 2311 // | parallel for |parallel for simd| * | 2312 // | parallel for |parallel sections| * | 2313 // | parallel for | task | * | 2314 // | parallel for | taskyield | * | 2315 // | parallel for | barrier | + | 2316 // | parallel for | taskwait | * | 2317 // | parallel for | taskgroup | * | 2318 // | parallel for | flush | * | 2319 // | parallel for | ordered | * (if construct is ordered) | 2320 // | parallel for | atomic | * | 2321 // | parallel for | target | * | 2322 // | parallel for | target parallel | * | 2323 // | parallel for | target parallel | * | 2324 // | | for | | 2325 // | parallel for | target enter | * | 2326 // | | data | | 2327 // | parallel for | target exit | * | 2328 // | | data | | 2329 // | parallel for | teams | + | 2330 // | parallel for | cancellation | | 2331 // | | point | ! | 2332 // | parallel for | cancel | ! | 2333 // | parallel for | taskloop | * | 2334 // | parallel for | taskloop simd | * | 2335 // | parallel for | distribute | + | 2336 // | parallel for | distribute | + | 2337 // | | parallel for | | 2338 // | parallel for | distribute | + | 2339 // | |parallel for simd| | 2340 // | parallel for | distribute simd | + | 2341 // | parallel for | target parallel | + | 2342 // | | for simd | | 2343 // +------------------+-----------------+------------------------------------+ 2344 // | parallel sections| parallel | * | 2345 // | parallel sections| for | + | 2346 // | parallel sections| for simd | + | 2347 // | parallel sections| master | + | 2348 // | parallel sections| critical | + | 2349 // | parallel sections| simd | * | 2350 // | parallel sections| sections | + | 2351 // | parallel sections| section | * | 2352 // | parallel sections| single | + | 2353 // | parallel sections| parallel for | * | 2354 // | parallel sections|parallel for simd| * | 2355 // | parallel sections|parallel sections| * | 2356 // | parallel sections| task | * | 2357 // | parallel sections| taskyield | * | 2358 // | parallel sections| barrier | + | 2359 // | parallel sections| taskwait | * | 2360 // | parallel sections| taskgroup | * | 2361 // | parallel sections| flush | * | 2362 // | parallel sections| ordered | + | 2363 // | parallel sections| atomic | * | 2364 // | parallel sections| target | * | 2365 // | parallel sections| target parallel | * | 2366 // | parallel sections| target parallel | * | 2367 // | | for | | 2368 // | parallel sections| target enter | * | 2369 // | | data | | 2370 // | parallel sections| target exit | * | 2371 // | | data | | 2372 // | parallel sections| teams | + | 2373 // | parallel sections| cancellation | | 2374 // | | point | ! | 2375 // | parallel sections| cancel | ! | 2376 // | parallel sections| taskloop | * | 2377 // | parallel sections| taskloop simd | * | 2378 // | parallel sections| distribute | + | 2379 // | parallel sections| distribute | + | 2380 // | | parallel for | | 2381 // | parallel sections| distribute | + | 2382 // | |parallel for simd| | 2383 // | parallel sections| distribute simd | + | 2384 // | parallel sections| target parallel | + | 2385 // | | for simd | | 2386 // +------------------+-----------------+------------------------------------+ 2387 // | task | parallel | * | 2388 // | task | for | + | 2389 // | task | for simd | + | 2390 // | task | master | + | 2391 // | task | critical | * | 2392 // | task | simd | * | 2393 // | task | sections | + | 2394 // | task | section | + | 2395 // | task | single | + | 2396 // | task | parallel for | * | 2397 // | task |parallel for simd| * | 2398 // | task |parallel sections| * | 2399 // | task | task | * | 2400 // | task | taskyield | * | 2401 // | task | barrier | + | 2402 // | task | taskwait | * | 2403 // | task | taskgroup | * | 2404 // | task | flush | * | 2405 // | task | ordered | + | 2406 // | task | atomic | * | 2407 // | task | target | * | 2408 // | task | target parallel | * | 2409 // | task | target parallel | * | 2410 // | | for | | 2411 // | task | target enter | * | 2412 // | | data | | 2413 // | task | target exit | * | 2414 // | | data | | 2415 // | task | teams | + | 2416 // | task | cancellation | | 2417 // | | point | ! | 2418 // | task | cancel | ! | 2419 // | task | taskloop | * | 2420 // | task | taskloop simd | * | 2421 // | task | distribute | + | 2422 // | task | distribute | + | 2423 // | | parallel for | | 2424 // | task | distribute | + | 2425 // | |parallel for simd| | 2426 // | task | distribute simd | + | 2427 // | task | target parallel | + | 2428 // | | for simd | | 2429 // +------------------+-----------------+------------------------------------+ 2430 // | ordered | parallel | * | 2431 // | ordered | for | + | 2432 // | ordered | for simd | + | 2433 // | ordered | master | * | 2434 // | ordered | critical | * | 2435 // | ordered | simd | * | 2436 // | ordered | sections | + | 2437 // | ordered | section | + | 2438 // | ordered | single | + | 2439 // | ordered | parallel for | * | 2440 // | ordered |parallel for simd| * | 2441 // | ordered |parallel sections| * | 2442 // | ordered | task | * | 2443 // | ordered | taskyield | * | 2444 // | ordered | barrier | + | 2445 // | ordered | taskwait | * | 2446 // | ordered | taskgroup | * | 2447 // | ordered | flush | * | 2448 // | ordered | ordered | + | 2449 // | ordered | atomic | * | 2450 // | ordered | target | * | 2451 // | ordered | target parallel | * | 2452 // | ordered | target parallel | * | 2453 // | | for | | 2454 // | ordered | target enter | * | 2455 // | | data | | 2456 // | ordered | target exit | * | 2457 // | | data | | 2458 // | ordered | teams | + | 2459 // | ordered | cancellation | | 2460 // | | point | | 2461 // | ordered | cancel | | 2462 // | ordered | taskloop | * | 2463 // | ordered | taskloop simd | * | 2464 // | ordered | distribute | + | 2465 // | ordered | distribute | + | 2466 // | | parallel for | | 2467 // | ordered | distribute | + | 2468 // | |parallel for simd| | 2469 // | ordered | distribute simd | + | 2470 // | ordered | target parallel | + | 2471 // | | for simd | | 2472 // +------------------+-----------------+------------------------------------+ 2473 // | atomic | parallel | | 2474 // | atomic | for | | 2475 // | atomic | for simd | | 2476 // | atomic | master | | 2477 // | atomic | critical | | 2478 // | atomic | simd | | 2479 // | atomic | sections | | 2480 // | atomic | section | | 2481 // | atomic | single | | 2482 // | atomic | parallel for | | 2483 // | atomic |parallel for simd| | 2484 // | atomic |parallel sections| | 2485 // | atomic | task | | 2486 // | atomic | taskyield | | 2487 // | atomic | barrier | | 2488 // | atomic | taskwait | | 2489 // | atomic | taskgroup | | 2490 // | atomic | flush | | 2491 // | atomic | ordered | | 2492 // | atomic | atomic | | 2493 // | atomic | target | | 2494 // | atomic | target parallel | | 2495 // | atomic | target parallel | | 2496 // | | for | | 2497 // | atomic | target enter | | 2498 // | | data | | 2499 // | atomic | target exit | | 2500 // | | data | | 2501 // | atomic | teams | | 2502 // | atomic | cancellation | | 2503 // | | point | | 2504 // | atomic | cancel | | 2505 // | atomic | taskloop | | 2506 // | atomic | taskloop simd | | 2507 // | atomic | distribute | | 2508 // | atomic | distribute | | 2509 // | | parallel for | | 2510 // | atomic | distribute | | 2511 // | |parallel for simd| | 2512 // | atomic | distribute simd | | 2513 // | atomic | target parallel | | 2514 // | | for simd | | 2515 // +------------------+-----------------+------------------------------------+ 2516 // | target | parallel | * | 2517 // | target | for | * | 2518 // | target | for simd | * | 2519 // | target | master | * | 2520 // | target | critical | * | 2521 // | target | simd | * | 2522 // | target | sections | * | 2523 // | target | section | * | 2524 // | target | single | * | 2525 // | target | parallel for | * | 2526 // | target |parallel for simd| * | 2527 // | target |parallel sections| * | 2528 // | target | task | * | 2529 // | target | taskyield | * | 2530 // | target | barrier | * | 2531 // | target | taskwait | * | 2532 // | target | taskgroup | * | 2533 // | target | flush | * | 2534 // | target | ordered | * | 2535 // | target | atomic | * | 2536 // | target | target | | 2537 // | target | target parallel | | 2538 // | target | target parallel | | 2539 // | | for | | 2540 // | target | target enter | | 2541 // | | data | | 2542 // | target | target exit | | 2543 // | | data | | 2544 // | target | teams | * | 2545 // | target | cancellation | | 2546 // | | point | | 2547 // | target | cancel | | 2548 // | target | taskloop | * | 2549 // | target | taskloop simd | * | 2550 // | target | distribute | + | 2551 // | target | distribute | + | 2552 // | | parallel for | | 2553 // | target | distribute | + | 2554 // | |parallel for simd| | 2555 // | target | distribute simd | + | 2556 // | target | target parallel | | 2557 // | | for simd | | 2558 // +------------------+-----------------+------------------------------------+ 2559 // | target parallel | parallel | * | 2560 // | target parallel | for | * | 2561 // | target parallel | for simd | * | 2562 // | target parallel | master | * | 2563 // | target parallel | critical | * | 2564 // | target parallel | simd | * | 2565 // | target parallel | sections | * | 2566 // | target parallel | section | * | 2567 // | target parallel | single | * | 2568 // | target parallel | parallel for | * | 2569 // | target parallel |parallel for simd| * | 2570 // | target parallel |parallel sections| * | 2571 // | target parallel | task | * | 2572 // | target parallel | taskyield | * | 2573 // | target parallel | barrier | * | 2574 // | target parallel | taskwait | * | 2575 // | target parallel | taskgroup | * | 2576 // | target parallel | flush | * | 2577 // | target parallel | ordered | * | 2578 // | target parallel | atomic | * | 2579 // | target parallel | target | | 2580 // | target parallel | target parallel | | 2581 // | target parallel | target parallel | | 2582 // | | for | | 2583 // | target parallel | target enter | | 2584 // | | data | | 2585 // | target parallel | target exit | | 2586 // | | data | | 2587 // | target parallel | teams | | 2588 // | target parallel | cancellation | | 2589 // | | point | ! | 2590 // | target parallel | cancel | ! | 2591 // | target parallel | taskloop | * | 2592 // | target parallel | taskloop simd | * | 2593 // | target parallel | distribute | | 2594 // | target parallel | distribute | | 2595 // | | parallel for | | 2596 // | target parallel | distribute | | 2597 // | |parallel for simd| | 2598 // | target parallel | distribute simd | | 2599 // | target parallel | target parallel | | 2600 // | | for simd | | 2601 // +------------------+-----------------+------------------------------------+ 2602 // | target parallel | parallel | * | 2603 // | for | | | 2604 // | target parallel | for | * | 2605 // | for | | | 2606 // | target parallel | for simd | * | 2607 // | for | | | 2608 // | target parallel | master | * | 2609 // | for | | | 2610 // | target parallel | critical | * | 2611 // | for | | | 2612 // | target parallel | simd | * | 2613 // | for | | | 2614 // | target parallel | sections | * | 2615 // | for | | | 2616 // | target parallel | section | * | 2617 // | for | | | 2618 // | target parallel | single | * | 2619 // | for | | | 2620 // | target parallel | parallel for | * | 2621 // | for | | | 2622 // | target parallel |parallel for simd| * | 2623 // | for | | | 2624 // | target parallel |parallel sections| * | 2625 // | for | | | 2626 // | target parallel | task | * | 2627 // | for | | | 2628 // | target parallel | taskyield | * | 2629 // | for | | | 2630 // | target parallel | barrier | * | 2631 // | for | | | 2632 // | target parallel | taskwait | * | 2633 // | for | | | 2634 // | target parallel | taskgroup | * | 2635 // | for | | | 2636 // | target parallel | flush | * | 2637 // | for | | | 2638 // | target parallel | ordered | * | 2639 // | for | | | 2640 // | target parallel | atomic | * | 2641 // | for | | | 2642 // | target parallel | target | | 2643 // | for | | | 2644 // | target parallel | target parallel | | 2645 // | for | | | 2646 // | target parallel | target parallel | | 2647 // | for | for | | 2648 // | target parallel | target enter | | 2649 // | for | data | | 2650 // | target parallel | target exit | | 2651 // | for | data | | 2652 // | target parallel | teams | | 2653 // | for | | | 2654 // | target parallel | cancellation | | 2655 // | for | point | ! | 2656 // | target parallel | cancel | ! | 2657 // | for | | | 2658 // | target parallel | taskloop | * | 2659 // | for | | | 2660 // | target parallel | taskloop simd | * | 2661 // | for | | | 2662 // | target parallel | distribute | | 2663 // | for | | | 2664 // | target parallel | distribute | | 2665 // | for | parallel for | | 2666 // | target parallel | distribute | | 2667 // | for |parallel for simd| | 2668 // | target parallel | distribute simd | | 2669 // | for | | | 2670 // | target parallel | target parallel | | 2671 // | for | for simd | | 2672 // +------------------+-----------------+------------------------------------+ 2673 // | teams | parallel | * | 2674 // | teams | for | + | 2675 // | teams | for simd | + | 2676 // | teams | master | + | 2677 // | teams | critical | + | 2678 // | teams | simd | + | 2679 // | teams | sections | + | 2680 // | teams | section | + | 2681 // | teams | single | + | 2682 // | teams | parallel for | * | 2683 // | teams |parallel for simd| * | 2684 // | teams |parallel sections| * | 2685 // | teams | task | + | 2686 // | teams | taskyield | + | 2687 // | teams | barrier | + | 2688 // | teams | taskwait | + | 2689 // | teams | taskgroup | + | 2690 // | teams | flush | + | 2691 // | teams | ordered | + | 2692 // | teams | atomic | + | 2693 // | teams | target | + | 2694 // | teams | target parallel | + | 2695 // | teams | target parallel | + | 2696 // | | for | | 2697 // | teams | target enter | + | 2698 // | | data | | 2699 // | teams | target exit | + | 2700 // | | data | | 2701 // | teams | teams | + | 2702 // | teams | cancellation | | 2703 // | | point | | 2704 // | teams | cancel | | 2705 // | teams | taskloop | + | 2706 // | teams | taskloop simd | + | 2707 // | teams | distribute | ! | 2708 // | teams | distribute | ! | 2709 // | | parallel for | | 2710 // | teams | distribute | ! | 2711 // | |parallel for simd| | 2712 // | teams | distribute simd | ! | 2713 // | teams | target parallel | + | 2714 // | | for simd | | 2715 // +------------------+-----------------+------------------------------------+ 2716 // | taskloop | parallel | * | 2717 // | taskloop | for | + | 2718 // | taskloop | for simd | + | 2719 // | taskloop | master | + | 2720 // | taskloop | critical | * | 2721 // | taskloop | simd | * | 2722 // | taskloop | sections | + | 2723 // | taskloop | section | + | 2724 // | taskloop | single | + | 2725 // | taskloop | parallel for | * | 2726 // | taskloop |parallel for simd| * | 2727 // | taskloop |parallel sections| * | 2728 // | taskloop | task | * | 2729 // | taskloop | taskyield | * | 2730 // | taskloop | barrier | + | 2731 // | taskloop | taskwait | * | 2732 // | taskloop | taskgroup | * | 2733 // | taskloop | flush | * | 2734 // | taskloop | ordered | + | 2735 // | taskloop | atomic | * | 2736 // | taskloop | target | * | 2737 // | taskloop | target parallel | * | 2738 // | taskloop | target parallel | * | 2739 // | | for | | 2740 // | taskloop | target enter | * | 2741 // | | data | | 2742 // | taskloop | target exit | * | 2743 // | | data | | 2744 // | taskloop | teams | + | 2745 // | taskloop | cancellation | | 2746 // | | point | | 2747 // | taskloop | cancel | | 2748 // | taskloop | taskloop | * | 2749 // | taskloop | distribute | + | 2750 // | taskloop | distribute | + | 2751 // | | parallel for | | 2752 // | taskloop | distribute | + | 2753 // | |parallel for simd| | 2754 // | taskloop | distribute simd | + | 2755 // | taskloop | target parallel | * | 2756 // | | for simd | | 2757 // +------------------+-----------------+------------------------------------+ 2758 // | taskloop simd | parallel | | 2759 // | taskloop simd | for | | 2760 // | taskloop simd | for simd | | 2761 // | taskloop simd | master | | 2762 // | taskloop simd | critical | | 2763 // | taskloop simd | simd | * | 2764 // | taskloop simd | sections | | 2765 // | taskloop simd | section | | 2766 // | taskloop simd | single | | 2767 // | taskloop simd | parallel for | | 2768 // | taskloop simd |parallel for simd| | 2769 // | taskloop simd |parallel sections| | 2770 // | taskloop simd | task | | 2771 // | taskloop simd | taskyield | | 2772 // | taskloop simd | barrier | | 2773 // | taskloop simd | taskwait | | 2774 // | taskloop simd | taskgroup | | 2775 // | taskloop simd | flush | | 2776 // | taskloop simd | ordered | + (with simd clause) | 2777 // | taskloop simd | atomic | | 2778 // | taskloop simd | target | | 2779 // | taskloop simd | target parallel | | 2780 // | taskloop simd | target parallel | | 2781 // | | for | | 2782 // | taskloop simd | target enter | | 2783 // | | data | | 2784 // | taskloop simd | target exit | | 2785 // | | data | | 2786 // | taskloop simd | teams | | 2787 // | taskloop simd | cancellation | | 2788 // | | point | | 2789 // | taskloop simd | cancel | | 2790 // | taskloop simd | taskloop | | 2791 // | taskloop simd | taskloop simd | | 2792 // | taskloop simd | distribute | | 2793 // | taskloop simd | distribute | | 2794 // | | parallel for | | 2795 // | taskloop simd | distribute | | 2796 // | |parallel for simd| | 2797 // | taskloop simd | distribute simd | | 2798 // | taskloop simd | target parallel | | 2799 // | | for simd | | 2800 // +------------------+-----------------+------------------------------------+ 2801 // | distribute | parallel | * | 2802 // | distribute | for | * | 2803 // | distribute | for simd | * | 2804 // | distribute | master | * | 2805 // | distribute | critical | * | 2806 // | distribute | simd | * | 2807 // | distribute | sections | * | 2808 // | distribute | section | * | 2809 // | distribute | single | * | 2810 // | distribute | parallel for | * | 2811 // | distribute |parallel for simd| * | 2812 // | distribute |parallel sections| * | 2813 // | distribute | task | * | 2814 // | distribute | taskyield | * | 2815 // | distribute | barrier | * | 2816 // | distribute | taskwait | * | 2817 // | distribute | taskgroup | * | 2818 // | distribute | flush | * | 2819 // | distribute | ordered | + | 2820 // | distribute | atomic | * | 2821 // | distribute | target | | 2822 // | distribute | target parallel | | 2823 // | distribute | target parallel | | 2824 // | | for | | 2825 // | distribute | target enter | | 2826 // | | data | | 2827 // | distribute | target exit | | 2828 // | | data | | 2829 // | distribute | teams | | 2830 // | distribute | cancellation | + | 2831 // | | point | | 2832 // | distribute | cancel | + | 2833 // | distribute | taskloop | * | 2834 // | distribute | taskloop simd | * | 2835 // | distribute | distribute | | 2836 // | distribute | distribute | | 2837 // | | parallel for | | 2838 // | distribute | distribute | | 2839 // | |parallel for simd| | 2840 // | distribute | distribute simd | | 2841 // | distribute | target parallel | | 2842 // | | for simd | | 2843 // +------------------+-----------------+------------------------------------+ 2844 // | distribute | parallel | * | 2845 // | parallel for | | | 2846 // | distribute | for | * | 2847 // | parallel for | | | 2848 // | distribute | for simd | * | 2849 // | parallel for | | | 2850 // | distribute | master | * | 2851 // | parallel for | | | 2852 // | distribute | critical | * | 2853 // | parallel for | | | 2854 // | distribute | simd | * | 2855 // | parallel for | | | 2856 // | distribute | sections | * | 2857 // | parallel for | | | 2858 // | distribute | section | * | 2859 // | parallel for | | | 2860 // | distribute | single | * | 2861 // | parallel for | | | 2862 // | distribute | parallel for | * | 2863 // | parallel for | | | 2864 // | distribute |parallel for simd| * | 2865 // | parallel for | | | 2866 // | distribute |parallel sections| * | 2867 // | parallel for | | | 2868 // | distribute | task | * | 2869 // | parallel for | | | 2870 // | parallel for | | | 2871 // | distribute | taskyield | * | 2872 // | parallel for | | | 2873 // | distribute | barrier | * | 2874 // | parallel for | | | 2875 // | distribute | taskwait | * | 2876 // | parallel for | | | 2877 // | distribute | taskgroup | * | 2878 // | parallel for | | | 2879 // | distribute | flush | * | 2880 // | parallel for | | | 2881 // | distribute | ordered | + | 2882 // | parallel for | | | 2883 // | distribute | atomic | * | 2884 // | parallel for | | | 2885 // | distribute | target | | 2886 // | parallel for | | | 2887 // | distribute | target parallel | | 2888 // | parallel for | | | 2889 // | distribute | target parallel | | 2890 // | parallel for | for | | 2891 // | distribute | target enter | | 2892 // | parallel for | data | | 2893 // | distribute | target exit | | 2894 // | parallel for | data | | 2895 // | distribute | teams | | 2896 // | parallel for | | | 2897 // | distribute | cancellation | + | 2898 // | parallel for | point | | 2899 // | distribute | cancel | + | 2900 // | parallel for | | | 2901 // | distribute | taskloop | * | 2902 // | parallel for | | | 2903 // | distribute | taskloop simd | * | 2904 // | parallel for | | | 2905 // | distribute | distribute | | 2906 // | parallel for | | | 2907 // | distribute | distribute | | 2908 // | parallel for | parallel for | | 2909 // | distribute | distribute | | 2910 // | parallel for |parallel for simd| | 2911 // | distribute | distribute simd | | 2912 // | parallel for | | | 2913 // | distribute | target parallel | | 2914 // | parallel for | for simd | | 2915 // +------------------+-----------------+------------------------------------+ 2916 // | distribute | parallel | * | 2917 // | parallel for simd| | | 2918 // | distribute | for | * | 2919 // | parallel for simd| | | 2920 // | distribute | for simd | * | 2921 // | parallel for simd| | | 2922 // | distribute | master | * | 2923 // | parallel for simd| | | 2924 // | distribute | critical | * | 2925 // | parallel for simd| | | 2926 // | distribute | simd | * | 2927 // | parallel for simd| | | 2928 // | distribute | sections | * | 2929 // | parallel for simd| | | 2930 // | distribute | section | * | 2931 // | parallel for simd| | | 2932 // | distribute | single | * | 2933 // | parallel for simd| | | 2934 // | distribute | parallel for | * | 2935 // | parallel for simd| | | 2936 // | distribute |parallel for simd| * | 2937 // | parallel for simd| | | 2938 // | distribute |parallel sections| * | 2939 // | parallel for simd| | | 2940 // | distribute | task | * | 2941 // | parallel for simd| | | 2942 // | distribute | taskyield | * | 2943 // | parallel for simd| | | 2944 // | distribute | barrier | * | 2945 // | parallel for simd| | | 2946 // | distribute | taskwait | * | 2947 // | parallel for simd| | | 2948 // | distribute | taskgroup | * | 2949 // | parallel for simd| | | 2950 // | distribute | flush | * | 2951 // | parallel for simd| | | 2952 // | distribute | ordered | + | 2953 // | parallel for simd| | | 2954 // | distribute | atomic | * | 2955 // | parallel for simd| | | 2956 // | distribute | target | | 2957 // | parallel for simd| | | 2958 // | distribute | target parallel | | 2959 // | parallel for simd| | | 2960 // | distribute | target parallel | | 2961 // | parallel for simd| for | | 2962 // | distribute | target enter | | 2963 // | parallel for simd| data | | 2964 // | distribute | target exit | | 2965 // | parallel for simd| data | | 2966 // | distribute | teams | | 2967 // | parallel for simd| | | 2968 // | distribute | cancellation | + | 2969 // | parallel for simd| point | | 2970 // | distribute | cancel | + | 2971 // | parallel for simd| | | 2972 // | distribute | taskloop | * | 2973 // | parallel for simd| | | 2974 // | distribute | taskloop simd | * | 2975 // | parallel for simd| | | 2976 // | distribute | distribute | | 2977 // | parallel for simd| | | 2978 // | distribute | distribute | * | 2979 // | parallel for simd| parallel for | | 2980 // | distribute | distribute | * | 2981 // | parallel for simd|parallel for simd| | 2982 // | distribute | distribute simd | * | 2983 // | parallel for simd| | | 2984 // | distribute | target parallel | | 2985 // | parallel for simd| for simd | | 2986 // +------------------+-----------------+------------------------------------+ 2987 // | distribute simd | parallel | * | 2988 // | distribute simd | for | * | 2989 // | distribute simd | for simd | * | 2990 // | distribute simd | master | * | 2991 // | distribute simd | critical | * | 2992 // | distribute simd | simd | * | 2993 // | distribute simd | sections | * | 2994 // | distribute simd | section | * | 2995 // | distribute simd | single | * | 2996 // | distribute simd | parallel for | * | 2997 // | distribute simd |parallel for simd| * | 2998 // | distribute simd |parallel sections| * | 2999 // | distribute simd | task | * | 3000 // | distribute simd | taskyield | * | 3001 // | distribute simd | barrier | * | 3002 // | distribute simd | taskwait | * | 3003 // | distribute simd | taskgroup | * | 3004 // | distribute simd | flush | * | 3005 // | distribute simd | ordered | + | 3006 // | distribute simd | atomic | * | 3007 // | distribute simd | target | * | 3008 // | distribute simd | target parallel | * | 3009 // | distribute simd | target parallel | * | 3010 // | | for | | 3011 // | distribute simd | target enter | * | 3012 // | | data | | 3013 // | distribute simd | target exit | * | 3014 // | | data | | 3015 // | distribute simd | teams | * | 3016 // | distribute simd | cancellation | + | 3017 // | | point | | 3018 // | distribute simd | cancel | + | 3019 // | distribute simd | taskloop | * | 3020 // | distribute simd | taskloop simd | * | 3021 // | distribute simd | distribute | | 3022 // | distribute simd | distribute | * | 3023 // | | parallel for | | 3024 // | distribute simd | distribute | * | 3025 // | |parallel for simd| | 3026 // | distribute simd | distribute simd | * | 3027 // | distribute simd | target parallel | * | 3028 // | | for simd | | 3029 // +------------------+-----------------+------------------------------------+ 3030 // | target parallel | parallel | * | 3031 // | for simd | | | 3032 // | target parallel | for | * | 3033 // | for simd | | | 3034 // | target parallel | for simd | * | 3035 // | for simd | | | 3036 // | target parallel | master | * | 3037 // | for simd | | | 3038 // | target parallel | critical | * | 3039 // | for simd | | | 3040 // | target parallel | simd | ! | 3041 // | for simd | | | 3042 // | target parallel | sections | * | 3043 // | for simd | | | 3044 // | target parallel | section | * | 3045 // | for simd | | | 3046 // | target parallel | single | * | 3047 // | for simd | | | 3048 // | target parallel | parallel for | * | 3049 // | for simd | | | 3050 // | target parallel |parallel for simd| * | 3051 // | for simd | | | 3052 // | target parallel |parallel sections| * | 3053 // | for simd | | | 3054 // | target parallel | task | * | 3055 // | for simd | | | 3056 // | target parallel | taskyield | * | 3057 // | for simd | | | 3058 // | target parallel | barrier | * | 3059 // | for simd | | | 3060 // | target parallel | taskwait | * | 3061 // | for simd | | | 3062 // | target parallel | taskgroup | * | 3063 // | for simd | | | 3064 // | target parallel | flush | * | 3065 // | for simd | | | 3066 // | target parallel | ordered | + (with simd clause) | 3067 // | for simd | | | 3068 // | target parallel | atomic | * | 3069 // | for simd | | | 3070 // | target parallel | target | * | 3071 // | for simd | | | 3072 // | target parallel | target parallel | * | 3073 // | for simd | | | 3074 // | target parallel | target parallel | * | 3075 // | for simd | for | | 3076 // | target parallel | target enter | * | 3077 // | for simd | data | | 3078 // | target parallel | target exit | * | 3079 // | for simd | data | | 3080 // | target parallel | teams | * | 3081 // | for simd | | | 3082 // | target parallel | cancellation | * | 3083 // | for simd | point | | 3084 // | target parallel | cancel | * | 3085 // | for simd | | | 3086 // | target parallel | taskloop | * | 3087 // | for simd | | | 3088 // | target parallel | taskloop simd | * | 3089 // | for simd | | | 3090 // | target parallel | distribute | * | 3091 // | for simd | | | 3092 // | target parallel | distribute | * | 3093 // | for simd | parallel for | | 3094 // | target parallel | distribute | * | 3095 // | for simd |parallel for simd| | 3096 // | target parallel | distribute simd | * | 3097 // | for simd | | | 3098 // | target parallel | target parallel | * | 3099 // | for simd | for simd | | 3100 // +------------------+-----------------+------------------------------------+ 3101 if (Stack->getCurScope()) { 3102 auto ParentRegion = Stack->getParentDirective(); 3103 auto OffendingRegion = ParentRegion; 3104 bool NestingProhibited = false; 3105 bool CloseNesting = true; 3106 enum { 3107 NoRecommend, 3108 ShouldBeInParallelRegion, 3109 ShouldBeInOrderedRegion, 3110 ShouldBeInTargetRegion, 3111 ShouldBeInTeamsRegion 3112 } Recommend = NoRecommend; 3113 if (isOpenMPSimdDirective(ParentRegion) && CurrentRegion != OMPD_ordered) { 3114 // OpenMP [2.16, Nesting of Regions] 3115 // OpenMP constructs may not be nested inside a simd region. 3116 // OpenMP [2.8.1,simd Construct, Restrictions] 3117 // An ordered construct with the simd clause is the only OpenMP 3118 // construct that can appear in the simd region. 3119 // Allowing a SIMD consruct nested in another SIMD construct is an 3120 // extension. The OpenMP 4.5 spec does not allow it. Issue a warning 3121 // message. 3122 SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd) 3123 ? diag::err_omp_prohibited_region_simd 3124 : diag::warn_omp_nesting_simd); 3125 return CurrentRegion != OMPD_simd; 3126 } 3127 if (ParentRegion == OMPD_atomic) { 3128 // OpenMP [2.16, Nesting of Regions] 3129 // OpenMP constructs may not be nested inside an atomic region. 3130 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_atomic); 3131 return true; 3132 } 3133 if (CurrentRegion == OMPD_section) { 3134 // OpenMP [2.7.2, sections Construct, Restrictions] 3135 // Orphaned section directives are prohibited. That is, the section 3136 // directives must appear within the sections construct and must not be 3137 // encountered elsewhere in the sections region. 3138 if (ParentRegion != OMPD_sections && 3139 ParentRegion != OMPD_parallel_sections) { 3140 SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive) 3141 << (ParentRegion != OMPD_unknown) 3142 << getOpenMPDirectiveName(ParentRegion); 3143 return true; 3144 } 3145 return false; 3146 } 3147 // Allow some constructs to be orphaned (they could be used in functions, 3148 // called from OpenMP regions with the required preconditions). 3149 if (ParentRegion == OMPD_unknown) 3150 return false; 3151 if (CurrentRegion == OMPD_cancellation_point || 3152 CurrentRegion == OMPD_cancel) { 3153 // OpenMP [2.16, Nesting of Regions] 3154 // A cancellation point construct for which construct-type-clause is 3155 // taskgroup must be nested inside a task construct. A cancellation 3156 // point construct for which construct-type-clause is not taskgroup must 3157 // be closely nested inside an OpenMP construct that matches the type 3158 // specified in construct-type-clause. 3159 // A cancel construct for which construct-type-clause is taskgroup must be 3160 // nested inside a task construct. A cancel construct for which 3161 // construct-type-clause is not taskgroup must be closely nested inside an 3162 // OpenMP construct that matches the type specified in 3163 // construct-type-clause. 3164 NestingProhibited = 3165 !((CancelRegion == OMPD_parallel && 3166 (ParentRegion == OMPD_parallel || 3167 ParentRegion == OMPD_target_parallel)) || 3168 (CancelRegion == OMPD_for && 3169 (ParentRegion == OMPD_for || ParentRegion == OMPD_parallel_for || 3170 ParentRegion == OMPD_target_parallel_for)) || 3171 (CancelRegion == OMPD_taskgroup && ParentRegion == OMPD_task) || 3172 (CancelRegion == OMPD_sections && 3173 (ParentRegion == OMPD_section || ParentRegion == OMPD_sections || 3174 ParentRegion == OMPD_parallel_sections))); 3175 } else if (CurrentRegion == OMPD_master) { 3176 // OpenMP [2.16, Nesting of Regions] 3177 // A master region may not be closely nested inside a worksharing, 3178 // atomic, or explicit task region. 3179 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) || 3180 isOpenMPTaskingDirective(ParentRegion); 3181 } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) { 3182 // OpenMP [2.16, Nesting of Regions] 3183 // A critical region may not be nested (closely or otherwise) inside a 3184 // critical region with the same name. Note that this restriction is not 3185 // sufficient to prevent deadlock. 3186 SourceLocation PreviousCriticalLoc; 3187 bool DeadLock = 3188 Stack->hasDirective([CurrentName, &PreviousCriticalLoc]( 3189 OpenMPDirectiveKind K, 3190 const DeclarationNameInfo &DNI, 3191 SourceLocation Loc) 3192 ->bool { 3193 if (K == OMPD_critical && 3194 DNI.getName() == CurrentName.getName()) { 3195 PreviousCriticalLoc = Loc; 3196 return true; 3197 } else 3198 return false; 3199 }, 3200 false /* skip top directive */); 3201 if (DeadLock) { 3202 SemaRef.Diag(StartLoc, 3203 diag::err_omp_prohibited_region_critical_same_name) 3204 << CurrentName.getName(); 3205 if (PreviousCriticalLoc.isValid()) 3206 SemaRef.Diag(PreviousCriticalLoc, 3207 diag::note_omp_previous_critical_region); 3208 return true; 3209 } 3210 } else if (CurrentRegion == OMPD_barrier) { 3211 // OpenMP [2.16, Nesting of Regions] 3212 // A barrier region may not be closely nested inside a worksharing, 3213 // explicit task, critical, ordered, atomic, or master region. 3214 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) || 3215 isOpenMPTaskingDirective(ParentRegion) || 3216 ParentRegion == OMPD_master || 3217 ParentRegion == OMPD_critical || 3218 ParentRegion == OMPD_ordered; 3219 } else if (isOpenMPWorksharingDirective(CurrentRegion) && 3220 !isOpenMPParallelDirective(CurrentRegion)) { 3221 // OpenMP [2.16, Nesting of Regions] 3222 // A worksharing region may not be closely nested inside a worksharing, 3223 // explicit task, critical, ordered, atomic, or master region. 3224 NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) || 3225 isOpenMPTaskingDirective(ParentRegion) || 3226 ParentRegion == OMPD_master || 3227 ParentRegion == OMPD_critical || 3228 ParentRegion == OMPD_ordered; 3229 Recommend = ShouldBeInParallelRegion; 3230 } else if (CurrentRegion == OMPD_ordered) { 3231 // OpenMP [2.16, Nesting of Regions] 3232 // An ordered region may not be closely nested inside a critical, 3233 // atomic, or explicit task region. 3234 // An ordered region must be closely nested inside a loop region (or 3235 // parallel loop region) with an ordered clause. 3236 // OpenMP [2.8.1,simd Construct, Restrictions] 3237 // An ordered construct with the simd clause is the only OpenMP construct 3238 // that can appear in the simd region. 3239 NestingProhibited = ParentRegion == OMPD_critical || 3240 isOpenMPTaskingDirective(ParentRegion) || 3241 !(isOpenMPSimdDirective(ParentRegion) || 3242 Stack->isParentOrderedRegion()); 3243 Recommend = ShouldBeInOrderedRegion; 3244 } else if (isOpenMPTeamsDirective(CurrentRegion)) { 3245 // OpenMP [2.16, Nesting of Regions] 3246 // If specified, a teams construct must be contained within a target 3247 // construct. 3248 NestingProhibited = ParentRegion != OMPD_target; 3249 Recommend = ShouldBeInTargetRegion; 3250 Stack->setParentTeamsRegionLoc(Stack->getConstructLoc()); 3251 } 3252 if (!NestingProhibited && isOpenMPTeamsDirective(ParentRegion)) { 3253 // OpenMP [2.16, Nesting of Regions] 3254 // distribute, parallel, parallel sections, parallel workshare, and the 3255 // parallel loop and parallel loop SIMD constructs are the only OpenMP 3256 // constructs that can be closely nested in the teams region. 3257 NestingProhibited = !isOpenMPParallelDirective(CurrentRegion) && 3258 !isOpenMPDistributeDirective(CurrentRegion); 3259 Recommend = ShouldBeInParallelRegion; 3260 } 3261 if (!NestingProhibited && isOpenMPDistributeDirective(CurrentRegion)) { 3262 // OpenMP 4.5 [2.17 Nesting of Regions] 3263 // The region associated with the distribute construct must be strictly 3264 // nested inside a teams region 3265 NestingProhibited = !isOpenMPTeamsDirective(ParentRegion); 3266 Recommend = ShouldBeInTeamsRegion; 3267 } 3268 if (!NestingProhibited && 3269 (isOpenMPTargetExecutionDirective(CurrentRegion) || 3270 isOpenMPTargetDataManagementDirective(CurrentRegion))) { 3271 // OpenMP 4.5 [2.17 Nesting of Regions] 3272 // If a target, target update, target data, target enter data, or 3273 // target exit data construct is encountered during execution of a 3274 // target region, the behavior is unspecified. 3275 NestingProhibited = Stack->hasDirective( 3276 [&OffendingRegion](OpenMPDirectiveKind K, const DeclarationNameInfo &, 3277 SourceLocation) -> bool { 3278 if (isOpenMPTargetExecutionDirective(K)) { 3279 OffendingRegion = K; 3280 return true; 3281 } else 3282 return false; 3283 }, 3284 false /* don't skip top directive */); 3285 CloseNesting = false; 3286 } 3287 if (NestingProhibited) { 3288 SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region) 3289 << CloseNesting << getOpenMPDirectiveName(OffendingRegion) 3290 << Recommend << getOpenMPDirectiveName(CurrentRegion); 3291 return true; 3292 } 3293 } 3294 return false; 3295 } 3296 3297 static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind, 3298 ArrayRef<OMPClause *> Clauses, 3299 ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) { 3300 bool ErrorFound = false; 3301 unsigned NamedModifiersNumber = 0; 3302 SmallVector<const OMPIfClause *, OMPC_unknown + 1> FoundNameModifiers( 3303 OMPD_unknown + 1); 3304 SmallVector<SourceLocation, 4> NameModifierLoc; 3305 for (const auto *C : Clauses) { 3306 if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) { 3307 // At most one if clause without a directive-name-modifier can appear on 3308 // the directive. 3309 OpenMPDirectiveKind CurNM = IC->getNameModifier(); 3310 if (FoundNameModifiers[CurNM]) { 3311 S.Diag(C->getLocStart(), diag::err_omp_more_one_clause) 3312 << getOpenMPDirectiveName(Kind) << getOpenMPClauseName(OMPC_if) 3313 << (CurNM != OMPD_unknown) << getOpenMPDirectiveName(CurNM); 3314 ErrorFound = true; 3315 } else if (CurNM != OMPD_unknown) { 3316 NameModifierLoc.push_back(IC->getNameModifierLoc()); 3317 ++NamedModifiersNumber; 3318 } 3319 FoundNameModifiers[CurNM] = IC; 3320 if (CurNM == OMPD_unknown) 3321 continue; 3322 // Check if the specified name modifier is allowed for the current 3323 // directive. 3324 // At most one if clause with the particular directive-name-modifier can 3325 // appear on the directive. 3326 bool MatchFound = false; 3327 for (auto NM : AllowedNameModifiers) { 3328 if (CurNM == NM) { 3329 MatchFound = true; 3330 break; 3331 } 3332 } 3333 if (!MatchFound) { 3334 S.Diag(IC->getNameModifierLoc(), 3335 diag::err_omp_wrong_if_directive_name_modifier) 3336 << getOpenMPDirectiveName(CurNM) << getOpenMPDirectiveName(Kind); 3337 ErrorFound = true; 3338 } 3339 } 3340 } 3341 // If any if clause on the directive includes a directive-name-modifier then 3342 // all if clauses on the directive must include a directive-name-modifier. 3343 if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) { 3344 if (NamedModifiersNumber == AllowedNameModifiers.size()) { 3345 S.Diag(FoundNameModifiers[OMPD_unknown]->getLocStart(), 3346 diag::err_omp_no_more_if_clause); 3347 } else { 3348 std::string Values; 3349 std::string Sep(", "); 3350 unsigned AllowedCnt = 0; 3351 unsigned TotalAllowedNum = 3352 AllowedNameModifiers.size() - NamedModifiersNumber; 3353 for (unsigned Cnt = 0, End = AllowedNameModifiers.size(); Cnt < End; 3354 ++Cnt) { 3355 OpenMPDirectiveKind NM = AllowedNameModifiers[Cnt]; 3356 if (!FoundNameModifiers[NM]) { 3357 Values += "'"; 3358 Values += getOpenMPDirectiveName(NM); 3359 Values += "'"; 3360 if (AllowedCnt + 2 == TotalAllowedNum) 3361 Values += " or "; 3362 else if (AllowedCnt + 1 != TotalAllowedNum) 3363 Values += Sep; 3364 ++AllowedCnt; 3365 } 3366 } 3367 S.Diag(FoundNameModifiers[OMPD_unknown]->getCondition()->getLocStart(), 3368 diag::err_omp_unnamed_if_clause) 3369 << (TotalAllowedNum > 1) << Values; 3370 } 3371 for (auto Loc : NameModifierLoc) { 3372 S.Diag(Loc, diag::note_omp_previous_named_if_clause); 3373 } 3374 ErrorFound = true; 3375 } 3376 return ErrorFound; 3377 } 3378 3379 StmtResult Sema::ActOnOpenMPExecutableDirective( 3380 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, 3381 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses, 3382 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) { 3383 StmtResult Res = StmtError(); 3384 if (CheckNestingOfRegions(*this, DSAStack, Kind, DirName, CancelRegion, 3385 StartLoc)) 3386 return StmtError(); 3387 3388 llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit; 3389 llvm::DenseMap<ValueDecl *, Expr *> VarsWithInheritedDSA; 3390 bool ErrorFound = false; 3391 ClausesWithImplicit.append(Clauses.begin(), Clauses.end()); 3392 if (AStmt) { 3393 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 3394 3395 // Check default data sharing attributes for referenced variables. 3396 DSAAttrChecker DSAChecker(DSAStack, *this, cast<CapturedStmt>(AStmt)); 3397 DSAChecker.Visit(cast<CapturedStmt>(AStmt)->getCapturedStmt()); 3398 if (DSAChecker.isErrorFound()) 3399 return StmtError(); 3400 // Generate list of implicitly defined firstprivate variables. 3401 VarsWithInheritedDSA = DSAChecker.getVarsWithInheritedDSA(); 3402 3403 if (!DSAChecker.getImplicitFirstprivate().empty()) { 3404 if (OMPClause *Implicit = ActOnOpenMPFirstprivateClause( 3405 DSAChecker.getImplicitFirstprivate(), SourceLocation(), 3406 SourceLocation(), SourceLocation())) { 3407 ClausesWithImplicit.push_back(Implicit); 3408 ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() != 3409 DSAChecker.getImplicitFirstprivate().size(); 3410 } else 3411 ErrorFound = true; 3412 } 3413 } 3414 3415 llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers; 3416 switch (Kind) { 3417 case OMPD_parallel: 3418 Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc, 3419 EndLoc); 3420 AllowedNameModifiers.push_back(OMPD_parallel); 3421 break; 3422 case OMPD_simd: 3423 Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc, 3424 VarsWithInheritedDSA); 3425 break; 3426 case OMPD_for: 3427 Res = ActOnOpenMPForDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc, 3428 VarsWithInheritedDSA); 3429 break; 3430 case OMPD_for_simd: 3431 Res = ActOnOpenMPForSimdDirective(ClausesWithImplicit, AStmt, StartLoc, 3432 EndLoc, VarsWithInheritedDSA); 3433 break; 3434 case OMPD_sections: 3435 Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc, 3436 EndLoc); 3437 break; 3438 case OMPD_section: 3439 assert(ClausesWithImplicit.empty() && 3440 "No clauses are allowed for 'omp section' directive"); 3441 Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc); 3442 break; 3443 case OMPD_single: 3444 Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc, 3445 EndLoc); 3446 break; 3447 case OMPD_master: 3448 assert(ClausesWithImplicit.empty() && 3449 "No clauses are allowed for 'omp master' directive"); 3450 Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc); 3451 break; 3452 case OMPD_critical: 3453 Res = ActOnOpenMPCriticalDirective(DirName, ClausesWithImplicit, AStmt, 3454 StartLoc, EndLoc); 3455 break; 3456 case OMPD_parallel_for: 3457 Res = ActOnOpenMPParallelForDirective(ClausesWithImplicit, AStmt, StartLoc, 3458 EndLoc, VarsWithInheritedDSA); 3459 AllowedNameModifiers.push_back(OMPD_parallel); 3460 break; 3461 case OMPD_parallel_for_simd: 3462 Res = ActOnOpenMPParallelForSimdDirective( 3463 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); 3464 AllowedNameModifiers.push_back(OMPD_parallel); 3465 break; 3466 case OMPD_parallel_sections: 3467 Res = ActOnOpenMPParallelSectionsDirective(ClausesWithImplicit, AStmt, 3468 StartLoc, EndLoc); 3469 AllowedNameModifiers.push_back(OMPD_parallel); 3470 break; 3471 case OMPD_task: 3472 Res = 3473 ActOnOpenMPTaskDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc); 3474 AllowedNameModifiers.push_back(OMPD_task); 3475 break; 3476 case OMPD_taskyield: 3477 assert(ClausesWithImplicit.empty() && 3478 "No clauses are allowed for 'omp taskyield' directive"); 3479 assert(AStmt == nullptr && 3480 "No associated statement allowed for 'omp taskyield' directive"); 3481 Res = ActOnOpenMPTaskyieldDirective(StartLoc, EndLoc); 3482 break; 3483 case OMPD_barrier: 3484 assert(ClausesWithImplicit.empty() && 3485 "No clauses are allowed for 'omp barrier' directive"); 3486 assert(AStmt == nullptr && 3487 "No associated statement allowed for 'omp barrier' directive"); 3488 Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc); 3489 break; 3490 case OMPD_taskwait: 3491 assert(ClausesWithImplicit.empty() && 3492 "No clauses are allowed for 'omp taskwait' directive"); 3493 assert(AStmt == nullptr && 3494 "No associated statement allowed for 'omp taskwait' directive"); 3495 Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc); 3496 break; 3497 case OMPD_taskgroup: 3498 assert(ClausesWithImplicit.empty() && 3499 "No clauses are allowed for 'omp taskgroup' directive"); 3500 Res = ActOnOpenMPTaskgroupDirective(AStmt, StartLoc, EndLoc); 3501 break; 3502 case OMPD_flush: 3503 assert(AStmt == nullptr && 3504 "No associated statement allowed for 'omp flush' directive"); 3505 Res = ActOnOpenMPFlushDirective(ClausesWithImplicit, StartLoc, EndLoc); 3506 break; 3507 case OMPD_ordered: 3508 Res = ActOnOpenMPOrderedDirective(ClausesWithImplicit, AStmt, StartLoc, 3509 EndLoc); 3510 break; 3511 case OMPD_atomic: 3512 Res = ActOnOpenMPAtomicDirective(ClausesWithImplicit, AStmt, StartLoc, 3513 EndLoc); 3514 break; 3515 case OMPD_teams: 3516 Res = 3517 ActOnOpenMPTeamsDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc); 3518 break; 3519 case OMPD_target: 3520 Res = ActOnOpenMPTargetDirective(ClausesWithImplicit, AStmt, StartLoc, 3521 EndLoc); 3522 AllowedNameModifiers.push_back(OMPD_target); 3523 break; 3524 case OMPD_target_parallel: 3525 Res = ActOnOpenMPTargetParallelDirective(ClausesWithImplicit, AStmt, 3526 StartLoc, EndLoc); 3527 AllowedNameModifiers.push_back(OMPD_target); 3528 AllowedNameModifiers.push_back(OMPD_parallel); 3529 break; 3530 case OMPD_target_parallel_for: 3531 Res = ActOnOpenMPTargetParallelForDirective( 3532 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); 3533 AllowedNameModifiers.push_back(OMPD_target); 3534 AllowedNameModifiers.push_back(OMPD_parallel); 3535 break; 3536 case OMPD_cancellation_point: 3537 assert(ClausesWithImplicit.empty() && 3538 "No clauses are allowed for 'omp cancellation point' directive"); 3539 assert(AStmt == nullptr && "No associated statement allowed for 'omp " 3540 "cancellation point' directive"); 3541 Res = ActOnOpenMPCancellationPointDirective(StartLoc, EndLoc, CancelRegion); 3542 break; 3543 case OMPD_cancel: 3544 assert(AStmt == nullptr && 3545 "No associated statement allowed for 'omp cancel' directive"); 3546 Res = ActOnOpenMPCancelDirective(ClausesWithImplicit, StartLoc, EndLoc, 3547 CancelRegion); 3548 AllowedNameModifiers.push_back(OMPD_cancel); 3549 break; 3550 case OMPD_target_data: 3551 Res = ActOnOpenMPTargetDataDirective(ClausesWithImplicit, AStmt, StartLoc, 3552 EndLoc); 3553 AllowedNameModifiers.push_back(OMPD_target_data); 3554 break; 3555 case OMPD_target_enter_data: 3556 Res = ActOnOpenMPTargetEnterDataDirective(ClausesWithImplicit, StartLoc, 3557 EndLoc); 3558 AllowedNameModifiers.push_back(OMPD_target_enter_data); 3559 break; 3560 case OMPD_target_exit_data: 3561 Res = ActOnOpenMPTargetExitDataDirective(ClausesWithImplicit, StartLoc, 3562 EndLoc); 3563 AllowedNameModifiers.push_back(OMPD_target_exit_data); 3564 break; 3565 case OMPD_taskloop: 3566 Res = ActOnOpenMPTaskLoopDirective(ClausesWithImplicit, AStmt, StartLoc, 3567 EndLoc, VarsWithInheritedDSA); 3568 AllowedNameModifiers.push_back(OMPD_taskloop); 3569 break; 3570 case OMPD_taskloop_simd: 3571 Res = ActOnOpenMPTaskLoopSimdDirective(ClausesWithImplicit, AStmt, StartLoc, 3572 EndLoc, VarsWithInheritedDSA); 3573 AllowedNameModifiers.push_back(OMPD_taskloop); 3574 break; 3575 case OMPD_distribute: 3576 Res = ActOnOpenMPDistributeDirective(ClausesWithImplicit, AStmt, StartLoc, 3577 EndLoc, VarsWithInheritedDSA); 3578 break; 3579 case OMPD_target_update: 3580 assert(!AStmt && "Statement is not allowed for target update"); 3581 Res = 3582 ActOnOpenMPTargetUpdateDirective(ClausesWithImplicit, StartLoc, EndLoc); 3583 AllowedNameModifiers.push_back(OMPD_target_update); 3584 break; 3585 case OMPD_distribute_parallel_for: 3586 Res = ActOnOpenMPDistributeParallelForDirective( 3587 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); 3588 AllowedNameModifiers.push_back(OMPD_parallel); 3589 break; 3590 case OMPD_distribute_parallel_for_simd: 3591 Res = ActOnOpenMPDistributeParallelForSimdDirective( 3592 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); 3593 AllowedNameModifiers.push_back(OMPD_parallel); 3594 break; 3595 case OMPD_distribute_simd: 3596 Res = ActOnOpenMPDistributeSimdDirective( 3597 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); 3598 break; 3599 case OMPD_target_parallel_for_simd: 3600 Res = ActOnOpenMPTargetParallelForSimdDirective( 3601 ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA); 3602 AllowedNameModifiers.push_back(OMPD_target); 3603 AllowedNameModifiers.push_back(OMPD_parallel); 3604 break; 3605 case OMPD_declare_target: 3606 case OMPD_end_declare_target: 3607 case OMPD_threadprivate: 3608 case OMPD_declare_reduction: 3609 case OMPD_declare_simd: 3610 llvm_unreachable("OpenMP Directive is not allowed"); 3611 case OMPD_unknown: 3612 llvm_unreachable("Unknown OpenMP directive"); 3613 } 3614 3615 for (auto P : VarsWithInheritedDSA) { 3616 Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable) 3617 << P.first << P.second->getSourceRange(); 3618 } 3619 ErrorFound = !VarsWithInheritedDSA.empty() || ErrorFound; 3620 3621 if (!AllowedNameModifiers.empty()) 3622 ErrorFound = checkIfClauses(*this, Kind, Clauses, AllowedNameModifiers) || 3623 ErrorFound; 3624 3625 if (ErrorFound) 3626 return StmtError(); 3627 return Res; 3628 } 3629 3630 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective( 3631 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, 3632 ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds, 3633 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears, 3634 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) { 3635 assert(Aligneds.size() == Alignments.size()); 3636 assert(Linears.size() == LinModifiers.size()); 3637 assert(Linears.size() == Steps.size()); 3638 if (!DG || DG.get().isNull()) 3639 return DeclGroupPtrTy(); 3640 3641 if (!DG.get().isSingleDecl()) { 3642 Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd); 3643 return DG; 3644 } 3645 auto *ADecl = DG.get().getSingleDecl(); 3646 if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl)) 3647 ADecl = FTD->getTemplatedDecl(); 3648 3649 auto *FD = dyn_cast<FunctionDecl>(ADecl); 3650 if (!FD) { 3651 Diag(ADecl->getLocation(), diag::err_omp_function_expected); 3652 return DeclGroupPtrTy(); 3653 } 3654 3655 // OpenMP [2.8.2, declare simd construct, Description] 3656 // The parameter of the simdlen clause must be a constant positive integer 3657 // expression. 3658 ExprResult SL; 3659 if (Simdlen) 3660 SL = VerifyPositiveIntegerConstantInClause(Simdlen, OMPC_simdlen); 3661 // OpenMP [2.8.2, declare simd construct, Description] 3662 // The special this pointer can be used as if was one of the arguments to the 3663 // function in any of the linear, aligned, or uniform clauses. 3664 // The uniform clause declares one or more arguments to have an invariant 3665 // value for all concurrent invocations of the function in the execution of a 3666 // single SIMD loop. 3667 llvm::DenseMap<Decl *, Expr *> UniformedArgs; 3668 Expr *UniformedLinearThis = nullptr; 3669 for (auto *E : Uniforms) { 3670 E = E->IgnoreParenImpCasts(); 3671 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) 3672 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) 3673 if (FD->getNumParams() > PVD->getFunctionScopeIndex() && 3674 FD->getParamDecl(PVD->getFunctionScopeIndex()) 3675 ->getCanonicalDecl() == PVD->getCanonicalDecl()) { 3676 UniformedArgs.insert(std::make_pair(PVD->getCanonicalDecl(), E)); 3677 continue; 3678 } 3679 if (isa<CXXThisExpr>(E)) { 3680 UniformedLinearThis = E; 3681 continue; 3682 } 3683 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause) 3684 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0); 3685 } 3686 // OpenMP [2.8.2, declare simd construct, Description] 3687 // The aligned clause declares that the object to which each list item points 3688 // is aligned to the number of bytes expressed in the optional parameter of 3689 // the aligned clause. 3690 // The special this pointer can be used as if was one of the arguments to the 3691 // function in any of the linear, aligned, or uniform clauses. 3692 // The type of list items appearing in the aligned clause must be array, 3693 // pointer, reference to array, or reference to pointer. 3694 llvm::DenseMap<Decl *, Expr *> AlignedArgs; 3695 Expr *AlignedThis = nullptr; 3696 for (auto *E : Aligneds) { 3697 E = E->IgnoreParenImpCasts(); 3698 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) 3699 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) { 3700 auto *CanonPVD = PVD->getCanonicalDecl(); 3701 if (FD->getNumParams() > PVD->getFunctionScopeIndex() && 3702 FD->getParamDecl(PVD->getFunctionScopeIndex()) 3703 ->getCanonicalDecl() == CanonPVD) { 3704 // OpenMP [2.8.1, simd construct, Restrictions] 3705 // A list-item cannot appear in more than one aligned clause. 3706 if (AlignedArgs.count(CanonPVD) > 0) { 3707 Diag(E->getExprLoc(), diag::err_omp_aligned_twice) 3708 << 1 << E->getSourceRange(); 3709 Diag(AlignedArgs[CanonPVD]->getExprLoc(), 3710 diag::note_omp_explicit_dsa) 3711 << getOpenMPClauseName(OMPC_aligned); 3712 continue; 3713 } 3714 AlignedArgs[CanonPVD] = E; 3715 QualType QTy = PVD->getType() 3716 .getNonReferenceType() 3717 .getUnqualifiedType() 3718 .getCanonicalType(); 3719 const Type *Ty = QTy.getTypePtrOrNull(); 3720 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) { 3721 Diag(E->getExprLoc(), diag::err_omp_aligned_expected_array_or_ptr) 3722 << QTy << getLangOpts().CPlusPlus << E->getSourceRange(); 3723 Diag(PVD->getLocation(), diag::note_previous_decl) << PVD; 3724 } 3725 continue; 3726 } 3727 } 3728 if (isa<CXXThisExpr>(E)) { 3729 if (AlignedThis) { 3730 Diag(E->getExprLoc(), diag::err_omp_aligned_twice) 3731 << 2 << E->getSourceRange(); 3732 Diag(AlignedThis->getExprLoc(), diag::note_omp_explicit_dsa) 3733 << getOpenMPClauseName(OMPC_aligned); 3734 } 3735 AlignedThis = E; 3736 continue; 3737 } 3738 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause) 3739 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0); 3740 } 3741 // The optional parameter of the aligned clause, alignment, must be a constant 3742 // positive integer expression. If no optional parameter is specified, 3743 // implementation-defined default alignments for SIMD instructions on the 3744 // target platforms are assumed. 3745 SmallVector<Expr *, 4> NewAligns; 3746 for (auto *E : Alignments) { 3747 ExprResult Align; 3748 if (E) 3749 Align = VerifyPositiveIntegerConstantInClause(E, OMPC_aligned); 3750 NewAligns.push_back(Align.get()); 3751 } 3752 // OpenMP [2.8.2, declare simd construct, Description] 3753 // The linear clause declares one or more list items to be private to a SIMD 3754 // lane and to have a linear relationship with respect to the iteration space 3755 // of a loop. 3756 // The special this pointer can be used as if was one of the arguments to the 3757 // function in any of the linear, aligned, or uniform clauses. 3758 // When a linear-step expression is specified in a linear clause it must be 3759 // either a constant integer expression or an integer-typed parameter that is 3760 // specified in a uniform clause on the directive. 3761 llvm::DenseMap<Decl *, Expr *> LinearArgs; 3762 const bool IsUniformedThis = UniformedLinearThis != nullptr; 3763 auto MI = LinModifiers.begin(); 3764 for (auto *E : Linears) { 3765 auto LinKind = static_cast<OpenMPLinearClauseKind>(*MI); 3766 ++MI; 3767 E = E->IgnoreParenImpCasts(); 3768 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) 3769 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) { 3770 auto *CanonPVD = PVD->getCanonicalDecl(); 3771 if (FD->getNumParams() > PVD->getFunctionScopeIndex() && 3772 FD->getParamDecl(PVD->getFunctionScopeIndex()) 3773 ->getCanonicalDecl() == CanonPVD) { 3774 // OpenMP [2.15.3.7, linear Clause, Restrictions] 3775 // A list-item cannot appear in more than one linear clause. 3776 if (LinearArgs.count(CanonPVD) > 0) { 3777 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa) 3778 << getOpenMPClauseName(OMPC_linear) 3779 << getOpenMPClauseName(OMPC_linear) << E->getSourceRange(); 3780 Diag(LinearArgs[CanonPVD]->getExprLoc(), 3781 diag::note_omp_explicit_dsa) 3782 << getOpenMPClauseName(OMPC_linear); 3783 continue; 3784 } 3785 // Each argument can appear in at most one uniform or linear clause. 3786 if (UniformedArgs.count(CanonPVD) > 0) { 3787 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa) 3788 << getOpenMPClauseName(OMPC_linear) 3789 << getOpenMPClauseName(OMPC_uniform) << E->getSourceRange(); 3790 Diag(UniformedArgs[CanonPVD]->getExprLoc(), 3791 diag::note_omp_explicit_dsa) 3792 << getOpenMPClauseName(OMPC_uniform); 3793 continue; 3794 } 3795 LinearArgs[CanonPVD] = E; 3796 if (E->isValueDependent() || E->isTypeDependent() || 3797 E->isInstantiationDependent() || 3798 E->containsUnexpandedParameterPack()) 3799 continue; 3800 (void)CheckOpenMPLinearDecl(CanonPVD, E->getExprLoc(), LinKind, 3801 PVD->getOriginalType()); 3802 continue; 3803 } 3804 } 3805 if (isa<CXXThisExpr>(E)) { 3806 if (UniformedLinearThis) { 3807 Diag(E->getExprLoc(), diag::err_omp_wrong_dsa) 3808 << getOpenMPClauseName(OMPC_linear) 3809 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform : OMPC_linear) 3810 << E->getSourceRange(); 3811 Diag(UniformedLinearThis->getExprLoc(), diag::note_omp_explicit_dsa) 3812 << getOpenMPClauseName(IsUniformedThis ? OMPC_uniform 3813 : OMPC_linear); 3814 continue; 3815 } 3816 UniformedLinearThis = E; 3817 if (E->isValueDependent() || E->isTypeDependent() || 3818 E->isInstantiationDependent() || E->containsUnexpandedParameterPack()) 3819 continue; 3820 (void)CheckOpenMPLinearDecl(/*D=*/nullptr, E->getExprLoc(), LinKind, 3821 E->getType()); 3822 continue; 3823 } 3824 Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause) 3825 << FD->getDeclName() << (isa<CXXMethodDecl>(ADecl) ? 1 : 0); 3826 } 3827 Expr *Step = nullptr; 3828 Expr *NewStep = nullptr; 3829 SmallVector<Expr *, 4> NewSteps; 3830 for (auto *E : Steps) { 3831 // Skip the same step expression, it was checked already. 3832 if (Step == E || !E) { 3833 NewSteps.push_back(E ? NewStep : nullptr); 3834 continue; 3835 } 3836 Step = E; 3837 if (auto *DRE = dyn_cast<DeclRefExpr>(Step)) 3838 if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) { 3839 auto *CanonPVD = PVD->getCanonicalDecl(); 3840 if (UniformedArgs.count(CanonPVD) == 0) { 3841 Diag(Step->getExprLoc(), diag::err_omp_expected_uniform_param) 3842 << Step->getSourceRange(); 3843 } else if (E->isValueDependent() || E->isTypeDependent() || 3844 E->isInstantiationDependent() || 3845 E->containsUnexpandedParameterPack() || 3846 CanonPVD->getType()->hasIntegerRepresentation()) 3847 NewSteps.push_back(Step); 3848 else { 3849 Diag(Step->getExprLoc(), diag::err_omp_expected_int_param) 3850 << Step->getSourceRange(); 3851 } 3852 continue; 3853 } 3854 NewStep = Step; 3855 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() && 3856 !Step->isInstantiationDependent() && 3857 !Step->containsUnexpandedParameterPack()) { 3858 NewStep = PerformOpenMPImplicitIntegerConversion(Step->getExprLoc(), Step) 3859 .get(); 3860 if (NewStep) 3861 NewStep = VerifyIntegerConstantExpression(NewStep).get(); 3862 } 3863 NewSteps.push_back(NewStep); 3864 } 3865 auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit( 3866 Context, BS, SL.get(), const_cast<Expr **>(Uniforms.data()), 3867 Uniforms.size(), const_cast<Expr **>(Aligneds.data()), Aligneds.size(), 3868 const_cast<Expr **>(NewAligns.data()), NewAligns.size(), 3869 const_cast<Expr **>(Linears.data()), Linears.size(), 3870 const_cast<unsigned *>(LinModifiers.data()), LinModifiers.size(), 3871 NewSteps.data(), NewSteps.size(), SR); 3872 ADecl->addAttr(NewAttr); 3873 return ConvertDeclToDeclGroup(ADecl); 3874 } 3875 3876 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses, 3877 Stmt *AStmt, 3878 SourceLocation StartLoc, 3879 SourceLocation EndLoc) { 3880 if (!AStmt) 3881 return StmtError(); 3882 3883 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 3884 // 1.2.2 OpenMP Language Terminology 3885 // Structured block - An executable statement with a single entry at the 3886 // top and a single exit at the bottom. 3887 // The point of exit cannot be a branch out of the structured block. 3888 // longjmp() and throw() must not violate the entry/exit criteria. 3889 CS->getCapturedDecl()->setNothrow(); 3890 3891 getCurFunction()->setHasBranchProtectedScope(); 3892 3893 return OMPParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt, 3894 DSAStack->isCancelRegion()); 3895 } 3896 3897 namespace { 3898 /// \brief Helper class for checking canonical form of the OpenMP loops and 3899 /// extracting iteration space of each loop in the loop nest, that will be used 3900 /// for IR generation. 3901 class OpenMPIterationSpaceChecker { 3902 /// \brief Reference to Sema. 3903 Sema &SemaRef; 3904 /// \brief A location for diagnostics (when there is no some better location). 3905 SourceLocation DefaultLoc; 3906 /// \brief A location for diagnostics (when increment is not compatible). 3907 SourceLocation ConditionLoc; 3908 /// \brief A source location for referring to loop init later. 3909 SourceRange InitSrcRange; 3910 /// \brief A source location for referring to condition later. 3911 SourceRange ConditionSrcRange; 3912 /// \brief A source location for referring to increment later. 3913 SourceRange IncrementSrcRange; 3914 /// \brief Loop variable. 3915 ValueDecl *LCDecl = nullptr; 3916 /// \brief Reference to loop variable. 3917 Expr *LCRef = nullptr; 3918 /// \brief Lower bound (initializer for the var). 3919 Expr *LB = nullptr; 3920 /// \brief Upper bound. 3921 Expr *UB = nullptr; 3922 /// \brief Loop step (increment). 3923 Expr *Step = nullptr; 3924 /// \brief This flag is true when condition is one of: 3925 /// Var < UB 3926 /// Var <= UB 3927 /// UB > Var 3928 /// UB >= Var 3929 bool TestIsLessOp = false; 3930 /// \brief This flag is true when condition is strict ( < or > ). 3931 bool TestIsStrictOp = false; 3932 /// \brief This flag is true when step is subtracted on each iteration. 3933 bool SubtractStep = false; 3934 3935 public: 3936 OpenMPIterationSpaceChecker(Sema &SemaRef, SourceLocation DefaultLoc) 3937 : SemaRef(SemaRef), DefaultLoc(DefaultLoc), ConditionLoc(DefaultLoc) {} 3938 /// \brief Check init-expr for canonical loop form and save loop counter 3939 /// variable - #Var and its initialization value - #LB. 3940 bool CheckInit(Stmt *S, bool EmitDiags = true); 3941 /// \brief Check test-expr for canonical form, save upper-bound (#UB), flags 3942 /// for less/greater and for strict/non-strict comparison. 3943 bool CheckCond(Expr *S); 3944 /// \brief Check incr-expr for canonical loop form and return true if it 3945 /// does not conform, otherwise save loop step (#Step). 3946 bool CheckInc(Expr *S); 3947 /// \brief Return the loop counter variable. 3948 ValueDecl *GetLoopDecl() const { return LCDecl; } 3949 /// \brief Return the reference expression to loop counter variable. 3950 Expr *GetLoopDeclRefExpr() const { return LCRef; } 3951 /// \brief Source range of the loop init. 3952 SourceRange GetInitSrcRange() const { return InitSrcRange; } 3953 /// \brief Source range of the loop condition. 3954 SourceRange GetConditionSrcRange() const { return ConditionSrcRange; } 3955 /// \brief Source range of the loop increment. 3956 SourceRange GetIncrementSrcRange() const { return IncrementSrcRange; } 3957 /// \brief True if the step should be subtracted. 3958 bool ShouldSubtractStep() const { return SubtractStep; } 3959 /// \brief Build the expression to calculate the number of iterations. 3960 Expr * 3961 BuildNumIterations(Scope *S, const bool LimitedType, 3962 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const; 3963 /// \brief Build the precondition expression for the loops. 3964 Expr *BuildPreCond(Scope *S, Expr *Cond, 3965 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const; 3966 /// \brief Build reference expression to the counter be used for codegen. 3967 DeclRefExpr *BuildCounterVar(llvm::MapVector<Expr *, DeclRefExpr *> &Captures, 3968 DSAStackTy &DSA) const; 3969 /// \brief Build reference expression to the private counter be used for 3970 /// codegen. 3971 Expr *BuildPrivateCounterVar() const; 3972 /// \brief Build initization of the counter be used for codegen. 3973 Expr *BuildCounterInit() const; 3974 /// \brief Build step of the counter be used for codegen. 3975 Expr *BuildCounterStep() const; 3976 /// \brief Return true if any expression is dependent. 3977 bool Dependent() const; 3978 3979 private: 3980 /// \brief Check the right-hand side of an assignment in the increment 3981 /// expression. 3982 bool CheckIncRHS(Expr *RHS); 3983 /// \brief Helper to set loop counter variable and its initializer. 3984 bool SetLCDeclAndLB(ValueDecl *NewLCDecl, Expr *NewDeclRefExpr, Expr *NewLB); 3985 /// \brief Helper to set upper bound. 3986 bool SetUB(Expr *NewUB, bool LessOp, bool StrictOp, SourceRange SR, 3987 SourceLocation SL); 3988 /// \brief Helper to set loop increment. 3989 bool SetStep(Expr *NewStep, bool Subtract); 3990 }; 3991 3992 bool OpenMPIterationSpaceChecker::Dependent() const { 3993 if (!LCDecl) { 3994 assert(!LB && !UB && !Step); 3995 return false; 3996 } 3997 return LCDecl->getType()->isDependentType() || 3998 (LB && LB->isValueDependent()) || (UB && UB->isValueDependent()) || 3999 (Step && Step->isValueDependent()); 4000 } 4001 4002 static Expr *getExprAsWritten(Expr *E) { 4003 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(E)) 4004 E = ExprTemp->getSubExpr(); 4005 4006 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) 4007 E = MTE->GetTemporaryExpr(); 4008 4009 while (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E)) 4010 E = Binder->getSubExpr(); 4011 4012 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) 4013 E = ICE->getSubExprAsWritten(); 4014 return E->IgnoreParens(); 4015 } 4016 4017 bool OpenMPIterationSpaceChecker::SetLCDeclAndLB(ValueDecl *NewLCDecl, 4018 Expr *NewLCRefExpr, 4019 Expr *NewLB) { 4020 // State consistency checking to ensure correct usage. 4021 assert(LCDecl == nullptr && LB == nullptr && LCRef == nullptr && 4022 UB == nullptr && Step == nullptr && !TestIsLessOp && !TestIsStrictOp); 4023 if (!NewLCDecl || !NewLB) 4024 return true; 4025 LCDecl = getCanonicalDecl(NewLCDecl); 4026 LCRef = NewLCRefExpr; 4027 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(NewLB)) 4028 if (const CXXConstructorDecl *Ctor = CE->getConstructor()) 4029 if ((Ctor->isCopyOrMoveConstructor() || 4030 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) && 4031 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr) 4032 NewLB = CE->getArg(0)->IgnoreParenImpCasts(); 4033 LB = NewLB; 4034 return false; 4035 } 4036 4037 bool OpenMPIterationSpaceChecker::SetUB(Expr *NewUB, bool LessOp, bool StrictOp, 4038 SourceRange SR, SourceLocation SL) { 4039 // State consistency checking to ensure correct usage. 4040 assert(LCDecl != nullptr && LB != nullptr && UB == nullptr && 4041 Step == nullptr && !TestIsLessOp && !TestIsStrictOp); 4042 if (!NewUB) 4043 return true; 4044 UB = NewUB; 4045 TestIsLessOp = LessOp; 4046 TestIsStrictOp = StrictOp; 4047 ConditionSrcRange = SR; 4048 ConditionLoc = SL; 4049 return false; 4050 } 4051 4052 bool OpenMPIterationSpaceChecker::SetStep(Expr *NewStep, bool Subtract) { 4053 // State consistency checking to ensure correct usage. 4054 assert(LCDecl != nullptr && LB != nullptr && Step == nullptr); 4055 if (!NewStep) 4056 return true; 4057 if (!NewStep->isValueDependent()) { 4058 // Check that the step is integer expression. 4059 SourceLocation StepLoc = NewStep->getLocStart(); 4060 ExprResult Val = 4061 SemaRef.PerformOpenMPImplicitIntegerConversion(StepLoc, NewStep); 4062 if (Val.isInvalid()) 4063 return true; 4064 NewStep = Val.get(); 4065 4066 // OpenMP [2.6, Canonical Loop Form, Restrictions] 4067 // If test-expr is of form var relational-op b and relational-op is < or 4068 // <= then incr-expr must cause var to increase on each iteration of the 4069 // loop. If test-expr is of form var relational-op b and relational-op is 4070 // > or >= then incr-expr must cause var to decrease on each iteration of 4071 // the loop. 4072 // If test-expr is of form b relational-op var and relational-op is < or 4073 // <= then incr-expr must cause var to decrease on each iteration of the 4074 // loop. If test-expr is of form b relational-op var and relational-op is 4075 // > or >= then incr-expr must cause var to increase on each iteration of 4076 // the loop. 4077 llvm::APSInt Result; 4078 bool IsConstant = NewStep->isIntegerConstantExpr(Result, SemaRef.Context); 4079 bool IsUnsigned = !NewStep->getType()->hasSignedIntegerRepresentation(); 4080 bool IsConstNeg = 4081 IsConstant && Result.isSigned() && (Subtract != Result.isNegative()); 4082 bool IsConstPos = 4083 IsConstant && Result.isSigned() && (Subtract == Result.isNegative()); 4084 bool IsConstZero = IsConstant && !Result.getBoolValue(); 4085 if (UB && (IsConstZero || 4086 (TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract)) 4087 : (IsConstPos || (IsUnsigned && !Subtract))))) { 4088 SemaRef.Diag(NewStep->getExprLoc(), 4089 diag::err_omp_loop_incr_not_compatible) 4090 << LCDecl << TestIsLessOp << NewStep->getSourceRange(); 4091 SemaRef.Diag(ConditionLoc, 4092 diag::note_omp_loop_cond_requres_compatible_incr) 4093 << TestIsLessOp << ConditionSrcRange; 4094 return true; 4095 } 4096 if (TestIsLessOp == Subtract) { 4097 NewStep = SemaRef.CreateBuiltinUnaryOp(NewStep->getExprLoc(), UO_Minus, 4098 NewStep).get(); 4099 Subtract = !Subtract; 4100 } 4101 } 4102 4103 Step = NewStep; 4104 SubtractStep = Subtract; 4105 return false; 4106 } 4107 4108 bool OpenMPIterationSpaceChecker::CheckInit(Stmt *S, bool EmitDiags) { 4109 // Check init-expr for canonical loop form and save loop counter 4110 // variable - #Var and its initialization value - #LB. 4111 // OpenMP [2.6] Canonical loop form. init-expr may be one of the following: 4112 // var = lb 4113 // integer-type var = lb 4114 // random-access-iterator-type var = lb 4115 // pointer-type var = lb 4116 // 4117 if (!S) { 4118 if (EmitDiags) { 4119 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_init); 4120 } 4121 return true; 4122 } 4123 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S)) 4124 if (!ExprTemp->cleanupsHaveSideEffects()) 4125 S = ExprTemp->getSubExpr(); 4126 4127 InitSrcRange = S->getSourceRange(); 4128 if (Expr *E = dyn_cast<Expr>(S)) 4129 S = E->IgnoreParens(); 4130 if (auto BO = dyn_cast<BinaryOperator>(S)) { 4131 if (BO->getOpcode() == BO_Assign) { 4132 auto *LHS = BO->getLHS()->IgnoreParens(); 4133 if (auto *DRE = dyn_cast<DeclRefExpr>(LHS)) { 4134 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl())) 4135 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit()))) 4136 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS()); 4137 return SetLCDeclAndLB(DRE->getDecl(), DRE, BO->getRHS()); 4138 } 4139 if (auto *ME = dyn_cast<MemberExpr>(LHS)) { 4140 if (ME->isArrow() && 4141 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts())) 4142 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS()); 4143 } 4144 } 4145 } else if (auto DS = dyn_cast<DeclStmt>(S)) { 4146 if (DS->isSingleDecl()) { 4147 if (auto Var = dyn_cast_or_null<VarDecl>(DS->getSingleDecl())) { 4148 if (Var->hasInit() && !Var->getType()->isReferenceType()) { 4149 // Accept non-canonical init form here but emit ext. warning. 4150 if (Var->getInitStyle() != VarDecl::CInit && EmitDiags) 4151 SemaRef.Diag(S->getLocStart(), 4152 diag::ext_omp_loop_not_canonical_init) 4153 << S->getSourceRange(); 4154 return SetLCDeclAndLB(Var, nullptr, Var->getInit()); 4155 } 4156 } 4157 } 4158 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) { 4159 if (CE->getOperator() == OO_Equal) { 4160 auto *LHS = CE->getArg(0); 4161 if (auto DRE = dyn_cast<DeclRefExpr>(LHS)) { 4162 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(DRE->getDecl())) 4163 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit()))) 4164 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS()); 4165 return SetLCDeclAndLB(DRE->getDecl(), DRE, CE->getArg(1)); 4166 } 4167 if (auto *ME = dyn_cast<MemberExpr>(LHS)) { 4168 if (ME->isArrow() && 4169 isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts())) 4170 return SetLCDeclAndLB(ME->getMemberDecl(), ME, BO->getRHS()); 4171 } 4172 } 4173 } 4174 4175 if (Dependent() || SemaRef.CurContext->isDependentContext()) 4176 return false; 4177 if (EmitDiags) { 4178 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_init) 4179 << S->getSourceRange(); 4180 } 4181 return true; 4182 } 4183 4184 /// \brief Ignore parenthesizes, implicit casts, copy constructor and return the 4185 /// variable (which may be the loop variable) if possible. 4186 static const ValueDecl *GetInitLCDecl(Expr *E) { 4187 if (!E) 4188 return nullptr; 4189 E = getExprAsWritten(E); 4190 if (auto *CE = dyn_cast_or_null<CXXConstructExpr>(E)) 4191 if (const CXXConstructorDecl *Ctor = CE->getConstructor()) 4192 if ((Ctor->isCopyOrMoveConstructor() || 4193 Ctor->isConvertingConstructor(/*AllowExplicit=*/false)) && 4194 CE->getNumArgs() > 0 && CE->getArg(0) != nullptr) 4195 E = CE->getArg(0)->IgnoreParenImpCasts(); 4196 if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) { 4197 if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) { 4198 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD)) 4199 if (auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit()))) 4200 return getCanonicalDecl(ME->getMemberDecl()); 4201 return getCanonicalDecl(VD); 4202 } 4203 } 4204 if (auto *ME = dyn_cast_or_null<MemberExpr>(E)) 4205 if (ME->isArrow() && isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts())) 4206 return getCanonicalDecl(ME->getMemberDecl()); 4207 return nullptr; 4208 } 4209 4210 bool OpenMPIterationSpaceChecker::CheckCond(Expr *S) { 4211 // Check test-expr for canonical form, save upper-bound UB, flags for 4212 // less/greater and for strict/non-strict comparison. 4213 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following: 4214 // var relational-op b 4215 // b relational-op var 4216 // 4217 if (!S) { 4218 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_cond) << LCDecl; 4219 return true; 4220 } 4221 S = getExprAsWritten(S); 4222 SourceLocation CondLoc = S->getLocStart(); 4223 if (auto BO = dyn_cast<BinaryOperator>(S)) { 4224 if (BO->isRelationalOp()) { 4225 if (GetInitLCDecl(BO->getLHS()) == LCDecl) 4226 return SetUB(BO->getRHS(), 4227 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_LE), 4228 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT), 4229 BO->getSourceRange(), BO->getOperatorLoc()); 4230 if (GetInitLCDecl(BO->getRHS()) == LCDecl) 4231 return SetUB(BO->getLHS(), 4232 (BO->getOpcode() == BO_GT || BO->getOpcode() == BO_GE), 4233 (BO->getOpcode() == BO_LT || BO->getOpcode() == BO_GT), 4234 BO->getSourceRange(), BO->getOperatorLoc()); 4235 } 4236 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) { 4237 if (CE->getNumArgs() == 2) { 4238 auto Op = CE->getOperator(); 4239 switch (Op) { 4240 case OO_Greater: 4241 case OO_GreaterEqual: 4242 case OO_Less: 4243 case OO_LessEqual: 4244 if (GetInitLCDecl(CE->getArg(0)) == LCDecl) 4245 return SetUB(CE->getArg(1), Op == OO_Less || Op == OO_LessEqual, 4246 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(), 4247 CE->getOperatorLoc()); 4248 if (GetInitLCDecl(CE->getArg(1)) == LCDecl) 4249 return SetUB(CE->getArg(0), Op == OO_Greater || Op == OO_GreaterEqual, 4250 Op == OO_Less || Op == OO_Greater, CE->getSourceRange(), 4251 CE->getOperatorLoc()); 4252 break; 4253 default: 4254 break; 4255 } 4256 } 4257 } 4258 if (Dependent() || SemaRef.CurContext->isDependentContext()) 4259 return false; 4260 SemaRef.Diag(CondLoc, diag::err_omp_loop_not_canonical_cond) 4261 << S->getSourceRange() << LCDecl; 4262 return true; 4263 } 4264 4265 bool OpenMPIterationSpaceChecker::CheckIncRHS(Expr *RHS) { 4266 // RHS of canonical loop form increment can be: 4267 // var + incr 4268 // incr + var 4269 // var - incr 4270 // 4271 RHS = RHS->IgnoreParenImpCasts(); 4272 if (auto BO = dyn_cast<BinaryOperator>(RHS)) { 4273 if (BO->isAdditiveOp()) { 4274 bool IsAdd = BO->getOpcode() == BO_Add; 4275 if (GetInitLCDecl(BO->getLHS()) == LCDecl) 4276 return SetStep(BO->getRHS(), !IsAdd); 4277 if (IsAdd && GetInitLCDecl(BO->getRHS()) == LCDecl) 4278 return SetStep(BO->getLHS(), false); 4279 } 4280 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(RHS)) { 4281 bool IsAdd = CE->getOperator() == OO_Plus; 4282 if ((IsAdd || CE->getOperator() == OO_Minus) && CE->getNumArgs() == 2) { 4283 if (GetInitLCDecl(CE->getArg(0)) == LCDecl) 4284 return SetStep(CE->getArg(1), !IsAdd); 4285 if (IsAdd && GetInitLCDecl(CE->getArg(1)) == LCDecl) 4286 return SetStep(CE->getArg(0), false); 4287 } 4288 } 4289 if (Dependent() || SemaRef.CurContext->isDependentContext()) 4290 return false; 4291 SemaRef.Diag(RHS->getLocStart(), diag::err_omp_loop_not_canonical_incr) 4292 << RHS->getSourceRange() << LCDecl; 4293 return true; 4294 } 4295 4296 bool OpenMPIterationSpaceChecker::CheckInc(Expr *S) { 4297 // Check incr-expr for canonical loop form and return true if it 4298 // does not conform. 4299 // OpenMP [2.6] Canonical loop form. Test-expr may be one of the following: 4300 // ++var 4301 // var++ 4302 // --var 4303 // var-- 4304 // var += incr 4305 // var -= incr 4306 // var = var + incr 4307 // var = incr + var 4308 // var = var - incr 4309 // 4310 if (!S) { 4311 SemaRef.Diag(DefaultLoc, diag::err_omp_loop_not_canonical_incr) << LCDecl; 4312 return true; 4313 } 4314 if (auto *ExprTemp = dyn_cast<ExprWithCleanups>(S)) 4315 if (!ExprTemp->cleanupsHaveSideEffects()) 4316 S = ExprTemp->getSubExpr(); 4317 4318 IncrementSrcRange = S->getSourceRange(); 4319 S = S->IgnoreParens(); 4320 if (auto UO = dyn_cast<UnaryOperator>(S)) { 4321 if (UO->isIncrementDecrementOp() && 4322 GetInitLCDecl(UO->getSubExpr()) == LCDecl) 4323 return SetStep( 4324 SemaRef.ActOnIntegerConstant(UO->getLocStart(), 4325 (UO->isDecrementOp() ? -1 : 1)).get(), 4326 false); 4327 } else if (auto BO = dyn_cast<BinaryOperator>(S)) { 4328 switch (BO->getOpcode()) { 4329 case BO_AddAssign: 4330 case BO_SubAssign: 4331 if (GetInitLCDecl(BO->getLHS()) == LCDecl) 4332 return SetStep(BO->getRHS(), BO->getOpcode() == BO_SubAssign); 4333 break; 4334 case BO_Assign: 4335 if (GetInitLCDecl(BO->getLHS()) == LCDecl) 4336 return CheckIncRHS(BO->getRHS()); 4337 break; 4338 default: 4339 break; 4340 } 4341 } else if (auto CE = dyn_cast<CXXOperatorCallExpr>(S)) { 4342 switch (CE->getOperator()) { 4343 case OO_PlusPlus: 4344 case OO_MinusMinus: 4345 if (GetInitLCDecl(CE->getArg(0)) == LCDecl) 4346 return SetStep( 4347 SemaRef.ActOnIntegerConstant( 4348 CE->getLocStart(), 4349 ((CE->getOperator() == OO_MinusMinus) ? -1 : 1)).get(), 4350 false); 4351 break; 4352 case OO_PlusEqual: 4353 case OO_MinusEqual: 4354 if (GetInitLCDecl(CE->getArg(0)) == LCDecl) 4355 return SetStep(CE->getArg(1), CE->getOperator() == OO_MinusEqual); 4356 break; 4357 case OO_Equal: 4358 if (GetInitLCDecl(CE->getArg(0)) == LCDecl) 4359 return CheckIncRHS(CE->getArg(1)); 4360 break; 4361 default: 4362 break; 4363 } 4364 } 4365 if (Dependent() || SemaRef.CurContext->isDependentContext()) 4366 return false; 4367 SemaRef.Diag(S->getLocStart(), diag::err_omp_loop_not_canonical_incr) 4368 << S->getSourceRange() << LCDecl; 4369 return true; 4370 } 4371 4372 static ExprResult 4373 tryBuildCapture(Sema &SemaRef, Expr *Capture, 4374 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) { 4375 if (SemaRef.CurContext->isDependentContext()) 4376 return ExprResult(Capture); 4377 if (Capture->isEvaluatable(SemaRef.Context, Expr::SE_AllowSideEffects)) 4378 return SemaRef.PerformImplicitConversion( 4379 Capture->IgnoreImpCasts(), Capture->getType(), Sema::AA_Converting, 4380 /*AllowExplicit=*/true); 4381 auto I = Captures.find(Capture); 4382 if (I != Captures.end()) 4383 return buildCapture(SemaRef, Capture, I->second); 4384 DeclRefExpr *Ref = nullptr; 4385 ExprResult Res = buildCapture(SemaRef, Capture, Ref); 4386 Captures[Capture] = Ref; 4387 return Res; 4388 } 4389 4390 /// \brief Build the expression to calculate the number of iterations. 4391 Expr *OpenMPIterationSpaceChecker::BuildNumIterations( 4392 Scope *S, const bool LimitedType, 4393 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const { 4394 ExprResult Diff; 4395 auto VarType = LCDecl->getType().getNonReferenceType(); 4396 if (VarType->isIntegerType() || VarType->isPointerType() || 4397 SemaRef.getLangOpts().CPlusPlus) { 4398 // Upper - Lower 4399 auto *UBExpr = TestIsLessOp ? UB : LB; 4400 auto *LBExpr = TestIsLessOp ? LB : UB; 4401 Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get(); 4402 Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get(); 4403 if (!Upper || !Lower) 4404 return nullptr; 4405 4406 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Sub, Upper, Lower); 4407 4408 if (!Diff.isUsable() && VarType->getAsCXXRecordDecl()) { 4409 // BuildBinOp already emitted error, this one is to point user to upper 4410 // and lower bound, and to tell what is passed to 'operator-'. 4411 SemaRef.Diag(Upper->getLocStart(), diag::err_omp_loop_diff_cxx) 4412 << Upper->getSourceRange() << Lower->getSourceRange(); 4413 return nullptr; 4414 } 4415 } 4416 4417 if (!Diff.isUsable()) 4418 return nullptr; 4419 4420 // Upper - Lower [- 1] 4421 if (TestIsStrictOp) 4422 Diff = SemaRef.BuildBinOp( 4423 S, DefaultLoc, BO_Sub, Diff.get(), 4424 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get()); 4425 if (!Diff.isUsable()) 4426 return nullptr; 4427 4428 // Upper - Lower [- 1] + Step 4429 auto NewStep = tryBuildCapture(SemaRef, Step, Captures); 4430 if (!NewStep.isUsable()) 4431 return nullptr; 4432 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Add, Diff.get(), NewStep.get()); 4433 if (!Diff.isUsable()) 4434 return nullptr; 4435 4436 // Parentheses (for dumping/debugging purposes only). 4437 Diff = SemaRef.ActOnParenExpr(DefaultLoc, DefaultLoc, Diff.get()); 4438 if (!Diff.isUsable()) 4439 return nullptr; 4440 4441 // (Upper - Lower [- 1] + Step) / Step 4442 Diff = SemaRef.BuildBinOp(S, DefaultLoc, BO_Div, Diff.get(), NewStep.get()); 4443 if (!Diff.isUsable()) 4444 return nullptr; 4445 4446 // OpenMP runtime requires 32-bit or 64-bit loop variables. 4447 QualType Type = Diff.get()->getType(); 4448 auto &C = SemaRef.Context; 4449 bool UseVarType = VarType->hasIntegerRepresentation() && 4450 C.getTypeSize(Type) > C.getTypeSize(VarType); 4451 if (!Type->isIntegerType() || UseVarType) { 4452 unsigned NewSize = 4453 UseVarType ? C.getTypeSize(VarType) : C.getTypeSize(Type); 4454 bool IsSigned = UseVarType ? VarType->hasSignedIntegerRepresentation() 4455 : Type->hasSignedIntegerRepresentation(); 4456 Type = C.getIntTypeForBitwidth(NewSize, IsSigned); 4457 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), Type)) { 4458 Diff = SemaRef.PerformImplicitConversion( 4459 Diff.get(), Type, Sema::AA_Converting, /*AllowExplicit=*/true); 4460 if (!Diff.isUsable()) 4461 return nullptr; 4462 } 4463 } 4464 if (LimitedType) { 4465 unsigned NewSize = (C.getTypeSize(Type) > 32) ? 64 : 32; 4466 if (NewSize != C.getTypeSize(Type)) { 4467 if (NewSize < C.getTypeSize(Type)) { 4468 assert(NewSize == 64 && "incorrect loop var size"); 4469 SemaRef.Diag(DefaultLoc, diag::warn_omp_loop_64_bit_var) 4470 << InitSrcRange << ConditionSrcRange; 4471 } 4472 QualType NewType = C.getIntTypeForBitwidth( 4473 NewSize, Type->hasSignedIntegerRepresentation() || 4474 C.getTypeSize(Type) < NewSize); 4475 if (!SemaRef.Context.hasSameType(Diff.get()->getType(), NewType)) { 4476 Diff = SemaRef.PerformImplicitConversion(Diff.get(), NewType, 4477 Sema::AA_Converting, true); 4478 if (!Diff.isUsable()) 4479 return nullptr; 4480 } 4481 } 4482 } 4483 4484 return Diff.get(); 4485 } 4486 4487 Expr *OpenMPIterationSpaceChecker::BuildPreCond( 4488 Scope *S, Expr *Cond, 4489 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) const { 4490 // Try to build LB <op> UB, where <op> is <, >, <=, or >=. 4491 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics(); 4492 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true); 4493 4494 auto NewLB = tryBuildCapture(SemaRef, LB, Captures); 4495 auto NewUB = tryBuildCapture(SemaRef, UB, Captures); 4496 if (!NewLB.isUsable() || !NewUB.isUsable()) 4497 return nullptr; 4498 4499 auto CondExpr = SemaRef.BuildBinOp( 4500 S, DefaultLoc, TestIsLessOp ? (TestIsStrictOp ? BO_LT : BO_LE) 4501 : (TestIsStrictOp ? BO_GT : BO_GE), 4502 NewLB.get(), NewUB.get()); 4503 if (CondExpr.isUsable()) { 4504 if (!SemaRef.Context.hasSameUnqualifiedType(CondExpr.get()->getType(), 4505 SemaRef.Context.BoolTy)) 4506 CondExpr = SemaRef.PerformImplicitConversion( 4507 CondExpr.get(), SemaRef.Context.BoolTy, /*Action=*/Sema::AA_Casting, 4508 /*AllowExplicit=*/true); 4509 } 4510 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress); 4511 // Otherwise use original loop conditon and evaluate it in runtime. 4512 return CondExpr.isUsable() ? CondExpr.get() : Cond; 4513 } 4514 4515 /// \brief Build reference expression to the counter be used for codegen. 4516 DeclRefExpr *OpenMPIterationSpaceChecker::BuildCounterVar( 4517 llvm::MapVector<Expr *, DeclRefExpr *> &Captures, DSAStackTy &DSA) const { 4518 auto *VD = dyn_cast<VarDecl>(LCDecl); 4519 if (!VD) { 4520 VD = SemaRef.IsOpenMPCapturedDecl(LCDecl); 4521 auto *Ref = buildDeclRefExpr( 4522 SemaRef, VD, VD->getType().getNonReferenceType(), DefaultLoc); 4523 DSAStackTy::DSAVarData Data = DSA.getTopDSA(LCDecl, /*FromParent=*/false); 4524 // If the loop control decl is explicitly marked as private, do not mark it 4525 // as captured again. 4526 if (!isOpenMPPrivate(Data.CKind) || !Data.RefExpr) 4527 Captures.insert(std::make_pair(LCRef, Ref)); 4528 return Ref; 4529 } 4530 return buildDeclRefExpr(SemaRef, VD, VD->getType().getNonReferenceType(), 4531 DefaultLoc); 4532 } 4533 4534 Expr *OpenMPIterationSpaceChecker::BuildPrivateCounterVar() const { 4535 if (LCDecl && !LCDecl->isInvalidDecl()) { 4536 auto Type = LCDecl->getType().getNonReferenceType(); 4537 auto *PrivateVar = 4538 buildVarDecl(SemaRef, DefaultLoc, Type, LCDecl->getName(), 4539 LCDecl->hasAttrs() ? &LCDecl->getAttrs() : nullptr); 4540 if (PrivateVar->isInvalidDecl()) 4541 return nullptr; 4542 return buildDeclRefExpr(SemaRef, PrivateVar, Type, DefaultLoc); 4543 } 4544 return nullptr; 4545 } 4546 4547 /// \brief Build initization of the counter be used for codegen. 4548 Expr *OpenMPIterationSpaceChecker::BuildCounterInit() const { return LB; } 4549 4550 /// \brief Build step of the counter be used for codegen. 4551 Expr *OpenMPIterationSpaceChecker::BuildCounterStep() const { return Step; } 4552 4553 /// \brief Iteration space of a single for loop. 4554 struct LoopIterationSpace final { 4555 /// \brief Condition of the loop. 4556 Expr *PreCond = nullptr; 4557 /// \brief This expression calculates the number of iterations in the loop. 4558 /// It is always possible to calculate it before starting the loop. 4559 Expr *NumIterations = nullptr; 4560 /// \brief The loop counter variable. 4561 Expr *CounterVar = nullptr; 4562 /// \brief Private loop counter variable. 4563 Expr *PrivateCounterVar = nullptr; 4564 /// \brief This is initializer for the initial value of #CounterVar. 4565 Expr *CounterInit = nullptr; 4566 /// \brief This is step for the #CounterVar used to generate its update: 4567 /// #CounterVar = #CounterInit + #CounterStep * CurrentIteration. 4568 Expr *CounterStep = nullptr; 4569 /// \brief Should step be subtracted? 4570 bool Subtract = false; 4571 /// \brief Source range of the loop init. 4572 SourceRange InitSrcRange; 4573 /// \brief Source range of the loop condition. 4574 SourceRange CondSrcRange; 4575 /// \brief Source range of the loop increment. 4576 SourceRange IncSrcRange; 4577 }; 4578 4579 } // namespace 4580 4581 void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) { 4582 assert(getLangOpts().OpenMP && "OpenMP is not active."); 4583 assert(Init && "Expected loop in canonical form."); 4584 unsigned AssociatedLoops = DSAStack->getAssociatedLoops(); 4585 if (AssociatedLoops > 0 && 4586 isOpenMPLoopDirective(DSAStack->getCurrentDirective())) { 4587 OpenMPIterationSpaceChecker ISC(*this, ForLoc); 4588 if (!ISC.CheckInit(Init, /*EmitDiags=*/false)) { 4589 if (auto *D = ISC.GetLoopDecl()) { 4590 auto *VD = dyn_cast<VarDecl>(D); 4591 if (!VD) { 4592 if (auto *Private = IsOpenMPCapturedDecl(D)) 4593 VD = Private; 4594 else { 4595 auto *Ref = buildCapture(*this, D, ISC.GetLoopDeclRefExpr(), 4596 /*WithInit=*/false); 4597 VD = cast<VarDecl>(Ref->getDecl()); 4598 } 4599 } 4600 DSAStack->addLoopControlVariable(D, VD); 4601 } 4602 } 4603 DSAStack->setAssociatedLoops(AssociatedLoops - 1); 4604 } 4605 } 4606 4607 /// \brief Called on a for stmt to check and extract its iteration space 4608 /// for further processing (such as collapsing). 4609 static bool CheckOpenMPIterationSpace( 4610 OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA, 4611 unsigned CurrentNestedLoopCount, unsigned NestedLoopCount, 4612 Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr, 4613 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA, 4614 LoopIterationSpace &ResultIterSpace, 4615 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) { 4616 // OpenMP [2.6, Canonical Loop Form] 4617 // for (init-expr; test-expr; incr-expr) structured-block 4618 auto For = dyn_cast_or_null<ForStmt>(S); 4619 if (!For) { 4620 SemaRef.Diag(S->getLocStart(), diag::err_omp_not_for) 4621 << (CollapseLoopCountExpr != nullptr || OrderedLoopCountExpr != nullptr) 4622 << getOpenMPDirectiveName(DKind) << NestedLoopCount 4623 << (CurrentNestedLoopCount > 0) << CurrentNestedLoopCount; 4624 if (NestedLoopCount > 1) { 4625 if (CollapseLoopCountExpr && OrderedLoopCountExpr) 4626 SemaRef.Diag(DSA.getConstructLoc(), 4627 diag::note_omp_collapse_ordered_expr) 4628 << 2 << CollapseLoopCountExpr->getSourceRange() 4629 << OrderedLoopCountExpr->getSourceRange(); 4630 else if (CollapseLoopCountExpr) 4631 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(), 4632 diag::note_omp_collapse_ordered_expr) 4633 << 0 << CollapseLoopCountExpr->getSourceRange(); 4634 else 4635 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(), 4636 diag::note_omp_collapse_ordered_expr) 4637 << 1 << OrderedLoopCountExpr->getSourceRange(); 4638 } 4639 return true; 4640 } 4641 assert(For->getBody()); 4642 4643 OpenMPIterationSpaceChecker ISC(SemaRef, For->getForLoc()); 4644 4645 // Check init. 4646 auto Init = For->getInit(); 4647 if (ISC.CheckInit(Init)) 4648 return true; 4649 4650 bool HasErrors = false; 4651 4652 // Check loop variable's type. 4653 if (auto *LCDecl = ISC.GetLoopDecl()) { 4654 auto *LoopDeclRefExpr = ISC.GetLoopDeclRefExpr(); 4655 4656 // OpenMP [2.6, Canonical Loop Form] 4657 // Var is one of the following: 4658 // A variable of signed or unsigned integer type. 4659 // For C++, a variable of a random access iterator type. 4660 // For C, a variable of a pointer type. 4661 auto VarType = LCDecl->getType().getNonReferenceType(); 4662 if (!VarType->isDependentType() && !VarType->isIntegerType() && 4663 !VarType->isPointerType() && 4664 !(SemaRef.getLangOpts().CPlusPlus && VarType->isOverloadableType())) { 4665 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_variable_type) 4666 << SemaRef.getLangOpts().CPlusPlus; 4667 HasErrors = true; 4668 } 4669 4670 // OpenMP, 2.14.1.1 Data-sharing Attribute Rules for Variables Referenced in 4671 // a Construct 4672 // The loop iteration variable(s) in the associated for-loop(s) of a for or 4673 // parallel for construct is (are) private. 4674 // The loop iteration variable in the associated for-loop of a simd 4675 // construct with just one associated for-loop is linear with a 4676 // constant-linear-step that is the increment of the associated for-loop. 4677 // Exclude loop var from the list of variables with implicitly defined data 4678 // sharing attributes. 4679 VarsWithImplicitDSA.erase(LCDecl); 4680 4681 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced 4682 // in a Construct, C/C++]. 4683 // The loop iteration variable in the associated for-loop of a simd 4684 // construct with just one associated for-loop may be listed in a linear 4685 // clause with a constant-linear-step that is the increment of the 4686 // associated for-loop. 4687 // The loop iteration variable(s) in the associated for-loop(s) of a for or 4688 // parallel for construct may be listed in a private or lastprivate clause. 4689 DSAStackTy::DSAVarData DVar = DSA.getTopDSA(LCDecl, false); 4690 // If LoopVarRefExpr is nullptr it means the corresponding loop variable is 4691 // declared in the loop and it is predetermined as a private. 4692 auto PredeterminedCKind = 4693 isOpenMPSimdDirective(DKind) 4694 ? ((NestedLoopCount == 1) ? OMPC_linear : OMPC_lastprivate) 4695 : OMPC_private; 4696 if (((isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown && 4697 DVar.CKind != PredeterminedCKind) || 4698 ((isOpenMPWorksharingDirective(DKind) || DKind == OMPD_taskloop || 4699 isOpenMPDistributeDirective(DKind)) && 4700 !isOpenMPSimdDirective(DKind) && DVar.CKind != OMPC_unknown && 4701 DVar.CKind != OMPC_private && DVar.CKind != OMPC_lastprivate)) && 4702 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) { 4703 SemaRef.Diag(Init->getLocStart(), diag::err_omp_loop_var_dsa) 4704 << getOpenMPClauseName(DVar.CKind) << getOpenMPDirectiveName(DKind) 4705 << getOpenMPClauseName(PredeterminedCKind); 4706 if (DVar.RefExpr == nullptr) 4707 DVar.CKind = PredeterminedCKind; 4708 ReportOriginalDSA(SemaRef, &DSA, LCDecl, DVar, /*IsLoopIterVar=*/true); 4709 HasErrors = true; 4710 } else if (LoopDeclRefExpr != nullptr) { 4711 // Make the loop iteration variable private (for worksharing constructs), 4712 // linear (for simd directives with the only one associated loop) or 4713 // lastprivate (for simd directives with several collapsed or ordered 4714 // loops). 4715 if (DVar.CKind == OMPC_unknown) 4716 DVar = DSA.hasDSA(LCDecl, isOpenMPPrivate, 4717 [](OpenMPDirectiveKind) -> bool { return true; }, 4718 /*FromParent=*/false); 4719 DSA.addDSA(LCDecl, LoopDeclRefExpr, PredeterminedCKind); 4720 } 4721 4722 assert(isOpenMPLoopDirective(DKind) && "DSA for non-loop vars"); 4723 4724 // Check test-expr. 4725 HasErrors |= ISC.CheckCond(For->getCond()); 4726 4727 // Check incr-expr. 4728 HasErrors |= ISC.CheckInc(For->getInc()); 4729 } 4730 4731 if (ISC.Dependent() || SemaRef.CurContext->isDependentContext() || HasErrors) 4732 return HasErrors; 4733 4734 // Build the loop's iteration space representation. 4735 ResultIterSpace.PreCond = 4736 ISC.BuildPreCond(DSA.getCurScope(), For->getCond(), Captures); 4737 ResultIterSpace.NumIterations = ISC.BuildNumIterations( 4738 DSA.getCurScope(), 4739 (isOpenMPWorksharingDirective(DKind) || 4740 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind)), 4741 Captures); 4742 ResultIterSpace.CounterVar = ISC.BuildCounterVar(Captures, DSA); 4743 ResultIterSpace.PrivateCounterVar = ISC.BuildPrivateCounterVar(); 4744 ResultIterSpace.CounterInit = ISC.BuildCounterInit(); 4745 ResultIterSpace.CounterStep = ISC.BuildCounterStep(); 4746 ResultIterSpace.InitSrcRange = ISC.GetInitSrcRange(); 4747 ResultIterSpace.CondSrcRange = ISC.GetConditionSrcRange(); 4748 ResultIterSpace.IncSrcRange = ISC.GetIncrementSrcRange(); 4749 ResultIterSpace.Subtract = ISC.ShouldSubtractStep(); 4750 4751 HasErrors |= (ResultIterSpace.PreCond == nullptr || 4752 ResultIterSpace.NumIterations == nullptr || 4753 ResultIterSpace.CounterVar == nullptr || 4754 ResultIterSpace.PrivateCounterVar == nullptr || 4755 ResultIterSpace.CounterInit == nullptr || 4756 ResultIterSpace.CounterStep == nullptr); 4757 4758 return HasErrors; 4759 } 4760 4761 /// \brief Build 'VarRef = Start. 4762 static ExprResult 4763 BuildCounterInit(Sema &SemaRef, Scope *S, SourceLocation Loc, ExprResult VarRef, 4764 ExprResult Start, 4765 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) { 4766 // Build 'VarRef = Start. 4767 auto NewStart = tryBuildCapture(SemaRef, Start.get(), Captures); 4768 if (!NewStart.isUsable()) 4769 return ExprError(); 4770 if (!SemaRef.Context.hasSameType(NewStart.get()->getType(), 4771 VarRef.get()->getType())) { 4772 NewStart = SemaRef.PerformImplicitConversion( 4773 NewStart.get(), VarRef.get()->getType(), Sema::AA_Converting, 4774 /*AllowExplicit=*/true); 4775 if (!NewStart.isUsable()) 4776 return ExprError(); 4777 } 4778 4779 auto Init = 4780 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get()); 4781 return Init; 4782 } 4783 4784 /// \brief Build 'VarRef = Start + Iter * Step'. 4785 static ExprResult 4786 BuildCounterUpdate(Sema &SemaRef, Scope *S, SourceLocation Loc, 4787 ExprResult VarRef, ExprResult Start, ExprResult Iter, 4788 ExprResult Step, bool Subtract, 4789 llvm::MapVector<Expr *, DeclRefExpr *> *Captures = nullptr) { 4790 // Add parentheses (for debugging purposes only). 4791 Iter = SemaRef.ActOnParenExpr(Loc, Loc, Iter.get()); 4792 if (!VarRef.isUsable() || !Start.isUsable() || !Iter.isUsable() || 4793 !Step.isUsable()) 4794 return ExprError(); 4795 4796 ExprResult NewStep = Step; 4797 if (Captures) 4798 NewStep = tryBuildCapture(SemaRef, Step.get(), *Captures); 4799 if (NewStep.isInvalid()) 4800 return ExprError(); 4801 ExprResult Update = 4802 SemaRef.BuildBinOp(S, Loc, BO_Mul, Iter.get(), NewStep.get()); 4803 if (!Update.isUsable()) 4804 return ExprError(); 4805 4806 // Try to build 'VarRef = Start, VarRef (+|-)= Iter * Step' or 4807 // 'VarRef = Start (+|-) Iter * Step'. 4808 ExprResult NewStart = Start; 4809 if (Captures) 4810 NewStart = tryBuildCapture(SemaRef, Start.get(), *Captures); 4811 if (NewStart.isInvalid()) 4812 return ExprError(); 4813 4814 // First attempt: try to build 'VarRef = Start, VarRef += Iter * Step'. 4815 ExprResult SavedUpdate = Update; 4816 ExprResult UpdateVal; 4817 if (VarRef.get()->getType()->isOverloadableType() || 4818 NewStart.get()->getType()->isOverloadableType() || 4819 Update.get()->getType()->isOverloadableType()) { 4820 bool Suppress = SemaRef.getDiagnostics().getSuppressAllDiagnostics(); 4821 SemaRef.getDiagnostics().setSuppressAllDiagnostics(/*Val=*/true); 4822 Update = 4823 SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), NewStart.get()); 4824 if (Update.isUsable()) { 4825 UpdateVal = 4826 SemaRef.BuildBinOp(S, Loc, Subtract ? BO_SubAssign : BO_AddAssign, 4827 VarRef.get(), SavedUpdate.get()); 4828 if (UpdateVal.isUsable()) { 4829 Update = SemaRef.CreateBuiltinBinOp(Loc, BO_Comma, Update.get(), 4830 UpdateVal.get()); 4831 } 4832 } 4833 SemaRef.getDiagnostics().setSuppressAllDiagnostics(Suppress); 4834 } 4835 4836 // Second attempt: try to build 'VarRef = Start (+|-) Iter * Step'. 4837 if (!Update.isUsable() || !UpdateVal.isUsable()) { 4838 Update = SemaRef.BuildBinOp(S, Loc, Subtract ? BO_Sub : BO_Add, 4839 NewStart.get(), SavedUpdate.get()); 4840 if (!Update.isUsable()) 4841 return ExprError(); 4842 4843 if (!SemaRef.Context.hasSameType(Update.get()->getType(), 4844 VarRef.get()->getType())) { 4845 Update = SemaRef.PerformImplicitConversion( 4846 Update.get(), VarRef.get()->getType(), Sema::AA_Converting, true); 4847 if (!Update.isUsable()) 4848 return ExprError(); 4849 } 4850 4851 Update = SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), Update.get()); 4852 } 4853 return Update; 4854 } 4855 4856 /// \brief Convert integer expression \a E to make it have at least \a Bits 4857 /// bits. 4858 static ExprResult WidenIterationCount(unsigned Bits, Expr *E, 4859 Sema &SemaRef) { 4860 if (E == nullptr) 4861 return ExprError(); 4862 auto &C = SemaRef.Context; 4863 QualType OldType = E->getType(); 4864 unsigned HasBits = C.getTypeSize(OldType); 4865 if (HasBits >= Bits) 4866 return ExprResult(E); 4867 // OK to convert to signed, because new type has more bits than old. 4868 QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true); 4869 return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting, 4870 true); 4871 } 4872 4873 /// \brief Check if the given expression \a E is a constant integer that fits 4874 /// into \a Bits bits. 4875 static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) { 4876 if (E == nullptr) 4877 return false; 4878 llvm::APSInt Result; 4879 if (E->isIntegerConstantExpr(Result, SemaRef.Context)) 4880 return Signed ? Result.isSignedIntN(Bits) : Result.isIntN(Bits); 4881 return false; 4882 } 4883 4884 /// Build preinits statement for the given declarations. 4885 static Stmt *buildPreInits(ASTContext &Context, 4886 SmallVectorImpl<Decl *> &PreInits) { 4887 if (!PreInits.empty()) { 4888 return new (Context) DeclStmt( 4889 DeclGroupRef::Create(Context, PreInits.begin(), PreInits.size()), 4890 SourceLocation(), SourceLocation()); 4891 } 4892 return nullptr; 4893 } 4894 4895 /// Build preinits statement for the given declarations. 4896 static Stmt *buildPreInits(ASTContext &Context, 4897 llvm::MapVector<Expr *, DeclRefExpr *> &Captures) { 4898 if (!Captures.empty()) { 4899 SmallVector<Decl *, 16> PreInits; 4900 for (auto &Pair : Captures) 4901 PreInits.push_back(Pair.second->getDecl()); 4902 return buildPreInits(Context, PreInits); 4903 } 4904 return nullptr; 4905 } 4906 4907 /// Build postupdate expression for the given list of postupdates expressions. 4908 static Expr *buildPostUpdate(Sema &S, ArrayRef<Expr *> PostUpdates) { 4909 Expr *PostUpdate = nullptr; 4910 if (!PostUpdates.empty()) { 4911 for (auto *E : PostUpdates) { 4912 Expr *ConvE = S.BuildCStyleCastExpr( 4913 E->getExprLoc(), 4914 S.Context.getTrivialTypeSourceInfo(S.Context.VoidTy), 4915 E->getExprLoc(), E) 4916 .get(); 4917 PostUpdate = PostUpdate 4918 ? S.CreateBuiltinBinOp(ConvE->getExprLoc(), BO_Comma, 4919 PostUpdate, ConvE) 4920 .get() 4921 : ConvE; 4922 } 4923 } 4924 return PostUpdate; 4925 } 4926 4927 /// \brief Called on a for stmt to check itself and nested loops (if any). 4928 /// \return Returns 0 if one of the collapsed stmts is not canonical for loop, 4929 /// number of collapsed loops otherwise. 4930 static unsigned 4931 CheckOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr, 4932 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef, 4933 DSAStackTy &DSA, 4934 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA, 4935 OMPLoopDirective::HelperExprs &Built) { 4936 unsigned NestedLoopCount = 1; 4937 if (CollapseLoopCountExpr) { 4938 // Found 'collapse' clause - calculate collapse number. 4939 llvm::APSInt Result; 4940 if (CollapseLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext())) 4941 NestedLoopCount = Result.getLimitedValue(); 4942 } 4943 if (OrderedLoopCountExpr) { 4944 // Found 'ordered' clause - calculate collapse number. 4945 llvm::APSInt Result; 4946 if (OrderedLoopCountExpr->EvaluateAsInt(Result, SemaRef.getASTContext())) { 4947 if (Result.getLimitedValue() < NestedLoopCount) { 4948 SemaRef.Diag(OrderedLoopCountExpr->getExprLoc(), 4949 diag::err_omp_wrong_ordered_loop_count) 4950 << OrderedLoopCountExpr->getSourceRange(); 4951 SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(), 4952 diag::note_collapse_loop_count) 4953 << CollapseLoopCountExpr->getSourceRange(); 4954 } 4955 NestedLoopCount = Result.getLimitedValue(); 4956 } 4957 } 4958 // This is helper routine for loop directives (e.g., 'for', 'simd', 4959 // 'for simd', etc.). 4960 llvm::MapVector<Expr *, DeclRefExpr *> Captures; 4961 SmallVector<LoopIterationSpace, 4> IterSpaces; 4962 IterSpaces.resize(NestedLoopCount); 4963 Stmt *CurStmt = AStmt->IgnoreContainers(/* IgnoreCaptured */ true); 4964 for (unsigned Cnt = 0; Cnt < NestedLoopCount; ++Cnt) { 4965 if (CheckOpenMPIterationSpace(DKind, CurStmt, SemaRef, DSA, Cnt, 4966 NestedLoopCount, CollapseLoopCountExpr, 4967 OrderedLoopCountExpr, VarsWithImplicitDSA, 4968 IterSpaces[Cnt], Captures)) 4969 return 0; 4970 // Move on to the next nested for loop, or to the loop body. 4971 // OpenMP [2.8.1, simd construct, Restrictions] 4972 // All loops associated with the construct must be perfectly nested; that 4973 // is, there must be no intervening code nor any OpenMP directive between 4974 // any two loops. 4975 CurStmt = cast<ForStmt>(CurStmt)->getBody()->IgnoreContainers(); 4976 } 4977 4978 Built.clear(/* size */ NestedLoopCount); 4979 4980 if (SemaRef.CurContext->isDependentContext()) 4981 return NestedLoopCount; 4982 4983 // An example of what is generated for the following code: 4984 // 4985 // #pragma omp simd collapse(2) ordered(2) 4986 // for (i = 0; i < NI; ++i) 4987 // for (k = 0; k < NK; ++k) 4988 // for (j = J0; j < NJ; j+=2) { 4989 // <loop body> 4990 // } 4991 // 4992 // We generate the code below. 4993 // Note: the loop body may be outlined in CodeGen. 4994 // Note: some counters may be C++ classes, operator- is used to find number of 4995 // iterations and operator+= to calculate counter value. 4996 // Note: decltype(NumIterations) must be integer type (in 'omp for', only i32 4997 // or i64 is currently supported). 4998 // 4999 // #define NumIterations (NI * ((NJ - J0 - 1 + 2) / 2)) 5000 // for (int[32|64]_t IV = 0; IV < NumIterations; ++IV ) { 5001 // .local.i = IV / ((NJ - J0 - 1 + 2) / 2); 5002 // .local.j = J0 + (IV % ((NJ - J0 - 1 + 2) / 2)) * 2; 5003 // // similar updates for vars in clauses (e.g. 'linear') 5004 // <loop body (using local i and j)> 5005 // } 5006 // i = NI; // assign final values of counters 5007 // j = NJ; 5008 // 5009 5010 // Last iteration number is (I1 * I2 * ... In) - 1, where I1, I2 ... In are 5011 // the iteration counts of the collapsed for loops. 5012 // Precondition tests if there is at least one iteration (all conditions are 5013 // true). 5014 auto PreCond = ExprResult(IterSpaces[0].PreCond); 5015 auto N0 = IterSpaces[0].NumIterations; 5016 ExprResult LastIteration32 = WidenIterationCount( 5017 32 /* Bits */, SemaRef.PerformImplicitConversion( 5018 N0->IgnoreImpCasts(), N0->getType(), 5019 Sema::AA_Converting, /*AllowExplicit=*/true) 5020 .get(), 5021 SemaRef); 5022 ExprResult LastIteration64 = WidenIterationCount( 5023 64 /* Bits */, SemaRef.PerformImplicitConversion( 5024 N0->IgnoreImpCasts(), N0->getType(), 5025 Sema::AA_Converting, /*AllowExplicit=*/true) 5026 .get(), 5027 SemaRef); 5028 5029 if (!LastIteration32.isUsable() || !LastIteration64.isUsable()) 5030 return NestedLoopCount; 5031 5032 auto &C = SemaRef.Context; 5033 bool AllCountsNeedLessThan32Bits = C.getTypeSize(N0->getType()) < 32; 5034 5035 Scope *CurScope = DSA.getCurScope(); 5036 for (unsigned Cnt = 1; Cnt < NestedLoopCount; ++Cnt) { 5037 if (PreCond.isUsable()) { 5038 PreCond = SemaRef.BuildBinOp(CurScope, SourceLocation(), BO_LAnd, 5039 PreCond.get(), IterSpaces[Cnt].PreCond); 5040 } 5041 auto N = IterSpaces[Cnt].NumIterations; 5042 AllCountsNeedLessThan32Bits &= C.getTypeSize(N->getType()) < 32; 5043 if (LastIteration32.isUsable()) 5044 LastIteration32 = SemaRef.BuildBinOp( 5045 CurScope, SourceLocation(), BO_Mul, LastIteration32.get(), 5046 SemaRef.PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(), 5047 Sema::AA_Converting, 5048 /*AllowExplicit=*/true) 5049 .get()); 5050 if (LastIteration64.isUsable()) 5051 LastIteration64 = SemaRef.BuildBinOp( 5052 CurScope, SourceLocation(), BO_Mul, LastIteration64.get(), 5053 SemaRef.PerformImplicitConversion(N->IgnoreImpCasts(), N->getType(), 5054 Sema::AA_Converting, 5055 /*AllowExplicit=*/true) 5056 .get()); 5057 } 5058 5059 // Choose either the 32-bit or 64-bit version. 5060 ExprResult LastIteration = LastIteration64; 5061 if (LastIteration32.isUsable() && 5062 C.getTypeSize(LastIteration32.get()->getType()) == 32 && 5063 (AllCountsNeedLessThan32Bits || NestedLoopCount == 1 || 5064 FitsInto( 5065 32 /* Bits */, 5066 LastIteration32.get()->getType()->hasSignedIntegerRepresentation(), 5067 LastIteration64.get(), SemaRef))) 5068 LastIteration = LastIteration32; 5069 QualType VType = LastIteration.get()->getType(); 5070 QualType RealVType = VType; 5071 QualType StrideVType = VType; 5072 if (isOpenMPTaskLoopDirective(DKind)) { 5073 VType = 5074 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0); 5075 StrideVType = 5076 SemaRef.Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1); 5077 } 5078 5079 if (!LastIteration.isUsable()) 5080 return 0; 5081 5082 // Save the number of iterations. 5083 ExprResult NumIterations = LastIteration; 5084 { 5085 LastIteration = SemaRef.BuildBinOp( 5086 CurScope, SourceLocation(), BO_Sub, LastIteration.get(), 5087 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get()); 5088 if (!LastIteration.isUsable()) 5089 return 0; 5090 } 5091 5092 // Calculate the last iteration number beforehand instead of doing this on 5093 // each iteration. Do not do this if the number of iterations may be kfold-ed. 5094 llvm::APSInt Result; 5095 bool IsConstant = 5096 LastIteration.get()->isIntegerConstantExpr(Result, SemaRef.Context); 5097 ExprResult CalcLastIteration; 5098 if (!IsConstant) { 5099 ExprResult SaveRef = 5100 tryBuildCapture(SemaRef, LastIteration.get(), Captures); 5101 LastIteration = SaveRef; 5102 5103 // Prepare SaveRef + 1. 5104 NumIterations = SemaRef.BuildBinOp( 5105 CurScope, SourceLocation(), BO_Add, SaveRef.get(), 5106 SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get()); 5107 if (!NumIterations.isUsable()) 5108 return 0; 5109 } 5110 5111 SourceLocation InitLoc = IterSpaces[0].InitSrcRange.getBegin(); 5112 5113 // Build variables passed into runtime, nesessary for worksharing directives. 5114 ExprResult LB, UB, IL, ST, EUB, PrevLB, PrevUB; 5115 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) || 5116 isOpenMPDistributeDirective(DKind)) { 5117 // Lower bound variable, initialized with zero. 5118 VarDecl *LBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.lb"); 5119 LB = buildDeclRefExpr(SemaRef, LBDecl, VType, InitLoc); 5120 SemaRef.AddInitializerToDecl( 5121 LBDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(), 5122 /*DirectInit*/ false, /*TypeMayContainAuto*/ false); 5123 5124 // Upper bound variable, initialized with last iteration number. 5125 VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub"); 5126 UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc); 5127 SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(), 5128 /*DirectInit*/ false, 5129 /*TypeMayContainAuto*/ false); 5130 5131 // A 32-bit variable-flag where runtime returns 1 for the last iteration. 5132 // This will be used to implement clause 'lastprivate'. 5133 QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true); 5134 VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last"); 5135 IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc); 5136 SemaRef.AddInitializerToDecl( 5137 ILDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(), 5138 /*DirectInit*/ false, /*TypeMayContainAuto*/ false); 5139 5140 // Stride variable returned by runtime (we initialize it to 1 by default). 5141 VarDecl *STDecl = 5142 buildVarDecl(SemaRef, InitLoc, StrideVType, ".omp.stride"); 5143 ST = buildDeclRefExpr(SemaRef, STDecl, StrideVType, InitLoc); 5144 SemaRef.AddInitializerToDecl( 5145 STDecl, SemaRef.ActOnIntegerConstant(InitLoc, 1).get(), 5146 /*DirectInit*/ false, /*TypeMayContainAuto*/ false); 5147 5148 // Build expression: UB = min(UB, LastIteration) 5149 // It is nesessary for CodeGen of directives with static scheduling. 5150 ExprResult IsUBGreater = SemaRef.BuildBinOp(CurScope, InitLoc, BO_GT, 5151 UB.get(), LastIteration.get()); 5152 ExprResult CondOp = SemaRef.ActOnConditionalOp( 5153 InitLoc, InitLoc, IsUBGreater.get(), LastIteration.get(), UB.get()); 5154 EUB = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, UB.get(), 5155 CondOp.get()); 5156 EUB = SemaRef.ActOnFinishFullExpr(EUB.get()); 5157 5158 // If we have a combined directive that combines 'distribute', 'for' or 5159 // 'simd' we need to be able to access the bounds of the schedule of the 5160 // enclosing region. E.g. in 'distribute parallel for' the bounds obtained 5161 // by scheduling 'distribute' have to be passed to the schedule of 'for'. 5162 if (isOpenMPLoopBoundSharingDirective(DKind)) { 5163 auto *CD = cast<CapturedStmt>(AStmt)->getCapturedDecl(); 5164 5165 // We expect to have at least 2 more parameters than the 'parallel' 5166 // directive does - the lower and upper bounds of the previous schedule. 5167 assert(CD->getNumParams() >= 4 && 5168 "Unexpected number of parameters in loop combined directive"); 5169 5170 // Set the proper type for the bounds given what we learned from the 5171 // enclosed loops. 5172 auto *PrevLBDecl = CD->getParam(/*PrevLB=*/2); 5173 auto *PrevUBDecl = CD->getParam(/*PrevUB=*/3); 5174 5175 // Previous lower and upper bounds are obtained from the region 5176 // parameters. 5177 PrevLB = 5178 buildDeclRefExpr(SemaRef, PrevLBDecl, PrevLBDecl->getType(), InitLoc); 5179 PrevUB = 5180 buildDeclRefExpr(SemaRef, PrevUBDecl, PrevUBDecl->getType(), InitLoc); 5181 } 5182 } 5183 5184 // Build the iteration variable and its initialization before loop. 5185 ExprResult IV; 5186 ExprResult Init; 5187 { 5188 VarDecl *IVDecl = buildVarDecl(SemaRef, InitLoc, RealVType, ".omp.iv"); 5189 IV = buildDeclRefExpr(SemaRef, IVDecl, RealVType, InitLoc); 5190 Expr *RHS = (isOpenMPWorksharingDirective(DKind) || 5191 isOpenMPTaskLoopDirective(DKind) || 5192 isOpenMPDistributeDirective(DKind)) 5193 ? LB.get() 5194 : SemaRef.ActOnIntegerConstant(SourceLocation(), 0).get(); 5195 Init = SemaRef.BuildBinOp(CurScope, InitLoc, BO_Assign, IV.get(), RHS); 5196 Init = SemaRef.ActOnFinishFullExpr(Init.get()); 5197 } 5198 5199 // Loop condition (IV < NumIterations) or (IV <= UB) for worksharing loops. 5200 SourceLocation CondLoc; 5201 ExprResult Cond = 5202 (isOpenMPWorksharingDirective(DKind) || 5203 isOpenMPTaskLoopDirective(DKind) || isOpenMPDistributeDirective(DKind)) 5204 ? SemaRef.BuildBinOp(CurScope, CondLoc, BO_LE, IV.get(), UB.get()) 5205 : SemaRef.BuildBinOp(CurScope, CondLoc, BO_LT, IV.get(), 5206 NumIterations.get()); 5207 5208 // Loop increment (IV = IV + 1) 5209 SourceLocation IncLoc; 5210 ExprResult Inc = 5211 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, IV.get(), 5212 SemaRef.ActOnIntegerConstant(IncLoc, 1).get()); 5213 if (!Inc.isUsable()) 5214 return 0; 5215 Inc = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, IV.get(), Inc.get()); 5216 Inc = SemaRef.ActOnFinishFullExpr(Inc.get()); 5217 if (!Inc.isUsable()) 5218 return 0; 5219 5220 // Increments for worksharing loops (LB = LB + ST; UB = UB + ST). 5221 // Used for directives with static scheduling. 5222 ExprResult NextLB, NextUB; 5223 if (isOpenMPWorksharingDirective(DKind) || isOpenMPTaskLoopDirective(DKind) || 5224 isOpenMPDistributeDirective(DKind)) { 5225 // LB + ST 5226 NextLB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, LB.get(), ST.get()); 5227 if (!NextLB.isUsable()) 5228 return 0; 5229 // LB = LB + ST 5230 NextLB = 5231 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, LB.get(), NextLB.get()); 5232 NextLB = SemaRef.ActOnFinishFullExpr(NextLB.get()); 5233 if (!NextLB.isUsable()) 5234 return 0; 5235 // UB + ST 5236 NextUB = SemaRef.BuildBinOp(CurScope, IncLoc, BO_Add, UB.get(), ST.get()); 5237 if (!NextUB.isUsable()) 5238 return 0; 5239 // UB = UB + ST 5240 NextUB = 5241 SemaRef.BuildBinOp(CurScope, IncLoc, BO_Assign, UB.get(), NextUB.get()); 5242 NextUB = SemaRef.ActOnFinishFullExpr(NextUB.get()); 5243 if (!NextUB.isUsable()) 5244 return 0; 5245 } 5246 5247 // Build updates and final values of the loop counters. 5248 bool HasErrors = false; 5249 Built.Counters.resize(NestedLoopCount); 5250 Built.Inits.resize(NestedLoopCount); 5251 Built.Updates.resize(NestedLoopCount); 5252 Built.Finals.resize(NestedLoopCount); 5253 SmallVector<Expr *, 4> LoopMultipliers; 5254 { 5255 ExprResult Div; 5256 // Go from inner nested loop to outer. 5257 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) { 5258 LoopIterationSpace &IS = IterSpaces[Cnt]; 5259 SourceLocation UpdLoc = IS.IncSrcRange.getBegin(); 5260 // Build: Iter = (IV / Div) % IS.NumIters 5261 // where Div is product of previous iterations' IS.NumIters. 5262 ExprResult Iter; 5263 if (Div.isUsable()) { 5264 Iter = 5265 SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Div, IV.get(), Div.get()); 5266 } else { 5267 Iter = IV; 5268 assert((Cnt == (int)NestedLoopCount - 1) && 5269 "unusable div expected on first iteration only"); 5270 } 5271 5272 if (Cnt != 0 && Iter.isUsable()) 5273 Iter = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Rem, Iter.get(), 5274 IS.NumIterations); 5275 if (!Iter.isUsable()) { 5276 HasErrors = true; 5277 break; 5278 } 5279 5280 // Build update: IS.CounterVar(Private) = IS.Start + Iter * IS.Step 5281 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IS.CounterVar)->getDecl()); 5282 auto *CounterVar = buildDeclRefExpr(SemaRef, VD, IS.CounterVar->getType(), 5283 IS.CounterVar->getExprLoc(), 5284 /*RefersToCapture=*/true); 5285 ExprResult Init = BuildCounterInit(SemaRef, CurScope, UpdLoc, CounterVar, 5286 IS.CounterInit, Captures); 5287 if (!Init.isUsable()) { 5288 HasErrors = true; 5289 break; 5290 } 5291 ExprResult Update = BuildCounterUpdate( 5292 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit, Iter, 5293 IS.CounterStep, IS.Subtract, &Captures); 5294 if (!Update.isUsable()) { 5295 HasErrors = true; 5296 break; 5297 } 5298 5299 // Build final: IS.CounterVar = IS.Start + IS.NumIters * IS.Step 5300 ExprResult Final = BuildCounterUpdate( 5301 SemaRef, CurScope, UpdLoc, CounterVar, IS.CounterInit, 5302 IS.NumIterations, IS.CounterStep, IS.Subtract, &Captures); 5303 if (!Final.isUsable()) { 5304 HasErrors = true; 5305 break; 5306 } 5307 5308 // Build Div for the next iteration: Div <- Div * IS.NumIters 5309 if (Cnt != 0) { 5310 if (Div.isUnset()) 5311 Div = IS.NumIterations; 5312 else 5313 Div = SemaRef.BuildBinOp(CurScope, UpdLoc, BO_Mul, Div.get(), 5314 IS.NumIterations); 5315 5316 // Add parentheses (for debugging purposes only). 5317 if (Div.isUsable()) 5318 Div = tryBuildCapture(SemaRef, Div.get(), Captures); 5319 if (!Div.isUsable()) { 5320 HasErrors = true; 5321 break; 5322 } 5323 LoopMultipliers.push_back(Div.get()); 5324 } 5325 if (!Update.isUsable() || !Final.isUsable()) { 5326 HasErrors = true; 5327 break; 5328 } 5329 // Save results 5330 Built.Counters[Cnt] = IS.CounterVar; 5331 Built.PrivateCounters[Cnt] = IS.PrivateCounterVar; 5332 Built.Inits[Cnt] = Init.get(); 5333 Built.Updates[Cnt] = Update.get(); 5334 Built.Finals[Cnt] = Final.get(); 5335 } 5336 } 5337 5338 if (HasErrors) 5339 return 0; 5340 5341 // Save results 5342 Built.IterationVarRef = IV.get(); 5343 Built.LastIteration = LastIteration.get(); 5344 Built.NumIterations = NumIterations.get(); 5345 Built.CalcLastIteration = 5346 SemaRef.ActOnFinishFullExpr(CalcLastIteration.get()).get(); 5347 Built.PreCond = PreCond.get(); 5348 Built.PreInits = buildPreInits(C, Captures); 5349 Built.Cond = Cond.get(); 5350 Built.Init = Init.get(); 5351 Built.Inc = Inc.get(); 5352 Built.LB = LB.get(); 5353 Built.UB = UB.get(); 5354 Built.IL = IL.get(); 5355 Built.ST = ST.get(); 5356 Built.EUB = EUB.get(); 5357 Built.NLB = NextLB.get(); 5358 Built.NUB = NextUB.get(); 5359 Built.PrevLB = PrevLB.get(); 5360 Built.PrevUB = PrevUB.get(); 5361 5362 Expr *CounterVal = SemaRef.DefaultLvalueConversion(IV.get()).get(); 5363 // Fill data for doacross depend clauses. 5364 for (auto Pair : DSA.getDoacrossDependClauses()) { 5365 if (Pair.first->getDependencyKind() == OMPC_DEPEND_source) 5366 Pair.first->setCounterValue(CounterVal); 5367 else { 5368 if (NestedLoopCount != Pair.second.size() || 5369 NestedLoopCount != LoopMultipliers.size() + 1) { 5370 // Erroneous case - clause has some problems. 5371 Pair.first->setCounterValue(CounterVal); 5372 continue; 5373 } 5374 assert(Pair.first->getDependencyKind() == OMPC_DEPEND_sink); 5375 auto I = Pair.second.rbegin(); 5376 auto IS = IterSpaces.rbegin(); 5377 auto ILM = LoopMultipliers.rbegin(); 5378 Expr *UpCounterVal = CounterVal; 5379 Expr *Multiplier = nullptr; 5380 for (int Cnt = NestedLoopCount - 1; Cnt >= 0; --Cnt) { 5381 if (I->first) { 5382 assert(IS->CounterStep); 5383 Expr *NormalizedOffset = 5384 SemaRef 5385 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Div, 5386 I->first, IS->CounterStep) 5387 .get(); 5388 if (Multiplier) { 5389 NormalizedOffset = 5390 SemaRef 5391 .BuildBinOp(CurScope, I->first->getExprLoc(), BO_Mul, 5392 NormalizedOffset, Multiplier) 5393 .get(); 5394 } 5395 assert(I->second == OO_Plus || I->second == OO_Minus); 5396 BinaryOperatorKind BOK = (I->second == OO_Plus) ? BO_Add : BO_Sub; 5397 UpCounterVal = 5398 SemaRef.BuildBinOp(CurScope, I->first->getExprLoc(), BOK, 5399 UpCounterVal, NormalizedOffset).get(); 5400 } 5401 Multiplier = *ILM; 5402 ++I; 5403 ++IS; 5404 ++ILM; 5405 } 5406 Pair.first->setCounterValue(UpCounterVal); 5407 } 5408 } 5409 5410 return NestedLoopCount; 5411 } 5412 5413 static Expr *getCollapseNumberExpr(ArrayRef<OMPClause *> Clauses) { 5414 auto CollapseClauses = 5415 OMPExecutableDirective::getClausesOfKind<OMPCollapseClause>(Clauses); 5416 if (CollapseClauses.begin() != CollapseClauses.end()) 5417 return (*CollapseClauses.begin())->getNumForLoops(); 5418 return nullptr; 5419 } 5420 5421 static Expr *getOrderedNumberExpr(ArrayRef<OMPClause *> Clauses) { 5422 auto OrderedClauses = 5423 OMPExecutableDirective::getClausesOfKind<OMPOrderedClause>(Clauses); 5424 if (OrderedClauses.begin() != OrderedClauses.end()) 5425 return (*OrderedClauses.begin())->getNumForLoops(); 5426 return nullptr; 5427 } 5428 5429 static bool checkSimdlenSafelenValues(Sema &S, const Expr *Simdlen, 5430 const Expr *Safelen) { 5431 llvm::APSInt SimdlenRes, SafelenRes; 5432 if (Simdlen->isValueDependent() || Simdlen->isTypeDependent() || 5433 Simdlen->isInstantiationDependent() || 5434 Simdlen->containsUnexpandedParameterPack()) 5435 return false; 5436 if (Safelen->isValueDependent() || Safelen->isTypeDependent() || 5437 Safelen->isInstantiationDependent() || 5438 Safelen->containsUnexpandedParameterPack()) 5439 return false; 5440 Simdlen->EvaluateAsInt(SimdlenRes, S.Context); 5441 Safelen->EvaluateAsInt(SafelenRes, S.Context); 5442 // OpenMP 4.1 [2.8.1, simd Construct, Restrictions] 5443 // If both simdlen and safelen clauses are specified, the value of the simdlen 5444 // parameter must be less than or equal to the value of the safelen parameter. 5445 if (SimdlenRes > SafelenRes) { 5446 S.Diag(Simdlen->getExprLoc(), diag::err_omp_wrong_simdlen_safelen_values) 5447 << Simdlen->getSourceRange() << Safelen->getSourceRange(); 5448 return true; 5449 } 5450 return false; 5451 } 5452 5453 StmtResult Sema::ActOnOpenMPSimdDirective( 5454 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 5455 SourceLocation EndLoc, 5456 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 5457 if (!AStmt) 5458 return StmtError(); 5459 5460 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5461 OMPLoopDirective::HelperExprs B; 5462 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 5463 // define the nested loops number. 5464 unsigned NestedLoopCount = CheckOpenMPLoop( 5465 OMPD_simd, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses), 5466 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B); 5467 if (NestedLoopCount == 0) 5468 return StmtError(); 5469 5470 assert((CurContext->isDependentContext() || B.builtAll()) && 5471 "omp simd loop exprs were not built"); 5472 5473 if (!CurContext->isDependentContext()) { 5474 // Finalize the clauses that need pre-built expressions for CodeGen. 5475 for (auto C : Clauses) { 5476 if (auto LC = dyn_cast<OMPLinearClause>(C)) 5477 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 5478 B.NumIterations, *this, CurScope, 5479 DSAStack)) 5480 return StmtError(); 5481 } 5482 } 5483 5484 // OpenMP 4.1 [2.8.1, simd Construct, Restrictions] 5485 // If both simdlen and safelen clauses are specified, the value of the simdlen 5486 // parameter must be less than or equal to the value of the safelen parameter. 5487 OMPSafelenClause *Safelen = nullptr; 5488 OMPSimdlenClause *Simdlen = nullptr; 5489 for (auto *Clause : Clauses) { 5490 if (Clause->getClauseKind() == OMPC_safelen) 5491 Safelen = cast<OMPSafelenClause>(Clause); 5492 else if (Clause->getClauseKind() == OMPC_simdlen) 5493 Simdlen = cast<OMPSimdlenClause>(Clause); 5494 if (Safelen && Simdlen) 5495 break; 5496 } 5497 if (Simdlen && Safelen && 5498 checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(), 5499 Safelen->getSafelen())) 5500 return StmtError(); 5501 5502 getCurFunction()->setHasBranchProtectedScope(); 5503 return OMPSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount, 5504 Clauses, AStmt, B); 5505 } 5506 5507 StmtResult Sema::ActOnOpenMPForDirective( 5508 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 5509 SourceLocation EndLoc, 5510 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 5511 if (!AStmt) 5512 return StmtError(); 5513 5514 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5515 OMPLoopDirective::HelperExprs B; 5516 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 5517 // define the nested loops number. 5518 unsigned NestedLoopCount = CheckOpenMPLoop( 5519 OMPD_for, getCollapseNumberExpr(Clauses), getOrderedNumberExpr(Clauses), 5520 AStmt, *this, *DSAStack, VarsWithImplicitDSA, B); 5521 if (NestedLoopCount == 0) 5522 return StmtError(); 5523 5524 assert((CurContext->isDependentContext() || B.builtAll()) && 5525 "omp for loop exprs were not built"); 5526 5527 if (!CurContext->isDependentContext()) { 5528 // Finalize the clauses that need pre-built expressions for CodeGen. 5529 for (auto C : Clauses) { 5530 if (auto LC = dyn_cast<OMPLinearClause>(C)) 5531 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 5532 B.NumIterations, *this, CurScope, 5533 DSAStack)) 5534 return StmtError(); 5535 } 5536 } 5537 5538 getCurFunction()->setHasBranchProtectedScope(); 5539 return OMPForDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount, 5540 Clauses, AStmt, B, DSAStack->isCancelRegion()); 5541 } 5542 5543 StmtResult Sema::ActOnOpenMPForSimdDirective( 5544 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 5545 SourceLocation EndLoc, 5546 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 5547 if (!AStmt) 5548 return StmtError(); 5549 5550 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5551 OMPLoopDirective::HelperExprs B; 5552 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 5553 // define the nested loops number. 5554 unsigned NestedLoopCount = 5555 CheckOpenMPLoop(OMPD_for_simd, getCollapseNumberExpr(Clauses), 5556 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack, 5557 VarsWithImplicitDSA, B); 5558 if (NestedLoopCount == 0) 5559 return StmtError(); 5560 5561 assert((CurContext->isDependentContext() || B.builtAll()) && 5562 "omp for simd loop exprs were not built"); 5563 5564 if (!CurContext->isDependentContext()) { 5565 // Finalize the clauses that need pre-built expressions for CodeGen. 5566 for (auto C : Clauses) { 5567 if (auto LC = dyn_cast<OMPLinearClause>(C)) 5568 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 5569 B.NumIterations, *this, CurScope, 5570 DSAStack)) 5571 return StmtError(); 5572 } 5573 } 5574 5575 // OpenMP 4.1 [2.8.1, simd Construct, Restrictions] 5576 // If both simdlen and safelen clauses are specified, the value of the simdlen 5577 // parameter must be less than or equal to the value of the safelen parameter. 5578 OMPSafelenClause *Safelen = nullptr; 5579 OMPSimdlenClause *Simdlen = nullptr; 5580 for (auto *Clause : Clauses) { 5581 if (Clause->getClauseKind() == OMPC_safelen) 5582 Safelen = cast<OMPSafelenClause>(Clause); 5583 else if (Clause->getClauseKind() == OMPC_simdlen) 5584 Simdlen = cast<OMPSimdlenClause>(Clause); 5585 if (Safelen && Simdlen) 5586 break; 5587 } 5588 if (Simdlen && Safelen && 5589 checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(), 5590 Safelen->getSafelen())) 5591 return StmtError(); 5592 5593 getCurFunction()->setHasBranchProtectedScope(); 5594 return OMPForSimdDirective::Create(Context, StartLoc, EndLoc, NestedLoopCount, 5595 Clauses, AStmt, B); 5596 } 5597 5598 StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses, 5599 Stmt *AStmt, 5600 SourceLocation StartLoc, 5601 SourceLocation EndLoc) { 5602 if (!AStmt) 5603 return StmtError(); 5604 5605 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5606 auto BaseStmt = AStmt; 5607 while (CapturedStmt *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt)) 5608 BaseStmt = CS->getCapturedStmt(); 5609 if (auto C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) { 5610 auto S = C->children(); 5611 if (S.begin() == S.end()) 5612 return StmtError(); 5613 // All associated statements must be '#pragma omp section' except for 5614 // the first one. 5615 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) { 5616 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) { 5617 if (SectionStmt) 5618 Diag(SectionStmt->getLocStart(), 5619 diag::err_omp_sections_substmt_not_section); 5620 return StmtError(); 5621 } 5622 cast<OMPSectionDirective>(SectionStmt) 5623 ->setHasCancel(DSAStack->isCancelRegion()); 5624 } 5625 } else { 5626 Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt); 5627 return StmtError(); 5628 } 5629 5630 getCurFunction()->setHasBranchProtectedScope(); 5631 5632 return OMPSectionsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt, 5633 DSAStack->isCancelRegion()); 5634 } 5635 5636 StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt, 5637 SourceLocation StartLoc, 5638 SourceLocation EndLoc) { 5639 if (!AStmt) 5640 return StmtError(); 5641 5642 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5643 5644 getCurFunction()->setHasBranchProtectedScope(); 5645 DSAStack->setParentCancelRegion(DSAStack->isCancelRegion()); 5646 5647 return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt, 5648 DSAStack->isCancelRegion()); 5649 } 5650 5651 StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses, 5652 Stmt *AStmt, 5653 SourceLocation StartLoc, 5654 SourceLocation EndLoc) { 5655 if (!AStmt) 5656 return StmtError(); 5657 5658 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5659 5660 getCurFunction()->setHasBranchProtectedScope(); 5661 5662 // OpenMP [2.7.3, single Construct, Restrictions] 5663 // The copyprivate clause must not be used with the nowait clause. 5664 OMPClause *Nowait = nullptr; 5665 OMPClause *Copyprivate = nullptr; 5666 for (auto *Clause : Clauses) { 5667 if (Clause->getClauseKind() == OMPC_nowait) 5668 Nowait = Clause; 5669 else if (Clause->getClauseKind() == OMPC_copyprivate) 5670 Copyprivate = Clause; 5671 if (Copyprivate && Nowait) { 5672 Diag(Copyprivate->getLocStart(), 5673 diag::err_omp_single_copyprivate_with_nowait); 5674 Diag(Nowait->getLocStart(), diag::note_omp_nowait_clause_here); 5675 return StmtError(); 5676 } 5677 } 5678 5679 return OMPSingleDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt); 5680 } 5681 5682 StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt, 5683 SourceLocation StartLoc, 5684 SourceLocation EndLoc) { 5685 if (!AStmt) 5686 return StmtError(); 5687 5688 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5689 5690 getCurFunction()->setHasBranchProtectedScope(); 5691 5692 return OMPMasterDirective::Create(Context, StartLoc, EndLoc, AStmt); 5693 } 5694 5695 StmtResult Sema::ActOnOpenMPCriticalDirective( 5696 const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses, 5697 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) { 5698 if (!AStmt) 5699 return StmtError(); 5700 5701 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5702 5703 bool ErrorFound = false; 5704 llvm::APSInt Hint; 5705 SourceLocation HintLoc; 5706 bool DependentHint = false; 5707 for (auto *C : Clauses) { 5708 if (C->getClauseKind() == OMPC_hint) { 5709 if (!DirName.getName()) { 5710 Diag(C->getLocStart(), diag::err_omp_hint_clause_no_name); 5711 ErrorFound = true; 5712 } 5713 Expr *E = cast<OMPHintClause>(C)->getHint(); 5714 if (E->isTypeDependent() || E->isValueDependent() || 5715 E->isInstantiationDependent()) 5716 DependentHint = true; 5717 else { 5718 Hint = E->EvaluateKnownConstInt(Context); 5719 HintLoc = C->getLocStart(); 5720 } 5721 } 5722 } 5723 if (ErrorFound) 5724 return StmtError(); 5725 auto Pair = DSAStack->getCriticalWithHint(DirName); 5726 if (Pair.first && DirName.getName() && !DependentHint) { 5727 if (llvm::APSInt::compareValues(Hint, Pair.second) != 0) { 5728 Diag(StartLoc, diag::err_omp_critical_with_hint); 5729 if (HintLoc.isValid()) { 5730 Diag(HintLoc, diag::note_omp_critical_hint_here) 5731 << 0 << Hint.toString(/*Radix=*/10, /*Signed=*/false); 5732 } else 5733 Diag(StartLoc, diag::note_omp_critical_no_hint) << 0; 5734 if (auto *C = Pair.first->getSingleClause<OMPHintClause>()) { 5735 Diag(C->getLocStart(), diag::note_omp_critical_hint_here) 5736 << 1 5737 << C->getHint()->EvaluateKnownConstInt(Context).toString( 5738 /*Radix=*/10, /*Signed=*/false); 5739 } else 5740 Diag(Pair.first->getLocStart(), diag::note_omp_critical_no_hint) << 1; 5741 } 5742 } 5743 5744 getCurFunction()->setHasBranchProtectedScope(); 5745 5746 auto *Dir = OMPCriticalDirective::Create(Context, DirName, StartLoc, EndLoc, 5747 Clauses, AStmt); 5748 if (!Pair.first && DirName.getName() && !DependentHint) 5749 DSAStack->addCriticalWithHint(Dir, Hint); 5750 return Dir; 5751 } 5752 5753 StmtResult Sema::ActOnOpenMPParallelForDirective( 5754 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 5755 SourceLocation EndLoc, 5756 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 5757 if (!AStmt) 5758 return StmtError(); 5759 5760 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 5761 // 1.2.2 OpenMP Language Terminology 5762 // Structured block - An executable statement with a single entry at the 5763 // top and a single exit at the bottom. 5764 // The point of exit cannot be a branch out of the structured block. 5765 // longjmp() and throw() must not violate the entry/exit criteria. 5766 CS->getCapturedDecl()->setNothrow(); 5767 5768 OMPLoopDirective::HelperExprs B; 5769 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 5770 // define the nested loops number. 5771 unsigned NestedLoopCount = 5772 CheckOpenMPLoop(OMPD_parallel_for, getCollapseNumberExpr(Clauses), 5773 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack, 5774 VarsWithImplicitDSA, B); 5775 if (NestedLoopCount == 0) 5776 return StmtError(); 5777 5778 assert((CurContext->isDependentContext() || B.builtAll()) && 5779 "omp parallel for loop exprs were not built"); 5780 5781 if (!CurContext->isDependentContext()) { 5782 // Finalize the clauses that need pre-built expressions for CodeGen. 5783 for (auto C : Clauses) { 5784 if (auto LC = dyn_cast<OMPLinearClause>(C)) 5785 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 5786 B.NumIterations, *this, CurScope, 5787 DSAStack)) 5788 return StmtError(); 5789 } 5790 } 5791 5792 getCurFunction()->setHasBranchProtectedScope(); 5793 return OMPParallelForDirective::Create(Context, StartLoc, EndLoc, 5794 NestedLoopCount, Clauses, AStmt, B, 5795 DSAStack->isCancelRegion()); 5796 } 5797 5798 StmtResult Sema::ActOnOpenMPParallelForSimdDirective( 5799 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 5800 SourceLocation EndLoc, 5801 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 5802 if (!AStmt) 5803 return StmtError(); 5804 5805 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 5806 // 1.2.2 OpenMP Language Terminology 5807 // Structured block - An executable statement with a single entry at the 5808 // top and a single exit at the bottom. 5809 // The point of exit cannot be a branch out of the structured block. 5810 // longjmp() and throw() must not violate the entry/exit criteria. 5811 CS->getCapturedDecl()->setNothrow(); 5812 5813 OMPLoopDirective::HelperExprs B; 5814 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 5815 // define the nested loops number. 5816 unsigned NestedLoopCount = 5817 CheckOpenMPLoop(OMPD_parallel_for_simd, getCollapseNumberExpr(Clauses), 5818 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack, 5819 VarsWithImplicitDSA, B); 5820 if (NestedLoopCount == 0) 5821 return StmtError(); 5822 5823 if (!CurContext->isDependentContext()) { 5824 // Finalize the clauses that need pre-built expressions for CodeGen. 5825 for (auto C : Clauses) { 5826 if (auto LC = dyn_cast<OMPLinearClause>(C)) 5827 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 5828 B.NumIterations, *this, CurScope, 5829 DSAStack)) 5830 return StmtError(); 5831 } 5832 } 5833 5834 // OpenMP 4.1 [2.8.1, simd Construct, Restrictions] 5835 // If both simdlen and safelen clauses are specified, the value of the simdlen 5836 // parameter must be less than or equal to the value of the safelen parameter. 5837 OMPSafelenClause *Safelen = nullptr; 5838 OMPSimdlenClause *Simdlen = nullptr; 5839 for (auto *Clause : Clauses) { 5840 if (Clause->getClauseKind() == OMPC_safelen) 5841 Safelen = cast<OMPSafelenClause>(Clause); 5842 else if (Clause->getClauseKind() == OMPC_simdlen) 5843 Simdlen = cast<OMPSimdlenClause>(Clause); 5844 if (Safelen && Simdlen) 5845 break; 5846 } 5847 if (Simdlen && Safelen && 5848 checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(), 5849 Safelen->getSafelen())) 5850 return StmtError(); 5851 5852 getCurFunction()->setHasBranchProtectedScope(); 5853 return OMPParallelForSimdDirective::Create( 5854 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B); 5855 } 5856 5857 StmtResult 5858 Sema::ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses, 5859 Stmt *AStmt, SourceLocation StartLoc, 5860 SourceLocation EndLoc) { 5861 if (!AStmt) 5862 return StmtError(); 5863 5864 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5865 auto BaseStmt = AStmt; 5866 while (CapturedStmt *CS = dyn_cast_or_null<CapturedStmt>(BaseStmt)) 5867 BaseStmt = CS->getCapturedStmt(); 5868 if (auto C = dyn_cast_or_null<CompoundStmt>(BaseStmt)) { 5869 auto S = C->children(); 5870 if (S.begin() == S.end()) 5871 return StmtError(); 5872 // All associated statements must be '#pragma omp section' except for 5873 // the first one. 5874 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) { 5875 if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) { 5876 if (SectionStmt) 5877 Diag(SectionStmt->getLocStart(), 5878 diag::err_omp_parallel_sections_substmt_not_section); 5879 return StmtError(); 5880 } 5881 cast<OMPSectionDirective>(SectionStmt) 5882 ->setHasCancel(DSAStack->isCancelRegion()); 5883 } 5884 } else { 5885 Diag(AStmt->getLocStart(), 5886 diag::err_omp_parallel_sections_not_compound_stmt); 5887 return StmtError(); 5888 } 5889 5890 getCurFunction()->setHasBranchProtectedScope(); 5891 5892 return OMPParallelSectionsDirective::Create( 5893 Context, StartLoc, EndLoc, Clauses, AStmt, DSAStack->isCancelRegion()); 5894 } 5895 5896 StmtResult Sema::ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses, 5897 Stmt *AStmt, SourceLocation StartLoc, 5898 SourceLocation EndLoc) { 5899 if (!AStmt) 5900 return StmtError(); 5901 5902 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 5903 // 1.2.2 OpenMP Language Terminology 5904 // Structured block - An executable statement with a single entry at the 5905 // top and a single exit at the bottom. 5906 // The point of exit cannot be a branch out of the structured block. 5907 // longjmp() and throw() must not violate the entry/exit criteria. 5908 CS->getCapturedDecl()->setNothrow(); 5909 5910 getCurFunction()->setHasBranchProtectedScope(); 5911 5912 return OMPTaskDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt, 5913 DSAStack->isCancelRegion()); 5914 } 5915 5916 StmtResult Sema::ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc, 5917 SourceLocation EndLoc) { 5918 return OMPTaskyieldDirective::Create(Context, StartLoc, EndLoc); 5919 } 5920 5921 StmtResult Sema::ActOnOpenMPBarrierDirective(SourceLocation StartLoc, 5922 SourceLocation EndLoc) { 5923 return OMPBarrierDirective::Create(Context, StartLoc, EndLoc); 5924 } 5925 5926 StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc, 5927 SourceLocation EndLoc) { 5928 return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc); 5929 } 5930 5931 StmtResult Sema::ActOnOpenMPTaskgroupDirective(Stmt *AStmt, 5932 SourceLocation StartLoc, 5933 SourceLocation EndLoc) { 5934 if (!AStmt) 5935 return StmtError(); 5936 5937 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 5938 5939 getCurFunction()->setHasBranchProtectedScope(); 5940 5941 return OMPTaskgroupDirective::Create(Context, StartLoc, EndLoc, AStmt); 5942 } 5943 5944 StmtResult Sema::ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses, 5945 SourceLocation StartLoc, 5946 SourceLocation EndLoc) { 5947 assert(Clauses.size() <= 1 && "Extra clauses in flush directive"); 5948 return OMPFlushDirective::Create(Context, StartLoc, EndLoc, Clauses); 5949 } 5950 5951 StmtResult Sema::ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses, 5952 Stmt *AStmt, 5953 SourceLocation StartLoc, 5954 SourceLocation EndLoc) { 5955 OMPClause *DependFound = nullptr; 5956 OMPClause *DependSourceClause = nullptr; 5957 OMPClause *DependSinkClause = nullptr; 5958 bool ErrorFound = false; 5959 OMPThreadsClause *TC = nullptr; 5960 OMPSIMDClause *SC = nullptr; 5961 for (auto *C : Clauses) { 5962 if (auto *DC = dyn_cast<OMPDependClause>(C)) { 5963 DependFound = C; 5964 if (DC->getDependencyKind() == OMPC_DEPEND_source) { 5965 if (DependSourceClause) { 5966 Diag(C->getLocStart(), diag::err_omp_more_one_clause) 5967 << getOpenMPDirectiveName(OMPD_ordered) 5968 << getOpenMPClauseName(OMPC_depend) << 2; 5969 ErrorFound = true; 5970 } else 5971 DependSourceClause = C; 5972 if (DependSinkClause) { 5973 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed) 5974 << 0; 5975 ErrorFound = true; 5976 } 5977 } else if (DC->getDependencyKind() == OMPC_DEPEND_sink) { 5978 if (DependSourceClause) { 5979 Diag(C->getLocStart(), diag::err_omp_depend_sink_source_not_allowed) 5980 << 1; 5981 ErrorFound = true; 5982 } 5983 DependSinkClause = C; 5984 } 5985 } else if (C->getClauseKind() == OMPC_threads) 5986 TC = cast<OMPThreadsClause>(C); 5987 else if (C->getClauseKind() == OMPC_simd) 5988 SC = cast<OMPSIMDClause>(C); 5989 } 5990 if (!ErrorFound && !SC && 5991 isOpenMPSimdDirective(DSAStack->getParentDirective())) { 5992 // OpenMP [2.8.1,simd Construct, Restrictions] 5993 // An ordered construct with the simd clause is the only OpenMP construct 5994 // that can appear in the simd region. 5995 Diag(StartLoc, diag::err_omp_prohibited_region_simd); 5996 ErrorFound = true; 5997 } else if (DependFound && (TC || SC)) { 5998 Diag(DependFound->getLocStart(), diag::err_omp_depend_clause_thread_simd) 5999 << getOpenMPClauseName(TC ? TC->getClauseKind() : SC->getClauseKind()); 6000 ErrorFound = true; 6001 } else if (DependFound && !DSAStack->getParentOrderedRegionParam()) { 6002 Diag(DependFound->getLocStart(), 6003 diag::err_omp_ordered_directive_without_param); 6004 ErrorFound = true; 6005 } else if (TC || Clauses.empty()) { 6006 if (auto *Param = DSAStack->getParentOrderedRegionParam()) { 6007 SourceLocation ErrLoc = TC ? TC->getLocStart() : StartLoc; 6008 Diag(ErrLoc, diag::err_omp_ordered_directive_with_param) 6009 << (TC != nullptr); 6010 Diag(Param->getLocStart(), diag::note_omp_ordered_param); 6011 ErrorFound = true; 6012 } 6013 } 6014 if ((!AStmt && !DependFound) || ErrorFound) 6015 return StmtError(); 6016 6017 if (AStmt) { 6018 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 6019 6020 getCurFunction()->setHasBranchProtectedScope(); 6021 } 6022 6023 return OMPOrderedDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt); 6024 } 6025 6026 namespace { 6027 /// \brief Helper class for checking expression in 'omp atomic [update]' 6028 /// construct. 6029 class OpenMPAtomicUpdateChecker { 6030 /// \brief Error results for atomic update expressions. 6031 enum ExprAnalysisErrorCode { 6032 /// \brief A statement is not an expression statement. 6033 NotAnExpression, 6034 /// \brief Expression is not builtin binary or unary operation. 6035 NotABinaryOrUnaryExpression, 6036 /// \brief Unary operation is not post-/pre- increment/decrement operation. 6037 NotAnUnaryIncDecExpression, 6038 /// \brief An expression is not of scalar type. 6039 NotAScalarType, 6040 /// \brief A binary operation is not an assignment operation. 6041 NotAnAssignmentOp, 6042 /// \brief RHS part of the binary operation is not a binary expression. 6043 NotABinaryExpression, 6044 /// \brief RHS part is not additive/multiplicative/shift/biwise binary 6045 /// expression. 6046 NotABinaryOperator, 6047 /// \brief RHS binary operation does not have reference to the updated LHS 6048 /// part. 6049 NotAnUpdateExpression, 6050 /// \brief No errors is found. 6051 NoError 6052 }; 6053 /// \brief Reference to Sema. 6054 Sema &SemaRef; 6055 /// \brief A location for note diagnostics (when error is found). 6056 SourceLocation NoteLoc; 6057 /// \brief 'x' lvalue part of the source atomic expression. 6058 Expr *X; 6059 /// \brief 'expr' rvalue part of the source atomic expression. 6060 Expr *E; 6061 /// \brief Helper expression of the form 6062 /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or 6063 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'. 6064 Expr *UpdateExpr; 6065 /// \brief Is 'x' a LHS in a RHS part of full update expression. It is 6066 /// important for non-associative operations. 6067 bool IsXLHSInRHSPart; 6068 BinaryOperatorKind Op; 6069 SourceLocation OpLoc; 6070 /// \brief true if the source expression is a postfix unary operation, false 6071 /// if it is a prefix unary operation. 6072 bool IsPostfixUpdate; 6073 6074 public: 6075 OpenMPAtomicUpdateChecker(Sema &SemaRef) 6076 : SemaRef(SemaRef), X(nullptr), E(nullptr), UpdateExpr(nullptr), 6077 IsXLHSInRHSPart(false), Op(BO_PtrMemD), IsPostfixUpdate(false) {} 6078 /// \brief Check specified statement that it is suitable for 'atomic update' 6079 /// constructs and extract 'x', 'expr' and Operation from the original 6080 /// expression. If DiagId and NoteId == 0, then only check is performed 6081 /// without error notification. 6082 /// \param DiagId Diagnostic which should be emitted if error is found. 6083 /// \param NoteId Diagnostic note for the main error message. 6084 /// \return true if statement is not an update expression, false otherwise. 6085 bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0); 6086 /// \brief Return the 'x' lvalue part of the source atomic expression. 6087 Expr *getX() const { return X; } 6088 /// \brief Return the 'expr' rvalue part of the source atomic expression. 6089 Expr *getExpr() const { return E; } 6090 /// \brief Return the update expression used in calculation of the updated 6091 /// value. Always has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or 6092 /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'. 6093 Expr *getUpdateExpr() const { return UpdateExpr; } 6094 /// \brief Return true if 'x' is LHS in RHS part of full update expression, 6095 /// false otherwise. 6096 bool isXLHSInRHSPart() const { return IsXLHSInRHSPart; } 6097 6098 /// \brief true if the source expression is a postfix unary operation, false 6099 /// if it is a prefix unary operation. 6100 bool isPostfixUpdate() const { return IsPostfixUpdate; } 6101 6102 private: 6103 bool checkBinaryOperation(BinaryOperator *AtomicBinOp, unsigned DiagId = 0, 6104 unsigned NoteId = 0); 6105 }; 6106 } // namespace 6107 6108 bool OpenMPAtomicUpdateChecker::checkBinaryOperation( 6109 BinaryOperator *AtomicBinOp, unsigned DiagId, unsigned NoteId) { 6110 ExprAnalysisErrorCode ErrorFound = NoError; 6111 SourceLocation ErrorLoc, NoteLoc; 6112 SourceRange ErrorRange, NoteRange; 6113 // Allowed constructs are: 6114 // x = x binop expr; 6115 // x = expr binop x; 6116 if (AtomicBinOp->getOpcode() == BO_Assign) { 6117 X = AtomicBinOp->getLHS(); 6118 if (auto *AtomicInnerBinOp = dyn_cast<BinaryOperator>( 6119 AtomicBinOp->getRHS()->IgnoreParenImpCasts())) { 6120 if (AtomicInnerBinOp->isMultiplicativeOp() || 6121 AtomicInnerBinOp->isAdditiveOp() || AtomicInnerBinOp->isShiftOp() || 6122 AtomicInnerBinOp->isBitwiseOp()) { 6123 Op = AtomicInnerBinOp->getOpcode(); 6124 OpLoc = AtomicInnerBinOp->getOperatorLoc(); 6125 auto *LHS = AtomicInnerBinOp->getLHS(); 6126 auto *RHS = AtomicInnerBinOp->getRHS(); 6127 llvm::FoldingSetNodeID XId, LHSId, RHSId; 6128 X->IgnoreParenImpCasts()->Profile(XId, SemaRef.getASTContext(), 6129 /*Canonical=*/true); 6130 LHS->IgnoreParenImpCasts()->Profile(LHSId, SemaRef.getASTContext(), 6131 /*Canonical=*/true); 6132 RHS->IgnoreParenImpCasts()->Profile(RHSId, SemaRef.getASTContext(), 6133 /*Canonical=*/true); 6134 if (XId == LHSId) { 6135 E = RHS; 6136 IsXLHSInRHSPart = true; 6137 } else if (XId == RHSId) { 6138 E = LHS; 6139 IsXLHSInRHSPart = false; 6140 } else { 6141 ErrorLoc = AtomicInnerBinOp->getExprLoc(); 6142 ErrorRange = AtomicInnerBinOp->getSourceRange(); 6143 NoteLoc = X->getExprLoc(); 6144 NoteRange = X->getSourceRange(); 6145 ErrorFound = NotAnUpdateExpression; 6146 } 6147 } else { 6148 ErrorLoc = AtomicInnerBinOp->getExprLoc(); 6149 ErrorRange = AtomicInnerBinOp->getSourceRange(); 6150 NoteLoc = AtomicInnerBinOp->getOperatorLoc(); 6151 NoteRange = SourceRange(NoteLoc, NoteLoc); 6152 ErrorFound = NotABinaryOperator; 6153 } 6154 } else { 6155 NoteLoc = ErrorLoc = AtomicBinOp->getRHS()->getExprLoc(); 6156 NoteRange = ErrorRange = AtomicBinOp->getRHS()->getSourceRange(); 6157 ErrorFound = NotABinaryExpression; 6158 } 6159 } else { 6160 ErrorLoc = AtomicBinOp->getExprLoc(); 6161 ErrorRange = AtomicBinOp->getSourceRange(); 6162 NoteLoc = AtomicBinOp->getOperatorLoc(); 6163 NoteRange = SourceRange(NoteLoc, NoteLoc); 6164 ErrorFound = NotAnAssignmentOp; 6165 } 6166 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) { 6167 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange; 6168 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange; 6169 return true; 6170 } else if (SemaRef.CurContext->isDependentContext()) 6171 E = X = UpdateExpr = nullptr; 6172 return ErrorFound != NoError; 6173 } 6174 6175 bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId, 6176 unsigned NoteId) { 6177 ExprAnalysisErrorCode ErrorFound = NoError; 6178 SourceLocation ErrorLoc, NoteLoc; 6179 SourceRange ErrorRange, NoteRange; 6180 // Allowed constructs are: 6181 // x++; 6182 // x--; 6183 // ++x; 6184 // --x; 6185 // x binop= expr; 6186 // x = x binop expr; 6187 // x = expr binop x; 6188 if (auto *AtomicBody = dyn_cast<Expr>(S)) { 6189 AtomicBody = AtomicBody->IgnoreParenImpCasts(); 6190 if (AtomicBody->getType()->isScalarType() || 6191 AtomicBody->isInstantiationDependent()) { 6192 if (auto *AtomicCompAssignOp = dyn_cast<CompoundAssignOperator>( 6193 AtomicBody->IgnoreParenImpCasts())) { 6194 // Check for Compound Assignment Operation 6195 Op = BinaryOperator::getOpForCompoundAssignment( 6196 AtomicCompAssignOp->getOpcode()); 6197 OpLoc = AtomicCompAssignOp->getOperatorLoc(); 6198 E = AtomicCompAssignOp->getRHS(); 6199 X = AtomicCompAssignOp->getLHS(); 6200 IsXLHSInRHSPart = true; 6201 } else if (auto *AtomicBinOp = dyn_cast<BinaryOperator>( 6202 AtomicBody->IgnoreParenImpCasts())) { 6203 // Check for Binary Operation 6204 if(checkBinaryOperation(AtomicBinOp, DiagId, NoteId)) 6205 return true; 6206 } else if (auto *AtomicUnaryOp = 6207 dyn_cast<UnaryOperator>(AtomicBody->IgnoreParenImpCasts())) { 6208 // Check for Unary Operation 6209 if (AtomicUnaryOp->isIncrementDecrementOp()) { 6210 IsPostfixUpdate = AtomicUnaryOp->isPostfix(); 6211 Op = AtomicUnaryOp->isIncrementOp() ? BO_Add : BO_Sub; 6212 OpLoc = AtomicUnaryOp->getOperatorLoc(); 6213 X = AtomicUnaryOp->getSubExpr(); 6214 E = SemaRef.ActOnIntegerConstant(OpLoc, /*uint64_t Val=*/1).get(); 6215 IsXLHSInRHSPart = true; 6216 } else { 6217 ErrorFound = NotAnUnaryIncDecExpression; 6218 ErrorLoc = AtomicUnaryOp->getExprLoc(); 6219 ErrorRange = AtomicUnaryOp->getSourceRange(); 6220 NoteLoc = AtomicUnaryOp->getOperatorLoc(); 6221 NoteRange = SourceRange(NoteLoc, NoteLoc); 6222 } 6223 } else if (!AtomicBody->isInstantiationDependent()) { 6224 ErrorFound = NotABinaryOrUnaryExpression; 6225 NoteLoc = ErrorLoc = AtomicBody->getExprLoc(); 6226 NoteRange = ErrorRange = AtomicBody->getSourceRange(); 6227 } 6228 } else { 6229 ErrorFound = NotAScalarType; 6230 NoteLoc = ErrorLoc = AtomicBody->getLocStart(); 6231 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc); 6232 } 6233 } else { 6234 ErrorFound = NotAnExpression; 6235 NoteLoc = ErrorLoc = S->getLocStart(); 6236 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc); 6237 } 6238 if (ErrorFound != NoError && DiagId != 0 && NoteId != 0) { 6239 SemaRef.Diag(ErrorLoc, DiagId) << ErrorRange; 6240 SemaRef.Diag(NoteLoc, NoteId) << ErrorFound << NoteRange; 6241 return true; 6242 } else if (SemaRef.CurContext->isDependentContext()) 6243 E = X = UpdateExpr = nullptr; 6244 if (ErrorFound == NoError && E && X) { 6245 // Build an update expression of form 'OpaqueValueExpr(x) binop 6246 // OpaqueValueExpr(expr)' or 'OpaqueValueExpr(expr) binop 6247 // OpaqueValueExpr(x)' and then cast it to the type of the 'x' expression. 6248 auto *OVEX = new (SemaRef.getASTContext()) 6249 OpaqueValueExpr(X->getExprLoc(), X->getType(), VK_RValue); 6250 auto *OVEExpr = new (SemaRef.getASTContext()) 6251 OpaqueValueExpr(E->getExprLoc(), E->getType(), VK_RValue); 6252 auto Update = 6253 SemaRef.CreateBuiltinBinOp(OpLoc, Op, IsXLHSInRHSPart ? OVEX : OVEExpr, 6254 IsXLHSInRHSPart ? OVEExpr : OVEX); 6255 if (Update.isInvalid()) 6256 return true; 6257 Update = SemaRef.PerformImplicitConversion(Update.get(), X->getType(), 6258 Sema::AA_Casting); 6259 if (Update.isInvalid()) 6260 return true; 6261 UpdateExpr = Update.get(); 6262 } 6263 return ErrorFound != NoError; 6264 } 6265 6266 StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses, 6267 Stmt *AStmt, 6268 SourceLocation StartLoc, 6269 SourceLocation EndLoc) { 6270 if (!AStmt) 6271 return StmtError(); 6272 6273 auto CS = cast<CapturedStmt>(AStmt); 6274 // 1.2.2 OpenMP Language Terminology 6275 // Structured block - An executable statement with a single entry at the 6276 // top and a single exit at the bottom. 6277 // The point of exit cannot be a branch out of the structured block. 6278 // longjmp() and throw() must not violate the entry/exit criteria. 6279 OpenMPClauseKind AtomicKind = OMPC_unknown; 6280 SourceLocation AtomicKindLoc; 6281 for (auto *C : Clauses) { 6282 if (C->getClauseKind() == OMPC_read || C->getClauseKind() == OMPC_write || 6283 C->getClauseKind() == OMPC_update || 6284 C->getClauseKind() == OMPC_capture) { 6285 if (AtomicKind != OMPC_unknown) { 6286 Diag(C->getLocStart(), diag::err_omp_atomic_several_clauses) 6287 << SourceRange(C->getLocStart(), C->getLocEnd()); 6288 Diag(AtomicKindLoc, diag::note_omp_atomic_previous_clause) 6289 << getOpenMPClauseName(AtomicKind); 6290 } else { 6291 AtomicKind = C->getClauseKind(); 6292 AtomicKindLoc = C->getLocStart(); 6293 } 6294 } 6295 } 6296 6297 auto Body = CS->getCapturedStmt(); 6298 if (auto *EWC = dyn_cast<ExprWithCleanups>(Body)) 6299 Body = EWC->getSubExpr(); 6300 6301 Expr *X = nullptr; 6302 Expr *V = nullptr; 6303 Expr *E = nullptr; 6304 Expr *UE = nullptr; 6305 bool IsXLHSInRHSPart = false; 6306 bool IsPostfixUpdate = false; 6307 // OpenMP [2.12.6, atomic Construct] 6308 // In the next expressions: 6309 // * x and v (as applicable) are both l-value expressions with scalar type. 6310 // * During the execution of an atomic region, multiple syntactic 6311 // occurrences of x must designate the same storage location. 6312 // * Neither of v and expr (as applicable) may access the storage location 6313 // designated by x. 6314 // * Neither of x and expr (as applicable) may access the storage location 6315 // designated by v. 6316 // * expr is an expression with scalar type. 6317 // * binop is one of +, *, -, /, &, ^, |, <<, or >>. 6318 // * binop, binop=, ++, and -- are not overloaded operators. 6319 // * The expression x binop expr must be numerically equivalent to x binop 6320 // (expr). This requirement is satisfied if the operators in expr have 6321 // precedence greater than binop, or by using parentheses around expr or 6322 // subexpressions of expr. 6323 // * The expression expr binop x must be numerically equivalent to (expr) 6324 // binop x. This requirement is satisfied if the operators in expr have 6325 // precedence equal to or greater than binop, or by using parentheses around 6326 // expr or subexpressions of expr. 6327 // * For forms that allow multiple occurrences of x, the number of times 6328 // that x is evaluated is unspecified. 6329 if (AtomicKind == OMPC_read) { 6330 enum { 6331 NotAnExpression, 6332 NotAnAssignmentOp, 6333 NotAScalarType, 6334 NotAnLValue, 6335 NoError 6336 } ErrorFound = NoError; 6337 SourceLocation ErrorLoc, NoteLoc; 6338 SourceRange ErrorRange, NoteRange; 6339 // If clause is read: 6340 // v = x; 6341 if (auto AtomicBody = dyn_cast<Expr>(Body)) { 6342 auto AtomicBinOp = 6343 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts()); 6344 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) { 6345 X = AtomicBinOp->getRHS()->IgnoreParenImpCasts(); 6346 V = AtomicBinOp->getLHS()->IgnoreParenImpCasts(); 6347 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) && 6348 (V->isInstantiationDependent() || V->getType()->isScalarType())) { 6349 if (!X->isLValue() || !V->isLValue()) { 6350 auto NotLValueExpr = X->isLValue() ? V : X; 6351 ErrorFound = NotAnLValue; 6352 ErrorLoc = AtomicBinOp->getExprLoc(); 6353 ErrorRange = AtomicBinOp->getSourceRange(); 6354 NoteLoc = NotLValueExpr->getExprLoc(); 6355 NoteRange = NotLValueExpr->getSourceRange(); 6356 } 6357 } else if (!X->isInstantiationDependent() || 6358 !V->isInstantiationDependent()) { 6359 auto NotScalarExpr = 6360 (X->isInstantiationDependent() || X->getType()->isScalarType()) 6361 ? V 6362 : X; 6363 ErrorFound = NotAScalarType; 6364 ErrorLoc = AtomicBinOp->getExprLoc(); 6365 ErrorRange = AtomicBinOp->getSourceRange(); 6366 NoteLoc = NotScalarExpr->getExprLoc(); 6367 NoteRange = NotScalarExpr->getSourceRange(); 6368 } 6369 } else if (!AtomicBody->isInstantiationDependent()) { 6370 ErrorFound = NotAnAssignmentOp; 6371 ErrorLoc = AtomicBody->getExprLoc(); 6372 ErrorRange = AtomicBody->getSourceRange(); 6373 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc() 6374 : AtomicBody->getExprLoc(); 6375 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange() 6376 : AtomicBody->getSourceRange(); 6377 } 6378 } else { 6379 ErrorFound = NotAnExpression; 6380 NoteLoc = ErrorLoc = Body->getLocStart(); 6381 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc); 6382 } 6383 if (ErrorFound != NoError) { 6384 Diag(ErrorLoc, diag::err_omp_atomic_read_not_expression_statement) 6385 << ErrorRange; 6386 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound 6387 << NoteRange; 6388 return StmtError(); 6389 } else if (CurContext->isDependentContext()) 6390 V = X = nullptr; 6391 } else if (AtomicKind == OMPC_write) { 6392 enum { 6393 NotAnExpression, 6394 NotAnAssignmentOp, 6395 NotAScalarType, 6396 NotAnLValue, 6397 NoError 6398 } ErrorFound = NoError; 6399 SourceLocation ErrorLoc, NoteLoc; 6400 SourceRange ErrorRange, NoteRange; 6401 // If clause is write: 6402 // x = expr; 6403 if (auto AtomicBody = dyn_cast<Expr>(Body)) { 6404 auto AtomicBinOp = 6405 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts()); 6406 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) { 6407 X = AtomicBinOp->getLHS(); 6408 E = AtomicBinOp->getRHS(); 6409 if ((X->isInstantiationDependent() || X->getType()->isScalarType()) && 6410 (E->isInstantiationDependent() || E->getType()->isScalarType())) { 6411 if (!X->isLValue()) { 6412 ErrorFound = NotAnLValue; 6413 ErrorLoc = AtomicBinOp->getExprLoc(); 6414 ErrorRange = AtomicBinOp->getSourceRange(); 6415 NoteLoc = X->getExprLoc(); 6416 NoteRange = X->getSourceRange(); 6417 } 6418 } else if (!X->isInstantiationDependent() || 6419 !E->isInstantiationDependent()) { 6420 auto NotScalarExpr = 6421 (X->isInstantiationDependent() || X->getType()->isScalarType()) 6422 ? E 6423 : X; 6424 ErrorFound = NotAScalarType; 6425 ErrorLoc = AtomicBinOp->getExprLoc(); 6426 ErrorRange = AtomicBinOp->getSourceRange(); 6427 NoteLoc = NotScalarExpr->getExprLoc(); 6428 NoteRange = NotScalarExpr->getSourceRange(); 6429 } 6430 } else if (!AtomicBody->isInstantiationDependent()) { 6431 ErrorFound = NotAnAssignmentOp; 6432 ErrorLoc = AtomicBody->getExprLoc(); 6433 ErrorRange = AtomicBody->getSourceRange(); 6434 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc() 6435 : AtomicBody->getExprLoc(); 6436 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange() 6437 : AtomicBody->getSourceRange(); 6438 } 6439 } else { 6440 ErrorFound = NotAnExpression; 6441 NoteLoc = ErrorLoc = Body->getLocStart(); 6442 NoteRange = ErrorRange = SourceRange(NoteLoc, NoteLoc); 6443 } 6444 if (ErrorFound != NoError) { 6445 Diag(ErrorLoc, diag::err_omp_atomic_write_not_expression_statement) 6446 << ErrorRange; 6447 Diag(NoteLoc, diag::note_omp_atomic_read_write) << ErrorFound 6448 << NoteRange; 6449 return StmtError(); 6450 } else if (CurContext->isDependentContext()) 6451 E = X = nullptr; 6452 } else if (AtomicKind == OMPC_update || AtomicKind == OMPC_unknown) { 6453 // If clause is update: 6454 // x++; 6455 // x--; 6456 // ++x; 6457 // --x; 6458 // x binop= expr; 6459 // x = x binop expr; 6460 // x = expr binop x; 6461 OpenMPAtomicUpdateChecker Checker(*this); 6462 if (Checker.checkStatement( 6463 Body, (AtomicKind == OMPC_update) 6464 ? diag::err_omp_atomic_update_not_expression_statement 6465 : diag::err_omp_atomic_not_expression_statement, 6466 diag::note_omp_atomic_update)) 6467 return StmtError(); 6468 if (!CurContext->isDependentContext()) { 6469 E = Checker.getExpr(); 6470 X = Checker.getX(); 6471 UE = Checker.getUpdateExpr(); 6472 IsXLHSInRHSPart = Checker.isXLHSInRHSPart(); 6473 } 6474 } else if (AtomicKind == OMPC_capture) { 6475 enum { 6476 NotAnAssignmentOp, 6477 NotACompoundStatement, 6478 NotTwoSubstatements, 6479 NotASpecificExpression, 6480 NoError 6481 } ErrorFound = NoError; 6482 SourceLocation ErrorLoc, NoteLoc; 6483 SourceRange ErrorRange, NoteRange; 6484 if (auto *AtomicBody = dyn_cast<Expr>(Body)) { 6485 // If clause is a capture: 6486 // v = x++; 6487 // v = x--; 6488 // v = ++x; 6489 // v = --x; 6490 // v = x binop= expr; 6491 // v = x = x binop expr; 6492 // v = x = expr binop x; 6493 auto *AtomicBinOp = 6494 dyn_cast<BinaryOperator>(AtomicBody->IgnoreParenImpCasts()); 6495 if (AtomicBinOp && AtomicBinOp->getOpcode() == BO_Assign) { 6496 V = AtomicBinOp->getLHS(); 6497 Body = AtomicBinOp->getRHS()->IgnoreParenImpCasts(); 6498 OpenMPAtomicUpdateChecker Checker(*this); 6499 if (Checker.checkStatement( 6500 Body, diag::err_omp_atomic_capture_not_expression_statement, 6501 diag::note_omp_atomic_update)) 6502 return StmtError(); 6503 E = Checker.getExpr(); 6504 X = Checker.getX(); 6505 UE = Checker.getUpdateExpr(); 6506 IsXLHSInRHSPart = Checker.isXLHSInRHSPart(); 6507 IsPostfixUpdate = Checker.isPostfixUpdate(); 6508 } else if (!AtomicBody->isInstantiationDependent()) { 6509 ErrorLoc = AtomicBody->getExprLoc(); 6510 ErrorRange = AtomicBody->getSourceRange(); 6511 NoteLoc = AtomicBinOp ? AtomicBinOp->getOperatorLoc() 6512 : AtomicBody->getExprLoc(); 6513 NoteRange = AtomicBinOp ? AtomicBinOp->getSourceRange() 6514 : AtomicBody->getSourceRange(); 6515 ErrorFound = NotAnAssignmentOp; 6516 } 6517 if (ErrorFound != NoError) { 6518 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_expression_statement) 6519 << ErrorRange; 6520 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange; 6521 return StmtError(); 6522 } else if (CurContext->isDependentContext()) { 6523 UE = V = E = X = nullptr; 6524 } 6525 } else { 6526 // If clause is a capture: 6527 // { v = x; x = expr; } 6528 // { v = x; x++; } 6529 // { v = x; x--; } 6530 // { v = x; ++x; } 6531 // { v = x; --x; } 6532 // { v = x; x binop= expr; } 6533 // { v = x; x = x binop expr; } 6534 // { v = x; x = expr binop x; } 6535 // { x++; v = x; } 6536 // { x--; v = x; } 6537 // { ++x; v = x; } 6538 // { --x; v = x; } 6539 // { x binop= expr; v = x; } 6540 // { x = x binop expr; v = x; } 6541 // { x = expr binop x; v = x; } 6542 if (auto *CS = dyn_cast<CompoundStmt>(Body)) { 6543 // Check that this is { expr1; expr2; } 6544 if (CS->size() == 2) { 6545 auto *First = CS->body_front(); 6546 auto *Second = CS->body_back(); 6547 if (auto *EWC = dyn_cast<ExprWithCleanups>(First)) 6548 First = EWC->getSubExpr()->IgnoreParenImpCasts(); 6549 if (auto *EWC = dyn_cast<ExprWithCleanups>(Second)) 6550 Second = EWC->getSubExpr()->IgnoreParenImpCasts(); 6551 // Need to find what subexpression is 'v' and what is 'x'. 6552 OpenMPAtomicUpdateChecker Checker(*this); 6553 bool IsUpdateExprFound = !Checker.checkStatement(Second); 6554 BinaryOperator *BinOp = nullptr; 6555 if (IsUpdateExprFound) { 6556 BinOp = dyn_cast<BinaryOperator>(First); 6557 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign; 6558 } 6559 if (IsUpdateExprFound && !CurContext->isDependentContext()) { 6560 // { v = x; x++; } 6561 // { v = x; x--; } 6562 // { v = x; ++x; } 6563 // { v = x; --x; } 6564 // { v = x; x binop= expr; } 6565 // { v = x; x = x binop expr; } 6566 // { v = x; x = expr binop x; } 6567 // Check that the first expression has form v = x. 6568 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts(); 6569 llvm::FoldingSetNodeID XId, PossibleXId; 6570 Checker.getX()->Profile(XId, Context, /*Canonical=*/true); 6571 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true); 6572 IsUpdateExprFound = XId == PossibleXId; 6573 if (IsUpdateExprFound) { 6574 V = BinOp->getLHS(); 6575 X = Checker.getX(); 6576 E = Checker.getExpr(); 6577 UE = Checker.getUpdateExpr(); 6578 IsXLHSInRHSPart = Checker.isXLHSInRHSPart(); 6579 IsPostfixUpdate = true; 6580 } 6581 } 6582 if (!IsUpdateExprFound) { 6583 IsUpdateExprFound = !Checker.checkStatement(First); 6584 BinOp = nullptr; 6585 if (IsUpdateExprFound) { 6586 BinOp = dyn_cast<BinaryOperator>(Second); 6587 IsUpdateExprFound = BinOp && BinOp->getOpcode() == BO_Assign; 6588 } 6589 if (IsUpdateExprFound && !CurContext->isDependentContext()) { 6590 // { x++; v = x; } 6591 // { x--; v = x; } 6592 // { ++x; v = x; } 6593 // { --x; v = x; } 6594 // { x binop= expr; v = x; } 6595 // { x = x binop expr; v = x; } 6596 // { x = expr binop x; v = x; } 6597 // Check that the second expression has form v = x. 6598 auto *PossibleX = BinOp->getRHS()->IgnoreParenImpCasts(); 6599 llvm::FoldingSetNodeID XId, PossibleXId; 6600 Checker.getX()->Profile(XId, Context, /*Canonical=*/true); 6601 PossibleX->Profile(PossibleXId, Context, /*Canonical=*/true); 6602 IsUpdateExprFound = XId == PossibleXId; 6603 if (IsUpdateExprFound) { 6604 V = BinOp->getLHS(); 6605 X = Checker.getX(); 6606 E = Checker.getExpr(); 6607 UE = Checker.getUpdateExpr(); 6608 IsXLHSInRHSPart = Checker.isXLHSInRHSPart(); 6609 IsPostfixUpdate = false; 6610 } 6611 } 6612 } 6613 if (!IsUpdateExprFound) { 6614 // { v = x; x = expr; } 6615 auto *FirstExpr = dyn_cast<Expr>(First); 6616 auto *SecondExpr = dyn_cast<Expr>(Second); 6617 if (!FirstExpr || !SecondExpr || 6618 !(FirstExpr->isInstantiationDependent() || 6619 SecondExpr->isInstantiationDependent())) { 6620 auto *FirstBinOp = dyn_cast<BinaryOperator>(First); 6621 if (!FirstBinOp || FirstBinOp->getOpcode() != BO_Assign) { 6622 ErrorFound = NotAnAssignmentOp; 6623 NoteLoc = ErrorLoc = FirstBinOp ? FirstBinOp->getOperatorLoc() 6624 : First->getLocStart(); 6625 NoteRange = ErrorRange = FirstBinOp 6626 ? FirstBinOp->getSourceRange() 6627 : SourceRange(ErrorLoc, ErrorLoc); 6628 } else { 6629 auto *SecondBinOp = dyn_cast<BinaryOperator>(Second); 6630 if (!SecondBinOp || SecondBinOp->getOpcode() != BO_Assign) { 6631 ErrorFound = NotAnAssignmentOp; 6632 NoteLoc = ErrorLoc = SecondBinOp 6633 ? SecondBinOp->getOperatorLoc() 6634 : Second->getLocStart(); 6635 NoteRange = ErrorRange = 6636 SecondBinOp ? SecondBinOp->getSourceRange() 6637 : SourceRange(ErrorLoc, ErrorLoc); 6638 } else { 6639 auto *PossibleXRHSInFirst = 6640 FirstBinOp->getRHS()->IgnoreParenImpCasts(); 6641 auto *PossibleXLHSInSecond = 6642 SecondBinOp->getLHS()->IgnoreParenImpCasts(); 6643 llvm::FoldingSetNodeID X1Id, X2Id; 6644 PossibleXRHSInFirst->Profile(X1Id, Context, 6645 /*Canonical=*/true); 6646 PossibleXLHSInSecond->Profile(X2Id, Context, 6647 /*Canonical=*/true); 6648 IsUpdateExprFound = X1Id == X2Id; 6649 if (IsUpdateExprFound) { 6650 V = FirstBinOp->getLHS(); 6651 X = SecondBinOp->getLHS(); 6652 E = SecondBinOp->getRHS(); 6653 UE = nullptr; 6654 IsXLHSInRHSPart = false; 6655 IsPostfixUpdate = true; 6656 } else { 6657 ErrorFound = NotASpecificExpression; 6658 ErrorLoc = FirstBinOp->getExprLoc(); 6659 ErrorRange = FirstBinOp->getSourceRange(); 6660 NoteLoc = SecondBinOp->getLHS()->getExprLoc(); 6661 NoteRange = SecondBinOp->getRHS()->getSourceRange(); 6662 } 6663 } 6664 } 6665 } 6666 } 6667 } else { 6668 NoteLoc = ErrorLoc = Body->getLocStart(); 6669 NoteRange = ErrorRange = 6670 SourceRange(Body->getLocStart(), Body->getLocStart()); 6671 ErrorFound = NotTwoSubstatements; 6672 } 6673 } else { 6674 NoteLoc = ErrorLoc = Body->getLocStart(); 6675 NoteRange = ErrorRange = 6676 SourceRange(Body->getLocStart(), Body->getLocStart()); 6677 ErrorFound = NotACompoundStatement; 6678 } 6679 if (ErrorFound != NoError) { 6680 Diag(ErrorLoc, diag::err_omp_atomic_capture_not_compound_statement) 6681 << ErrorRange; 6682 Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange; 6683 return StmtError(); 6684 } else if (CurContext->isDependentContext()) { 6685 UE = V = E = X = nullptr; 6686 } 6687 } 6688 } 6689 6690 getCurFunction()->setHasBranchProtectedScope(); 6691 6692 return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt, 6693 X, V, E, UE, IsXLHSInRHSPart, 6694 IsPostfixUpdate); 6695 } 6696 6697 StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses, 6698 Stmt *AStmt, 6699 SourceLocation StartLoc, 6700 SourceLocation EndLoc) { 6701 if (!AStmt) 6702 return StmtError(); 6703 6704 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 6705 // 1.2.2 OpenMP Language Terminology 6706 // Structured block - An executable statement with a single entry at the 6707 // top and a single exit at the bottom. 6708 // The point of exit cannot be a branch out of the structured block. 6709 // longjmp() and throw() must not violate the entry/exit criteria. 6710 CS->getCapturedDecl()->setNothrow(); 6711 6712 // OpenMP [2.16, Nesting of Regions] 6713 // If specified, a teams construct must be contained within a target 6714 // construct. That target construct must contain no statements or directives 6715 // outside of the teams construct. 6716 if (DSAStack->hasInnerTeamsRegion()) { 6717 auto S = AStmt->IgnoreContainers(/*IgnoreCaptured*/ true); 6718 bool OMPTeamsFound = true; 6719 if (auto *CS = dyn_cast<CompoundStmt>(S)) { 6720 auto I = CS->body_begin(); 6721 while (I != CS->body_end()) { 6722 auto OED = dyn_cast<OMPExecutableDirective>(*I); 6723 if (!OED || !isOpenMPTeamsDirective(OED->getDirectiveKind())) { 6724 OMPTeamsFound = false; 6725 break; 6726 } 6727 ++I; 6728 } 6729 assert(I != CS->body_end() && "Not found statement"); 6730 S = *I; 6731 } else { 6732 auto *OED = dyn_cast<OMPExecutableDirective>(S); 6733 OMPTeamsFound = OED && isOpenMPTeamsDirective(OED->getDirectiveKind()); 6734 } 6735 if (!OMPTeamsFound) { 6736 Diag(StartLoc, diag::err_omp_target_contains_not_only_teams); 6737 Diag(DSAStack->getInnerTeamsRegionLoc(), 6738 diag::note_omp_nested_teams_construct_here); 6739 Diag(S->getLocStart(), diag::note_omp_nested_statement_here) 6740 << isa<OMPExecutableDirective>(S); 6741 return StmtError(); 6742 } 6743 } 6744 6745 getCurFunction()->setHasBranchProtectedScope(); 6746 6747 return OMPTargetDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt); 6748 } 6749 6750 StmtResult 6751 Sema::ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses, 6752 Stmt *AStmt, SourceLocation StartLoc, 6753 SourceLocation EndLoc) { 6754 if (!AStmt) 6755 return StmtError(); 6756 6757 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 6758 // 1.2.2 OpenMP Language Terminology 6759 // Structured block - An executable statement with a single entry at the 6760 // top and a single exit at the bottom. 6761 // The point of exit cannot be a branch out of the structured block. 6762 // longjmp() and throw() must not violate the entry/exit criteria. 6763 CS->getCapturedDecl()->setNothrow(); 6764 6765 getCurFunction()->setHasBranchProtectedScope(); 6766 6767 return OMPTargetParallelDirective::Create(Context, StartLoc, EndLoc, Clauses, 6768 AStmt); 6769 } 6770 6771 StmtResult Sema::ActOnOpenMPTargetParallelForDirective( 6772 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 6773 SourceLocation EndLoc, 6774 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 6775 if (!AStmt) 6776 return StmtError(); 6777 6778 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 6779 // 1.2.2 OpenMP Language Terminology 6780 // Structured block - An executable statement with a single entry at the 6781 // top and a single exit at the bottom. 6782 // The point of exit cannot be a branch out of the structured block. 6783 // longjmp() and throw() must not violate the entry/exit criteria. 6784 CS->getCapturedDecl()->setNothrow(); 6785 6786 OMPLoopDirective::HelperExprs B; 6787 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 6788 // define the nested loops number. 6789 unsigned NestedLoopCount = 6790 CheckOpenMPLoop(OMPD_target_parallel_for, getCollapseNumberExpr(Clauses), 6791 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack, 6792 VarsWithImplicitDSA, B); 6793 if (NestedLoopCount == 0) 6794 return StmtError(); 6795 6796 assert((CurContext->isDependentContext() || B.builtAll()) && 6797 "omp target parallel for loop exprs were not built"); 6798 6799 if (!CurContext->isDependentContext()) { 6800 // Finalize the clauses that need pre-built expressions for CodeGen. 6801 for (auto C : Clauses) { 6802 if (auto LC = dyn_cast<OMPLinearClause>(C)) 6803 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 6804 B.NumIterations, *this, CurScope, 6805 DSAStack)) 6806 return StmtError(); 6807 } 6808 } 6809 6810 getCurFunction()->setHasBranchProtectedScope(); 6811 return OMPTargetParallelForDirective::Create(Context, StartLoc, EndLoc, 6812 NestedLoopCount, Clauses, AStmt, 6813 B, DSAStack->isCancelRegion()); 6814 } 6815 6816 /// \brief Check for existence of a map clause in the list of clauses. 6817 static bool HasMapClause(ArrayRef<OMPClause *> Clauses) { 6818 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end(); 6819 I != E; ++I) { 6820 if (*I != nullptr && (*I)->getClauseKind() == OMPC_map) { 6821 return true; 6822 } 6823 } 6824 6825 return false; 6826 } 6827 6828 StmtResult Sema::ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses, 6829 Stmt *AStmt, 6830 SourceLocation StartLoc, 6831 SourceLocation EndLoc) { 6832 if (!AStmt) 6833 return StmtError(); 6834 6835 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 6836 6837 // OpenMP [2.10.1, Restrictions, p. 97] 6838 // At least one map clause must appear on the directive. 6839 if (!HasMapClause(Clauses)) { 6840 Diag(StartLoc, diag::err_omp_no_map_for_directive) << 6841 getOpenMPDirectiveName(OMPD_target_data); 6842 return StmtError(); 6843 } 6844 6845 getCurFunction()->setHasBranchProtectedScope(); 6846 6847 return OMPTargetDataDirective::Create(Context, StartLoc, EndLoc, Clauses, 6848 AStmt); 6849 } 6850 6851 StmtResult 6852 Sema::ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses, 6853 SourceLocation StartLoc, 6854 SourceLocation EndLoc) { 6855 // OpenMP [2.10.2, Restrictions, p. 99] 6856 // At least one map clause must appear on the directive. 6857 if (!HasMapClause(Clauses)) { 6858 Diag(StartLoc, diag::err_omp_no_map_for_directive) 6859 << getOpenMPDirectiveName(OMPD_target_enter_data); 6860 return StmtError(); 6861 } 6862 6863 return OMPTargetEnterDataDirective::Create(Context, StartLoc, EndLoc, 6864 Clauses); 6865 } 6866 6867 StmtResult 6868 Sema::ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses, 6869 SourceLocation StartLoc, 6870 SourceLocation EndLoc) { 6871 // OpenMP [2.10.3, Restrictions, p. 102] 6872 // At least one map clause must appear on the directive. 6873 if (!HasMapClause(Clauses)) { 6874 Diag(StartLoc, diag::err_omp_no_map_for_directive) 6875 << getOpenMPDirectiveName(OMPD_target_exit_data); 6876 return StmtError(); 6877 } 6878 6879 return OMPTargetExitDataDirective::Create(Context, StartLoc, EndLoc, Clauses); 6880 } 6881 6882 StmtResult Sema::ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses, 6883 SourceLocation StartLoc, 6884 SourceLocation EndLoc) { 6885 bool seenMotionClause = false; 6886 for (auto *C : Clauses) { 6887 if (C->getClauseKind() == OMPC_to || C->getClauseKind() == OMPC_from) 6888 seenMotionClause = true; 6889 } 6890 if (!seenMotionClause) { 6891 Diag(StartLoc, diag::err_omp_at_least_one_motion_clause_required); 6892 return StmtError(); 6893 } 6894 return OMPTargetUpdateDirective::Create(Context, StartLoc, EndLoc, Clauses); 6895 } 6896 6897 StmtResult Sema::ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses, 6898 Stmt *AStmt, SourceLocation StartLoc, 6899 SourceLocation EndLoc) { 6900 if (!AStmt) 6901 return StmtError(); 6902 6903 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 6904 // 1.2.2 OpenMP Language Terminology 6905 // Structured block - An executable statement with a single entry at the 6906 // top and a single exit at the bottom. 6907 // The point of exit cannot be a branch out of the structured block. 6908 // longjmp() and throw() must not violate the entry/exit criteria. 6909 CS->getCapturedDecl()->setNothrow(); 6910 6911 getCurFunction()->setHasBranchProtectedScope(); 6912 6913 return OMPTeamsDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt); 6914 } 6915 6916 StmtResult 6917 Sema::ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc, 6918 SourceLocation EndLoc, 6919 OpenMPDirectiveKind CancelRegion) { 6920 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for && 6921 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) { 6922 Diag(StartLoc, diag::err_omp_wrong_cancel_region) 6923 << getOpenMPDirectiveName(CancelRegion); 6924 return StmtError(); 6925 } 6926 if (DSAStack->isParentNowaitRegion()) { 6927 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 0; 6928 return StmtError(); 6929 } 6930 if (DSAStack->isParentOrderedRegion()) { 6931 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 0; 6932 return StmtError(); 6933 } 6934 return OMPCancellationPointDirective::Create(Context, StartLoc, EndLoc, 6935 CancelRegion); 6936 } 6937 6938 StmtResult Sema::ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses, 6939 SourceLocation StartLoc, 6940 SourceLocation EndLoc, 6941 OpenMPDirectiveKind CancelRegion) { 6942 if (CancelRegion != OMPD_parallel && CancelRegion != OMPD_for && 6943 CancelRegion != OMPD_sections && CancelRegion != OMPD_taskgroup) { 6944 Diag(StartLoc, diag::err_omp_wrong_cancel_region) 6945 << getOpenMPDirectiveName(CancelRegion); 6946 return StmtError(); 6947 } 6948 if (DSAStack->isParentNowaitRegion()) { 6949 Diag(StartLoc, diag::err_omp_parent_cancel_region_nowait) << 1; 6950 return StmtError(); 6951 } 6952 if (DSAStack->isParentOrderedRegion()) { 6953 Diag(StartLoc, diag::err_omp_parent_cancel_region_ordered) << 1; 6954 return StmtError(); 6955 } 6956 DSAStack->setParentCancelRegion(/*Cancel=*/true); 6957 return OMPCancelDirective::Create(Context, StartLoc, EndLoc, Clauses, 6958 CancelRegion); 6959 } 6960 6961 static bool checkGrainsizeNumTasksClauses(Sema &S, 6962 ArrayRef<OMPClause *> Clauses) { 6963 OMPClause *PrevClause = nullptr; 6964 bool ErrorFound = false; 6965 for (auto *C : Clauses) { 6966 if (C->getClauseKind() == OMPC_grainsize || 6967 C->getClauseKind() == OMPC_num_tasks) { 6968 if (!PrevClause) 6969 PrevClause = C; 6970 else if (PrevClause->getClauseKind() != C->getClauseKind()) { 6971 S.Diag(C->getLocStart(), 6972 diag::err_omp_grainsize_num_tasks_mutually_exclusive) 6973 << getOpenMPClauseName(C->getClauseKind()) 6974 << getOpenMPClauseName(PrevClause->getClauseKind()); 6975 S.Diag(PrevClause->getLocStart(), 6976 diag::note_omp_previous_grainsize_num_tasks) 6977 << getOpenMPClauseName(PrevClause->getClauseKind()); 6978 ErrorFound = true; 6979 } 6980 } 6981 } 6982 return ErrorFound; 6983 } 6984 6985 StmtResult Sema::ActOnOpenMPTaskLoopDirective( 6986 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 6987 SourceLocation EndLoc, 6988 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 6989 if (!AStmt) 6990 return StmtError(); 6991 6992 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 6993 OMPLoopDirective::HelperExprs B; 6994 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 6995 // define the nested loops number. 6996 unsigned NestedLoopCount = 6997 CheckOpenMPLoop(OMPD_taskloop, getCollapseNumberExpr(Clauses), 6998 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack, 6999 VarsWithImplicitDSA, B); 7000 if (NestedLoopCount == 0) 7001 return StmtError(); 7002 7003 assert((CurContext->isDependentContext() || B.builtAll()) && 7004 "omp for loop exprs were not built"); 7005 7006 // OpenMP, [2.9.2 taskloop Construct, Restrictions] 7007 // The grainsize clause and num_tasks clause are mutually exclusive and may 7008 // not appear on the same taskloop directive. 7009 if (checkGrainsizeNumTasksClauses(*this, Clauses)) 7010 return StmtError(); 7011 7012 getCurFunction()->setHasBranchProtectedScope(); 7013 return OMPTaskLoopDirective::Create(Context, StartLoc, EndLoc, 7014 NestedLoopCount, Clauses, AStmt, B); 7015 } 7016 7017 StmtResult Sema::ActOnOpenMPTaskLoopSimdDirective( 7018 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 7019 SourceLocation EndLoc, 7020 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 7021 if (!AStmt) 7022 return StmtError(); 7023 7024 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 7025 OMPLoopDirective::HelperExprs B; 7026 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 7027 // define the nested loops number. 7028 unsigned NestedLoopCount = 7029 CheckOpenMPLoop(OMPD_taskloop_simd, getCollapseNumberExpr(Clauses), 7030 /*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack, 7031 VarsWithImplicitDSA, B); 7032 if (NestedLoopCount == 0) 7033 return StmtError(); 7034 7035 assert((CurContext->isDependentContext() || B.builtAll()) && 7036 "omp for loop exprs were not built"); 7037 7038 if (!CurContext->isDependentContext()) { 7039 // Finalize the clauses that need pre-built expressions for CodeGen. 7040 for (auto C : Clauses) { 7041 if (auto LC = dyn_cast<OMPLinearClause>(C)) 7042 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 7043 B.NumIterations, *this, CurScope, 7044 DSAStack)) 7045 return StmtError(); 7046 } 7047 } 7048 7049 // OpenMP, [2.9.2 taskloop Construct, Restrictions] 7050 // The grainsize clause and num_tasks clause are mutually exclusive and may 7051 // not appear on the same taskloop directive. 7052 if (checkGrainsizeNumTasksClauses(*this, Clauses)) 7053 return StmtError(); 7054 7055 getCurFunction()->setHasBranchProtectedScope(); 7056 return OMPTaskLoopSimdDirective::Create(Context, StartLoc, EndLoc, 7057 NestedLoopCount, Clauses, AStmt, B); 7058 } 7059 7060 StmtResult Sema::ActOnOpenMPDistributeDirective( 7061 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 7062 SourceLocation EndLoc, 7063 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 7064 if (!AStmt) 7065 return StmtError(); 7066 7067 assert(isa<CapturedStmt>(AStmt) && "Captured statement expected"); 7068 OMPLoopDirective::HelperExprs B; 7069 // In presence of clause 'collapse' with number of loops, it will 7070 // define the nested loops number. 7071 unsigned NestedLoopCount = 7072 CheckOpenMPLoop(OMPD_distribute, getCollapseNumberExpr(Clauses), 7073 nullptr /*ordered not a clause on distribute*/, AStmt, 7074 *this, *DSAStack, VarsWithImplicitDSA, B); 7075 if (NestedLoopCount == 0) 7076 return StmtError(); 7077 7078 assert((CurContext->isDependentContext() || B.builtAll()) && 7079 "omp for loop exprs were not built"); 7080 7081 getCurFunction()->setHasBranchProtectedScope(); 7082 return OMPDistributeDirective::Create(Context, StartLoc, EndLoc, 7083 NestedLoopCount, Clauses, AStmt, B); 7084 } 7085 7086 StmtResult Sema::ActOnOpenMPDistributeParallelForDirective( 7087 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 7088 SourceLocation EndLoc, 7089 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 7090 if (!AStmt) 7091 return StmtError(); 7092 7093 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 7094 // 1.2.2 OpenMP Language Terminology 7095 // Structured block - An executable statement with a single entry at the 7096 // top and a single exit at the bottom. 7097 // The point of exit cannot be a branch out of the structured block. 7098 // longjmp() and throw() must not violate the entry/exit criteria. 7099 CS->getCapturedDecl()->setNothrow(); 7100 7101 OMPLoopDirective::HelperExprs B; 7102 // In presence of clause 'collapse' with number of loops, it will 7103 // define the nested loops number. 7104 unsigned NestedLoopCount = CheckOpenMPLoop( 7105 OMPD_distribute_parallel_for, getCollapseNumberExpr(Clauses), 7106 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack, 7107 VarsWithImplicitDSA, B); 7108 if (NestedLoopCount == 0) 7109 return StmtError(); 7110 7111 assert((CurContext->isDependentContext() || B.builtAll()) && 7112 "omp for loop exprs were not built"); 7113 7114 getCurFunction()->setHasBranchProtectedScope(); 7115 return OMPDistributeParallelForDirective::Create( 7116 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B); 7117 } 7118 7119 StmtResult Sema::ActOnOpenMPDistributeParallelForSimdDirective( 7120 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 7121 SourceLocation EndLoc, 7122 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 7123 if (!AStmt) 7124 return StmtError(); 7125 7126 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 7127 // 1.2.2 OpenMP Language Terminology 7128 // Structured block - An executable statement with a single entry at the 7129 // top and a single exit at the bottom. 7130 // The point of exit cannot be a branch out of the structured block. 7131 // longjmp() and throw() must not violate the entry/exit criteria. 7132 CS->getCapturedDecl()->setNothrow(); 7133 7134 OMPLoopDirective::HelperExprs B; 7135 // In presence of clause 'collapse' with number of loops, it will 7136 // define the nested loops number. 7137 unsigned NestedLoopCount = CheckOpenMPLoop( 7138 OMPD_distribute_parallel_for_simd, getCollapseNumberExpr(Clauses), 7139 nullptr /*ordered not a clause on distribute*/, AStmt, *this, *DSAStack, 7140 VarsWithImplicitDSA, B); 7141 if (NestedLoopCount == 0) 7142 return StmtError(); 7143 7144 assert((CurContext->isDependentContext() || B.builtAll()) && 7145 "omp for loop exprs were not built"); 7146 7147 getCurFunction()->setHasBranchProtectedScope(); 7148 return OMPDistributeParallelForSimdDirective::Create( 7149 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B); 7150 } 7151 7152 StmtResult Sema::ActOnOpenMPDistributeSimdDirective( 7153 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 7154 SourceLocation EndLoc, 7155 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 7156 if (!AStmt) 7157 return StmtError(); 7158 7159 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 7160 // 1.2.2 OpenMP Language Terminology 7161 // Structured block - An executable statement with a single entry at the 7162 // top and a single exit at the bottom. 7163 // The point of exit cannot be a branch out of the structured block. 7164 // longjmp() and throw() must not violate the entry/exit criteria. 7165 CS->getCapturedDecl()->setNothrow(); 7166 7167 OMPLoopDirective::HelperExprs B; 7168 // In presence of clause 'collapse' with number of loops, it will 7169 // define the nested loops number. 7170 unsigned NestedLoopCount = 7171 CheckOpenMPLoop(OMPD_distribute_simd, getCollapseNumberExpr(Clauses), 7172 nullptr /*ordered not a clause on distribute*/, AStmt, 7173 *this, *DSAStack, VarsWithImplicitDSA, B); 7174 if (NestedLoopCount == 0) 7175 return StmtError(); 7176 7177 assert((CurContext->isDependentContext() || B.builtAll()) && 7178 "omp for loop exprs were not built"); 7179 7180 getCurFunction()->setHasBranchProtectedScope(); 7181 return OMPDistributeSimdDirective::Create(Context, StartLoc, EndLoc, 7182 NestedLoopCount, Clauses, AStmt, B); 7183 } 7184 7185 StmtResult Sema::ActOnOpenMPTargetParallelForSimdDirective( 7186 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc, 7187 SourceLocation EndLoc, 7188 llvm::DenseMap<ValueDecl *, Expr *> &VarsWithImplicitDSA) { 7189 if (!AStmt) 7190 return StmtError(); 7191 7192 CapturedStmt *CS = cast<CapturedStmt>(AStmt); 7193 // 1.2.2 OpenMP Language Terminology 7194 // Structured block - An executable statement with a single entry at the 7195 // top and a single exit at the bottom. 7196 // The point of exit cannot be a branch out of the structured block. 7197 // longjmp() and throw() must not violate the entry/exit criteria. 7198 CS->getCapturedDecl()->setNothrow(); 7199 7200 OMPLoopDirective::HelperExprs B; 7201 // In presence of clause 'collapse' or 'ordered' with number of loops, it will 7202 // define the nested loops number. 7203 unsigned NestedLoopCount = CheckOpenMPLoop( 7204 OMPD_target_parallel_for_simd, getCollapseNumberExpr(Clauses), 7205 getOrderedNumberExpr(Clauses), AStmt, *this, *DSAStack, 7206 VarsWithImplicitDSA, B); 7207 if (NestedLoopCount == 0) 7208 return StmtError(); 7209 7210 assert((CurContext->isDependentContext() || B.builtAll()) && 7211 "omp target parallel for simd loop exprs were not built"); 7212 7213 if (!CurContext->isDependentContext()) { 7214 // Finalize the clauses that need pre-built expressions for CodeGen. 7215 for (auto C : Clauses) { 7216 if (auto LC = dyn_cast<OMPLinearClause>(C)) 7217 if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef), 7218 B.NumIterations, *this, CurScope, 7219 DSAStack)) 7220 return StmtError(); 7221 } 7222 } 7223 7224 // OpenMP 4.1 [2.8.1, simd Construct, Restrictions] 7225 // If both simdlen and safelen clauses are specified, the value of the simdlen 7226 // parameter must be less than or equal to the value of the safelen parameter. 7227 OMPSafelenClause *Safelen = nullptr; 7228 OMPSimdlenClause *Simdlen = nullptr; 7229 for (auto *Clause : Clauses) { 7230 if (Clause->getClauseKind() == OMPC_safelen) 7231 Safelen = cast<OMPSafelenClause>(Clause); 7232 else if (Clause->getClauseKind() == OMPC_simdlen) 7233 Simdlen = cast<OMPSimdlenClause>(Clause); 7234 if (Safelen && Simdlen) 7235 break; 7236 } 7237 if (Simdlen && Safelen && 7238 checkSimdlenSafelenValues(*this, Simdlen->getSimdlen(), 7239 Safelen->getSafelen())) 7240 return StmtError(); 7241 7242 getCurFunction()->setHasBranchProtectedScope(); 7243 return OMPTargetParallelForSimdDirective::Create( 7244 Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B); 7245 } 7246 7247 OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr, 7248 SourceLocation StartLoc, 7249 SourceLocation LParenLoc, 7250 SourceLocation EndLoc) { 7251 OMPClause *Res = nullptr; 7252 switch (Kind) { 7253 case OMPC_final: 7254 Res = ActOnOpenMPFinalClause(Expr, StartLoc, LParenLoc, EndLoc); 7255 break; 7256 case OMPC_num_threads: 7257 Res = ActOnOpenMPNumThreadsClause(Expr, StartLoc, LParenLoc, EndLoc); 7258 break; 7259 case OMPC_safelen: 7260 Res = ActOnOpenMPSafelenClause(Expr, StartLoc, LParenLoc, EndLoc); 7261 break; 7262 case OMPC_simdlen: 7263 Res = ActOnOpenMPSimdlenClause(Expr, StartLoc, LParenLoc, EndLoc); 7264 break; 7265 case OMPC_collapse: 7266 Res = ActOnOpenMPCollapseClause(Expr, StartLoc, LParenLoc, EndLoc); 7267 break; 7268 case OMPC_ordered: 7269 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc, LParenLoc, Expr); 7270 break; 7271 case OMPC_device: 7272 Res = ActOnOpenMPDeviceClause(Expr, StartLoc, LParenLoc, EndLoc); 7273 break; 7274 case OMPC_num_teams: 7275 Res = ActOnOpenMPNumTeamsClause(Expr, StartLoc, LParenLoc, EndLoc); 7276 break; 7277 case OMPC_thread_limit: 7278 Res = ActOnOpenMPThreadLimitClause(Expr, StartLoc, LParenLoc, EndLoc); 7279 break; 7280 case OMPC_priority: 7281 Res = ActOnOpenMPPriorityClause(Expr, StartLoc, LParenLoc, EndLoc); 7282 break; 7283 case OMPC_grainsize: 7284 Res = ActOnOpenMPGrainsizeClause(Expr, StartLoc, LParenLoc, EndLoc); 7285 break; 7286 case OMPC_num_tasks: 7287 Res = ActOnOpenMPNumTasksClause(Expr, StartLoc, LParenLoc, EndLoc); 7288 break; 7289 case OMPC_hint: 7290 Res = ActOnOpenMPHintClause(Expr, StartLoc, LParenLoc, EndLoc); 7291 break; 7292 case OMPC_if: 7293 case OMPC_default: 7294 case OMPC_proc_bind: 7295 case OMPC_schedule: 7296 case OMPC_private: 7297 case OMPC_firstprivate: 7298 case OMPC_lastprivate: 7299 case OMPC_shared: 7300 case OMPC_reduction: 7301 case OMPC_linear: 7302 case OMPC_aligned: 7303 case OMPC_copyin: 7304 case OMPC_copyprivate: 7305 case OMPC_nowait: 7306 case OMPC_untied: 7307 case OMPC_mergeable: 7308 case OMPC_threadprivate: 7309 case OMPC_flush: 7310 case OMPC_read: 7311 case OMPC_write: 7312 case OMPC_update: 7313 case OMPC_capture: 7314 case OMPC_seq_cst: 7315 case OMPC_depend: 7316 case OMPC_threads: 7317 case OMPC_simd: 7318 case OMPC_map: 7319 case OMPC_nogroup: 7320 case OMPC_dist_schedule: 7321 case OMPC_defaultmap: 7322 case OMPC_unknown: 7323 case OMPC_uniform: 7324 case OMPC_to: 7325 case OMPC_from: 7326 case OMPC_use_device_ptr: 7327 case OMPC_is_device_ptr: 7328 llvm_unreachable("Clause is not allowed."); 7329 } 7330 return Res; 7331 } 7332 7333 OMPClause *Sema::ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier, 7334 Expr *Condition, SourceLocation StartLoc, 7335 SourceLocation LParenLoc, 7336 SourceLocation NameModifierLoc, 7337 SourceLocation ColonLoc, 7338 SourceLocation EndLoc) { 7339 Expr *ValExpr = Condition; 7340 if (!Condition->isValueDependent() && !Condition->isTypeDependent() && 7341 !Condition->isInstantiationDependent() && 7342 !Condition->containsUnexpandedParameterPack()) { 7343 ExprResult Val = CheckBooleanCondition(StartLoc, Condition); 7344 if (Val.isInvalid()) 7345 return nullptr; 7346 7347 ValExpr = MakeFullExpr(Val.get()).get(); 7348 } 7349 7350 return new (Context) OMPIfClause(NameModifier, ValExpr, StartLoc, LParenLoc, 7351 NameModifierLoc, ColonLoc, EndLoc); 7352 } 7353 7354 OMPClause *Sema::ActOnOpenMPFinalClause(Expr *Condition, 7355 SourceLocation StartLoc, 7356 SourceLocation LParenLoc, 7357 SourceLocation EndLoc) { 7358 Expr *ValExpr = Condition; 7359 if (!Condition->isValueDependent() && !Condition->isTypeDependent() && 7360 !Condition->isInstantiationDependent() && 7361 !Condition->containsUnexpandedParameterPack()) { 7362 ExprResult Val = CheckBooleanCondition(StartLoc, Condition); 7363 if (Val.isInvalid()) 7364 return nullptr; 7365 7366 ValExpr = MakeFullExpr(Val.get()).get(); 7367 } 7368 7369 return new (Context) OMPFinalClause(ValExpr, StartLoc, LParenLoc, EndLoc); 7370 } 7371 ExprResult Sema::PerformOpenMPImplicitIntegerConversion(SourceLocation Loc, 7372 Expr *Op) { 7373 if (!Op) 7374 return ExprError(); 7375 7376 class IntConvertDiagnoser : public ICEConvertDiagnoser { 7377 public: 7378 IntConvertDiagnoser() 7379 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false, false, true) {} 7380 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, 7381 QualType T) override { 7382 return S.Diag(Loc, diag::err_omp_not_integral) << T; 7383 } 7384 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, 7385 QualType T) override { 7386 return S.Diag(Loc, diag::err_omp_incomplete_type) << T; 7387 } 7388 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc, 7389 QualType T, 7390 QualType ConvTy) override { 7391 return S.Diag(Loc, diag::err_omp_explicit_conversion) << T << ConvTy; 7392 } 7393 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, 7394 QualType ConvTy) override { 7395 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here) 7396 << ConvTy->isEnumeralType() << ConvTy; 7397 } 7398 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, 7399 QualType T) override { 7400 return S.Diag(Loc, diag::err_omp_ambiguous_conversion) << T; 7401 } 7402 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, 7403 QualType ConvTy) override { 7404 return S.Diag(Conv->getLocation(), diag::note_omp_conversion_here) 7405 << ConvTy->isEnumeralType() << ConvTy; 7406 } 7407 SemaDiagnosticBuilder diagnoseConversion(Sema &, SourceLocation, QualType, 7408 QualType) override { 7409 llvm_unreachable("conversion functions are permitted"); 7410 } 7411 } ConvertDiagnoser; 7412 return PerformContextualImplicitConversion(Loc, Op, ConvertDiagnoser); 7413 } 7414 7415 static bool IsNonNegativeIntegerValue(Expr *&ValExpr, Sema &SemaRef, 7416 OpenMPClauseKind CKind, 7417 bool StrictlyPositive) { 7418 if (!ValExpr->isTypeDependent() && !ValExpr->isValueDependent() && 7419 !ValExpr->isInstantiationDependent()) { 7420 SourceLocation Loc = ValExpr->getExprLoc(); 7421 ExprResult Value = 7422 SemaRef.PerformOpenMPImplicitIntegerConversion(Loc, ValExpr); 7423 if (Value.isInvalid()) 7424 return false; 7425 7426 ValExpr = Value.get(); 7427 // The expression must evaluate to a non-negative integer value. 7428 llvm::APSInt Result; 7429 if (ValExpr->isIntegerConstantExpr(Result, SemaRef.Context) && 7430 Result.isSigned() && 7431 !((!StrictlyPositive && Result.isNonNegative()) || 7432 (StrictlyPositive && Result.isStrictlyPositive()))) { 7433 SemaRef.Diag(Loc, diag::err_omp_negative_expression_in_clause) 7434 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0) 7435 << ValExpr->getSourceRange(); 7436 return false; 7437 } 7438 } 7439 return true; 7440 } 7441 7442 OMPClause *Sema::ActOnOpenMPNumThreadsClause(Expr *NumThreads, 7443 SourceLocation StartLoc, 7444 SourceLocation LParenLoc, 7445 SourceLocation EndLoc) { 7446 Expr *ValExpr = NumThreads; 7447 7448 // OpenMP [2.5, Restrictions] 7449 // The num_threads expression must evaluate to a positive integer value. 7450 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_threads, 7451 /*StrictlyPositive=*/true)) 7452 return nullptr; 7453 7454 return new (Context) 7455 OMPNumThreadsClause(ValExpr, StartLoc, LParenLoc, EndLoc); 7456 } 7457 7458 ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E, 7459 OpenMPClauseKind CKind, 7460 bool StrictlyPositive) { 7461 if (!E) 7462 return ExprError(); 7463 if (E->isValueDependent() || E->isTypeDependent() || 7464 E->isInstantiationDependent() || E->containsUnexpandedParameterPack()) 7465 return E; 7466 llvm::APSInt Result; 7467 ExprResult ICE = VerifyIntegerConstantExpression(E, &Result); 7468 if (ICE.isInvalid()) 7469 return ExprError(); 7470 if ((StrictlyPositive && !Result.isStrictlyPositive()) || 7471 (!StrictlyPositive && !Result.isNonNegative())) { 7472 Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause) 7473 << getOpenMPClauseName(CKind) << (StrictlyPositive ? 1 : 0) 7474 << E->getSourceRange(); 7475 return ExprError(); 7476 } 7477 if (CKind == OMPC_aligned && !Result.isPowerOf2()) { 7478 Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two) 7479 << E->getSourceRange(); 7480 return ExprError(); 7481 } 7482 if (CKind == OMPC_collapse && DSAStack->getAssociatedLoops() == 1) 7483 DSAStack->setAssociatedLoops(Result.getExtValue()); 7484 else if (CKind == OMPC_ordered) 7485 DSAStack->setAssociatedLoops(Result.getExtValue()); 7486 return ICE; 7487 } 7488 7489 OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc, 7490 SourceLocation LParenLoc, 7491 SourceLocation EndLoc) { 7492 // OpenMP [2.8.1, simd construct, Description] 7493 // The parameter of the safelen clause must be a constant 7494 // positive integer expression. 7495 ExprResult Safelen = VerifyPositiveIntegerConstantInClause(Len, OMPC_safelen); 7496 if (Safelen.isInvalid()) 7497 return nullptr; 7498 return new (Context) 7499 OMPSafelenClause(Safelen.get(), StartLoc, LParenLoc, EndLoc); 7500 } 7501 7502 OMPClause *Sema::ActOnOpenMPSimdlenClause(Expr *Len, SourceLocation StartLoc, 7503 SourceLocation LParenLoc, 7504 SourceLocation EndLoc) { 7505 // OpenMP [2.8.1, simd construct, Description] 7506 // The parameter of the simdlen clause must be a constant 7507 // positive integer expression. 7508 ExprResult Simdlen = VerifyPositiveIntegerConstantInClause(Len, OMPC_simdlen); 7509 if (Simdlen.isInvalid()) 7510 return nullptr; 7511 return new (Context) 7512 OMPSimdlenClause(Simdlen.get(), StartLoc, LParenLoc, EndLoc); 7513 } 7514 7515 OMPClause *Sema::ActOnOpenMPCollapseClause(Expr *NumForLoops, 7516 SourceLocation StartLoc, 7517 SourceLocation LParenLoc, 7518 SourceLocation EndLoc) { 7519 // OpenMP [2.7.1, loop construct, Description] 7520 // OpenMP [2.8.1, simd construct, Description] 7521 // OpenMP [2.9.6, distribute construct, Description] 7522 // The parameter of the collapse clause must be a constant 7523 // positive integer expression. 7524 ExprResult NumForLoopsResult = 7525 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_collapse); 7526 if (NumForLoopsResult.isInvalid()) 7527 return nullptr; 7528 return new (Context) 7529 OMPCollapseClause(NumForLoopsResult.get(), StartLoc, LParenLoc, EndLoc); 7530 } 7531 7532 OMPClause *Sema::ActOnOpenMPOrderedClause(SourceLocation StartLoc, 7533 SourceLocation EndLoc, 7534 SourceLocation LParenLoc, 7535 Expr *NumForLoops) { 7536 // OpenMP [2.7.1, loop construct, Description] 7537 // OpenMP [2.8.1, simd construct, Description] 7538 // OpenMP [2.9.6, distribute construct, Description] 7539 // The parameter of the ordered clause must be a constant 7540 // positive integer expression if any. 7541 if (NumForLoops && LParenLoc.isValid()) { 7542 ExprResult NumForLoopsResult = 7543 VerifyPositiveIntegerConstantInClause(NumForLoops, OMPC_ordered); 7544 if (NumForLoopsResult.isInvalid()) 7545 return nullptr; 7546 NumForLoops = NumForLoopsResult.get(); 7547 } else 7548 NumForLoops = nullptr; 7549 DSAStack->setOrderedRegion(/*IsOrdered=*/true, NumForLoops); 7550 return new (Context) 7551 OMPOrderedClause(NumForLoops, StartLoc, LParenLoc, EndLoc); 7552 } 7553 7554 OMPClause *Sema::ActOnOpenMPSimpleClause( 7555 OpenMPClauseKind Kind, unsigned Argument, SourceLocation ArgumentLoc, 7556 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) { 7557 OMPClause *Res = nullptr; 7558 switch (Kind) { 7559 case OMPC_default: 7560 Res = 7561 ActOnOpenMPDefaultClause(static_cast<OpenMPDefaultClauseKind>(Argument), 7562 ArgumentLoc, StartLoc, LParenLoc, EndLoc); 7563 break; 7564 case OMPC_proc_bind: 7565 Res = ActOnOpenMPProcBindClause( 7566 static_cast<OpenMPProcBindClauseKind>(Argument), ArgumentLoc, StartLoc, 7567 LParenLoc, EndLoc); 7568 break; 7569 case OMPC_if: 7570 case OMPC_final: 7571 case OMPC_num_threads: 7572 case OMPC_safelen: 7573 case OMPC_simdlen: 7574 case OMPC_collapse: 7575 case OMPC_schedule: 7576 case OMPC_private: 7577 case OMPC_firstprivate: 7578 case OMPC_lastprivate: 7579 case OMPC_shared: 7580 case OMPC_reduction: 7581 case OMPC_linear: 7582 case OMPC_aligned: 7583 case OMPC_copyin: 7584 case OMPC_copyprivate: 7585 case OMPC_ordered: 7586 case OMPC_nowait: 7587 case OMPC_untied: 7588 case OMPC_mergeable: 7589 case OMPC_threadprivate: 7590 case OMPC_flush: 7591 case OMPC_read: 7592 case OMPC_write: 7593 case OMPC_update: 7594 case OMPC_capture: 7595 case OMPC_seq_cst: 7596 case OMPC_depend: 7597 case OMPC_device: 7598 case OMPC_threads: 7599 case OMPC_simd: 7600 case OMPC_map: 7601 case OMPC_num_teams: 7602 case OMPC_thread_limit: 7603 case OMPC_priority: 7604 case OMPC_grainsize: 7605 case OMPC_nogroup: 7606 case OMPC_num_tasks: 7607 case OMPC_hint: 7608 case OMPC_dist_schedule: 7609 case OMPC_defaultmap: 7610 case OMPC_unknown: 7611 case OMPC_uniform: 7612 case OMPC_to: 7613 case OMPC_from: 7614 case OMPC_use_device_ptr: 7615 case OMPC_is_device_ptr: 7616 llvm_unreachable("Clause is not allowed."); 7617 } 7618 return Res; 7619 } 7620 7621 static std::string 7622 getListOfPossibleValues(OpenMPClauseKind K, unsigned First, unsigned Last, 7623 ArrayRef<unsigned> Exclude = llvm::None) { 7624 std::string Values; 7625 unsigned Bound = Last >= 2 ? Last - 2 : 0; 7626 unsigned Skipped = Exclude.size(); 7627 auto S = Exclude.begin(), E = Exclude.end(); 7628 for (unsigned i = First; i < Last; ++i) { 7629 if (std::find(S, E, i) != E) { 7630 --Skipped; 7631 continue; 7632 } 7633 Values += "'"; 7634 Values += getOpenMPSimpleClauseTypeName(K, i); 7635 Values += "'"; 7636 if (i == Bound - Skipped) 7637 Values += " or "; 7638 else if (i != Bound + 1 - Skipped) 7639 Values += ", "; 7640 } 7641 return Values; 7642 } 7643 7644 OMPClause *Sema::ActOnOpenMPDefaultClause(OpenMPDefaultClauseKind Kind, 7645 SourceLocation KindKwLoc, 7646 SourceLocation StartLoc, 7647 SourceLocation LParenLoc, 7648 SourceLocation EndLoc) { 7649 if (Kind == OMPC_DEFAULT_unknown) { 7650 static_assert(OMPC_DEFAULT_unknown > 0, 7651 "OMPC_DEFAULT_unknown not greater than 0"); 7652 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value) 7653 << getListOfPossibleValues(OMPC_default, /*First=*/0, 7654 /*Last=*/OMPC_DEFAULT_unknown) 7655 << getOpenMPClauseName(OMPC_default); 7656 return nullptr; 7657 } 7658 switch (Kind) { 7659 case OMPC_DEFAULT_none: 7660 DSAStack->setDefaultDSANone(KindKwLoc); 7661 break; 7662 case OMPC_DEFAULT_shared: 7663 DSAStack->setDefaultDSAShared(KindKwLoc); 7664 break; 7665 case OMPC_DEFAULT_unknown: 7666 llvm_unreachable("Clause kind is not allowed."); 7667 break; 7668 } 7669 return new (Context) 7670 OMPDefaultClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc); 7671 } 7672 7673 OMPClause *Sema::ActOnOpenMPProcBindClause(OpenMPProcBindClauseKind Kind, 7674 SourceLocation KindKwLoc, 7675 SourceLocation StartLoc, 7676 SourceLocation LParenLoc, 7677 SourceLocation EndLoc) { 7678 if (Kind == OMPC_PROC_BIND_unknown) { 7679 Diag(KindKwLoc, diag::err_omp_unexpected_clause_value) 7680 << getListOfPossibleValues(OMPC_proc_bind, /*First=*/0, 7681 /*Last=*/OMPC_PROC_BIND_unknown) 7682 << getOpenMPClauseName(OMPC_proc_bind); 7683 return nullptr; 7684 } 7685 return new (Context) 7686 OMPProcBindClause(Kind, KindKwLoc, StartLoc, LParenLoc, EndLoc); 7687 } 7688 7689 OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause( 7690 OpenMPClauseKind Kind, ArrayRef<unsigned> Argument, Expr *Expr, 7691 SourceLocation StartLoc, SourceLocation LParenLoc, 7692 ArrayRef<SourceLocation> ArgumentLoc, SourceLocation DelimLoc, 7693 SourceLocation EndLoc) { 7694 OMPClause *Res = nullptr; 7695 switch (Kind) { 7696 case OMPC_schedule: 7697 enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements }; 7698 assert(Argument.size() == NumberOfElements && 7699 ArgumentLoc.size() == NumberOfElements); 7700 Res = ActOnOpenMPScheduleClause( 7701 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier1]), 7702 static_cast<OpenMPScheduleClauseModifier>(Argument[Modifier2]), 7703 static_cast<OpenMPScheduleClauseKind>(Argument[ScheduleKind]), Expr, 7704 StartLoc, LParenLoc, ArgumentLoc[Modifier1], ArgumentLoc[Modifier2], 7705 ArgumentLoc[ScheduleKind], DelimLoc, EndLoc); 7706 break; 7707 case OMPC_if: 7708 assert(Argument.size() == 1 && ArgumentLoc.size() == 1); 7709 Res = ActOnOpenMPIfClause(static_cast<OpenMPDirectiveKind>(Argument.back()), 7710 Expr, StartLoc, LParenLoc, ArgumentLoc.back(), 7711 DelimLoc, EndLoc); 7712 break; 7713 case OMPC_dist_schedule: 7714 Res = ActOnOpenMPDistScheduleClause( 7715 static_cast<OpenMPDistScheduleClauseKind>(Argument.back()), Expr, 7716 StartLoc, LParenLoc, ArgumentLoc.back(), DelimLoc, EndLoc); 7717 break; 7718 case OMPC_defaultmap: 7719 enum { Modifier, DefaultmapKind }; 7720 Res = ActOnOpenMPDefaultmapClause( 7721 static_cast<OpenMPDefaultmapClauseModifier>(Argument[Modifier]), 7722 static_cast<OpenMPDefaultmapClauseKind>(Argument[DefaultmapKind]), 7723 StartLoc, LParenLoc, ArgumentLoc[Modifier], 7724 ArgumentLoc[DefaultmapKind], EndLoc); 7725 break; 7726 case OMPC_final: 7727 case OMPC_num_threads: 7728 case OMPC_safelen: 7729 case OMPC_simdlen: 7730 case OMPC_collapse: 7731 case OMPC_default: 7732 case OMPC_proc_bind: 7733 case OMPC_private: 7734 case OMPC_firstprivate: 7735 case OMPC_lastprivate: 7736 case OMPC_shared: 7737 case OMPC_reduction: 7738 case OMPC_linear: 7739 case OMPC_aligned: 7740 case OMPC_copyin: 7741 case OMPC_copyprivate: 7742 case OMPC_ordered: 7743 case OMPC_nowait: 7744 case OMPC_untied: 7745 case OMPC_mergeable: 7746 case OMPC_threadprivate: 7747 case OMPC_flush: 7748 case OMPC_read: 7749 case OMPC_write: 7750 case OMPC_update: 7751 case OMPC_capture: 7752 case OMPC_seq_cst: 7753 case OMPC_depend: 7754 case OMPC_device: 7755 case OMPC_threads: 7756 case OMPC_simd: 7757 case OMPC_map: 7758 case OMPC_num_teams: 7759 case OMPC_thread_limit: 7760 case OMPC_priority: 7761 case OMPC_grainsize: 7762 case OMPC_nogroup: 7763 case OMPC_num_tasks: 7764 case OMPC_hint: 7765 case OMPC_unknown: 7766 case OMPC_uniform: 7767 case OMPC_to: 7768 case OMPC_from: 7769 case OMPC_use_device_ptr: 7770 case OMPC_is_device_ptr: 7771 llvm_unreachable("Clause is not allowed."); 7772 } 7773 return Res; 7774 } 7775 7776 static bool checkScheduleModifiers(Sema &S, OpenMPScheduleClauseModifier M1, 7777 OpenMPScheduleClauseModifier M2, 7778 SourceLocation M1Loc, SourceLocation M2Loc) { 7779 if (M1 == OMPC_SCHEDULE_MODIFIER_unknown && M1Loc.isValid()) { 7780 SmallVector<unsigned, 2> Excluded; 7781 if (M2 != OMPC_SCHEDULE_MODIFIER_unknown) 7782 Excluded.push_back(M2); 7783 if (M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) 7784 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_monotonic); 7785 if (M2 == OMPC_SCHEDULE_MODIFIER_monotonic) 7786 Excluded.push_back(OMPC_SCHEDULE_MODIFIER_nonmonotonic); 7787 S.Diag(M1Loc, diag::err_omp_unexpected_clause_value) 7788 << getListOfPossibleValues(OMPC_schedule, 7789 /*First=*/OMPC_SCHEDULE_MODIFIER_unknown + 1, 7790 /*Last=*/OMPC_SCHEDULE_MODIFIER_last, 7791 Excluded) 7792 << getOpenMPClauseName(OMPC_schedule); 7793 return true; 7794 } 7795 return false; 7796 } 7797 7798 OMPClause *Sema::ActOnOpenMPScheduleClause( 7799 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2, 7800 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc, 7801 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc, 7802 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc) { 7803 if (checkScheduleModifiers(*this, M1, M2, M1Loc, M2Loc) || 7804 checkScheduleModifiers(*this, M2, M1, M2Loc, M1Loc)) 7805 return nullptr; 7806 // OpenMP, 2.7.1, Loop Construct, Restrictions 7807 // Either the monotonic modifier or the nonmonotonic modifier can be specified 7808 // but not both. 7809 if ((M1 == M2 && M1 != OMPC_SCHEDULE_MODIFIER_unknown) || 7810 (M1 == OMPC_SCHEDULE_MODIFIER_monotonic && 7811 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) || 7812 (M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic && 7813 M2 == OMPC_SCHEDULE_MODIFIER_monotonic)) { 7814 Diag(M2Loc, diag::err_omp_unexpected_schedule_modifier) 7815 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M2) 7816 << getOpenMPSimpleClauseTypeName(OMPC_schedule, M1); 7817 return nullptr; 7818 } 7819 if (Kind == OMPC_SCHEDULE_unknown) { 7820 std::string Values; 7821 if (M1Loc.isInvalid() && M2Loc.isInvalid()) { 7822 unsigned Exclude[] = {OMPC_SCHEDULE_unknown}; 7823 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0, 7824 /*Last=*/OMPC_SCHEDULE_MODIFIER_last, 7825 Exclude); 7826 } else { 7827 Values = getListOfPossibleValues(OMPC_schedule, /*First=*/0, 7828 /*Last=*/OMPC_SCHEDULE_unknown); 7829 } 7830 Diag(KindLoc, diag::err_omp_unexpected_clause_value) 7831 << Values << getOpenMPClauseName(OMPC_schedule); 7832 return nullptr; 7833 } 7834 // OpenMP, 2.7.1, Loop Construct, Restrictions 7835 // The nonmonotonic modifier can only be specified with schedule(dynamic) or 7836 // schedule(guided). 7837 if ((M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic || 7838 M2 == OMPC_SCHEDULE_MODIFIER_nonmonotonic) && 7839 Kind != OMPC_SCHEDULE_dynamic && Kind != OMPC_SCHEDULE_guided) { 7840 Diag(M1 == OMPC_SCHEDULE_MODIFIER_nonmonotonic ? M1Loc : M2Loc, 7841 diag::err_omp_schedule_nonmonotonic_static); 7842 return nullptr; 7843 } 7844 Expr *ValExpr = ChunkSize; 7845 Stmt *HelperValStmt = nullptr; 7846 if (ChunkSize) { 7847 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() && 7848 !ChunkSize->isInstantiationDependent() && 7849 !ChunkSize->containsUnexpandedParameterPack()) { 7850 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart(); 7851 ExprResult Val = 7852 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize); 7853 if (Val.isInvalid()) 7854 return nullptr; 7855 7856 ValExpr = Val.get(); 7857 7858 // OpenMP [2.7.1, Restrictions] 7859 // chunk_size must be a loop invariant integer expression with a positive 7860 // value. 7861 llvm::APSInt Result; 7862 if (ValExpr->isIntegerConstantExpr(Result, Context)) { 7863 if (Result.isSigned() && !Result.isStrictlyPositive()) { 7864 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause) 7865 << "schedule" << 1 << ChunkSize->getSourceRange(); 7866 return nullptr; 7867 } 7868 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) && 7869 !CurContext->isDependentContext()) { 7870 llvm::MapVector<Expr *, DeclRefExpr *> Captures; 7871 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get(); 7872 HelperValStmt = buildPreInits(Context, Captures); 7873 } 7874 } 7875 } 7876 7877 return new (Context) 7878 OMPScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc, Kind, 7879 ValExpr, HelperValStmt, M1, M1Loc, M2, M2Loc); 7880 } 7881 7882 OMPClause *Sema::ActOnOpenMPClause(OpenMPClauseKind Kind, 7883 SourceLocation StartLoc, 7884 SourceLocation EndLoc) { 7885 OMPClause *Res = nullptr; 7886 switch (Kind) { 7887 case OMPC_ordered: 7888 Res = ActOnOpenMPOrderedClause(StartLoc, EndLoc); 7889 break; 7890 case OMPC_nowait: 7891 Res = ActOnOpenMPNowaitClause(StartLoc, EndLoc); 7892 break; 7893 case OMPC_untied: 7894 Res = ActOnOpenMPUntiedClause(StartLoc, EndLoc); 7895 break; 7896 case OMPC_mergeable: 7897 Res = ActOnOpenMPMergeableClause(StartLoc, EndLoc); 7898 break; 7899 case OMPC_read: 7900 Res = ActOnOpenMPReadClause(StartLoc, EndLoc); 7901 break; 7902 case OMPC_write: 7903 Res = ActOnOpenMPWriteClause(StartLoc, EndLoc); 7904 break; 7905 case OMPC_update: 7906 Res = ActOnOpenMPUpdateClause(StartLoc, EndLoc); 7907 break; 7908 case OMPC_capture: 7909 Res = ActOnOpenMPCaptureClause(StartLoc, EndLoc); 7910 break; 7911 case OMPC_seq_cst: 7912 Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc); 7913 break; 7914 case OMPC_threads: 7915 Res = ActOnOpenMPThreadsClause(StartLoc, EndLoc); 7916 break; 7917 case OMPC_simd: 7918 Res = ActOnOpenMPSIMDClause(StartLoc, EndLoc); 7919 break; 7920 case OMPC_nogroup: 7921 Res = ActOnOpenMPNogroupClause(StartLoc, EndLoc); 7922 break; 7923 case OMPC_if: 7924 case OMPC_final: 7925 case OMPC_num_threads: 7926 case OMPC_safelen: 7927 case OMPC_simdlen: 7928 case OMPC_collapse: 7929 case OMPC_schedule: 7930 case OMPC_private: 7931 case OMPC_firstprivate: 7932 case OMPC_lastprivate: 7933 case OMPC_shared: 7934 case OMPC_reduction: 7935 case OMPC_linear: 7936 case OMPC_aligned: 7937 case OMPC_copyin: 7938 case OMPC_copyprivate: 7939 case OMPC_default: 7940 case OMPC_proc_bind: 7941 case OMPC_threadprivate: 7942 case OMPC_flush: 7943 case OMPC_depend: 7944 case OMPC_device: 7945 case OMPC_map: 7946 case OMPC_num_teams: 7947 case OMPC_thread_limit: 7948 case OMPC_priority: 7949 case OMPC_grainsize: 7950 case OMPC_num_tasks: 7951 case OMPC_hint: 7952 case OMPC_dist_schedule: 7953 case OMPC_defaultmap: 7954 case OMPC_unknown: 7955 case OMPC_uniform: 7956 case OMPC_to: 7957 case OMPC_from: 7958 case OMPC_use_device_ptr: 7959 case OMPC_is_device_ptr: 7960 llvm_unreachable("Clause is not allowed."); 7961 } 7962 return Res; 7963 } 7964 7965 OMPClause *Sema::ActOnOpenMPNowaitClause(SourceLocation StartLoc, 7966 SourceLocation EndLoc) { 7967 DSAStack->setNowaitRegion(); 7968 return new (Context) OMPNowaitClause(StartLoc, EndLoc); 7969 } 7970 7971 OMPClause *Sema::ActOnOpenMPUntiedClause(SourceLocation StartLoc, 7972 SourceLocation EndLoc) { 7973 return new (Context) OMPUntiedClause(StartLoc, EndLoc); 7974 } 7975 7976 OMPClause *Sema::ActOnOpenMPMergeableClause(SourceLocation StartLoc, 7977 SourceLocation EndLoc) { 7978 return new (Context) OMPMergeableClause(StartLoc, EndLoc); 7979 } 7980 7981 OMPClause *Sema::ActOnOpenMPReadClause(SourceLocation StartLoc, 7982 SourceLocation EndLoc) { 7983 return new (Context) OMPReadClause(StartLoc, EndLoc); 7984 } 7985 7986 OMPClause *Sema::ActOnOpenMPWriteClause(SourceLocation StartLoc, 7987 SourceLocation EndLoc) { 7988 return new (Context) OMPWriteClause(StartLoc, EndLoc); 7989 } 7990 7991 OMPClause *Sema::ActOnOpenMPUpdateClause(SourceLocation StartLoc, 7992 SourceLocation EndLoc) { 7993 return new (Context) OMPUpdateClause(StartLoc, EndLoc); 7994 } 7995 7996 OMPClause *Sema::ActOnOpenMPCaptureClause(SourceLocation StartLoc, 7997 SourceLocation EndLoc) { 7998 return new (Context) OMPCaptureClause(StartLoc, EndLoc); 7999 } 8000 8001 OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc, 8002 SourceLocation EndLoc) { 8003 return new (Context) OMPSeqCstClause(StartLoc, EndLoc); 8004 } 8005 8006 OMPClause *Sema::ActOnOpenMPThreadsClause(SourceLocation StartLoc, 8007 SourceLocation EndLoc) { 8008 return new (Context) OMPThreadsClause(StartLoc, EndLoc); 8009 } 8010 8011 OMPClause *Sema::ActOnOpenMPSIMDClause(SourceLocation StartLoc, 8012 SourceLocation EndLoc) { 8013 return new (Context) OMPSIMDClause(StartLoc, EndLoc); 8014 } 8015 8016 OMPClause *Sema::ActOnOpenMPNogroupClause(SourceLocation StartLoc, 8017 SourceLocation EndLoc) { 8018 return new (Context) OMPNogroupClause(StartLoc, EndLoc); 8019 } 8020 8021 OMPClause *Sema::ActOnOpenMPVarListClause( 8022 OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *TailExpr, 8023 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, 8024 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, 8025 const DeclarationNameInfo &ReductionId, OpenMPDependClauseKind DepKind, 8026 OpenMPLinearClauseKind LinKind, OpenMPMapClauseKind MapTypeModifier, 8027 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, 8028 SourceLocation DepLinMapLoc) { 8029 OMPClause *Res = nullptr; 8030 switch (Kind) { 8031 case OMPC_private: 8032 Res = ActOnOpenMPPrivateClause(VarList, StartLoc, LParenLoc, EndLoc); 8033 break; 8034 case OMPC_firstprivate: 8035 Res = ActOnOpenMPFirstprivateClause(VarList, StartLoc, LParenLoc, EndLoc); 8036 break; 8037 case OMPC_lastprivate: 8038 Res = ActOnOpenMPLastprivateClause(VarList, StartLoc, LParenLoc, EndLoc); 8039 break; 8040 case OMPC_shared: 8041 Res = ActOnOpenMPSharedClause(VarList, StartLoc, LParenLoc, EndLoc); 8042 break; 8043 case OMPC_reduction: 8044 Res = ActOnOpenMPReductionClause(VarList, StartLoc, LParenLoc, ColonLoc, 8045 EndLoc, ReductionIdScopeSpec, ReductionId); 8046 break; 8047 case OMPC_linear: 8048 Res = ActOnOpenMPLinearClause(VarList, TailExpr, StartLoc, LParenLoc, 8049 LinKind, DepLinMapLoc, ColonLoc, EndLoc); 8050 break; 8051 case OMPC_aligned: 8052 Res = ActOnOpenMPAlignedClause(VarList, TailExpr, StartLoc, LParenLoc, 8053 ColonLoc, EndLoc); 8054 break; 8055 case OMPC_copyin: 8056 Res = ActOnOpenMPCopyinClause(VarList, StartLoc, LParenLoc, EndLoc); 8057 break; 8058 case OMPC_copyprivate: 8059 Res = ActOnOpenMPCopyprivateClause(VarList, StartLoc, LParenLoc, EndLoc); 8060 break; 8061 case OMPC_flush: 8062 Res = ActOnOpenMPFlushClause(VarList, StartLoc, LParenLoc, EndLoc); 8063 break; 8064 case OMPC_depend: 8065 Res = ActOnOpenMPDependClause(DepKind, DepLinMapLoc, ColonLoc, VarList, 8066 StartLoc, LParenLoc, EndLoc); 8067 break; 8068 case OMPC_map: 8069 Res = ActOnOpenMPMapClause(MapTypeModifier, MapType, IsMapTypeImplicit, 8070 DepLinMapLoc, ColonLoc, VarList, StartLoc, 8071 LParenLoc, EndLoc); 8072 break; 8073 case OMPC_to: 8074 Res = ActOnOpenMPToClause(VarList, StartLoc, LParenLoc, EndLoc); 8075 break; 8076 case OMPC_from: 8077 Res = ActOnOpenMPFromClause(VarList, StartLoc, LParenLoc, EndLoc); 8078 break; 8079 case OMPC_use_device_ptr: 8080 Res = ActOnOpenMPUseDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc); 8081 break; 8082 case OMPC_is_device_ptr: 8083 Res = ActOnOpenMPIsDevicePtrClause(VarList, StartLoc, LParenLoc, EndLoc); 8084 break; 8085 case OMPC_if: 8086 case OMPC_final: 8087 case OMPC_num_threads: 8088 case OMPC_safelen: 8089 case OMPC_simdlen: 8090 case OMPC_collapse: 8091 case OMPC_default: 8092 case OMPC_proc_bind: 8093 case OMPC_schedule: 8094 case OMPC_ordered: 8095 case OMPC_nowait: 8096 case OMPC_untied: 8097 case OMPC_mergeable: 8098 case OMPC_threadprivate: 8099 case OMPC_read: 8100 case OMPC_write: 8101 case OMPC_update: 8102 case OMPC_capture: 8103 case OMPC_seq_cst: 8104 case OMPC_device: 8105 case OMPC_threads: 8106 case OMPC_simd: 8107 case OMPC_num_teams: 8108 case OMPC_thread_limit: 8109 case OMPC_priority: 8110 case OMPC_grainsize: 8111 case OMPC_nogroup: 8112 case OMPC_num_tasks: 8113 case OMPC_hint: 8114 case OMPC_dist_schedule: 8115 case OMPC_defaultmap: 8116 case OMPC_unknown: 8117 case OMPC_uniform: 8118 llvm_unreachable("Clause is not allowed."); 8119 } 8120 return Res; 8121 } 8122 8123 ExprResult Sema::getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK, 8124 ExprObjectKind OK, SourceLocation Loc) { 8125 ExprResult Res = BuildDeclRefExpr( 8126 Capture, Capture->getType().getNonReferenceType(), VK_LValue, Loc); 8127 if (!Res.isUsable()) 8128 return ExprError(); 8129 if (OK == OK_Ordinary && !getLangOpts().CPlusPlus) { 8130 Res = CreateBuiltinUnaryOp(Loc, UO_Deref, Res.get()); 8131 if (!Res.isUsable()) 8132 return ExprError(); 8133 } 8134 if (VK != VK_LValue && Res.get()->isGLValue()) { 8135 Res = DefaultLvalueConversion(Res.get()); 8136 if (!Res.isUsable()) 8137 return ExprError(); 8138 } 8139 return Res; 8140 } 8141 8142 static std::pair<ValueDecl *, bool> 8143 getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc, 8144 SourceRange &ERange, bool AllowArraySection = false) { 8145 if (RefExpr->isTypeDependent() || RefExpr->isValueDependent() || 8146 RefExpr->containsUnexpandedParameterPack()) 8147 return std::make_pair(nullptr, true); 8148 8149 // OpenMP [3.1, C/C++] 8150 // A list item is a variable name. 8151 // OpenMP [2.9.3.3, Restrictions, p.1] 8152 // A variable that is part of another variable (as an array or 8153 // structure element) cannot appear in a private clause. 8154 RefExpr = RefExpr->IgnoreParens(); 8155 enum { 8156 NoArrayExpr = -1, 8157 ArraySubscript = 0, 8158 OMPArraySection = 1 8159 } IsArrayExpr = NoArrayExpr; 8160 if (AllowArraySection) { 8161 if (auto *ASE = dyn_cast_or_null<ArraySubscriptExpr>(RefExpr)) { 8162 auto *Base = ASE->getBase()->IgnoreParenImpCasts(); 8163 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base)) 8164 Base = TempASE->getBase()->IgnoreParenImpCasts(); 8165 RefExpr = Base; 8166 IsArrayExpr = ArraySubscript; 8167 } else if (auto *OASE = dyn_cast_or_null<OMPArraySectionExpr>(RefExpr)) { 8168 auto *Base = OASE->getBase()->IgnoreParenImpCasts(); 8169 while (auto *TempOASE = dyn_cast<OMPArraySectionExpr>(Base)) 8170 Base = TempOASE->getBase()->IgnoreParenImpCasts(); 8171 while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base)) 8172 Base = TempASE->getBase()->IgnoreParenImpCasts(); 8173 RefExpr = Base; 8174 IsArrayExpr = OMPArraySection; 8175 } 8176 } 8177 ELoc = RefExpr->getExprLoc(); 8178 ERange = RefExpr->getSourceRange(); 8179 RefExpr = RefExpr->IgnoreParenImpCasts(); 8180 auto *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr); 8181 auto *ME = dyn_cast_or_null<MemberExpr>(RefExpr); 8182 if ((!DE || !isa<VarDecl>(DE->getDecl())) && 8183 (S.getCurrentThisType().isNull() || !ME || 8184 !isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()) || 8185 !isa<FieldDecl>(ME->getMemberDecl()))) { 8186 if (IsArrayExpr != NoArrayExpr) 8187 S.Diag(ELoc, diag::err_omp_expected_base_var_name) << IsArrayExpr 8188 << ERange; 8189 else { 8190 S.Diag(ELoc, 8191 AllowArraySection 8192 ? diag::err_omp_expected_var_name_member_expr_or_array_item 8193 : diag::err_omp_expected_var_name_member_expr) 8194 << (S.getCurrentThisType().isNull() ? 0 : 1) << ERange; 8195 } 8196 return std::make_pair(nullptr, false); 8197 } 8198 return std::make_pair(DE ? DE->getDecl() : ME->getMemberDecl(), false); 8199 } 8200 8201 OMPClause *Sema::ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList, 8202 SourceLocation StartLoc, 8203 SourceLocation LParenLoc, 8204 SourceLocation EndLoc) { 8205 SmallVector<Expr *, 8> Vars; 8206 SmallVector<Expr *, 8> PrivateCopies; 8207 for (auto &RefExpr : VarList) { 8208 assert(RefExpr && "NULL expr in OpenMP private clause."); 8209 SourceLocation ELoc; 8210 SourceRange ERange; 8211 Expr *SimpleRefExpr = RefExpr; 8212 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange); 8213 if (Res.second) { 8214 // It will be analyzed later. 8215 Vars.push_back(RefExpr); 8216 PrivateCopies.push_back(nullptr); 8217 } 8218 ValueDecl *D = Res.first; 8219 if (!D) 8220 continue; 8221 8222 QualType Type = D->getType(); 8223 auto *VD = dyn_cast<VarDecl>(D); 8224 8225 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3] 8226 // A variable that appears in a private clause must not have an incomplete 8227 // type or a reference type. 8228 if (RequireCompleteType(ELoc, Type, diag::err_omp_private_incomplete_type)) 8229 continue; 8230 Type = Type.getNonReferenceType(); 8231 8232 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 8233 // in a Construct] 8234 // Variables with the predetermined data-sharing attributes may not be 8235 // listed in data-sharing attributes clauses, except for the cases 8236 // listed below. For these exceptions only, listing a predetermined 8237 // variable in a data-sharing attribute clause is allowed and overrides 8238 // the variable's predetermined data-sharing attributes. 8239 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false); 8240 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_private) { 8241 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind) 8242 << getOpenMPClauseName(OMPC_private); 8243 ReportOriginalDSA(*this, DSAStack, D, DVar); 8244 continue; 8245 } 8246 8247 // Variably modified types are not supported for tasks. 8248 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() && 8249 isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) { 8250 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported) 8251 << getOpenMPClauseName(OMPC_private) << Type 8252 << getOpenMPDirectiveName(DSAStack->getCurrentDirective()); 8253 bool IsDecl = 8254 !VD || 8255 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 8256 Diag(D->getLocation(), 8257 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 8258 << D; 8259 continue; 8260 } 8261 8262 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3] 8263 // A list item cannot appear in both a map clause and a data-sharing 8264 // attribute clause on the same construct 8265 if (DSAStack->getCurrentDirective() == OMPD_target) { 8266 if (DSAStack->checkMappableExprComponentListsForDecl( 8267 VD, /* CurrentRegionOnly = */ true, 8268 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef) 8269 -> bool { return true; })) { 8270 Diag(ELoc, diag::err_omp_variable_in_map_and_dsa) 8271 << getOpenMPClauseName(OMPC_private) 8272 << getOpenMPDirectiveName(DSAStack->getCurrentDirective()); 8273 ReportOriginalDSA(*this, DSAStack, D, DVar); 8274 continue; 8275 } 8276 } 8277 8278 // OpenMP [2.9.3.3, Restrictions, C/C++, p.1] 8279 // A variable of class type (or array thereof) that appears in a private 8280 // clause requires an accessible, unambiguous default constructor for the 8281 // class type. 8282 // Generate helper private variable and initialize it with the default 8283 // value. The address of the original variable is replaced by the address of 8284 // the new private variable in CodeGen. This new variable is not added to 8285 // IdResolver, so the code in the OpenMP region uses original variable for 8286 // proper diagnostics. 8287 Type = Type.getUnqualifiedType(); 8288 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(), 8289 D->hasAttrs() ? &D->getAttrs() : nullptr); 8290 ActOnUninitializedDecl(VDPrivate, /*TypeMayContainAuto=*/false); 8291 if (VDPrivate->isInvalidDecl()) 8292 continue; 8293 auto VDPrivateRefExpr = buildDeclRefExpr( 8294 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), ELoc); 8295 8296 DeclRefExpr *Ref = nullptr; 8297 if (!VD && !CurContext->isDependentContext()) 8298 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false); 8299 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_private, Ref); 8300 Vars.push_back((VD || CurContext->isDependentContext()) 8301 ? RefExpr->IgnoreParens() 8302 : Ref); 8303 PrivateCopies.push_back(VDPrivateRefExpr); 8304 } 8305 8306 if (Vars.empty()) 8307 return nullptr; 8308 8309 return OMPPrivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars, 8310 PrivateCopies); 8311 } 8312 8313 namespace { 8314 class DiagsUninitializedSeveretyRAII { 8315 private: 8316 DiagnosticsEngine &Diags; 8317 SourceLocation SavedLoc; 8318 bool IsIgnored; 8319 8320 public: 8321 DiagsUninitializedSeveretyRAII(DiagnosticsEngine &Diags, SourceLocation Loc, 8322 bool IsIgnored) 8323 : Diags(Diags), SavedLoc(Loc), IsIgnored(IsIgnored) { 8324 if (!IsIgnored) { 8325 Diags.setSeverity(/*Diag*/ diag::warn_uninit_self_reference_in_init, 8326 /*Map*/ diag::Severity::Ignored, Loc); 8327 } 8328 } 8329 ~DiagsUninitializedSeveretyRAII() { 8330 if (!IsIgnored) 8331 Diags.popMappings(SavedLoc); 8332 } 8333 }; 8334 } 8335 8336 OMPClause *Sema::ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList, 8337 SourceLocation StartLoc, 8338 SourceLocation LParenLoc, 8339 SourceLocation EndLoc) { 8340 SmallVector<Expr *, 8> Vars; 8341 SmallVector<Expr *, 8> PrivateCopies; 8342 SmallVector<Expr *, 8> Inits; 8343 SmallVector<Decl *, 4> ExprCaptures; 8344 bool IsImplicitClause = 8345 StartLoc.isInvalid() && LParenLoc.isInvalid() && EndLoc.isInvalid(); 8346 auto ImplicitClauseLoc = DSAStack->getConstructLoc(); 8347 8348 for (auto &RefExpr : VarList) { 8349 assert(RefExpr && "NULL expr in OpenMP firstprivate clause."); 8350 SourceLocation ELoc; 8351 SourceRange ERange; 8352 Expr *SimpleRefExpr = RefExpr; 8353 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange); 8354 if (Res.second) { 8355 // It will be analyzed later. 8356 Vars.push_back(RefExpr); 8357 PrivateCopies.push_back(nullptr); 8358 Inits.push_back(nullptr); 8359 } 8360 ValueDecl *D = Res.first; 8361 if (!D) 8362 continue; 8363 8364 ELoc = IsImplicitClause ? ImplicitClauseLoc : ELoc; 8365 QualType Type = D->getType(); 8366 auto *VD = dyn_cast<VarDecl>(D); 8367 8368 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3] 8369 // A variable that appears in a private clause must not have an incomplete 8370 // type or a reference type. 8371 if (RequireCompleteType(ELoc, Type, 8372 diag::err_omp_firstprivate_incomplete_type)) 8373 continue; 8374 Type = Type.getNonReferenceType(); 8375 8376 // OpenMP [2.9.3.4, Restrictions, C/C++, p.1] 8377 // A variable of class type (or array thereof) that appears in a private 8378 // clause requires an accessible, unambiguous copy constructor for the 8379 // class type. 8380 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType(); 8381 8382 // If an implicit firstprivate variable found it was checked already. 8383 DSAStackTy::DSAVarData TopDVar; 8384 if (!IsImplicitClause) { 8385 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false); 8386 TopDVar = DVar; 8387 bool IsConstant = ElemType.isConstant(Context); 8388 // OpenMP [2.4.13, Data-sharing Attribute Clauses] 8389 // A list item that specifies a given variable may not appear in more 8390 // than one clause on the same directive, except that a variable may be 8391 // specified in both firstprivate and lastprivate clauses. 8392 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_firstprivate && 8393 DVar.CKind != OMPC_lastprivate && DVar.RefExpr) { 8394 Diag(ELoc, diag::err_omp_wrong_dsa) 8395 << getOpenMPClauseName(DVar.CKind) 8396 << getOpenMPClauseName(OMPC_firstprivate); 8397 ReportOriginalDSA(*this, DSAStack, D, DVar); 8398 continue; 8399 } 8400 8401 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 8402 // in a Construct] 8403 // Variables with the predetermined data-sharing attributes may not be 8404 // listed in data-sharing attributes clauses, except for the cases 8405 // listed below. For these exceptions only, listing a predetermined 8406 // variable in a data-sharing attribute clause is allowed and overrides 8407 // the variable's predetermined data-sharing attributes. 8408 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 8409 // in a Construct, C/C++, p.2] 8410 // Variables with const-qualified type having no mutable member may be 8411 // listed in a firstprivate clause, even if they are static data members. 8412 if (!(IsConstant || (VD && VD->isStaticDataMember())) && !DVar.RefExpr && 8413 DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared) { 8414 Diag(ELoc, diag::err_omp_wrong_dsa) 8415 << getOpenMPClauseName(DVar.CKind) 8416 << getOpenMPClauseName(OMPC_firstprivate); 8417 ReportOriginalDSA(*this, DSAStack, D, DVar); 8418 continue; 8419 } 8420 8421 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective(); 8422 // OpenMP [2.9.3.4, Restrictions, p.2] 8423 // A list item that is private within a parallel region must not appear 8424 // in a firstprivate clause on a worksharing construct if any of the 8425 // worksharing regions arising from the worksharing construct ever bind 8426 // to any of the parallel regions arising from the parallel construct. 8427 if (isOpenMPWorksharingDirective(CurrDir) && 8428 !isOpenMPParallelDirective(CurrDir)) { 8429 DVar = DSAStack->getImplicitDSA(D, true); 8430 if (DVar.CKind != OMPC_shared && 8431 (isOpenMPParallelDirective(DVar.DKind) || 8432 DVar.DKind == OMPD_unknown)) { 8433 Diag(ELoc, diag::err_omp_required_access) 8434 << getOpenMPClauseName(OMPC_firstprivate) 8435 << getOpenMPClauseName(OMPC_shared); 8436 ReportOriginalDSA(*this, DSAStack, D, DVar); 8437 continue; 8438 } 8439 } 8440 // OpenMP [2.9.3.4, Restrictions, p.3] 8441 // A list item that appears in a reduction clause of a parallel construct 8442 // must not appear in a firstprivate clause on a worksharing or task 8443 // construct if any of the worksharing or task regions arising from the 8444 // worksharing or task construct ever bind to any of the parallel regions 8445 // arising from the parallel construct. 8446 // OpenMP [2.9.3.4, Restrictions, p.4] 8447 // A list item that appears in a reduction clause in worksharing 8448 // construct must not appear in a firstprivate clause in a task construct 8449 // encountered during execution of any of the worksharing regions arising 8450 // from the worksharing construct. 8451 if (isOpenMPTaskingDirective(CurrDir)) { 8452 DVar = DSAStack->hasInnermostDSA( 8453 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; }, 8454 [](OpenMPDirectiveKind K) -> bool { 8455 return isOpenMPParallelDirective(K) || 8456 isOpenMPWorksharingDirective(K); 8457 }, 8458 false); 8459 if (DVar.CKind == OMPC_reduction && 8460 (isOpenMPParallelDirective(DVar.DKind) || 8461 isOpenMPWorksharingDirective(DVar.DKind))) { 8462 Diag(ELoc, diag::err_omp_parallel_reduction_in_task_firstprivate) 8463 << getOpenMPDirectiveName(DVar.DKind); 8464 ReportOriginalDSA(*this, DSAStack, D, DVar); 8465 continue; 8466 } 8467 } 8468 8469 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3] 8470 // A list item that is private within a teams region must not appear in a 8471 // firstprivate clause on a distribute construct if any of the distribute 8472 // regions arising from the distribute construct ever bind to any of the 8473 // teams regions arising from the teams construct. 8474 // OpenMP 4.5 [2.15.3.4, Restrictions, p.3] 8475 // A list item that appears in a reduction clause of a teams construct 8476 // must not appear in a firstprivate clause on a distribute construct if 8477 // any of the distribute regions arising from the distribute construct 8478 // ever bind to any of the teams regions arising from the teams construct. 8479 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3] 8480 // A list item may appear in a firstprivate or lastprivate clause but not 8481 // both. 8482 if (CurrDir == OMPD_distribute) { 8483 DVar = DSAStack->hasInnermostDSA( 8484 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_private; }, 8485 [](OpenMPDirectiveKind K) -> bool { 8486 return isOpenMPTeamsDirective(K); 8487 }, 8488 false); 8489 if (DVar.CKind == OMPC_private && isOpenMPTeamsDirective(DVar.DKind)) { 8490 Diag(ELoc, diag::err_omp_firstprivate_distribute_private_teams); 8491 ReportOriginalDSA(*this, DSAStack, D, DVar); 8492 continue; 8493 } 8494 DVar = DSAStack->hasInnermostDSA( 8495 D, [](OpenMPClauseKind C) -> bool { return C == OMPC_reduction; }, 8496 [](OpenMPDirectiveKind K) -> bool { 8497 return isOpenMPTeamsDirective(K); 8498 }, 8499 false); 8500 if (DVar.CKind == OMPC_reduction && 8501 isOpenMPTeamsDirective(DVar.DKind)) { 8502 Diag(ELoc, diag::err_omp_firstprivate_distribute_in_teams_reduction); 8503 ReportOriginalDSA(*this, DSAStack, D, DVar); 8504 continue; 8505 } 8506 DVar = DSAStack->getTopDSA(D, false); 8507 if (DVar.CKind == OMPC_lastprivate) { 8508 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute); 8509 ReportOriginalDSA(*this, DSAStack, D, DVar); 8510 continue; 8511 } 8512 } 8513 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3] 8514 // A list item cannot appear in both a map clause and a data-sharing 8515 // attribute clause on the same construct 8516 if (CurrDir == OMPD_target) { 8517 if (DSAStack->checkMappableExprComponentListsForDecl( 8518 VD, /* CurrentRegionOnly = */ true, 8519 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef) 8520 -> bool { return true; })) { 8521 Diag(ELoc, diag::err_omp_variable_in_map_and_dsa) 8522 << getOpenMPClauseName(OMPC_firstprivate) 8523 << getOpenMPDirectiveName(DSAStack->getCurrentDirective()); 8524 ReportOriginalDSA(*this, DSAStack, D, DVar); 8525 continue; 8526 } 8527 } 8528 } 8529 8530 // Variably modified types are not supported for tasks. 8531 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType() && 8532 isOpenMPTaskingDirective(DSAStack->getCurrentDirective())) { 8533 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported) 8534 << getOpenMPClauseName(OMPC_firstprivate) << Type 8535 << getOpenMPDirectiveName(DSAStack->getCurrentDirective()); 8536 bool IsDecl = 8537 !VD || 8538 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 8539 Diag(D->getLocation(), 8540 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 8541 << D; 8542 continue; 8543 } 8544 8545 Type = Type.getUnqualifiedType(); 8546 auto VDPrivate = buildVarDecl(*this, ELoc, Type, D->getName(), 8547 D->hasAttrs() ? &D->getAttrs() : nullptr); 8548 // Generate helper private variable and initialize it with the value of the 8549 // original variable. The address of the original variable is replaced by 8550 // the address of the new private variable in the CodeGen. This new variable 8551 // is not added to IdResolver, so the code in the OpenMP region uses 8552 // original variable for proper diagnostics and variable capturing. 8553 Expr *VDInitRefExpr = nullptr; 8554 // For arrays generate initializer for single element and replace it by the 8555 // original array element in CodeGen. 8556 if (Type->isArrayType()) { 8557 auto VDInit = 8558 buildVarDecl(*this, RefExpr->getExprLoc(), ElemType, D->getName()); 8559 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, ElemType, ELoc); 8560 auto Init = DefaultLvalueConversion(VDInitRefExpr).get(); 8561 ElemType = ElemType.getUnqualifiedType(); 8562 auto *VDInitTemp = buildVarDecl(*this, RefExpr->getExprLoc(), ElemType, 8563 ".firstprivate.temp"); 8564 InitializedEntity Entity = 8565 InitializedEntity::InitializeVariable(VDInitTemp); 8566 InitializationKind Kind = InitializationKind::CreateCopy(ELoc, ELoc); 8567 8568 InitializationSequence InitSeq(*this, Entity, Kind, Init); 8569 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Init); 8570 if (Result.isInvalid()) 8571 VDPrivate->setInvalidDecl(); 8572 else 8573 VDPrivate->setInit(Result.getAs<Expr>()); 8574 // Remove temp variable declaration. 8575 Context.Deallocate(VDInitTemp); 8576 } else { 8577 auto *VDInit = buildVarDecl(*this, RefExpr->getExprLoc(), Type, 8578 ".firstprivate.temp"); 8579 VDInitRefExpr = buildDeclRefExpr(*this, VDInit, RefExpr->getType(), 8580 RefExpr->getExprLoc()); 8581 AddInitializerToDecl(VDPrivate, 8582 DefaultLvalueConversion(VDInitRefExpr).get(), 8583 /*DirectInit=*/false, /*TypeMayContainAuto=*/false); 8584 } 8585 if (VDPrivate->isInvalidDecl()) { 8586 if (IsImplicitClause) { 8587 Diag(RefExpr->getExprLoc(), 8588 diag::note_omp_task_predetermined_firstprivate_here); 8589 } 8590 continue; 8591 } 8592 CurContext->addDecl(VDPrivate); 8593 auto VDPrivateRefExpr = buildDeclRefExpr( 8594 *this, VDPrivate, RefExpr->getType().getUnqualifiedType(), 8595 RefExpr->getExprLoc()); 8596 DeclRefExpr *Ref = nullptr; 8597 if (!VD && !CurContext->isDependentContext()) { 8598 if (TopDVar.CKind == OMPC_lastprivate) 8599 Ref = TopDVar.PrivateCopy; 8600 else { 8601 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true); 8602 if (!IsOpenMPCapturedDecl(D)) 8603 ExprCaptures.push_back(Ref->getDecl()); 8604 } 8605 } 8606 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_firstprivate, Ref); 8607 Vars.push_back((VD || CurContext->isDependentContext()) 8608 ? RefExpr->IgnoreParens() 8609 : Ref); 8610 PrivateCopies.push_back(VDPrivateRefExpr); 8611 Inits.push_back(VDInitRefExpr); 8612 } 8613 8614 if (Vars.empty()) 8615 return nullptr; 8616 8617 return OMPFirstprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, 8618 Vars, PrivateCopies, Inits, 8619 buildPreInits(Context, ExprCaptures)); 8620 } 8621 8622 OMPClause *Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr *> VarList, 8623 SourceLocation StartLoc, 8624 SourceLocation LParenLoc, 8625 SourceLocation EndLoc) { 8626 SmallVector<Expr *, 8> Vars; 8627 SmallVector<Expr *, 8> SrcExprs; 8628 SmallVector<Expr *, 8> DstExprs; 8629 SmallVector<Expr *, 8> AssignmentOps; 8630 SmallVector<Decl *, 4> ExprCaptures; 8631 SmallVector<Expr *, 4> ExprPostUpdates; 8632 for (auto &RefExpr : VarList) { 8633 assert(RefExpr && "NULL expr in OpenMP lastprivate clause."); 8634 SourceLocation ELoc; 8635 SourceRange ERange; 8636 Expr *SimpleRefExpr = RefExpr; 8637 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange); 8638 if (Res.second) { 8639 // It will be analyzed later. 8640 Vars.push_back(RefExpr); 8641 SrcExprs.push_back(nullptr); 8642 DstExprs.push_back(nullptr); 8643 AssignmentOps.push_back(nullptr); 8644 } 8645 ValueDecl *D = Res.first; 8646 if (!D) 8647 continue; 8648 8649 QualType Type = D->getType(); 8650 auto *VD = dyn_cast<VarDecl>(D); 8651 8652 // OpenMP [2.14.3.5, Restrictions, C/C++, p.2] 8653 // A variable that appears in a lastprivate clause must not have an 8654 // incomplete type or a reference type. 8655 if (RequireCompleteType(ELoc, Type, 8656 diag::err_omp_lastprivate_incomplete_type)) 8657 continue; 8658 Type = Type.getNonReferenceType(); 8659 8660 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced 8661 // in a Construct] 8662 // Variables with the predetermined data-sharing attributes may not be 8663 // listed in data-sharing attributes clauses, except for the cases 8664 // listed below. 8665 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false); 8666 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_lastprivate && 8667 DVar.CKind != OMPC_firstprivate && 8668 (DVar.CKind != OMPC_private || DVar.RefExpr != nullptr)) { 8669 Diag(ELoc, diag::err_omp_wrong_dsa) 8670 << getOpenMPClauseName(DVar.CKind) 8671 << getOpenMPClauseName(OMPC_lastprivate); 8672 ReportOriginalDSA(*this, DSAStack, D, DVar); 8673 continue; 8674 } 8675 8676 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective(); 8677 // OpenMP [2.14.3.5, Restrictions, p.2] 8678 // A list item that is private within a parallel region, or that appears in 8679 // the reduction clause of a parallel construct, must not appear in a 8680 // lastprivate clause on a worksharing construct if any of the corresponding 8681 // worksharing regions ever binds to any of the corresponding parallel 8682 // regions. 8683 DSAStackTy::DSAVarData TopDVar = DVar; 8684 if (isOpenMPWorksharingDirective(CurrDir) && 8685 !isOpenMPParallelDirective(CurrDir)) { 8686 DVar = DSAStack->getImplicitDSA(D, true); 8687 if (DVar.CKind != OMPC_shared) { 8688 Diag(ELoc, diag::err_omp_required_access) 8689 << getOpenMPClauseName(OMPC_lastprivate) 8690 << getOpenMPClauseName(OMPC_shared); 8691 ReportOriginalDSA(*this, DSAStack, D, DVar); 8692 continue; 8693 } 8694 } 8695 8696 // OpenMP 4.5 [2.10.8, Distribute Construct, p.3] 8697 // A list item may appear in a firstprivate or lastprivate clause but not 8698 // both. 8699 if (CurrDir == OMPD_distribute) { 8700 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false); 8701 if (DVar.CKind == OMPC_firstprivate) { 8702 Diag(ELoc, diag::err_omp_firstprivate_and_lastprivate_in_distribute); 8703 ReportOriginalDSA(*this, DSAStack, D, DVar); 8704 continue; 8705 } 8706 } 8707 8708 // OpenMP [2.14.3.5, Restrictions, C++, p.1,2] 8709 // A variable of class type (or array thereof) that appears in a 8710 // lastprivate clause requires an accessible, unambiguous default 8711 // constructor for the class type, unless the list item is also specified 8712 // in a firstprivate clause. 8713 // A variable of class type (or array thereof) that appears in a 8714 // lastprivate clause requires an accessible, unambiguous copy assignment 8715 // operator for the class type. 8716 Type = Context.getBaseElementType(Type).getNonReferenceType(); 8717 auto *SrcVD = buildVarDecl(*this, ERange.getBegin(), 8718 Type.getUnqualifiedType(), ".lastprivate.src", 8719 D->hasAttrs() ? &D->getAttrs() : nullptr); 8720 auto *PseudoSrcExpr = 8721 buildDeclRefExpr(*this, SrcVD, Type.getUnqualifiedType(), ELoc); 8722 auto *DstVD = 8723 buildVarDecl(*this, ERange.getBegin(), Type, ".lastprivate.dst", 8724 D->hasAttrs() ? &D->getAttrs() : nullptr); 8725 auto *PseudoDstExpr = buildDeclRefExpr(*this, DstVD, Type, ELoc); 8726 // For arrays generate assignment operation for single element and replace 8727 // it by the original array element in CodeGen. 8728 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, ELoc, BO_Assign, 8729 PseudoDstExpr, PseudoSrcExpr); 8730 if (AssignmentOp.isInvalid()) 8731 continue; 8732 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc, 8733 /*DiscardedValue=*/true); 8734 if (AssignmentOp.isInvalid()) 8735 continue; 8736 8737 DeclRefExpr *Ref = nullptr; 8738 if (!VD && !CurContext->isDependentContext()) { 8739 if (TopDVar.CKind == OMPC_firstprivate) 8740 Ref = TopDVar.PrivateCopy; 8741 else { 8742 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false); 8743 if (!IsOpenMPCapturedDecl(D)) 8744 ExprCaptures.push_back(Ref->getDecl()); 8745 } 8746 if (TopDVar.CKind == OMPC_firstprivate || 8747 (!IsOpenMPCapturedDecl(D) && 8748 Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>())) { 8749 ExprResult RefRes = DefaultLvalueConversion(Ref); 8750 if (!RefRes.isUsable()) 8751 continue; 8752 ExprResult PostUpdateRes = 8753 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, SimpleRefExpr, 8754 RefRes.get()); 8755 if (!PostUpdateRes.isUsable()) 8756 continue; 8757 ExprPostUpdates.push_back( 8758 IgnoredValueConversions(PostUpdateRes.get()).get()); 8759 } 8760 } 8761 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_lastprivate, Ref); 8762 Vars.push_back((VD || CurContext->isDependentContext()) 8763 ? RefExpr->IgnoreParens() 8764 : Ref); 8765 SrcExprs.push_back(PseudoSrcExpr); 8766 DstExprs.push_back(PseudoDstExpr); 8767 AssignmentOps.push_back(AssignmentOp.get()); 8768 } 8769 8770 if (Vars.empty()) 8771 return nullptr; 8772 8773 return OMPLastprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, 8774 Vars, SrcExprs, DstExprs, AssignmentOps, 8775 buildPreInits(Context, ExprCaptures), 8776 buildPostUpdate(*this, ExprPostUpdates)); 8777 } 8778 8779 OMPClause *Sema::ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList, 8780 SourceLocation StartLoc, 8781 SourceLocation LParenLoc, 8782 SourceLocation EndLoc) { 8783 SmallVector<Expr *, 8> Vars; 8784 for (auto &RefExpr : VarList) { 8785 assert(RefExpr && "NULL expr in OpenMP lastprivate clause."); 8786 SourceLocation ELoc; 8787 SourceRange ERange; 8788 Expr *SimpleRefExpr = RefExpr; 8789 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange); 8790 if (Res.second) { 8791 // It will be analyzed later. 8792 Vars.push_back(RefExpr); 8793 } 8794 ValueDecl *D = Res.first; 8795 if (!D) 8796 continue; 8797 8798 auto *VD = dyn_cast<VarDecl>(D); 8799 // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced 8800 // in a Construct] 8801 // Variables with the predetermined data-sharing attributes may not be 8802 // listed in data-sharing attributes clauses, except for the cases 8803 // listed below. For these exceptions only, listing a predetermined 8804 // variable in a data-sharing attribute clause is allowed and overrides 8805 // the variable's predetermined data-sharing attributes. 8806 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false); 8807 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_shared && 8808 DVar.RefExpr) { 8809 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind) 8810 << getOpenMPClauseName(OMPC_shared); 8811 ReportOriginalDSA(*this, DSAStack, D, DVar); 8812 continue; 8813 } 8814 8815 DeclRefExpr *Ref = nullptr; 8816 if (!VD && IsOpenMPCapturedDecl(D) && !CurContext->isDependentContext()) 8817 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true); 8818 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_shared, Ref); 8819 Vars.push_back((VD || !Ref || CurContext->isDependentContext()) 8820 ? RefExpr->IgnoreParens() 8821 : Ref); 8822 } 8823 8824 if (Vars.empty()) 8825 return nullptr; 8826 8827 return OMPSharedClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars); 8828 } 8829 8830 namespace { 8831 class DSARefChecker : public StmtVisitor<DSARefChecker, bool> { 8832 DSAStackTy *Stack; 8833 8834 public: 8835 bool VisitDeclRefExpr(DeclRefExpr *E) { 8836 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) { 8837 DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD, false); 8838 if (DVar.CKind == OMPC_shared && !DVar.RefExpr) 8839 return false; 8840 if (DVar.CKind != OMPC_unknown) 8841 return true; 8842 DSAStackTy::DSAVarData DVarPrivate = Stack->hasDSA( 8843 VD, isOpenMPPrivate, [](OpenMPDirectiveKind) -> bool { return true; }, 8844 false); 8845 if (DVarPrivate.CKind != OMPC_unknown) 8846 return true; 8847 return false; 8848 } 8849 return false; 8850 } 8851 bool VisitStmt(Stmt *S) { 8852 for (auto Child : S->children()) { 8853 if (Child && Visit(Child)) 8854 return true; 8855 } 8856 return false; 8857 } 8858 explicit DSARefChecker(DSAStackTy *S) : Stack(S) {} 8859 }; 8860 } // namespace 8861 8862 namespace { 8863 // Transform MemberExpression for specified FieldDecl of current class to 8864 // DeclRefExpr to specified OMPCapturedExprDecl. 8865 class TransformExprToCaptures : public TreeTransform<TransformExprToCaptures> { 8866 typedef TreeTransform<TransformExprToCaptures> BaseTransform; 8867 ValueDecl *Field; 8868 DeclRefExpr *CapturedExpr; 8869 8870 public: 8871 TransformExprToCaptures(Sema &SemaRef, ValueDecl *FieldDecl) 8872 : BaseTransform(SemaRef), Field(FieldDecl), CapturedExpr(nullptr) {} 8873 8874 ExprResult TransformMemberExpr(MemberExpr *E) { 8875 if (isa<CXXThisExpr>(E->getBase()->IgnoreParenImpCasts()) && 8876 E->getMemberDecl() == Field) { 8877 CapturedExpr = buildCapture(SemaRef, Field, E, /*WithInit=*/false); 8878 return CapturedExpr; 8879 } 8880 return BaseTransform::TransformMemberExpr(E); 8881 } 8882 DeclRefExpr *getCapturedExpr() { return CapturedExpr; } 8883 }; 8884 } // namespace 8885 8886 template <typename T> 8887 static T filterLookupForUDR(SmallVectorImpl<UnresolvedSet<8>> &Lookups, 8888 const llvm::function_ref<T(ValueDecl *)> &Gen) { 8889 for (auto &Set : Lookups) { 8890 for (auto *D : Set) { 8891 if (auto Res = Gen(cast<ValueDecl>(D))) 8892 return Res; 8893 } 8894 } 8895 return T(); 8896 } 8897 8898 static ExprResult 8899 buildDeclareReductionRef(Sema &SemaRef, SourceLocation Loc, SourceRange Range, 8900 Scope *S, CXXScopeSpec &ReductionIdScopeSpec, 8901 const DeclarationNameInfo &ReductionId, QualType Ty, 8902 CXXCastPath &BasePath, Expr *UnresolvedReduction) { 8903 if (ReductionIdScopeSpec.isInvalid()) 8904 return ExprError(); 8905 SmallVector<UnresolvedSet<8>, 4> Lookups; 8906 if (S) { 8907 LookupResult Lookup(SemaRef, ReductionId, Sema::LookupOMPReductionName); 8908 Lookup.suppressDiagnostics(); 8909 while (S && SemaRef.LookupParsedName(Lookup, S, &ReductionIdScopeSpec)) { 8910 auto *D = Lookup.getRepresentativeDecl(); 8911 do { 8912 S = S->getParent(); 8913 } while (S && !S->isDeclScope(D)); 8914 if (S) 8915 S = S->getParent(); 8916 Lookups.push_back(UnresolvedSet<8>()); 8917 Lookups.back().append(Lookup.begin(), Lookup.end()); 8918 Lookup.clear(); 8919 } 8920 } else if (auto *ULE = 8921 cast_or_null<UnresolvedLookupExpr>(UnresolvedReduction)) { 8922 Lookups.push_back(UnresolvedSet<8>()); 8923 Decl *PrevD = nullptr; 8924 for(auto *D : ULE->decls()) { 8925 if (D == PrevD) 8926 Lookups.push_back(UnresolvedSet<8>()); 8927 else if (auto *DRD = cast<OMPDeclareReductionDecl>(D)) 8928 Lookups.back().addDecl(DRD); 8929 PrevD = D; 8930 } 8931 } 8932 if (Ty->isDependentType() || Ty->isInstantiationDependentType() || 8933 Ty->containsUnexpandedParameterPack() || 8934 filterLookupForUDR<bool>(Lookups, [](ValueDecl *D) -> bool { 8935 return !D->isInvalidDecl() && 8936 (D->getType()->isDependentType() || 8937 D->getType()->isInstantiationDependentType() || 8938 D->getType()->containsUnexpandedParameterPack()); 8939 })) { 8940 UnresolvedSet<8> ResSet; 8941 for (auto &Set : Lookups) { 8942 ResSet.append(Set.begin(), Set.end()); 8943 // The last item marks the end of all declarations at the specified scope. 8944 ResSet.addDecl(Set[Set.size() - 1]); 8945 } 8946 return UnresolvedLookupExpr::Create( 8947 SemaRef.Context, /*NamingClass=*/nullptr, 8948 ReductionIdScopeSpec.getWithLocInContext(SemaRef.Context), ReductionId, 8949 /*ADL=*/true, /*Overloaded=*/true, ResSet.begin(), ResSet.end()); 8950 } 8951 if (auto *VD = filterLookupForUDR<ValueDecl *>( 8952 Lookups, [&SemaRef, Ty](ValueDecl *D) -> ValueDecl * { 8953 if (!D->isInvalidDecl() && 8954 SemaRef.Context.hasSameType(D->getType(), Ty)) 8955 return D; 8956 return nullptr; 8957 })) 8958 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc); 8959 if (auto *VD = filterLookupForUDR<ValueDecl *>( 8960 Lookups, [&SemaRef, Ty, Loc](ValueDecl *D) -> ValueDecl * { 8961 if (!D->isInvalidDecl() && 8962 SemaRef.IsDerivedFrom(Loc, Ty, D->getType()) && 8963 !Ty.isMoreQualifiedThan(D->getType())) 8964 return D; 8965 return nullptr; 8966 })) { 8967 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 8968 /*DetectVirtual=*/false); 8969 if (SemaRef.IsDerivedFrom(Loc, Ty, VD->getType(), Paths)) { 8970 if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType( 8971 VD->getType().getUnqualifiedType()))) { 8972 if (SemaRef.CheckBaseClassAccess(Loc, VD->getType(), Ty, Paths.front(), 8973 /*DiagID=*/0) != 8974 Sema::AR_inaccessible) { 8975 SemaRef.BuildBasePathArray(Paths, BasePath); 8976 return SemaRef.BuildDeclRefExpr(VD, Ty, VK_LValue, Loc); 8977 } 8978 } 8979 } 8980 } 8981 if (ReductionIdScopeSpec.isSet()) { 8982 SemaRef.Diag(Loc, diag::err_omp_not_resolved_reduction_identifier) << Range; 8983 return ExprError(); 8984 } 8985 return ExprEmpty(); 8986 } 8987 8988 OMPClause *Sema::ActOnOpenMPReductionClause( 8989 ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, 8990 SourceLocation ColonLoc, SourceLocation EndLoc, 8991 CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, 8992 ArrayRef<Expr *> UnresolvedReductions) { 8993 auto DN = ReductionId.getName(); 8994 auto OOK = DN.getCXXOverloadedOperator(); 8995 BinaryOperatorKind BOK = BO_Comma; 8996 8997 // OpenMP [2.14.3.6, reduction clause] 8998 // C 8999 // reduction-identifier is either an identifier or one of the following 9000 // operators: +, -, *, &, |, ^, && and || 9001 // C++ 9002 // reduction-identifier is either an id-expression or one of the following 9003 // operators: +, -, *, &, |, ^, && and || 9004 // FIXME: Only 'min' and 'max' identifiers are supported for now. 9005 switch (OOK) { 9006 case OO_Plus: 9007 case OO_Minus: 9008 BOK = BO_Add; 9009 break; 9010 case OO_Star: 9011 BOK = BO_Mul; 9012 break; 9013 case OO_Amp: 9014 BOK = BO_And; 9015 break; 9016 case OO_Pipe: 9017 BOK = BO_Or; 9018 break; 9019 case OO_Caret: 9020 BOK = BO_Xor; 9021 break; 9022 case OO_AmpAmp: 9023 BOK = BO_LAnd; 9024 break; 9025 case OO_PipePipe: 9026 BOK = BO_LOr; 9027 break; 9028 case OO_New: 9029 case OO_Delete: 9030 case OO_Array_New: 9031 case OO_Array_Delete: 9032 case OO_Slash: 9033 case OO_Percent: 9034 case OO_Tilde: 9035 case OO_Exclaim: 9036 case OO_Equal: 9037 case OO_Less: 9038 case OO_Greater: 9039 case OO_LessEqual: 9040 case OO_GreaterEqual: 9041 case OO_PlusEqual: 9042 case OO_MinusEqual: 9043 case OO_StarEqual: 9044 case OO_SlashEqual: 9045 case OO_PercentEqual: 9046 case OO_CaretEqual: 9047 case OO_AmpEqual: 9048 case OO_PipeEqual: 9049 case OO_LessLess: 9050 case OO_GreaterGreater: 9051 case OO_LessLessEqual: 9052 case OO_GreaterGreaterEqual: 9053 case OO_EqualEqual: 9054 case OO_ExclaimEqual: 9055 case OO_PlusPlus: 9056 case OO_MinusMinus: 9057 case OO_Comma: 9058 case OO_ArrowStar: 9059 case OO_Arrow: 9060 case OO_Call: 9061 case OO_Subscript: 9062 case OO_Conditional: 9063 case OO_Coawait: 9064 case NUM_OVERLOADED_OPERATORS: 9065 llvm_unreachable("Unexpected reduction identifier"); 9066 case OO_None: 9067 if (auto II = DN.getAsIdentifierInfo()) { 9068 if (II->isStr("max")) 9069 BOK = BO_GT; 9070 else if (II->isStr("min")) 9071 BOK = BO_LT; 9072 } 9073 break; 9074 } 9075 SourceRange ReductionIdRange; 9076 if (ReductionIdScopeSpec.isValid()) 9077 ReductionIdRange.setBegin(ReductionIdScopeSpec.getBeginLoc()); 9078 ReductionIdRange.setEnd(ReductionId.getEndLoc()); 9079 9080 SmallVector<Expr *, 8> Vars; 9081 SmallVector<Expr *, 8> Privates; 9082 SmallVector<Expr *, 8> LHSs; 9083 SmallVector<Expr *, 8> RHSs; 9084 SmallVector<Expr *, 8> ReductionOps; 9085 SmallVector<Decl *, 4> ExprCaptures; 9086 SmallVector<Expr *, 4> ExprPostUpdates; 9087 auto IR = UnresolvedReductions.begin(), ER = UnresolvedReductions.end(); 9088 bool FirstIter = true; 9089 for (auto RefExpr : VarList) { 9090 assert(RefExpr && "nullptr expr in OpenMP reduction clause."); 9091 // OpenMP [2.1, C/C++] 9092 // A list item is a variable or array section, subject to the restrictions 9093 // specified in Section 2.4 on page 42 and in each of the sections 9094 // describing clauses and directives for which a list appears. 9095 // OpenMP [2.14.3.3, Restrictions, p.1] 9096 // A variable that is part of another variable (as an array or 9097 // structure element) cannot appear in a private clause. 9098 if (!FirstIter && IR != ER) 9099 ++IR; 9100 FirstIter = false; 9101 SourceLocation ELoc; 9102 SourceRange ERange; 9103 Expr *SimpleRefExpr = RefExpr; 9104 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange, 9105 /*AllowArraySection=*/true); 9106 if (Res.second) { 9107 // It will be analyzed later. 9108 Vars.push_back(RefExpr); 9109 Privates.push_back(nullptr); 9110 LHSs.push_back(nullptr); 9111 RHSs.push_back(nullptr); 9112 // Try to find 'declare reduction' corresponding construct before using 9113 // builtin/overloaded operators. 9114 QualType Type = Context.DependentTy; 9115 CXXCastPath BasePath; 9116 ExprResult DeclareReductionRef = buildDeclareReductionRef( 9117 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec, 9118 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR); 9119 if (CurContext->isDependentContext() && 9120 (DeclareReductionRef.isUnset() || 9121 isa<UnresolvedLookupExpr>(DeclareReductionRef.get()))) 9122 ReductionOps.push_back(DeclareReductionRef.get()); 9123 else 9124 ReductionOps.push_back(nullptr); 9125 } 9126 ValueDecl *D = Res.first; 9127 if (!D) 9128 continue; 9129 9130 QualType Type; 9131 auto *ASE = dyn_cast<ArraySubscriptExpr>(RefExpr->IgnoreParens()); 9132 auto *OASE = dyn_cast<OMPArraySectionExpr>(RefExpr->IgnoreParens()); 9133 if (ASE) 9134 Type = ASE->getType().getNonReferenceType(); 9135 else if (OASE) { 9136 auto BaseType = OMPArraySectionExpr::getBaseOriginalType(OASE->getBase()); 9137 if (auto *ATy = BaseType->getAsArrayTypeUnsafe()) 9138 Type = ATy->getElementType(); 9139 else 9140 Type = BaseType->getPointeeType(); 9141 Type = Type.getNonReferenceType(); 9142 } else 9143 Type = Context.getBaseElementType(D->getType().getNonReferenceType()); 9144 auto *VD = dyn_cast<VarDecl>(D); 9145 9146 // OpenMP [2.9.3.3, Restrictions, C/C++, p.3] 9147 // A variable that appears in a private clause must not have an incomplete 9148 // type or a reference type. 9149 if (RequireCompleteType(ELoc, Type, 9150 diag::err_omp_reduction_incomplete_type)) 9151 continue; 9152 // OpenMP [2.14.3.6, reduction clause, Restrictions] 9153 // A list item that appears in a reduction clause must not be 9154 // const-qualified. 9155 if (Type.getNonReferenceType().isConstant(Context)) { 9156 Diag(ELoc, diag::err_omp_const_reduction_list_item) 9157 << getOpenMPClauseName(OMPC_reduction) << Type << ERange; 9158 if (!ASE && !OASE) { 9159 bool IsDecl = !VD || 9160 VD->isThisDeclarationADefinition(Context) == 9161 VarDecl::DeclarationOnly; 9162 Diag(D->getLocation(), 9163 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 9164 << D; 9165 } 9166 continue; 9167 } 9168 // OpenMP [2.9.3.6, Restrictions, C/C++, p.4] 9169 // If a list-item is a reference type then it must bind to the same object 9170 // for all threads of the team. 9171 if (!ASE && !OASE && VD) { 9172 VarDecl *VDDef = VD->getDefinition(); 9173 if (VD->getType()->isReferenceType() && VDDef) { 9174 DSARefChecker Check(DSAStack); 9175 if (Check.Visit(VDDef->getInit())) { 9176 Diag(ELoc, diag::err_omp_reduction_ref_type_arg) << ERange; 9177 Diag(VDDef->getLocation(), diag::note_defined_here) << VDDef; 9178 continue; 9179 } 9180 } 9181 } 9182 9183 // OpenMP [2.14.1.1, Data-sharing Attribute Rules for Variables Referenced 9184 // in a Construct] 9185 // Variables with the predetermined data-sharing attributes may not be 9186 // listed in data-sharing attributes clauses, except for the cases 9187 // listed below. For these exceptions only, listing a predetermined 9188 // variable in a data-sharing attribute clause is allowed and overrides 9189 // the variable's predetermined data-sharing attributes. 9190 // OpenMP [2.14.3.6, Restrictions, p.3] 9191 // Any number of reduction clauses can be specified on the directive, 9192 // but a list item can appear only once in the reduction clauses for that 9193 // directive. 9194 DSAStackTy::DSAVarData DVar; 9195 DVar = DSAStack->getTopDSA(D, false); 9196 if (DVar.CKind == OMPC_reduction) { 9197 Diag(ELoc, diag::err_omp_once_referenced) 9198 << getOpenMPClauseName(OMPC_reduction); 9199 if (DVar.RefExpr) 9200 Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_referenced); 9201 } else if (DVar.CKind != OMPC_unknown) { 9202 Diag(ELoc, diag::err_omp_wrong_dsa) 9203 << getOpenMPClauseName(DVar.CKind) 9204 << getOpenMPClauseName(OMPC_reduction); 9205 ReportOriginalDSA(*this, DSAStack, D, DVar); 9206 continue; 9207 } 9208 9209 // OpenMP [2.14.3.6, Restrictions, p.1] 9210 // A list item that appears in a reduction clause of a worksharing 9211 // construct must be shared in the parallel regions to which any of the 9212 // worksharing regions arising from the worksharing construct bind. 9213 OpenMPDirectiveKind CurrDir = DSAStack->getCurrentDirective(); 9214 if (isOpenMPWorksharingDirective(CurrDir) && 9215 !isOpenMPParallelDirective(CurrDir)) { 9216 DVar = DSAStack->getImplicitDSA(D, true); 9217 if (DVar.CKind != OMPC_shared) { 9218 Diag(ELoc, diag::err_omp_required_access) 9219 << getOpenMPClauseName(OMPC_reduction) 9220 << getOpenMPClauseName(OMPC_shared); 9221 ReportOriginalDSA(*this, DSAStack, D, DVar); 9222 continue; 9223 } 9224 } 9225 9226 // Try to find 'declare reduction' corresponding construct before using 9227 // builtin/overloaded operators. 9228 CXXCastPath BasePath; 9229 ExprResult DeclareReductionRef = buildDeclareReductionRef( 9230 *this, ELoc, ERange, DSAStack->getCurScope(), ReductionIdScopeSpec, 9231 ReductionId, Type, BasePath, IR == ER ? nullptr : *IR); 9232 if (DeclareReductionRef.isInvalid()) 9233 continue; 9234 if (CurContext->isDependentContext() && 9235 (DeclareReductionRef.isUnset() || 9236 isa<UnresolvedLookupExpr>(DeclareReductionRef.get()))) { 9237 Vars.push_back(RefExpr); 9238 Privates.push_back(nullptr); 9239 LHSs.push_back(nullptr); 9240 RHSs.push_back(nullptr); 9241 ReductionOps.push_back(DeclareReductionRef.get()); 9242 continue; 9243 } 9244 if (BOK == BO_Comma && DeclareReductionRef.isUnset()) { 9245 // Not allowed reduction identifier is found. 9246 Diag(ReductionId.getLocStart(), 9247 diag::err_omp_unknown_reduction_identifier) 9248 << Type << ReductionIdRange; 9249 continue; 9250 } 9251 9252 // OpenMP [2.14.3.6, reduction clause, Restrictions] 9253 // The type of a list item that appears in a reduction clause must be valid 9254 // for the reduction-identifier. For a max or min reduction in C, the type 9255 // of the list item must be an allowed arithmetic data type: char, int, 9256 // float, double, or _Bool, possibly modified with long, short, signed, or 9257 // unsigned. For a max or min reduction in C++, the type of the list item 9258 // must be an allowed arithmetic data type: char, wchar_t, int, float, 9259 // double, or bool, possibly modified with long, short, signed, or unsigned. 9260 if (DeclareReductionRef.isUnset()) { 9261 if ((BOK == BO_GT || BOK == BO_LT) && 9262 !(Type->isScalarType() || 9263 (getLangOpts().CPlusPlus && Type->isArithmeticType()))) { 9264 Diag(ELoc, diag::err_omp_clause_not_arithmetic_type_arg) 9265 << getLangOpts().CPlusPlus; 9266 if (!ASE && !OASE) { 9267 bool IsDecl = !VD || 9268 VD->isThisDeclarationADefinition(Context) == 9269 VarDecl::DeclarationOnly; 9270 Diag(D->getLocation(), 9271 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 9272 << D; 9273 } 9274 continue; 9275 } 9276 if ((BOK == BO_OrAssign || BOK == BO_AndAssign || BOK == BO_XorAssign) && 9277 !getLangOpts().CPlusPlus && Type->isFloatingType()) { 9278 Diag(ELoc, diag::err_omp_clause_floating_type_arg); 9279 if (!ASE && !OASE) { 9280 bool IsDecl = !VD || 9281 VD->isThisDeclarationADefinition(Context) == 9282 VarDecl::DeclarationOnly; 9283 Diag(D->getLocation(), 9284 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 9285 << D; 9286 } 9287 continue; 9288 } 9289 } 9290 9291 Type = Type.getNonLValueExprType(Context).getUnqualifiedType(); 9292 auto *LHSVD = buildVarDecl(*this, ELoc, Type, ".reduction.lhs", 9293 D->hasAttrs() ? &D->getAttrs() : nullptr); 9294 auto *RHSVD = buildVarDecl(*this, ELoc, Type, D->getName(), 9295 D->hasAttrs() ? &D->getAttrs() : nullptr); 9296 auto PrivateTy = Type; 9297 if (OASE || 9298 (!ASE && 9299 D->getType().getNonReferenceType()->isVariablyModifiedType())) { 9300 // For arays/array sections only: 9301 // Create pseudo array type for private copy. The size for this array will 9302 // be generated during codegen. 9303 // For array subscripts or single variables Private Ty is the same as Type 9304 // (type of the variable or single array element). 9305 PrivateTy = Context.getVariableArrayType( 9306 Type, new (Context) OpaqueValueExpr(SourceLocation(), 9307 Context.getSizeType(), VK_RValue), 9308 ArrayType::Normal, /*IndexTypeQuals=*/0, SourceRange()); 9309 } else if (!ASE && !OASE && 9310 Context.getAsArrayType(D->getType().getNonReferenceType())) 9311 PrivateTy = D->getType().getNonReferenceType(); 9312 // Private copy. 9313 auto *PrivateVD = buildVarDecl(*this, ELoc, PrivateTy, D->getName(), 9314 D->hasAttrs() ? &D->getAttrs() : nullptr); 9315 // Add initializer for private variable. 9316 Expr *Init = nullptr; 9317 auto *LHSDRE = buildDeclRefExpr(*this, LHSVD, Type, ELoc); 9318 auto *RHSDRE = buildDeclRefExpr(*this, RHSVD, Type, ELoc); 9319 if (DeclareReductionRef.isUsable()) { 9320 auto *DRDRef = DeclareReductionRef.getAs<DeclRefExpr>(); 9321 auto *DRD = cast<OMPDeclareReductionDecl>(DRDRef->getDecl()); 9322 if (DRD->getInitializer()) { 9323 Init = DRDRef; 9324 RHSVD->setInit(DRDRef); 9325 RHSVD->setInitStyle(VarDecl::CallInit); 9326 } 9327 } else { 9328 switch (BOK) { 9329 case BO_Add: 9330 case BO_Xor: 9331 case BO_Or: 9332 case BO_LOr: 9333 // '+', '-', '^', '|', '||' reduction ops - initializer is '0'. 9334 if (Type->isScalarType() || Type->isAnyComplexType()) 9335 Init = ActOnIntegerConstant(ELoc, /*Val=*/0).get(); 9336 break; 9337 case BO_Mul: 9338 case BO_LAnd: 9339 if (Type->isScalarType() || Type->isAnyComplexType()) { 9340 // '*' and '&&' reduction ops - initializer is '1'. 9341 Init = ActOnIntegerConstant(ELoc, /*Val=*/1).get(); 9342 } 9343 break; 9344 case BO_And: { 9345 // '&' reduction op - initializer is '~0'. 9346 QualType OrigType = Type; 9347 if (auto *ComplexTy = OrigType->getAs<ComplexType>()) 9348 Type = ComplexTy->getElementType(); 9349 if (Type->isRealFloatingType()) { 9350 llvm::APFloat InitValue = 9351 llvm::APFloat::getAllOnesValue(Context.getTypeSize(Type), 9352 /*isIEEE=*/true); 9353 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true, 9354 Type, ELoc); 9355 } else if (Type->isScalarType()) { 9356 auto Size = Context.getTypeSize(Type); 9357 QualType IntTy = Context.getIntTypeForBitwidth(Size, /*Signed=*/0); 9358 llvm::APInt InitValue = llvm::APInt::getAllOnesValue(Size); 9359 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc); 9360 } 9361 if (Init && OrigType->isAnyComplexType()) { 9362 // Init = 0xFFFF + 0xFFFFi; 9363 auto *Im = new (Context) ImaginaryLiteral(Init, OrigType); 9364 Init = CreateBuiltinBinOp(ELoc, BO_Add, Init, Im).get(); 9365 } 9366 Type = OrigType; 9367 break; 9368 } 9369 case BO_LT: 9370 case BO_GT: { 9371 // 'min' reduction op - initializer is 'Largest representable number in 9372 // the reduction list item type'. 9373 // 'max' reduction op - initializer is 'Least representable number in 9374 // the reduction list item type'. 9375 if (Type->isIntegerType() || Type->isPointerType()) { 9376 bool IsSigned = Type->hasSignedIntegerRepresentation(); 9377 auto Size = Context.getTypeSize(Type); 9378 QualType IntTy = 9379 Context.getIntTypeForBitwidth(Size, /*Signed=*/IsSigned); 9380 llvm::APInt InitValue = 9381 (BOK != BO_LT) 9382 ? IsSigned ? llvm::APInt::getSignedMinValue(Size) 9383 : llvm::APInt::getMinValue(Size) 9384 : IsSigned ? llvm::APInt::getSignedMaxValue(Size) 9385 : llvm::APInt::getMaxValue(Size); 9386 Init = IntegerLiteral::Create(Context, InitValue, IntTy, ELoc); 9387 if (Type->isPointerType()) { 9388 // Cast to pointer type. 9389 auto CastExpr = BuildCStyleCastExpr( 9390 SourceLocation(), Context.getTrivialTypeSourceInfo(Type, ELoc), 9391 SourceLocation(), Init); 9392 if (CastExpr.isInvalid()) 9393 continue; 9394 Init = CastExpr.get(); 9395 } 9396 } else if (Type->isRealFloatingType()) { 9397 llvm::APFloat InitValue = llvm::APFloat::getLargest( 9398 Context.getFloatTypeSemantics(Type), BOK != BO_LT); 9399 Init = FloatingLiteral::Create(Context, InitValue, /*isexact=*/true, 9400 Type, ELoc); 9401 } 9402 break; 9403 } 9404 case BO_PtrMemD: 9405 case BO_PtrMemI: 9406 case BO_MulAssign: 9407 case BO_Div: 9408 case BO_Rem: 9409 case BO_Sub: 9410 case BO_Shl: 9411 case BO_Shr: 9412 case BO_LE: 9413 case BO_GE: 9414 case BO_EQ: 9415 case BO_NE: 9416 case BO_AndAssign: 9417 case BO_XorAssign: 9418 case BO_OrAssign: 9419 case BO_Assign: 9420 case BO_AddAssign: 9421 case BO_SubAssign: 9422 case BO_DivAssign: 9423 case BO_RemAssign: 9424 case BO_ShlAssign: 9425 case BO_ShrAssign: 9426 case BO_Comma: 9427 llvm_unreachable("Unexpected reduction operation"); 9428 } 9429 } 9430 if (Init && DeclareReductionRef.isUnset()) { 9431 AddInitializerToDecl(RHSVD, Init, /*DirectInit=*/false, 9432 /*TypeMayContainAuto=*/false); 9433 } else if (!Init) 9434 ActOnUninitializedDecl(RHSVD, /*TypeMayContainAuto=*/false); 9435 if (RHSVD->isInvalidDecl()) 9436 continue; 9437 if (!RHSVD->hasInit() && DeclareReductionRef.isUnset()) { 9438 Diag(ELoc, diag::err_omp_reduction_id_not_compatible) << Type 9439 << ReductionIdRange; 9440 bool IsDecl = 9441 !VD || 9442 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 9443 Diag(D->getLocation(), 9444 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 9445 << D; 9446 continue; 9447 } 9448 // Store initializer for single element in private copy. Will be used during 9449 // codegen. 9450 PrivateVD->setInit(RHSVD->getInit()); 9451 PrivateVD->setInitStyle(RHSVD->getInitStyle()); 9452 auto *PrivateDRE = buildDeclRefExpr(*this, PrivateVD, PrivateTy, ELoc); 9453 ExprResult ReductionOp; 9454 if (DeclareReductionRef.isUsable()) { 9455 QualType RedTy = DeclareReductionRef.get()->getType(); 9456 QualType PtrRedTy = Context.getPointerType(RedTy); 9457 ExprResult LHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, LHSDRE); 9458 ExprResult RHS = CreateBuiltinUnaryOp(ELoc, UO_AddrOf, RHSDRE); 9459 if (!BasePath.empty()) { 9460 LHS = DefaultLvalueConversion(LHS.get()); 9461 RHS = DefaultLvalueConversion(RHS.get()); 9462 LHS = ImplicitCastExpr::Create(Context, PtrRedTy, 9463 CK_UncheckedDerivedToBase, LHS.get(), 9464 &BasePath, LHS.get()->getValueKind()); 9465 RHS = ImplicitCastExpr::Create(Context, PtrRedTy, 9466 CK_UncheckedDerivedToBase, RHS.get(), 9467 &BasePath, RHS.get()->getValueKind()); 9468 } 9469 FunctionProtoType::ExtProtoInfo EPI; 9470 QualType Params[] = {PtrRedTy, PtrRedTy}; 9471 QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI); 9472 auto *OVE = new (Context) OpaqueValueExpr( 9473 ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary, 9474 DefaultLvalueConversion(DeclareReductionRef.get()).get()); 9475 Expr *Args[] = {LHS.get(), RHS.get()}; 9476 ReductionOp = new (Context) 9477 CallExpr(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc); 9478 } else { 9479 ReductionOp = BuildBinOp(DSAStack->getCurScope(), 9480 ReductionId.getLocStart(), BOK, LHSDRE, RHSDRE); 9481 if (ReductionOp.isUsable()) { 9482 if (BOK != BO_LT && BOK != BO_GT) { 9483 ReductionOp = 9484 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(), 9485 BO_Assign, LHSDRE, ReductionOp.get()); 9486 } else { 9487 auto *ConditionalOp = new (Context) ConditionalOperator( 9488 ReductionOp.get(), SourceLocation(), LHSDRE, SourceLocation(), 9489 RHSDRE, Type, VK_LValue, OK_Ordinary); 9490 ReductionOp = 9491 BuildBinOp(DSAStack->getCurScope(), ReductionId.getLocStart(), 9492 BO_Assign, LHSDRE, ConditionalOp); 9493 } 9494 ReductionOp = ActOnFinishFullExpr(ReductionOp.get()); 9495 } 9496 if (ReductionOp.isInvalid()) 9497 continue; 9498 } 9499 9500 DeclRefExpr *Ref = nullptr; 9501 Expr *VarsExpr = RefExpr->IgnoreParens(); 9502 if (!VD && !CurContext->isDependentContext()) { 9503 if (ASE || OASE) { 9504 TransformExprToCaptures RebuildToCapture(*this, D); 9505 VarsExpr = 9506 RebuildToCapture.TransformExpr(RefExpr->IgnoreParens()).get(); 9507 Ref = RebuildToCapture.getCapturedExpr(); 9508 } else { 9509 VarsExpr = Ref = 9510 buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false); 9511 } 9512 if (!IsOpenMPCapturedDecl(D)) { 9513 ExprCaptures.push_back(Ref->getDecl()); 9514 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) { 9515 ExprResult RefRes = DefaultLvalueConversion(Ref); 9516 if (!RefRes.isUsable()) 9517 continue; 9518 ExprResult PostUpdateRes = 9519 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, 9520 SimpleRefExpr, RefRes.get()); 9521 if (!PostUpdateRes.isUsable()) 9522 continue; 9523 ExprPostUpdates.push_back( 9524 IgnoredValueConversions(PostUpdateRes.get()).get()); 9525 } 9526 } 9527 } 9528 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_reduction, Ref); 9529 Vars.push_back(VarsExpr); 9530 Privates.push_back(PrivateDRE); 9531 LHSs.push_back(LHSDRE); 9532 RHSs.push_back(RHSDRE); 9533 ReductionOps.push_back(ReductionOp.get()); 9534 } 9535 9536 if (Vars.empty()) 9537 return nullptr; 9538 9539 return OMPReductionClause::Create( 9540 Context, StartLoc, LParenLoc, ColonLoc, EndLoc, Vars, 9541 ReductionIdScopeSpec.getWithLocInContext(Context), ReductionId, Privates, 9542 LHSs, RHSs, ReductionOps, buildPreInits(Context, ExprCaptures), 9543 buildPostUpdate(*this, ExprPostUpdates)); 9544 } 9545 9546 bool Sema::CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind, 9547 SourceLocation LinLoc) { 9548 if ((!LangOpts.CPlusPlus && LinKind != OMPC_LINEAR_val) || 9549 LinKind == OMPC_LINEAR_unknown) { 9550 Diag(LinLoc, diag::err_omp_wrong_linear_modifier) << LangOpts.CPlusPlus; 9551 return true; 9552 } 9553 return false; 9554 } 9555 9556 bool Sema::CheckOpenMPLinearDecl(ValueDecl *D, SourceLocation ELoc, 9557 OpenMPLinearClauseKind LinKind, 9558 QualType Type) { 9559 auto *VD = dyn_cast_or_null<VarDecl>(D); 9560 // A variable must not have an incomplete type or a reference type. 9561 if (RequireCompleteType(ELoc, Type, diag::err_omp_linear_incomplete_type)) 9562 return true; 9563 if ((LinKind == OMPC_LINEAR_uval || LinKind == OMPC_LINEAR_ref) && 9564 !Type->isReferenceType()) { 9565 Diag(ELoc, diag::err_omp_wrong_linear_modifier_non_reference) 9566 << Type << getOpenMPSimpleClauseTypeName(OMPC_linear, LinKind); 9567 return true; 9568 } 9569 Type = Type.getNonReferenceType(); 9570 9571 // A list item must not be const-qualified. 9572 if (Type.isConstant(Context)) { 9573 Diag(ELoc, diag::err_omp_const_variable) 9574 << getOpenMPClauseName(OMPC_linear); 9575 if (D) { 9576 bool IsDecl = 9577 !VD || 9578 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 9579 Diag(D->getLocation(), 9580 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 9581 << D; 9582 } 9583 return true; 9584 } 9585 9586 // A list item must be of integral or pointer type. 9587 Type = Type.getUnqualifiedType().getCanonicalType(); 9588 const auto *Ty = Type.getTypePtrOrNull(); 9589 if (!Ty || (!Ty->isDependentType() && !Ty->isIntegralType(Context) && 9590 !Ty->isPointerType())) { 9591 Diag(ELoc, diag::err_omp_linear_expected_int_or_ptr) << Type; 9592 if (D) { 9593 bool IsDecl = 9594 !VD || 9595 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 9596 Diag(D->getLocation(), 9597 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 9598 << D; 9599 } 9600 return true; 9601 } 9602 return false; 9603 } 9604 9605 OMPClause *Sema::ActOnOpenMPLinearClause( 9606 ArrayRef<Expr *> VarList, Expr *Step, SourceLocation StartLoc, 9607 SourceLocation LParenLoc, OpenMPLinearClauseKind LinKind, 9608 SourceLocation LinLoc, SourceLocation ColonLoc, SourceLocation EndLoc) { 9609 SmallVector<Expr *, 8> Vars; 9610 SmallVector<Expr *, 8> Privates; 9611 SmallVector<Expr *, 8> Inits; 9612 SmallVector<Decl *, 4> ExprCaptures; 9613 SmallVector<Expr *, 4> ExprPostUpdates; 9614 if (CheckOpenMPLinearModifier(LinKind, LinLoc)) 9615 LinKind = OMPC_LINEAR_val; 9616 for (auto &RefExpr : VarList) { 9617 assert(RefExpr && "NULL expr in OpenMP linear clause."); 9618 SourceLocation ELoc; 9619 SourceRange ERange; 9620 Expr *SimpleRefExpr = RefExpr; 9621 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange, 9622 /*AllowArraySection=*/false); 9623 if (Res.second) { 9624 // It will be analyzed later. 9625 Vars.push_back(RefExpr); 9626 Privates.push_back(nullptr); 9627 Inits.push_back(nullptr); 9628 } 9629 ValueDecl *D = Res.first; 9630 if (!D) 9631 continue; 9632 9633 QualType Type = D->getType(); 9634 auto *VD = dyn_cast<VarDecl>(D); 9635 9636 // OpenMP [2.14.3.7, linear clause] 9637 // A list-item cannot appear in more than one linear clause. 9638 // A list-item that appears in a linear clause cannot appear in any 9639 // other data-sharing attribute clause. 9640 DSAStackTy::DSAVarData DVar = DSAStack->getTopDSA(D, false); 9641 if (DVar.RefExpr) { 9642 Diag(ELoc, diag::err_omp_wrong_dsa) << getOpenMPClauseName(DVar.CKind) 9643 << getOpenMPClauseName(OMPC_linear); 9644 ReportOriginalDSA(*this, DSAStack, D, DVar); 9645 continue; 9646 } 9647 9648 if (CheckOpenMPLinearDecl(D, ELoc, LinKind, Type)) 9649 continue; 9650 Type = Type.getNonReferenceType().getUnqualifiedType().getCanonicalType(); 9651 9652 // Build private copy of original var. 9653 auto *Private = buildVarDecl(*this, ELoc, Type, D->getName(), 9654 D->hasAttrs() ? &D->getAttrs() : nullptr); 9655 auto *PrivateRef = buildDeclRefExpr(*this, Private, Type, ELoc); 9656 // Build var to save initial value. 9657 VarDecl *Init = buildVarDecl(*this, ELoc, Type, ".linear.start"); 9658 Expr *InitExpr; 9659 DeclRefExpr *Ref = nullptr; 9660 if (!VD && !CurContext->isDependentContext()) { 9661 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false); 9662 if (!IsOpenMPCapturedDecl(D)) { 9663 ExprCaptures.push_back(Ref->getDecl()); 9664 if (Ref->getDecl()->hasAttr<OMPCaptureNoInitAttr>()) { 9665 ExprResult RefRes = DefaultLvalueConversion(Ref); 9666 if (!RefRes.isUsable()) 9667 continue; 9668 ExprResult PostUpdateRes = 9669 BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, 9670 SimpleRefExpr, RefRes.get()); 9671 if (!PostUpdateRes.isUsable()) 9672 continue; 9673 ExprPostUpdates.push_back( 9674 IgnoredValueConversions(PostUpdateRes.get()).get()); 9675 } 9676 } 9677 } 9678 if (LinKind == OMPC_LINEAR_uval) 9679 InitExpr = VD ? VD->getInit() : SimpleRefExpr; 9680 else 9681 InitExpr = VD ? SimpleRefExpr : Ref; 9682 AddInitializerToDecl(Init, DefaultLvalueConversion(InitExpr).get(), 9683 /*DirectInit=*/false, /*TypeMayContainAuto=*/false); 9684 auto InitRef = buildDeclRefExpr(*this, Init, Type, ELoc); 9685 9686 DSAStack->addDSA(D, RefExpr->IgnoreParens(), OMPC_linear, Ref); 9687 Vars.push_back((VD || CurContext->isDependentContext()) 9688 ? RefExpr->IgnoreParens() 9689 : Ref); 9690 Privates.push_back(PrivateRef); 9691 Inits.push_back(InitRef); 9692 } 9693 9694 if (Vars.empty()) 9695 return nullptr; 9696 9697 Expr *StepExpr = Step; 9698 Expr *CalcStepExpr = nullptr; 9699 if (Step && !Step->isValueDependent() && !Step->isTypeDependent() && 9700 !Step->isInstantiationDependent() && 9701 !Step->containsUnexpandedParameterPack()) { 9702 SourceLocation StepLoc = Step->getLocStart(); 9703 ExprResult Val = PerformOpenMPImplicitIntegerConversion(StepLoc, Step); 9704 if (Val.isInvalid()) 9705 return nullptr; 9706 StepExpr = Val.get(); 9707 9708 // Build var to save the step value. 9709 VarDecl *SaveVar = 9710 buildVarDecl(*this, StepLoc, StepExpr->getType(), ".linear.step"); 9711 ExprResult SaveRef = 9712 buildDeclRefExpr(*this, SaveVar, StepExpr->getType(), StepLoc); 9713 ExprResult CalcStep = 9714 BuildBinOp(CurScope, StepLoc, BO_Assign, SaveRef.get(), StepExpr); 9715 CalcStep = ActOnFinishFullExpr(CalcStep.get()); 9716 9717 // Warn about zero linear step (it would be probably better specified as 9718 // making corresponding variables 'const'). 9719 llvm::APSInt Result; 9720 bool IsConstant = StepExpr->isIntegerConstantExpr(Result, Context); 9721 if (IsConstant && !Result.isNegative() && !Result.isStrictlyPositive()) 9722 Diag(StepLoc, diag::warn_omp_linear_step_zero) << Vars[0] 9723 << (Vars.size() > 1); 9724 if (!IsConstant && CalcStep.isUsable()) { 9725 // Calculate the step beforehand instead of doing this on each iteration. 9726 // (This is not used if the number of iterations may be kfold-ed). 9727 CalcStepExpr = CalcStep.get(); 9728 } 9729 } 9730 9731 return OMPLinearClause::Create(Context, StartLoc, LParenLoc, LinKind, LinLoc, 9732 ColonLoc, EndLoc, Vars, Privates, Inits, 9733 StepExpr, CalcStepExpr, 9734 buildPreInits(Context, ExprCaptures), 9735 buildPostUpdate(*this, ExprPostUpdates)); 9736 } 9737 9738 static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV, 9739 Expr *NumIterations, Sema &SemaRef, 9740 Scope *S, DSAStackTy *Stack) { 9741 // Walk the vars and build update/final expressions for the CodeGen. 9742 SmallVector<Expr *, 8> Updates; 9743 SmallVector<Expr *, 8> Finals; 9744 Expr *Step = Clause.getStep(); 9745 Expr *CalcStep = Clause.getCalcStep(); 9746 // OpenMP [2.14.3.7, linear clause] 9747 // If linear-step is not specified it is assumed to be 1. 9748 if (Step == nullptr) 9749 Step = SemaRef.ActOnIntegerConstant(SourceLocation(), 1).get(); 9750 else if (CalcStep) { 9751 Step = cast<BinaryOperator>(CalcStep)->getLHS(); 9752 } 9753 bool HasErrors = false; 9754 auto CurInit = Clause.inits().begin(); 9755 auto CurPrivate = Clause.privates().begin(); 9756 auto LinKind = Clause.getModifier(); 9757 for (auto &RefExpr : Clause.varlists()) { 9758 SourceLocation ELoc; 9759 SourceRange ERange; 9760 Expr *SimpleRefExpr = RefExpr; 9761 auto Res = getPrivateItem(SemaRef, SimpleRefExpr, ELoc, ERange, 9762 /*AllowArraySection=*/false); 9763 ValueDecl *D = Res.first; 9764 if (Res.second || !D) { 9765 Updates.push_back(nullptr); 9766 Finals.push_back(nullptr); 9767 HasErrors = true; 9768 continue; 9769 } 9770 if (auto *CED = dyn_cast<OMPCapturedExprDecl>(D)) { 9771 D = cast<MemberExpr>(CED->getInit()->IgnoreParenImpCasts()) 9772 ->getMemberDecl(); 9773 } 9774 auto &&Info = Stack->isLoopControlVariable(D); 9775 Expr *InitExpr = *CurInit; 9776 9777 // Build privatized reference to the current linear var. 9778 auto DE = cast<DeclRefExpr>(SimpleRefExpr); 9779 Expr *CapturedRef; 9780 if (LinKind == OMPC_LINEAR_uval) 9781 CapturedRef = cast<VarDecl>(DE->getDecl())->getInit(); 9782 else 9783 CapturedRef = 9784 buildDeclRefExpr(SemaRef, cast<VarDecl>(DE->getDecl()), 9785 DE->getType().getUnqualifiedType(), DE->getExprLoc(), 9786 /*RefersToCapture=*/true); 9787 9788 // Build update: Var = InitExpr + IV * Step 9789 ExprResult Update; 9790 if (!Info.first) { 9791 Update = 9792 BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), *CurPrivate, 9793 InitExpr, IV, Step, /* Subtract */ false); 9794 } else 9795 Update = *CurPrivate; 9796 Update = SemaRef.ActOnFinishFullExpr(Update.get(), DE->getLocStart(), 9797 /*DiscardedValue=*/true); 9798 9799 // Build final: Var = InitExpr + NumIterations * Step 9800 ExprResult Final; 9801 if (!Info.first) { 9802 Final = BuildCounterUpdate(SemaRef, S, RefExpr->getExprLoc(), CapturedRef, 9803 InitExpr, NumIterations, Step, 9804 /* Subtract */ false); 9805 } else 9806 Final = *CurPrivate; 9807 Final = SemaRef.ActOnFinishFullExpr(Final.get(), DE->getLocStart(), 9808 /*DiscardedValue=*/true); 9809 9810 if (!Update.isUsable() || !Final.isUsable()) { 9811 Updates.push_back(nullptr); 9812 Finals.push_back(nullptr); 9813 HasErrors = true; 9814 } else { 9815 Updates.push_back(Update.get()); 9816 Finals.push_back(Final.get()); 9817 } 9818 ++CurInit; 9819 ++CurPrivate; 9820 } 9821 Clause.setUpdates(Updates); 9822 Clause.setFinals(Finals); 9823 return HasErrors; 9824 } 9825 9826 OMPClause *Sema::ActOnOpenMPAlignedClause( 9827 ArrayRef<Expr *> VarList, Expr *Alignment, SourceLocation StartLoc, 9828 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc) { 9829 9830 SmallVector<Expr *, 8> Vars; 9831 for (auto &RefExpr : VarList) { 9832 assert(RefExpr && "NULL expr in OpenMP linear clause."); 9833 SourceLocation ELoc; 9834 SourceRange ERange; 9835 Expr *SimpleRefExpr = RefExpr; 9836 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange, 9837 /*AllowArraySection=*/false); 9838 if (Res.second) { 9839 // It will be analyzed later. 9840 Vars.push_back(RefExpr); 9841 } 9842 ValueDecl *D = Res.first; 9843 if (!D) 9844 continue; 9845 9846 QualType QType = D->getType(); 9847 auto *VD = dyn_cast<VarDecl>(D); 9848 9849 // OpenMP [2.8.1, simd construct, Restrictions] 9850 // The type of list items appearing in the aligned clause must be 9851 // array, pointer, reference to array, or reference to pointer. 9852 QType = QType.getNonReferenceType().getUnqualifiedType().getCanonicalType(); 9853 const Type *Ty = QType.getTypePtrOrNull(); 9854 if (!Ty || (!Ty->isArrayType() && !Ty->isPointerType())) { 9855 Diag(ELoc, diag::err_omp_aligned_expected_array_or_ptr) 9856 << QType << getLangOpts().CPlusPlus << ERange; 9857 bool IsDecl = 9858 !VD || 9859 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 9860 Diag(D->getLocation(), 9861 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 9862 << D; 9863 continue; 9864 } 9865 9866 // OpenMP [2.8.1, simd construct, Restrictions] 9867 // A list-item cannot appear in more than one aligned clause. 9868 if (Expr *PrevRef = DSAStack->addUniqueAligned(D, SimpleRefExpr)) { 9869 Diag(ELoc, diag::err_omp_aligned_twice) << 0 << ERange; 9870 Diag(PrevRef->getExprLoc(), diag::note_omp_explicit_dsa) 9871 << getOpenMPClauseName(OMPC_aligned); 9872 continue; 9873 } 9874 9875 DeclRefExpr *Ref = nullptr; 9876 if (!VD && IsOpenMPCapturedDecl(D)) 9877 Ref = buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/true); 9878 Vars.push_back(DefaultFunctionArrayConversion( 9879 (VD || !Ref) ? RefExpr->IgnoreParens() : Ref) 9880 .get()); 9881 } 9882 9883 // OpenMP [2.8.1, simd construct, Description] 9884 // The parameter of the aligned clause, alignment, must be a constant 9885 // positive integer expression. 9886 // If no optional parameter is specified, implementation-defined default 9887 // alignments for SIMD instructions on the target platforms are assumed. 9888 if (Alignment != nullptr) { 9889 ExprResult AlignResult = 9890 VerifyPositiveIntegerConstantInClause(Alignment, OMPC_aligned); 9891 if (AlignResult.isInvalid()) 9892 return nullptr; 9893 Alignment = AlignResult.get(); 9894 } 9895 if (Vars.empty()) 9896 return nullptr; 9897 9898 return OMPAlignedClause::Create(Context, StartLoc, LParenLoc, ColonLoc, 9899 EndLoc, Vars, Alignment); 9900 } 9901 9902 OMPClause *Sema::ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList, 9903 SourceLocation StartLoc, 9904 SourceLocation LParenLoc, 9905 SourceLocation EndLoc) { 9906 SmallVector<Expr *, 8> Vars; 9907 SmallVector<Expr *, 8> SrcExprs; 9908 SmallVector<Expr *, 8> DstExprs; 9909 SmallVector<Expr *, 8> AssignmentOps; 9910 for (auto &RefExpr : VarList) { 9911 assert(RefExpr && "NULL expr in OpenMP copyin clause."); 9912 if (isa<DependentScopeDeclRefExpr>(RefExpr)) { 9913 // It will be analyzed later. 9914 Vars.push_back(RefExpr); 9915 SrcExprs.push_back(nullptr); 9916 DstExprs.push_back(nullptr); 9917 AssignmentOps.push_back(nullptr); 9918 continue; 9919 } 9920 9921 SourceLocation ELoc = RefExpr->getExprLoc(); 9922 // OpenMP [2.1, C/C++] 9923 // A list item is a variable name. 9924 // OpenMP [2.14.4.1, Restrictions, p.1] 9925 // A list item that appears in a copyin clause must be threadprivate. 9926 DeclRefExpr *DE = dyn_cast<DeclRefExpr>(RefExpr); 9927 if (!DE || !isa<VarDecl>(DE->getDecl())) { 9928 Diag(ELoc, diag::err_omp_expected_var_name_member_expr) 9929 << 0 << RefExpr->getSourceRange(); 9930 continue; 9931 } 9932 9933 Decl *D = DE->getDecl(); 9934 VarDecl *VD = cast<VarDecl>(D); 9935 9936 QualType Type = VD->getType(); 9937 if (Type->isDependentType() || Type->isInstantiationDependentType()) { 9938 // It will be analyzed later. 9939 Vars.push_back(DE); 9940 SrcExprs.push_back(nullptr); 9941 DstExprs.push_back(nullptr); 9942 AssignmentOps.push_back(nullptr); 9943 continue; 9944 } 9945 9946 // OpenMP [2.14.4.1, Restrictions, C/C++, p.1] 9947 // A list item that appears in a copyin clause must be threadprivate. 9948 if (!DSAStack->isThreadPrivate(VD)) { 9949 Diag(ELoc, diag::err_omp_required_access) 9950 << getOpenMPClauseName(OMPC_copyin) 9951 << getOpenMPDirectiveName(OMPD_threadprivate); 9952 continue; 9953 } 9954 9955 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2] 9956 // A variable of class type (or array thereof) that appears in a 9957 // copyin clause requires an accessible, unambiguous copy assignment 9958 // operator for the class type. 9959 auto ElemType = Context.getBaseElementType(Type).getNonReferenceType(); 9960 auto *SrcVD = 9961 buildVarDecl(*this, DE->getLocStart(), ElemType.getUnqualifiedType(), 9962 ".copyin.src", VD->hasAttrs() ? &VD->getAttrs() : nullptr); 9963 auto *PseudoSrcExpr = buildDeclRefExpr( 9964 *this, SrcVD, ElemType.getUnqualifiedType(), DE->getExprLoc()); 9965 auto *DstVD = 9966 buildVarDecl(*this, DE->getLocStart(), ElemType, ".copyin.dst", 9967 VD->hasAttrs() ? &VD->getAttrs() : nullptr); 9968 auto *PseudoDstExpr = 9969 buildDeclRefExpr(*this, DstVD, ElemType, DE->getExprLoc()); 9970 // For arrays generate assignment operation for single element and replace 9971 // it by the original array element in CodeGen. 9972 auto AssignmentOp = BuildBinOp(/*S=*/nullptr, DE->getExprLoc(), BO_Assign, 9973 PseudoDstExpr, PseudoSrcExpr); 9974 if (AssignmentOp.isInvalid()) 9975 continue; 9976 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), DE->getExprLoc(), 9977 /*DiscardedValue=*/true); 9978 if (AssignmentOp.isInvalid()) 9979 continue; 9980 9981 DSAStack->addDSA(VD, DE, OMPC_copyin); 9982 Vars.push_back(DE); 9983 SrcExprs.push_back(PseudoSrcExpr); 9984 DstExprs.push_back(PseudoDstExpr); 9985 AssignmentOps.push_back(AssignmentOp.get()); 9986 } 9987 9988 if (Vars.empty()) 9989 return nullptr; 9990 9991 return OMPCopyinClause::Create(Context, StartLoc, LParenLoc, EndLoc, Vars, 9992 SrcExprs, DstExprs, AssignmentOps); 9993 } 9994 9995 OMPClause *Sema::ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList, 9996 SourceLocation StartLoc, 9997 SourceLocation LParenLoc, 9998 SourceLocation EndLoc) { 9999 SmallVector<Expr *, 8> Vars; 10000 SmallVector<Expr *, 8> SrcExprs; 10001 SmallVector<Expr *, 8> DstExprs; 10002 SmallVector<Expr *, 8> AssignmentOps; 10003 for (auto &RefExpr : VarList) { 10004 assert(RefExpr && "NULL expr in OpenMP linear clause."); 10005 SourceLocation ELoc; 10006 SourceRange ERange; 10007 Expr *SimpleRefExpr = RefExpr; 10008 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange, 10009 /*AllowArraySection=*/false); 10010 if (Res.second) { 10011 // It will be analyzed later. 10012 Vars.push_back(RefExpr); 10013 SrcExprs.push_back(nullptr); 10014 DstExprs.push_back(nullptr); 10015 AssignmentOps.push_back(nullptr); 10016 } 10017 ValueDecl *D = Res.first; 10018 if (!D) 10019 continue; 10020 10021 QualType Type = D->getType(); 10022 auto *VD = dyn_cast<VarDecl>(D); 10023 10024 // OpenMP [2.14.4.2, Restrictions, p.2] 10025 // A list item that appears in a copyprivate clause may not appear in a 10026 // private or firstprivate clause on the single construct. 10027 if (!VD || !DSAStack->isThreadPrivate(VD)) { 10028 auto DVar = DSAStack->getTopDSA(D, false); 10029 if (DVar.CKind != OMPC_unknown && DVar.CKind != OMPC_copyprivate && 10030 DVar.RefExpr) { 10031 Diag(ELoc, diag::err_omp_wrong_dsa) 10032 << getOpenMPClauseName(DVar.CKind) 10033 << getOpenMPClauseName(OMPC_copyprivate); 10034 ReportOriginalDSA(*this, DSAStack, D, DVar); 10035 continue; 10036 } 10037 10038 // OpenMP [2.11.4.2, Restrictions, p.1] 10039 // All list items that appear in a copyprivate clause must be either 10040 // threadprivate or private in the enclosing context. 10041 if (DVar.CKind == OMPC_unknown) { 10042 DVar = DSAStack->getImplicitDSA(D, false); 10043 if (DVar.CKind == OMPC_shared) { 10044 Diag(ELoc, diag::err_omp_required_access) 10045 << getOpenMPClauseName(OMPC_copyprivate) 10046 << "threadprivate or private in the enclosing context"; 10047 ReportOriginalDSA(*this, DSAStack, D, DVar); 10048 continue; 10049 } 10050 } 10051 } 10052 10053 // Variably modified types are not supported. 10054 if (!Type->isAnyPointerType() && Type->isVariablyModifiedType()) { 10055 Diag(ELoc, diag::err_omp_variably_modified_type_not_supported) 10056 << getOpenMPClauseName(OMPC_copyprivate) << Type 10057 << getOpenMPDirectiveName(DSAStack->getCurrentDirective()); 10058 bool IsDecl = 10059 !VD || 10060 VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly; 10061 Diag(D->getLocation(), 10062 IsDecl ? diag::note_previous_decl : diag::note_defined_here) 10063 << D; 10064 continue; 10065 } 10066 10067 // OpenMP [2.14.4.1, Restrictions, C/C++, p.2] 10068 // A variable of class type (or array thereof) that appears in a 10069 // copyin clause requires an accessible, unambiguous copy assignment 10070 // operator for the class type. 10071 Type = Context.getBaseElementType(Type.getNonReferenceType()) 10072 .getUnqualifiedType(); 10073 auto *SrcVD = 10074 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.src", 10075 D->hasAttrs() ? &D->getAttrs() : nullptr); 10076 auto *PseudoSrcExpr = buildDeclRefExpr(*this, SrcVD, Type, ELoc); 10077 auto *DstVD = 10078 buildVarDecl(*this, RefExpr->getLocStart(), Type, ".copyprivate.dst", 10079 D->hasAttrs() ? &D->getAttrs() : nullptr); 10080 auto *PseudoDstExpr = 10081 buildDeclRefExpr(*this, DstVD, Type, ELoc); 10082 auto AssignmentOp = BuildBinOp(DSAStack->getCurScope(), ELoc, BO_Assign, 10083 PseudoDstExpr, PseudoSrcExpr); 10084 if (AssignmentOp.isInvalid()) 10085 continue; 10086 AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), ELoc, 10087 /*DiscardedValue=*/true); 10088 if (AssignmentOp.isInvalid()) 10089 continue; 10090 10091 // No need to mark vars as copyprivate, they are already threadprivate or 10092 // implicitly private. 10093 assert(VD || IsOpenMPCapturedDecl(D)); 10094 Vars.push_back( 10095 VD ? RefExpr->IgnoreParens() 10096 : buildCapture(*this, D, SimpleRefExpr, /*WithInit=*/false)); 10097 SrcExprs.push_back(PseudoSrcExpr); 10098 DstExprs.push_back(PseudoDstExpr); 10099 AssignmentOps.push_back(AssignmentOp.get()); 10100 } 10101 10102 if (Vars.empty()) 10103 return nullptr; 10104 10105 return OMPCopyprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc, 10106 Vars, SrcExprs, DstExprs, AssignmentOps); 10107 } 10108 10109 OMPClause *Sema::ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList, 10110 SourceLocation StartLoc, 10111 SourceLocation LParenLoc, 10112 SourceLocation EndLoc) { 10113 if (VarList.empty()) 10114 return nullptr; 10115 10116 return OMPFlushClause::Create(Context, StartLoc, LParenLoc, EndLoc, VarList); 10117 } 10118 10119 OMPClause * 10120 Sema::ActOnOpenMPDependClause(OpenMPDependClauseKind DepKind, 10121 SourceLocation DepLoc, SourceLocation ColonLoc, 10122 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 10123 SourceLocation LParenLoc, SourceLocation EndLoc) { 10124 if (DSAStack->getCurrentDirective() == OMPD_ordered && 10125 DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink) { 10126 Diag(DepLoc, diag::err_omp_unexpected_clause_value) 10127 << "'source' or 'sink'" << getOpenMPClauseName(OMPC_depend); 10128 return nullptr; 10129 } 10130 if (DSAStack->getCurrentDirective() != OMPD_ordered && 10131 (DepKind == OMPC_DEPEND_unknown || DepKind == OMPC_DEPEND_source || 10132 DepKind == OMPC_DEPEND_sink)) { 10133 unsigned Except[] = {OMPC_DEPEND_source, OMPC_DEPEND_sink}; 10134 Diag(DepLoc, diag::err_omp_unexpected_clause_value) 10135 << getListOfPossibleValues(OMPC_depend, /*First=*/0, 10136 /*Last=*/OMPC_DEPEND_unknown, Except) 10137 << getOpenMPClauseName(OMPC_depend); 10138 return nullptr; 10139 } 10140 SmallVector<Expr *, 8> Vars; 10141 DSAStackTy::OperatorOffsetTy OpsOffs; 10142 llvm::APSInt DepCounter(/*BitWidth=*/32); 10143 llvm::APSInt TotalDepCount(/*BitWidth=*/32); 10144 if (DepKind == OMPC_DEPEND_sink) { 10145 if (auto *OrderedCountExpr = DSAStack->getParentOrderedRegionParam()) { 10146 TotalDepCount = OrderedCountExpr->EvaluateKnownConstInt(Context); 10147 TotalDepCount.setIsUnsigned(/*Val=*/true); 10148 } 10149 } 10150 if ((DepKind != OMPC_DEPEND_sink && DepKind != OMPC_DEPEND_source) || 10151 DSAStack->getParentOrderedRegionParam()) { 10152 for (auto &RefExpr : VarList) { 10153 assert(RefExpr && "NULL expr in OpenMP shared clause."); 10154 if (isa<DependentScopeDeclRefExpr>(RefExpr)) { 10155 // It will be analyzed later. 10156 Vars.push_back(RefExpr); 10157 continue; 10158 } 10159 10160 SourceLocation ELoc = RefExpr->getExprLoc(); 10161 auto *SimpleExpr = RefExpr->IgnoreParenCasts(); 10162 if (DepKind == OMPC_DEPEND_sink) { 10163 if (DepCounter >= TotalDepCount) { 10164 Diag(ELoc, diag::err_omp_depend_sink_unexpected_expr); 10165 continue; 10166 } 10167 ++DepCounter; 10168 // OpenMP [2.13.9, Summary] 10169 // depend(dependence-type : vec), where dependence-type is: 10170 // 'sink' and where vec is the iteration vector, which has the form: 10171 // x1 [+- d1], x2 [+- d2 ], . . . , xn [+- dn] 10172 // where n is the value specified by the ordered clause in the loop 10173 // directive, xi denotes the loop iteration variable of the i-th nested 10174 // loop associated with the loop directive, and di is a constant 10175 // non-negative integer. 10176 if (CurContext->isDependentContext()) { 10177 // It will be analyzed later. 10178 Vars.push_back(RefExpr); 10179 continue; 10180 } 10181 SimpleExpr = SimpleExpr->IgnoreImplicit(); 10182 OverloadedOperatorKind OOK = OO_None; 10183 SourceLocation OOLoc; 10184 Expr *LHS = SimpleExpr; 10185 Expr *RHS = nullptr; 10186 if (auto *BO = dyn_cast<BinaryOperator>(SimpleExpr)) { 10187 OOK = BinaryOperator::getOverloadedOperator(BO->getOpcode()); 10188 OOLoc = BO->getOperatorLoc(); 10189 LHS = BO->getLHS()->IgnoreParenImpCasts(); 10190 RHS = BO->getRHS()->IgnoreParenImpCasts(); 10191 } else if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(SimpleExpr)) { 10192 OOK = OCE->getOperator(); 10193 OOLoc = OCE->getOperatorLoc(); 10194 LHS = OCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts(); 10195 RHS = OCE->getArg(/*Arg=*/1)->IgnoreParenImpCasts(); 10196 } else if (auto *MCE = dyn_cast<CXXMemberCallExpr>(SimpleExpr)) { 10197 OOK = MCE->getMethodDecl() 10198 ->getNameInfo() 10199 .getName() 10200 .getCXXOverloadedOperator(); 10201 OOLoc = MCE->getCallee()->getExprLoc(); 10202 LHS = MCE->getImplicitObjectArgument()->IgnoreParenImpCasts(); 10203 RHS = MCE->getArg(/*Arg=*/0)->IgnoreParenImpCasts(); 10204 } 10205 SourceLocation ELoc; 10206 SourceRange ERange; 10207 auto Res = getPrivateItem(*this, LHS, ELoc, ERange, 10208 /*AllowArraySection=*/false); 10209 if (Res.second) { 10210 // It will be analyzed later. 10211 Vars.push_back(RefExpr); 10212 } 10213 ValueDecl *D = Res.first; 10214 if (!D) 10215 continue; 10216 10217 if (OOK != OO_Plus && OOK != OO_Minus && (RHS || OOK != OO_None)) { 10218 Diag(OOLoc, diag::err_omp_depend_sink_expected_plus_minus); 10219 continue; 10220 } 10221 if (RHS) { 10222 ExprResult RHSRes = VerifyPositiveIntegerConstantInClause( 10223 RHS, OMPC_depend, /*StrictlyPositive=*/false); 10224 if (RHSRes.isInvalid()) 10225 continue; 10226 } 10227 if (!CurContext->isDependentContext() && 10228 DSAStack->getParentOrderedRegionParam() && 10229 DepCounter != DSAStack->isParentLoopControlVariable(D).first) { 10230 Diag(ELoc, diag::err_omp_depend_sink_expected_loop_iteration) 10231 << DSAStack->getParentLoopControlVariable( 10232 DepCounter.getZExtValue()); 10233 continue; 10234 } 10235 OpsOffs.push_back({RHS, OOK}); 10236 } else { 10237 // OpenMP [2.11.1.1, Restrictions, p.3] 10238 // A variable that is part of another variable (such as a field of a 10239 // structure) but is not an array element or an array section cannot 10240 // appear in a depend clause. 10241 auto *DE = dyn_cast<DeclRefExpr>(SimpleExpr); 10242 auto *ASE = dyn_cast<ArraySubscriptExpr>(SimpleExpr); 10243 auto *OASE = dyn_cast<OMPArraySectionExpr>(SimpleExpr); 10244 if (!RefExpr->IgnoreParenImpCasts()->isLValue() || 10245 (!ASE && !DE && !OASE) || (DE && !isa<VarDecl>(DE->getDecl())) || 10246 (ASE && 10247 !ASE->getBase() 10248 ->getType() 10249 .getNonReferenceType() 10250 ->isPointerType() && 10251 !ASE->getBase()->getType().getNonReferenceType()->isArrayType())) { 10252 Diag(ELoc, diag::err_omp_expected_var_name_member_expr_or_array_item) 10253 << 0 << RefExpr->getSourceRange(); 10254 continue; 10255 } 10256 } 10257 Vars.push_back(RefExpr->IgnoreParenImpCasts()); 10258 } 10259 10260 if (!CurContext->isDependentContext() && DepKind == OMPC_DEPEND_sink && 10261 TotalDepCount > VarList.size() && 10262 DSAStack->getParentOrderedRegionParam()) { 10263 Diag(EndLoc, diag::err_omp_depend_sink_expected_loop_iteration) 10264 << DSAStack->getParentLoopControlVariable(VarList.size() + 1); 10265 } 10266 if (DepKind != OMPC_DEPEND_source && DepKind != OMPC_DEPEND_sink && 10267 Vars.empty()) 10268 return nullptr; 10269 } 10270 auto *C = OMPDependClause::Create(Context, StartLoc, LParenLoc, EndLoc, 10271 DepKind, DepLoc, ColonLoc, Vars); 10272 if (DepKind == OMPC_DEPEND_sink || DepKind == OMPC_DEPEND_source) 10273 DSAStack->addDoacrossDependClause(C, OpsOffs); 10274 return C; 10275 } 10276 10277 OMPClause *Sema::ActOnOpenMPDeviceClause(Expr *Device, SourceLocation StartLoc, 10278 SourceLocation LParenLoc, 10279 SourceLocation EndLoc) { 10280 Expr *ValExpr = Device; 10281 10282 // OpenMP [2.9.1, Restrictions] 10283 // The device expression must evaluate to a non-negative integer value. 10284 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_device, 10285 /*StrictlyPositive=*/false)) 10286 return nullptr; 10287 10288 return new (Context) OMPDeviceClause(ValExpr, StartLoc, LParenLoc, EndLoc); 10289 } 10290 10291 static bool IsCXXRecordForMappable(Sema &SemaRef, SourceLocation Loc, 10292 DSAStackTy *Stack, CXXRecordDecl *RD) { 10293 if (!RD || RD->isInvalidDecl()) 10294 return true; 10295 10296 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) 10297 if (auto *CTD = CTSD->getSpecializedTemplate()) 10298 RD = CTD->getTemplatedDecl(); 10299 auto QTy = SemaRef.Context.getRecordType(RD); 10300 if (RD->isDynamicClass()) { 10301 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; 10302 SemaRef.Diag(RD->getLocation(), diag::note_omp_polymorphic_in_target); 10303 return false; 10304 } 10305 auto *DC = RD; 10306 bool IsCorrect = true; 10307 for (auto *I : DC->decls()) { 10308 if (I) { 10309 if (auto *MD = dyn_cast<CXXMethodDecl>(I)) { 10310 if (MD->isStatic()) { 10311 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; 10312 SemaRef.Diag(MD->getLocation(), 10313 diag::note_omp_static_member_in_target); 10314 IsCorrect = false; 10315 } 10316 } else if (auto *VD = dyn_cast<VarDecl>(I)) { 10317 if (VD->isStaticDataMember()) { 10318 SemaRef.Diag(Loc, diag::err_omp_not_mappable_type) << QTy; 10319 SemaRef.Diag(VD->getLocation(), 10320 diag::note_omp_static_member_in_target); 10321 IsCorrect = false; 10322 } 10323 } 10324 } 10325 } 10326 10327 for (auto &I : RD->bases()) { 10328 if (!IsCXXRecordForMappable(SemaRef, I.getLocStart(), Stack, 10329 I.getType()->getAsCXXRecordDecl())) 10330 IsCorrect = false; 10331 } 10332 return IsCorrect; 10333 } 10334 10335 static bool CheckTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef, 10336 DSAStackTy *Stack, QualType QTy) { 10337 NamedDecl *ND; 10338 if (QTy->isIncompleteType(&ND)) { 10339 SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR; 10340 return false; 10341 } else if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(ND)) { 10342 if (!RD->isInvalidDecl() && 10343 !IsCXXRecordForMappable(SemaRef, SL, Stack, RD)) 10344 return false; 10345 } 10346 return true; 10347 } 10348 10349 /// \brief Return true if it can be proven that the provided array expression 10350 /// (array section or array subscript) does NOT specify the whole size of the 10351 /// array whose base type is \a BaseQTy. 10352 static bool CheckArrayExpressionDoesNotReferToWholeSize(Sema &SemaRef, 10353 const Expr *E, 10354 QualType BaseQTy) { 10355 auto *OASE = dyn_cast<OMPArraySectionExpr>(E); 10356 10357 // If this is an array subscript, it refers to the whole size if the size of 10358 // the dimension is constant and equals 1. Also, an array section assumes the 10359 // format of an array subscript if no colon is used. 10360 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid())) { 10361 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr())) 10362 return ATy->getSize().getSExtValue() != 1; 10363 // Size can't be evaluated statically. 10364 return false; 10365 } 10366 10367 assert(OASE && "Expecting array section if not an array subscript."); 10368 auto *LowerBound = OASE->getLowerBound(); 10369 auto *Length = OASE->getLength(); 10370 10371 // If there is a lower bound that does not evaluates to zero, we are not 10372 // convering the whole dimension. 10373 if (LowerBound) { 10374 llvm::APSInt ConstLowerBound; 10375 if (!LowerBound->EvaluateAsInt(ConstLowerBound, SemaRef.getASTContext())) 10376 return false; // Can't get the integer value as a constant. 10377 if (ConstLowerBound.getSExtValue()) 10378 return true; 10379 } 10380 10381 // If we don't have a length we covering the whole dimension. 10382 if (!Length) 10383 return false; 10384 10385 // If the base is a pointer, we don't have a way to get the size of the 10386 // pointee. 10387 if (BaseQTy->isPointerType()) 10388 return false; 10389 10390 // We can only check if the length is the same as the size of the dimension 10391 // if we have a constant array. 10392 auto *CATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr()); 10393 if (!CATy) 10394 return false; 10395 10396 llvm::APSInt ConstLength; 10397 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext())) 10398 return false; // Can't get the integer value as a constant. 10399 10400 return CATy->getSize().getSExtValue() != ConstLength.getSExtValue(); 10401 } 10402 10403 // Return true if it can be proven that the provided array expression (array 10404 // section or array subscript) does NOT specify a single element of the array 10405 // whose base type is \a BaseQTy. 10406 static bool CheckArrayExpressionDoesNotReferToUnitySize(Sema &SemaRef, 10407 const Expr *E, 10408 QualType BaseQTy) { 10409 auto *OASE = dyn_cast<OMPArraySectionExpr>(E); 10410 10411 // An array subscript always refer to a single element. Also, an array section 10412 // assumes the format of an array subscript if no colon is used. 10413 if (isa<ArraySubscriptExpr>(E) || (OASE && OASE->getColonLoc().isInvalid())) 10414 return false; 10415 10416 assert(OASE && "Expecting array section if not an array subscript."); 10417 auto *Length = OASE->getLength(); 10418 10419 // If we don't have a length we have to check if the array has unitary size 10420 // for this dimension. Also, we should always expect a length if the base type 10421 // is pointer. 10422 if (!Length) { 10423 if (auto *ATy = dyn_cast<ConstantArrayType>(BaseQTy.getTypePtr())) 10424 return ATy->getSize().getSExtValue() != 1; 10425 // We cannot assume anything. 10426 return false; 10427 } 10428 10429 // Check if the length evaluates to 1. 10430 llvm::APSInt ConstLength; 10431 if (!Length->EvaluateAsInt(ConstLength, SemaRef.getASTContext())) 10432 return false; // Can't get the integer value as a constant. 10433 10434 return ConstLength.getSExtValue() != 1; 10435 } 10436 10437 // Return the expression of the base of the mappable expression or null if it 10438 // cannot be determined and do all the necessary checks to see if the expression 10439 // is valid as a standalone mappable expression. In the process, record all the 10440 // components of the expression. 10441 static Expr *CheckMapClauseExpressionBase( 10442 Sema &SemaRef, Expr *E, 10443 OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents, 10444 OpenMPClauseKind CKind) { 10445 SourceLocation ELoc = E->getExprLoc(); 10446 SourceRange ERange = E->getSourceRange(); 10447 10448 // The base of elements of list in a map clause have to be either: 10449 // - a reference to variable or field. 10450 // - a member expression. 10451 // - an array expression. 10452 // 10453 // E.g. if we have the expression 'r.S.Arr[:12]', we want to retrieve the 10454 // reference to 'r'. 10455 // 10456 // If we have: 10457 // 10458 // struct SS { 10459 // Bla S; 10460 // foo() { 10461 // #pragma omp target map (S.Arr[:12]); 10462 // } 10463 // } 10464 // 10465 // We want to retrieve the member expression 'this->S'; 10466 10467 Expr *RelevantExpr = nullptr; 10468 10469 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.2] 10470 // If a list item is an array section, it must specify contiguous storage. 10471 // 10472 // For this restriction it is sufficient that we make sure only references 10473 // to variables or fields and array expressions, and that no array sections 10474 // exist except in the rightmost expression (unless they cover the whole 10475 // dimension of the array). E.g. these would be invalid: 10476 // 10477 // r.ArrS[3:5].Arr[6:7] 10478 // 10479 // r.ArrS[3:5].x 10480 // 10481 // but these would be valid: 10482 // r.ArrS[3].Arr[6:7] 10483 // 10484 // r.ArrS[3].x 10485 10486 bool AllowUnitySizeArraySection = true; 10487 bool AllowWholeSizeArraySection = true; 10488 10489 while (!RelevantExpr) { 10490 E = E->IgnoreParenImpCasts(); 10491 10492 if (auto *CurE = dyn_cast<DeclRefExpr>(E)) { 10493 if (!isa<VarDecl>(CurE->getDecl())) 10494 break; 10495 10496 RelevantExpr = CurE; 10497 10498 // If we got a reference to a declaration, we should not expect any array 10499 // section before that. 10500 AllowUnitySizeArraySection = false; 10501 AllowWholeSizeArraySection = false; 10502 10503 // Record the component. 10504 CurComponents.push_back(OMPClauseMappableExprCommon::MappableComponent( 10505 CurE, CurE->getDecl())); 10506 continue; 10507 } 10508 10509 if (auto *CurE = dyn_cast<MemberExpr>(E)) { 10510 auto *BaseE = CurE->getBase()->IgnoreParenImpCasts(); 10511 10512 if (isa<CXXThisExpr>(BaseE)) 10513 // We found a base expression: this->Val. 10514 RelevantExpr = CurE; 10515 else 10516 E = BaseE; 10517 10518 if (!isa<FieldDecl>(CurE->getMemberDecl())) { 10519 SemaRef.Diag(ELoc, diag::err_omp_expected_access_to_data_field) 10520 << CurE->getSourceRange(); 10521 break; 10522 } 10523 10524 auto *FD = cast<FieldDecl>(CurE->getMemberDecl()); 10525 10526 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.3] 10527 // A bit-field cannot appear in a map clause. 10528 // 10529 if (FD->isBitField()) { 10530 SemaRef.Diag(ELoc, diag::err_omp_bit_fields_forbidden_in_clause) 10531 << CurE->getSourceRange() << getOpenMPClauseName(CKind); 10532 break; 10533 } 10534 10535 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1] 10536 // If the type of a list item is a reference to a type T then the type 10537 // will be considered to be T for all purposes of this clause. 10538 QualType CurType = BaseE->getType().getNonReferenceType(); 10539 10540 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.2] 10541 // A list item cannot be a variable that is a member of a structure with 10542 // a union type. 10543 // 10544 if (auto *RT = CurType->getAs<RecordType>()) 10545 if (RT->isUnionType()) { 10546 SemaRef.Diag(ELoc, diag::err_omp_union_type_not_allowed) 10547 << CurE->getSourceRange(); 10548 break; 10549 } 10550 10551 // If we got a member expression, we should not expect any array section 10552 // before that: 10553 // 10554 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.7] 10555 // If a list item is an element of a structure, only the rightmost symbol 10556 // of the variable reference can be an array section. 10557 // 10558 AllowUnitySizeArraySection = false; 10559 AllowWholeSizeArraySection = false; 10560 10561 // Record the component. 10562 CurComponents.push_back( 10563 OMPClauseMappableExprCommon::MappableComponent(CurE, FD)); 10564 continue; 10565 } 10566 10567 if (auto *CurE = dyn_cast<ArraySubscriptExpr>(E)) { 10568 E = CurE->getBase()->IgnoreParenImpCasts(); 10569 10570 if (!E->getType()->isAnyPointerType() && !E->getType()->isArrayType()) { 10571 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name) 10572 << 0 << CurE->getSourceRange(); 10573 break; 10574 } 10575 10576 // If we got an array subscript that express the whole dimension we 10577 // can have any array expressions before. If it only expressing part of 10578 // the dimension, we can only have unitary-size array expressions. 10579 if (CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE, 10580 E->getType())) 10581 AllowWholeSizeArraySection = false; 10582 10583 // Record the component - we don't have any declaration associated. 10584 CurComponents.push_back( 10585 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr)); 10586 continue; 10587 } 10588 10589 if (auto *CurE = dyn_cast<OMPArraySectionExpr>(E)) { 10590 E = CurE->getBase()->IgnoreParenImpCasts(); 10591 10592 auto CurType = 10593 OMPArraySectionExpr::getBaseOriginalType(E).getCanonicalType(); 10594 10595 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1] 10596 // If the type of a list item is a reference to a type T then the type 10597 // will be considered to be T for all purposes of this clause. 10598 if (CurType->isReferenceType()) 10599 CurType = CurType->getPointeeType(); 10600 10601 bool IsPointer = CurType->isAnyPointerType(); 10602 10603 if (!IsPointer && !CurType->isArrayType()) { 10604 SemaRef.Diag(ELoc, diag::err_omp_expected_base_var_name) 10605 << 0 << CurE->getSourceRange(); 10606 break; 10607 } 10608 10609 bool NotWhole = 10610 CheckArrayExpressionDoesNotReferToWholeSize(SemaRef, CurE, CurType); 10611 bool NotUnity = 10612 CheckArrayExpressionDoesNotReferToUnitySize(SemaRef, CurE, CurType); 10613 10614 if (AllowWholeSizeArraySection && AllowUnitySizeArraySection) { 10615 // Any array section is currently allowed. 10616 // 10617 // If this array section refers to the whole dimension we can still 10618 // accept other array sections before this one, except if the base is a 10619 // pointer. Otherwise, only unitary sections are accepted. 10620 if (NotWhole || IsPointer) 10621 AllowWholeSizeArraySection = false; 10622 } else if ((AllowUnitySizeArraySection && NotUnity) || 10623 (AllowWholeSizeArraySection && NotWhole)) { 10624 // A unity or whole array section is not allowed and that is not 10625 // compatible with the properties of the current array section. 10626 SemaRef.Diag( 10627 ELoc, diag::err_array_section_does_not_specify_contiguous_storage) 10628 << CurE->getSourceRange(); 10629 break; 10630 } 10631 10632 // Record the component - we don't have any declaration associated. 10633 CurComponents.push_back( 10634 OMPClauseMappableExprCommon::MappableComponent(CurE, nullptr)); 10635 continue; 10636 } 10637 10638 // If nothing else worked, this is not a valid map clause expression. 10639 SemaRef.Diag(ELoc, 10640 diag::err_omp_expected_named_var_member_or_array_expression) 10641 << ERange; 10642 break; 10643 } 10644 10645 return RelevantExpr; 10646 } 10647 10648 // Return true if expression E associated with value VD has conflicts with other 10649 // map information. 10650 static bool CheckMapConflicts( 10651 Sema &SemaRef, DSAStackTy *DSAS, ValueDecl *VD, Expr *E, 10652 bool CurrentRegionOnly, 10653 OMPClauseMappableExprCommon::MappableExprComponentListRef CurComponents, 10654 OpenMPClauseKind CKind) { 10655 assert(VD && E); 10656 SourceLocation ELoc = E->getExprLoc(); 10657 SourceRange ERange = E->getSourceRange(); 10658 10659 // In order to easily check the conflicts we need to match each component of 10660 // the expression under test with the components of the expressions that are 10661 // already in the stack. 10662 10663 assert(!CurComponents.empty() && "Map clause expression with no components!"); 10664 assert(CurComponents.back().getAssociatedDeclaration() == VD && 10665 "Map clause expression with unexpected base!"); 10666 10667 // Variables to help detecting enclosing problems in data environment nests. 10668 bool IsEnclosedByDataEnvironmentExpr = false; 10669 const Expr *EnclosingExpr = nullptr; 10670 10671 bool FoundError = DSAS->checkMappableExprComponentListsForDecl( 10672 VD, CurrentRegionOnly, 10673 [&](OMPClauseMappableExprCommon::MappableExprComponentListRef 10674 StackComponents) -> bool { 10675 10676 assert(!StackComponents.empty() && 10677 "Map clause expression with no components!"); 10678 assert(StackComponents.back().getAssociatedDeclaration() == VD && 10679 "Map clause expression with unexpected base!"); 10680 10681 // The whole expression in the stack. 10682 auto *RE = StackComponents.front().getAssociatedExpression(); 10683 10684 // Expressions must start from the same base. Here we detect at which 10685 // point both expressions diverge from each other and see if we can 10686 // detect if the memory referred to both expressions is contiguous and 10687 // do not overlap. 10688 auto CI = CurComponents.rbegin(); 10689 auto CE = CurComponents.rend(); 10690 auto SI = StackComponents.rbegin(); 10691 auto SE = StackComponents.rend(); 10692 for (; CI != CE && SI != SE; ++CI, ++SI) { 10693 10694 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.3] 10695 // At most one list item can be an array item derived from a given 10696 // variable in map clauses of the same construct. 10697 if (CurrentRegionOnly && 10698 (isa<ArraySubscriptExpr>(CI->getAssociatedExpression()) || 10699 isa<OMPArraySectionExpr>(CI->getAssociatedExpression())) && 10700 (isa<ArraySubscriptExpr>(SI->getAssociatedExpression()) || 10701 isa<OMPArraySectionExpr>(SI->getAssociatedExpression()))) { 10702 SemaRef.Diag(CI->getAssociatedExpression()->getExprLoc(), 10703 diag::err_omp_multiple_array_items_in_map_clause) 10704 << CI->getAssociatedExpression()->getSourceRange(); 10705 SemaRef.Diag(SI->getAssociatedExpression()->getExprLoc(), 10706 diag::note_used_here) 10707 << SI->getAssociatedExpression()->getSourceRange(); 10708 return true; 10709 } 10710 10711 // Do both expressions have the same kind? 10712 if (CI->getAssociatedExpression()->getStmtClass() != 10713 SI->getAssociatedExpression()->getStmtClass()) 10714 break; 10715 10716 // Are we dealing with different variables/fields? 10717 if (CI->getAssociatedDeclaration() != SI->getAssociatedDeclaration()) 10718 break; 10719 } 10720 10721 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4] 10722 // List items of map clauses in the same construct must not share 10723 // original storage. 10724 // 10725 // If the expressions are exactly the same or one is a subset of the 10726 // other, it means they are sharing storage. 10727 if (CI == CE && SI == SE) { 10728 if (CurrentRegionOnly) { 10729 if (CKind == OMPC_map) 10730 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange; 10731 else { 10732 assert(CKind == OMPC_to || CKind == OMPC_from); 10733 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update) 10734 << ERange; 10735 } 10736 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here) 10737 << RE->getSourceRange(); 10738 return true; 10739 } else { 10740 // If we find the same expression in the enclosing data environment, 10741 // that is legal. 10742 IsEnclosedByDataEnvironmentExpr = true; 10743 return false; 10744 } 10745 } 10746 10747 QualType DerivedType = 10748 std::prev(CI)->getAssociatedDeclaration()->getType(); 10749 SourceLocation DerivedLoc = 10750 std::prev(CI)->getAssociatedExpression()->getExprLoc(); 10751 10752 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1] 10753 // If the type of a list item is a reference to a type T then the type 10754 // will be considered to be T for all purposes of this clause. 10755 DerivedType = DerivedType.getNonReferenceType(); 10756 10757 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.1] 10758 // A variable for which the type is pointer and an array section 10759 // derived from that variable must not appear as list items of map 10760 // clauses of the same construct. 10761 // 10762 // Also, cover one of the cases in: 10763 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5] 10764 // If any part of the original storage of a list item has corresponding 10765 // storage in the device data environment, all of the original storage 10766 // must have corresponding storage in the device data environment. 10767 // 10768 if (DerivedType->isAnyPointerType()) { 10769 if (CI == CE || SI == SE) { 10770 SemaRef.Diag( 10771 DerivedLoc, 10772 diag::err_omp_pointer_mapped_along_with_derived_section) 10773 << DerivedLoc; 10774 } else { 10775 assert(CI != CE && SI != SE); 10776 SemaRef.Diag(DerivedLoc, diag::err_omp_same_pointer_derreferenced) 10777 << DerivedLoc; 10778 } 10779 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here) 10780 << RE->getSourceRange(); 10781 return true; 10782 } 10783 10784 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.4] 10785 // List items of map clauses in the same construct must not share 10786 // original storage. 10787 // 10788 // An expression is a subset of the other. 10789 if (CurrentRegionOnly && (CI == CE || SI == SE)) { 10790 if (CKind == OMPC_map) 10791 SemaRef.Diag(ELoc, diag::err_omp_map_shared_storage) << ERange; 10792 else { 10793 assert(CKind == OMPC_to || CKind == OMPC_from); 10794 SemaRef.Diag(ELoc, diag::err_omp_once_referenced_in_target_update) 10795 << ERange; 10796 } 10797 SemaRef.Diag(RE->getExprLoc(), diag::note_used_here) 10798 << RE->getSourceRange(); 10799 return true; 10800 } 10801 10802 // The current expression uses the same base as other expression in the 10803 // data environment but does not contain it completely. 10804 if (!CurrentRegionOnly && SI != SE) 10805 EnclosingExpr = RE; 10806 10807 // The current expression is a subset of the expression in the data 10808 // environment. 10809 IsEnclosedByDataEnvironmentExpr |= 10810 (!CurrentRegionOnly && CI != CE && SI == SE); 10811 10812 return false; 10813 }); 10814 10815 if (CurrentRegionOnly) 10816 return FoundError; 10817 10818 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.5] 10819 // If any part of the original storage of a list item has corresponding 10820 // storage in the device data environment, all of the original storage must 10821 // have corresponding storage in the device data environment. 10822 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.6] 10823 // If a list item is an element of a structure, and a different element of 10824 // the structure has a corresponding list item in the device data environment 10825 // prior to a task encountering the construct associated with the map clause, 10826 // then the list item must also have a corresponding list item in the device 10827 // data environment prior to the task encountering the construct. 10828 // 10829 if (EnclosingExpr && !IsEnclosedByDataEnvironmentExpr) { 10830 SemaRef.Diag(ELoc, 10831 diag::err_omp_original_storage_is_shared_and_does_not_contain) 10832 << ERange; 10833 SemaRef.Diag(EnclosingExpr->getExprLoc(), diag::note_used_here) 10834 << EnclosingExpr->getSourceRange(); 10835 return true; 10836 } 10837 10838 return FoundError; 10839 } 10840 10841 namespace { 10842 // Utility struct that gathers all the related lists associated with a mappable 10843 // expression. 10844 struct MappableVarListInfo final { 10845 // The list of expressions. 10846 ArrayRef<Expr *> VarList; 10847 // The list of processed expressions. 10848 SmallVector<Expr *, 16> ProcessedVarList; 10849 // The mappble components for each expression. 10850 OMPClauseMappableExprCommon::MappableExprComponentLists VarComponents; 10851 // The base declaration of the variable. 10852 SmallVector<ValueDecl *, 16> VarBaseDeclarations; 10853 10854 MappableVarListInfo(ArrayRef<Expr *> VarList) : VarList(VarList) { 10855 // We have a list of components and base declarations for each entry in the 10856 // variable list. 10857 VarComponents.reserve(VarList.size()); 10858 VarBaseDeclarations.reserve(VarList.size()); 10859 } 10860 }; 10861 } 10862 10863 // Check the validity of the provided variable list for the provided clause kind 10864 // \a CKind. In the check process the valid expressions, and mappable expression 10865 // components and variables are extracted and used to fill \a Vars, 10866 // \a ClauseComponents, and \a ClauseBaseDeclarations. \a MapType and 10867 // \a IsMapTypeImplicit are expected to be valid if the clause kind is 'map'. 10868 static void 10869 checkMappableExpressionList(Sema &SemaRef, DSAStackTy *DSAS, 10870 OpenMPClauseKind CKind, MappableVarListInfo &MVLI, 10871 SourceLocation StartLoc, 10872 OpenMPMapClauseKind MapType = OMPC_MAP_unknown, 10873 bool IsMapTypeImplicit = false) { 10874 // We only expect mappable expressions in 'to', 'from', and 'map' clauses. 10875 assert((CKind == OMPC_map || CKind == OMPC_to || CKind == OMPC_from) && 10876 "Unexpected clause kind with mappable expressions!"); 10877 10878 // Keep track of the mappable components and base declarations in this clause. 10879 // Each entry in the list is going to have a list of components associated. We 10880 // record each set of the components so that we can build the clause later on. 10881 // In the end we should have the same amount of declarations and component 10882 // lists. 10883 10884 for (auto &RE : MVLI.VarList) { 10885 assert(RE && "Null expr in omp to/from/map clause"); 10886 SourceLocation ELoc = RE->getExprLoc(); 10887 10888 auto *VE = RE->IgnoreParenLValueCasts(); 10889 10890 if (VE->isValueDependent() || VE->isTypeDependent() || 10891 VE->isInstantiationDependent() || 10892 VE->containsUnexpandedParameterPack()) { 10893 // We can only analyze this information once the missing information is 10894 // resolved. 10895 MVLI.ProcessedVarList.push_back(RE); 10896 continue; 10897 } 10898 10899 auto *SimpleExpr = RE->IgnoreParenCasts(); 10900 10901 if (!RE->IgnoreParenImpCasts()->isLValue()) { 10902 SemaRef.Diag(ELoc, 10903 diag::err_omp_expected_named_var_member_or_array_expression) 10904 << RE->getSourceRange(); 10905 continue; 10906 } 10907 10908 OMPClauseMappableExprCommon::MappableExprComponentList CurComponents; 10909 ValueDecl *CurDeclaration = nullptr; 10910 10911 // Obtain the array or member expression bases if required. Also, fill the 10912 // components array with all the components identified in the process. 10913 auto *BE = 10914 CheckMapClauseExpressionBase(SemaRef, SimpleExpr, CurComponents, CKind); 10915 if (!BE) 10916 continue; 10917 10918 assert(!CurComponents.empty() && 10919 "Invalid mappable expression information."); 10920 10921 // For the following checks, we rely on the base declaration which is 10922 // expected to be associated with the last component. The declaration is 10923 // expected to be a variable or a field (if 'this' is being mapped). 10924 CurDeclaration = CurComponents.back().getAssociatedDeclaration(); 10925 assert(CurDeclaration && "Null decl on map clause."); 10926 assert( 10927 CurDeclaration->isCanonicalDecl() && 10928 "Expecting components to have associated only canonical declarations."); 10929 10930 auto *VD = dyn_cast<VarDecl>(CurDeclaration); 10931 auto *FD = dyn_cast<FieldDecl>(CurDeclaration); 10932 10933 assert((VD || FD) && "Only variables or fields are expected here!"); 10934 (void)FD; 10935 10936 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.10] 10937 // threadprivate variables cannot appear in a map clause. 10938 // OpenMP 4.5 [2.10.5, target update Construct] 10939 // threadprivate variables cannot appear in a from clause. 10940 if (VD && DSAS->isThreadPrivate(VD)) { 10941 auto DVar = DSAS->getTopDSA(VD, false); 10942 SemaRef.Diag(ELoc, diag::err_omp_threadprivate_in_clause) 10943 << getOpenMPClauseName(CKind); 10944 ReportOriginalDSA(SemaRef, DSAS, VD, DVar); 10945 continue; 10946 } 10947 10948 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9] 10949 // A list item cannot appear in both a map clause and a data-sharing 10950 // attribute clause on the same construct. 10951 10952 // Check conflicts with other map clause expressions. We check the conflicts 10953 // with the current construct separately from the enclosing data 10954 // environment, because the restrictions are different. We only have to 10955 // check conflicts across regions for the map clauses. 10956 if (CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr, 10957 /*CurrentRegionOnly=*/true, CurComponents, CKind)) 10958 break; 10959 if (CKind == OMPC_map && 10960 CheckMapConflicts(SemaRef, DSAS, CurDeclaration, SimpleExpr, 10961 /*CurrentRegionOnly=*/false, CurComponents, CKind)) 10962 break; 10963 10964 // OpenMP 4.5 [2.10.5, target update Construct] 10965 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C++, p.1] 10966 // If the type of a list item is a reference to a type T then the type will 10967 // be considered to be T for all purposes of this clause. 10968 QualType Type = CurDeclaration->getType().getNonReferenceType(); 10969 10970 // OpenMP 4.5 [2.10.5, target update Construct, Restrictions, p.4] 10971 // A list item in a to or from clause must have a mappable type. 10972 // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, p.9] 10973 // A list item must have a mappable type. 10974 if (!CheckTypeMappable(VE->getExprLoc(), VE->getSourceRange(), SemaRef, 10975 DSAS, Type)) 10976 continue; 10977 10978 if (CKind == OMPC_map) { 10979 // target enter data 10980 // OpenMP [2.10.2, Restrictions, p. 99] 10981 // A map-type must be specified in all map clauses and must be either 10982 // to or alloc. 10983 OpenMPDirectiveKind DKind = DSAS->getCurrentDirective(); 10984 if (DKind == OMPD_target_enter_data && 10985 !(MapType == OMPC_MAP_to || MapType == OMPC_MAP_alloc)) { 10986 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive) 10987 << (IsMapTypeImplicit ? 1 : 0) 10988 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType) 10989 << getOpenMPDirectiveName(DKind); 10990 continue; 10991 } 10992 10993 // target exit_data 10994 // OpenMP [2.10.3, Restrictions, p. 102] 10995 // A map-type must be specified in all map clauses and must be either 10996 // from, release, or delete. 10997 if (DKind == OMPD_target_exit_data && 10998 !(MapType == OMPC_MAP_from || MapType == OMPC_MAP_release || 10999 MapType == OMPC_MAP_delete)) { 11000 SemaRef.Diag(StartLoc, diag::err_omp_invalid_map_type_for_directive) 11001 << (IsMapTypeImplicit ? 1 : 0) 11002 << getOpenMPSimpleClauseTypeName(OMPC_map, MapType) 11003 << getOpenMPDirectiveName(DKind); 11004 continue; 11005 } 11006 11007 // OpenMP 4.5 [2.15.5.1, Restrictions, p.3] 11008 // A list item cannot appear in both a map clause and a data-sharing 11009 // attribute clause on the same construct 11010 if (DKind == OMPD_target && VD) { 11011 auto DVar = DSAS->getTopDSA(VD, false); 11012 if (isOpenMPPrivate(DVar.CKind)) { 11013 SemaRef.Diag(ELoc, diag::err_omp_variable_in_map_and_dsa) 11014 << getOpenMPClauseName(DVar.CKind) 11015 << getOpenMPDirectiveName(DSAS->getCurrentDirective()); 11016 ReportOriginalDSA(SemaRef, DSAS, CurDeclaration, DVar); 11017 continue; 11018 } 11019 } 11020 } 11021 11022 // Save the current expression. 11023 MVLI.ProcessedVarList.push_back(RE); 11024 11025 // Store the components in the stack so that they can be used to check 11026 // against other clauses later on. 11027 DSAS->addMappableExpressionComponents(CurDeclaration, CurComponents); 11028 11029 // Save the components and declaration to create the clause. For purposes of 11030 // the clause creation, any component list that has has base 'this' uses 11031 // null as base declaration. 11032 MVLI.VarComponents.resize(MVLI.VarComponents.size() + 1); 11033 MVLI.VarComponents.back().append(CurComponents.begin(), 11034 CurComponents.end()); 11035 MVLI.VarBaseDeclarations.push_back(isa<MemberExpr>(BE) ? nullptr 11036 : CurDeclaration); 11037 } 11038 } 11039 11040 OMPClause * 11041 Sema::ActOnOpenMPMapClause(OpenMPMapClauseKind MapTypeModifier, 11042 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, 11043 SourceLocation MapLoc, SourceLocation ColonLoc, 11044 ArrayRef<Expr *> VarList, SourceLocation StartLoc, 11045 SourceLocation LParenLoc, SourceLocation EndLoc) { 11046 MappableVarListInfo MVLI(VarList); 11047 checkMappableExpressionList(*this, DSAStack, OMPC_map, MVLI, StartLoc, 11048 MapType, IsMapTypeImplicit); 11049 11050 // We need to produce a map clause even if we don't have variables so that 11051 // other diagnostics related with non-existing map clauses are accurate. 11052 return OMPMapClause::Create(Context, StartLoc, LParenLoc, EndLoc, 11053 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations, 11054 MVLI.VarComponents, MapTypeModifier, MapType, 11055 IsMapTypeImplicit, MapLoc); 11056 } 11057 11058 QualType Sema::ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, 11059 TypeResult ParsedType) { 11060 assert(ParsedType.isUsable()); 11061 11062 QualType ReductionType = GetTypeFromParser(ParsedType.get()); 11063 if (ReductionType.isNull()) 11064 return QualType(); 11065 11066 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions, C\C++ 11067 // A type name in a declare reduction directive cannot be a function type, an 11068 // array type, a reference type, or a type qualified with const, volatile or 11069 // restrict. 11070 if (ReductionType.hasQualifiers()) { 11071 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 0; 11072 return QualType(); 11073 } 11074 11075 if (ReductionType->isFunctionType()) { 11076 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 1; 11077 return QualType(); 11078 } 11079 if (ReductionType->isReferenceType()) { 11080 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 2; 11081 return QualType(); 11082 } 11083 if (ReductionType->isArrayType()) { 11084 Diag(TyLoc, diag::err_omp_reduction_wrong_type) << 3; 11085 return QualType(); 11086 } 11087 return ReductionType; 11088 } 11089 11090 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveStart( 11091 Scope *S, DeclContext *DC, DeclarationName Name, 11092 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes, 11093 AccessSpecifier AS, Decl *PrevDeclInScope) { 11094 SmallVector<Decl *, 8> Decls; 11095 Decls.reserve(ReductionTypes.size()); 11096 11097 LookupResult Lookup(*this, Name, SourceLocation(), LookupOMPReductionName, 11098 ForRedeclaration); 11099 // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions 11100 // A reduction-identifier may not be re-declared in the current scope for the 11101 // same type or for a type that is compatible according to the base language 11102 // rules. 11103 llvm::DenseMap<QualType, SourceLocation> PreviousRedeclTypes; 11104 OMPDeclareReductionDecl *PrevDRD = nullptr; 11105 bool InCompoundScope = true; 11106 if (S != nullptr) { 11107 // Find previous declaration with the same name not referenced in other 11108 // declarations. 11109 FunctionScopeInfo *ParentFn = getEnclosingFunction(); 11110 InCompoundScope = 11111 (ParentFn != nullptr) && !ParentFn->CompoundScopes.empty(); 11112 LookupName(Lookup, S); 11113 FilterLookupForScope(Lookup, DC, S, /*ConsiderLinkage=*/false, 11114 /*AllowInlineNamespace=*/false); 11115 llvm::DenseMap<OMPDeclareReductionDecl *, bool> UsedAsPrevious; 11116 auto Filter = Lookup.makeFilter(); 11117 while (Filter.hasNext()) { 11118 auto *PrevDecl = cast<OMPDeclareReductionDecl>(Filter.next()); 11119 if (InCompoundScope) { 11120 auto I = UsedAsPrevious.find(PrevDecl); 11121 if (I == UsedAsPrevious.end()) 11122 UsedAsPrevious[PrevDecl] = false; 11123 if (auto *D = PrevDecl->getPrevDeclInScope()) 11124 UsedAsPrevious[D] = true; 11125 } 11126 PreviousRedeclTypes[PrevDecl->getType().getCanonicalType()] = 11127 PrevDecl->getLocation(); 11128 } 11129 Filter.done(); 11130 if (InCompoundScope) { 11131 for (auto &PrevData : UsedAsPrevious) { 11132 if (!PrevData.second) { 11133 PrevDRD = PrevData.first; 11134 break; 11135 } 11136 } 11137 } 11138 } else if (PrevDeclInScope != nullptr) { 11139 auto *PrevDRDInScope = PrevDRD = 11140 cast<OMPDeclareReductionDecl>(PrevDeclInScope); 11141 do { 11142 PreviousRedeclTypes[PrevDRDInScope->getType().getCanonicalType()] = 11143 PrevDRDInScope->getLocation(); 11144 PrevDRDInScope = PrevDRDInScope->getPrevDeclInScope(); 11145 } while (PrevDRDInScope != nullptr); 11146 } 11147 for (auto &TyData : ReductionTypes) { 11148 auto I = PreviousRedeclTypes.find(TyData.first.getCanonicalType()); 11149 bool Invalid = false; 11150 if (I != PreviousRedeclTypes.end()) { 11151 Diag(TyData.second, diag::err_omp_declare_reduction_redefinition) 11152 << TyData.first; 11153 Diag(I->second, diag::note_previous_definition); 11154 Invalid = true; 11155 } 11156 PreviousRedeclTypes[TyData.first.getCanonicalType()] = TyData.second; 11157 auto *DRD = OMPDeclareReductionDecl::Create(Context, DC, TyData.second, 11158 Name, TyData.first, PrevDRD); 11159 DC->addDecl(DRD); 11160 DRD->setAccess(AS); 11161 Decls.push_back(DRD); 11162 if (Invalid) 11163 DRD->setInvalidDecl(); 11164 else 11165 PrevDRD = DRD; 11166 } 11167 11168 return DeclGroupPtrTy::make( 11169 DeclGroupRef::Create(Context, Decls.begin(), Decls.size())); 11170 } 11171 11172 void Sema::ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D) { 11173 auto *DRD = cast<OMPDeclareReductionDecl>(D); 11174 11175 // Enter new function scope. 11176 PushFunctionScope(); 11177 getCurFunction()->setHasBranchProtectedScope(); 11178 getCurFunction()->setHasOMPDeclareReductionCombiner(); 11179 11180 if (S != nullptr) 11181 PushDeclContext(S, DRD); 11182 else 11183 CurContext = DRD; 11184 11185 PushExpressionEvaluationContext(PotentiallyEvaluated); 11186 11187 QualType ReductionType = DRD->getType(); 11188 // Create 'T* omp_parm;T omp_in;'. All references to 'omp_in' will 11189 // be replaced by '*omp_parm' during codegen. This required because 'omp_in' 11190 // uses semantics of argument handles by value, but it should be passed by 11191 // reference. C lang does not support references, so pass all parameters as 11192 // pointers. 11193 // Create 'T omp_in;' variable. 11194 auto *OmpInParm = 11195 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_in"); 11196 // Create 'T* omp_parm;T omp_out;'. All references to 'omp_out' will 11197 // be replaced by '*omp_parm' during codegen. This required because 'omp_out' 11198 // uses semantics of argument handles by value, but it should be passed by 11199 // reference. C lang does not support references, so pass all parameters as 11200 // pointers. 11201 // Create 'T omp_out;' variable. 11202 auto *OmpOutParm = 11203 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_out"); 11204 if (S != nullptr) { 11205 PushOnScopeChains(OmpInParm, S); 11206 PushOnScopeChains(OmpOutParm, S); 11207 } else { 11208 DRD->addDecl(OmpInParm); 11209 DRD->addDecl(OmpOutParm); 11210 } 11211 } 11212 11213 void Sema::ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner) { 11214 auto *DRD = cast<OMPDeclareReductionDecl>(D); 11215 DiscardCleanupsInEvaluationContext(); 11216 PopExpressionEvaluationContext(); 11217 11218 PopDeclContext(); 11219 PopFunctionScopeInfo(); 11220 11221 if (Combiner != nullptr) 11222 DRD->setCombiner(Combiner); 11223 else 11224 DRD->setInvalidDecl(); 11225 } 11226 11227 void Sema::ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D) { 11228 auto *DRD = cast<OMPDeclareReductionDecl>(D); 11229 11230 // Enter new function scope. 11231 PushFunctionScope(); 11232 getCurFunction()->setHasBranchProtectedScope(); 11233 11234 if (S != nullptr) 11235 PushDeclContext(S, DRD); 11236 else 11237 CurContext = DRD; 11238 11239 PushExpressionEvaluationContext(PotentiallyEvaluated); 11240 11241 QualType ReductionType = DRD->getType(); 11242 // Create 'T* omp_parm;T omp_priv;'. All references to 'omp_priv' will 11243 // be replaced by '*omp_parm' during codegen. This required because 'omp_priv' 11244 // uses semantics of argument handles by value, but it should be passed by 11245 // reference. C lang does not support references, so pass all parameters as 11246 // pointers. 11247 // Create 'T omp_priv;' variable. 11248 auto *OmpPrivParm = 11249 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_priv"); 11250 // Create 'T* omp_parm;T omp_orig;'. All references to 'omp_orig' will 11251 // be replaced by '*omp_parm' during codegen. This required because 'omp_orig' 11252 // uses semantics of argument handles by value, but it should be passed by 11253 // reference. C lang does not support references, so pass all parameters as 11254 // pointers. 11255 // Create 'T omp_orig;' variable. 11256 auto *OmpOrigParm = 11257 buildVarDecl(*this, D->getLocation(), ReductionType, "omp_orig"); 11258 if (S != nullptr) { 11259 PushOnScopeChains(OmpPrivParm, S); 11260 PushOnScopeChains(OmpOrigParm, S); 11261 } else { 11262 DRD->addDecl(OmpPrivParm); 11263 DRD->addDecl(OmpOrigParm); 11264 } 11265 } 11266 11267 void Sema::ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, 11268 Expr *Initializer) { 11269 auto *DRD = cast<OMPDeclareReductionDecl>(D); 11270 DiscardCleanupsInEvaluationContext(); 11271 PopExpressionEvaluationContext(); 11272 11273 PopDeclContext(); 11274 PopFunctionScopeInfo(); 11275 11276 if (Initializer != nullptr) 11277 DRD->setInitializer(Initializer); 11278 else 11279 DRD->setInvalidDecl(); 11280 } 11281 11282 Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareReductionDirectiveEnd( 11283 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid) { 11284 for (auto *D : DeclReductions.get()) { 11285 if (IsValid) { 11286 auto *DRD = cast<OMPDeclareReductionDecl>(D); 11287 if (S != nullptr) 11288 PushOnScopeChains(DRD, S, /*AddToContext=*/false); 11289 } else 11290 D->setInvalidDecl(); 11291 } 11292 return DeclReductions; 11293 } 11294 11295 OMPClause *Sema::ActOnOpenMPNumTeamsClause(Expr *NumTeams, 11296 SourceLocation StartLoc, 11297 SourceLocation LParenLoc, 11298 SourceLocation EndLoc) { 11299 Expr *ValExpr = NumTeams; 11300 11301 // OpenMP [teams Constrcut, Restrictions] 11302 // The num_teams expression must evaluate to a positive integer value. 11303 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_teams, 11304 /*StrictlyPositive=*/true)) 11305 return nullptr; 11306 11307 return new (Context) OMPNumTeamsClause(ValExpr, StartLoc, LParenLoc, EndLoc); 11308 } 11309 11310 OMPClause *Sema::ActOnOpenMPThreadLimitClause(Expr *ThreadLimit, 11311 SourceLocation StartLoc, 11312 SourceLocation LParenLoc, 11313 SourceLocation EndLoc) { 11314 Expr *ValExpr = ThreadLimit; 11315 11316 // OpenMP [teams Constrcut, Restrictions] 11317 // The thread_limit expression must evaluate to a positive integer value. 11318 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_thread_limit, 11319 /*StrictlyPositive=*/true)) 11320 return nullptr; 11321 11322 return new (Context) OMPThreadLimitClause(ValExpr, StartLoc, LParenLoc, 11323 EndLoc); 11324 } 11325 11326 OMPClause *Sema::ActOnOpenMPPriorityClause(Expr *Priority, 11327 SourceLocation StartLoc, 11328 SourceLocation LParenLoc, 11329 SourceLocation EndLoc) { 11330 Expr *ValExpr = Priority; 11331 11332 // OpenMP [2.9.1, task Constrcut] 11333 // The priority-value is a non-negative numerical scalar expression. 11334 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_priority, 11335 /*StrictlyPositive=*/false)) 11336 return nullptr; 11337 11338 return new (Context) OMPPriorityClause(ValExpr, StartLoc, LParenLoc, EndLoc); 11339 } 11340 11341 OMPClause *Sema::ActOnOpenMPGrainsizeClause(Expr *Grainsize, 11342 SourceLocation StartLoc, 11343 SourceLocation LParenLoc, 11344 SourceLocation EndLoc) { 11345 Expr *ValExpr = Grainsize; 11346 11347 // OpenMP [2.9.2, taskloop Constrcut] 11348 // The parameter of the grainsize clause must be a positive integer 11349 // expression. 11350 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_grainsize, 11351 /*StrictlyPositive=*/true)) 11352 return nullptr; 11353 11354 return new (Context) OMPGrainsizeClause(ValExpr, StartLoc, LParenLoc, EndLoc); 11355 } 11356 11357 OMPClause *Sema::ActOnOpenMPNumTasksClause(Expr *NumTasks, 11358 SourceLocation StartLoc, 11359 SourceLocation LParenLoc, 11360 SourceLocation EndLoc) { 11361 Expr *ValExpr = NumTasks; 11362 11363 // OpenMP [2.9.2, taskloop Constrcut] 11364 // The parameter of the num_tasks clause must be a positive integer 11365 // expression. 11366 if (!IsNonNegativeIntegerValue(ValExpr, *this, OMPC_num_tasks, 11367 /*StrictlyPositive=*/true)) 11368 return nullptr; 11369 11370 return new (Context) OMPNumTasksClause(ValExpr, StartLoc, LParenLoc, EndLoc); 11371 } 11372 11373 OMPClause *Sema::ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc, 11374 SourceLocation LParenLoc, 11375 SourceLocation EndLoc) { 11376 // OpenMP [2.13.2, critical construct, Description] 11377 // ... where hint-expression is an integer constant expression that evaluates 11378 // to a valid lock hint. 11379 ExprResult HintExpr = VerifyPositiveIntegerConstantInClause(Hint, OMPC_hint); 11380 if (HintExpr.isInvalid()) 11381 return nullptr; 11382 return new (Context) 11383 OMPHintClause(HintExpr.get(), StartLoc, LParenLoc, EndLoc); 11384 } 11385 11386 OMPClause *Sema::ActOnOpenMPDistScheduleClause( 11387 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc, 11388 SourceLocation LParenLoc, SourceLocation KindLoc, SourceLocation CommaLoc, 11389 SourceLocation EndLoc) { 11390 if (Kind == OMPC_DIST_SCHEDULE_unknown) { 11391 std::string Values; 11392 Values += "'"; 11393 Values += getOpenMPSimpleClauseTypeName(OMPC_dist_schedule, 0); 11394 Values += "'"; 11395 Diag(KindLoc, diag::err_omp_unexpected_clause_value) 11396 << Values << getOpenMPClauseName(OMPC_dist_schedule); 11397 return nullptr; 11398 } 11399 Expr *ValExpr = ChunkSize; 11400 Stmt *HelperValStmt = nullptr; 11401 if (ChunkSize) { 11402 if (!ChunkSize->isValueDependent() && !ChunkSize->isTypeDependent() && 11403 !ChunkSize->isInstantiationDependent() && 11404 !ChunkSize->containsUnexpandedParameterPack()) { 11405 SourceLocation ChunkSizeLoc = ChunkSize->getLocStart(); 11406 ExprResult Val = 11407 PerformOpenMPImplicitIntegerConversion(ChunkSizeLoc, ChunkSize); 11408 if (Val.isInvalid()) 11409 return nullptr; 11410 11411 ValExpr = Val.get(); 11412 11413 // OpenMP [2.7.1, Restrictions] 11414 // chunk_size must be a loop invariant integer expression with a positive 11415 // value. 11416 llvm::APSInt Result; 11417 if (ValExpr->isIntegerConstantExpr(Result, Context)) { 11418 if (Result.isSigned() && !Result.isStrictlyPositive()) { 11419 Diag(ChunkSizeLoc, diag::err_omp_negative_expression_in_clause) 11420 << "dist_schedule" << ChunkSize->getSourceRange(); 11421 return nullptr; 11422 } 11423 } else if (isParallelOrTaskRegion(DSAStack->getCurrentDirective()) && 11424 !CurContext->isDependentContext()) { 11425 llvm::MapVector<Expr *, DeclRefExpr *> Captures; 11426 ValExpr = tryBuildCapture(*this, ValExpr, Captures).get(); 11427 HelperValStmt = buildPreInits(Context, Captures); 11428 } 11429 } 11430 } 11431 11432 return new (Context) 11433 OMPDistScheduleClause(StartLoc, LParenLoc, KindLoc, CommaLoc, EndLoc, 11434 Kind, ValExpr, HelperValStmt); 11435 } 11436 11437 OMPClause *Sema::ActOnOpenMPDefaultmapClause( 11438 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind, 11439 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc, 11440 SourceLocation KindLoc, SourceLocation EndLoc) { 11441 // OpenMP 4.5 only supports 'defaultmap(tofrom: scalar)' 11442 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom || 11443 Kind != OMPC_DEFAULTMAP_scalar) { 11444 std::string Value; 11445 SourceLocation Loc; 11446 Value += "'"; 11447 if (M != OMPC_DEFAULTMAP_MODIFIER_tofrom) { 11448 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap, 11449 OMPC_DEFAULTMAP_MODIFIER_tofrom); 11450 Loc = MLoc; 11451 } else { 11452 Value += getOpenMPSimpleClauseTypeName(OMPC_defaultmap, 11453 OMPC_DEFAULTMAP_scalar); 11454 Loc = KindLoc; 11455 } 11456 Value += "'"; 11457 Diag(Loc, diag::err_omp_unexpected_clause_value) 11458 << Value << getOpenMPClauseName(OMPC_defaultmap); 11459 return nullptr; 11460 } 11461 11462 return new (Context) 11463 OMPDefaultmapClause(StartLoc, LParenLoc, MLoc, KindLoc, EndLoc, Kind, M); 11464 } 11465 11466 bool Sema::ActOnStartOpenMPDeclareTargetDirective(SourceLocation Loc) { 11467 DeclContext *CurLexicalContext = getCurLexicalContext(); 11468 if (!CurLexicalContext->isFileContext() && 11469 !CurLexicalContext->isExternCContext() && 11470 !CurLexicalContext->isExternCXXContext()) { 11471 Diag(Loc, diag::err_omp_region_not_file_context); 11472 return false; 11473 } 11474 if (IsInOpenMPDeclareTargetContext) { 11475 Diag(Loc, diag::err_omp_enclosed_declare_target); 11476 return false; 11477 } 11478 11479 IsInOpenMPDeclareTargetContext = true; 11480 return true; 11481 } 11482 11483 void Sema::ActOnFinishOpenMPDeclareTargetDirective() { 11484 assert(IsInOpenMPDeclareTargetContext && 11485 "Unexpected ActOnFinishOpenMPDeclareTargetDirective"); 11486 11487 IsInOpenMPDeclareTargetContext = false; 11488 } 11489 11490 void 11491 Sema::ActOnOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec, 11492 const DeclarationNameInfo &Id, 11493 OMPDeclareTargetDeclAttr::MapTypeTy MT, 11494 NamedDeclSetType &SameDirectiveDecls) { 11495 LookupResult Lookup(*this, Id, LookupOrdinaryName); 11496 LookupParsedName(Lookup, CurScope, &ScopeSpec, true); 11497 11498 if (Lookup.isAmbiguous()) 11499 return; 11500 Lookup.suppressDiagnostics(); 11501 11502 if (!Lookup.isSingleResult()) { 11503 if (TypoCorrection Corrected = 11504 CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr, 11505 llvm::make_unique<VarOrFuncDeclFilterCCC>(*this), 11506 CTK_ErrorRecovery)) { 11507 diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest) 11508 << Id.getName()); 11509 checkDeclIsAllowedInOpenMPTarget(nullptr, Corrected.getCorrectionDecl()); 11510 return; 11511 } 11512 11513 Diag(Id.getLoc(), diag::err_undeclared_var_use) << Id.getName(); 11514 return; 11515 } 11516 11517 NamedDecl *ND = Lookup.getAsSingle<NamedDecl>(); 11518 if (isa<VarDecl>(ND) || isa<FunctionDecl>(ND)) { 11519 if (!SameDirectiveDecls.insert(cast<NamedDecl>(ND->getCanonicalDecl()))) 11520 Diag(Id.getLoc(), diag::err_omp_declare_target_multiple) << Id.getName(); 11521 11522 if (!ND->hasAttr<OMPDeclareTargetDeclAttr>()) { 11523 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit(Context, MT); 11524 ND->addAttr(A); 11525 if (ASTMutationListener *ML = Context.getASTMutationListener()) 11526 ML->DeclarationMarkedOpenMPDeclareTarget(ND, A); 11527 checkDeclIsAllowedInOpenMPTarget(nullptr, ND); 11528 } else if (ND->getAttr<OMPDeclareTargetDeclAttr>()->getMapType() != MT) { 11529 Diag(Id.getLoc(), diag::err_omp_declare_target_to_and_link) 11530 << Id.getName(); 11531 } 11532 } else 11533 Diag(Id.getLoc(), diag::err_omp_invalid_target_decl) << Id.getName(); 11534 } 11535 11536 static void checkDeclInTargetContext(SourceLocation SL, SourceRange SR, 11537 Sema &SemaRef, Decl *D) { 11538 if (!D) 11539 return; 11540 Decl *LD = nullptr; 11541 if (isa<TagDecl>(D)) { 11542 LD = cast<TagDecl>(D)->getDefinition(); 11543 } else if (isa<VarDecl>(D)) { 11544 LD = cast<VarDecl>(D)->getDefinition(); 11545 11546 // If this is an implicit variable that is legal and we do not need to do 11547 // anything. 11548 if (cast<VarDecl>(D)->isImplicit()) { 11549 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit( 11550 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To); 11551 D->addAttr(A); 11552 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener()) 11553 ML->DeclarationMarkedOpenMPDeclareTarget(D, A); 11554 return; 11555 } 11556 11557 } else if (isa<FunctionDecl>(D)) { 11558 const FunctionDecl *FD = nullptr; 11559 if (cast<FunctionDecl>(D)->hasBody(FD)) 11560 LD = const_cast<FunctionDecl *>(FD); 11561 11562 // If the definition is associated with the current declaration in the 11563 // target region (it can be e.g. a lambda) that is legal and we do not need 11564 // to do anything else. 11565 if (LD == D) { 11566 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit( 11567 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To); 11568 D->addAttr(A); 11569 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener()) 11570 ML->DeclarationMarkedOpenMPDeclareTarget(D, A); 11571 return; 11572 } 11573 } 11574 if (!LD) 11575 LD = D; 11576 if (LD && !LD->hasAttr<OMPDeclareTargetDeclAttr>() && 11577 (isa<VarDecl>(LD) || isa<FunctionDecl>(LD))) { 11578 // Outlined declaration is not declared target. 11579 if (LD->isOutOfLine()) { 11580 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context); 11581 SemaRef.Diag(SL, diag::note_used_here) << SR; 11582 } else { 11583 DeclContext *DC = LD->getDeclContext(); 11584 while (DC) { 11585 if (isa<FunctionDecl>(DC) && 11586 cast<FunctionDecl>(DC)->hasAttr<OMPDeclareTargetDeclAttr>()) 11587 break; 11588 DC = DC->getParent(); 11589 } 11590 if (DC) 11591 return; 11592 11593 // Is not declared in target context. 11594 SemaRef.Diag(LD->getLocation(), diag::warn_omp_not_in_target_context); 11595 SemaRef.Diag(SL, diag::note_used_here) << SR; 11596 } 11597 // Mark decl as declared target to prevent further diagnostic. 11598 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit( 11599 SemaRef.Context, OMPDeclareTargetDeclAttr::MT_To); 11600 D->addAttr(A); 11601 if (ASTMutationListener *ML = SemaRef.Context.getASTMutationListener()) 11602 ML->DeclarationMarkedOpenMPDeclareTarget(D, A); 11603 } 11604 } 11605 11606 static bool checkValueDeclInTarget(SourceLocation SL, SourceRange SR, 11607 Sema &SemaRef, DSAStackTy *Stack, 11608 ValueDecl *VD) { 11609 if (VD->hasAttr<OMPDeclareTargetDeclAttr>()) 11610 return true; 11611 if (!CheckTypeMappable(SL, SR, SemaRef, Stack, VD->getType())) 11612 return false; 11613 return true; 11614 } 11615 11616 void Sema::checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D) { 11617 if (!D || D->isInvalidDecl()) 11618 return; 11619 SourceRange SR = E ? E->getSourceRange() : D->getSourceRange(); 11620 SourceLocation SL = E ? E->getLocStart() : D->getLocation(); 11621 // 2.10.6: threadprivate variable cannot appear in a declare target directive. 11622 if (VarDecl *VD = dyn_cast<VarDecl>(D)) { 11623 if (DSAStack->isThreadPrivate(VD)) { 11624 Diag(SL, diag::err_omp_threadprivate_in_target); 11625 ReportOriginalDSA(*this, DSAStack, VD, DSAStack->getTopDSA(VD, false)); 11626 return; 11627 } 11628 } 11629 if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 11630 // Problem if any with var declared with incomplete type will be reported 11631 // as normal, so no need to check it here. 11632 if ((E || !VD->getType()->isIncompleteType()) && 11633 !checkValueDeclInTarget(SL, SR, *this, DSAStack, VD)) { 11634 // Mark decl as declared target to prevent further diagnostic. 11635 if (isa<VarDecl>(VD) || isa<FunctionDecl>(VD)) { 11636 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit( 11637 Context, OMPDeclareTargetDeclAttr::MT_To); 11638 VD->addAttr(A); 11639 if (ASTMutationListener *ML = Context.getASTMutationListener()) 11640 ML->DeclarationMarkedOpenMPDeclareTarget(VD, A); 11641 } 11642 return; 11643 } 11644 } 11645 if (!E) { 11646 // Checking declaration inside declare target region. 11647 if (!D->hasAttr<OMPDeclareTargetDeclAttr>() && 11648 (isa<VarDecl>(D) || isa<FunctionDecl>(D))) { 11649 Attr *A = OMPDeclareTargetDeclAttr::CreateImplicit( 11650 Context, OMPDeclareTargetDeclAttr::MT_To); 11651 D->addAttr(A); 11652 if (ASTMutationListener *ML = Context.getASTMutationListener()) 11653 ML->DeclarationMarkedOpenMPDeclareTarget(D, A); 11654 } 11655 return; 11656 } 11657 checkDeclInTargetContext(E->getExprLoc(), E->getSourceRange(), *this, D); 11658 } 11659 11660 OMPClause *Sema::ActOnOpenMPToClause(ArrayRef<Expr *> VarList, 11661 SourceLocation StartLoc, 11662 SourceLocation LParenLoc, 11663 SourceLocation EndLoc) { 11664 MappableVarListInfo MVLI(VarList); 11665 checkMappableExpressionList(*this, DSAStack, OMPC_to, MVLI, StartLoc); 11666 if (MVLI.ProcessedVarList.empty()) 11667 return nullptr; 11668 11669 return OMPToClause::Create(Context, StartLoc, LParenLoc, EndLoc, 11670 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations, 11671 MVLI.VarComponents); 11672 } 11673 11674 OMPClause *Sema::ActOnOpenMPFromClause(ArrayRef<Expr *> VarList, 11675 SourceLocation StartLoc, 11676 SourceLocation LParenLoc, 11677 SourceLocation EndLoc) { 11678 MappableVarListInfo MVLI(VarList); 11679 checkMappableExpressionList(*this, DSAStack, OMPC_from, MVLI, StartLoc); 11680 if (MVLI.ProcessedVarList.empty()) 11681 return nullptr; 11682 11683 return OMPFromClause::Create(Context, StartLoc, LParenLoc, EndLoc, 11684 MVLI.ProcessedVarList, MVLI.VarBaseDeclarations, 11685 MVLI.VarComponents); 11686 } 11687 11688 OMPClause *Sema::ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList, 11689 SourceLocation StartLoc, 11690 SourceLocation LParenLoc, 11691 SourceLocation EndLoc) { 11692 SmallVector<Expr *, 8> Vars; 11693 for (auto &RefExpr : VarList) { 11694 assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause."); 11695 SourceLocation ELoc; 11696 SourceRange ERange; 11697 Expr *SimpleRefExpr = RefExpr; 11698 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange); 11699 if (Res.second) { 11700 // It will be analyzed later. 11701 Vars.push_back(RefExpr); 11702 } 11703 ValueDecl *D = Res.first; 11704 if (!D) 11705 continue; 11706 11707 QualType Type = D->getType(); 11708 // item should be a pointer or reference to pointer 11709 if (!Type.getNonReferenceType()->isPointerType()) { 11710 Diag(ELoc, diag::err_omp_usedeviceptr_not_a_pointer) 11711 << 0 << RefExpr->getSourceRange(); 11712 continue; 11713 } 11714 Vars.push_back(RefExpr->IgnoreParens()); 11715 } 11716 11717 if (Vars.empty()) 11718 return nullptr; 11719 11720 return OMPUseDevicePtrClause::Create(Context, StartLoc, LParenLoc, EndLoc, 11721 Vars); 11722 } 11723 11724 OMPClause *Sema::ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList, 11725 SourceLocation StartLoc, 11726 SourceLocation LParenLoc, 11727 SourceLocation EndLoc) { 11728 SmallVector<Expr *, 8> Vars; 11729 for (auto &RefExpr : VarList) { 11730 assert(RefExpr && "NULL expr in OpenMP use_device_ptr clause."); 11731 SourceLocation ELoc; 11732 SourceRange ERange; 11733 Expr *SimpleRefExpr = RefExpr; 11734 auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange); 11735 if (Res.second) { 11736 // It will be analyzed later. 11737 Vars.push_back(RefExpr); 11738 } 11739 ValueDecl *D = Res.first; 11740 if (!D) 11741 continue; 11742 11743 QualType Type = D->getType(); 11744 // item should be a pointer or array or reference to pointer or array 11745 if (!Type.getNonReferenceType()->isPointerType() && 11746 !Type.getNonReferenceType()->isArrayType()) { 11747 Diag(ELoc, diag::err_omp_argument_type_isdeviceptr) 11748 << 0 << RefExpr->getSourceRange(); 11749 continue; 11750 } 11751 Vars.push_back(RefExpr->IgnoreParens()); 11752 } 11753 11754 if (Vars.empty()) 11755 return nullptr; 11756 11757 return OMPIsDevicePtrClause::Create(Context, StartLoc, LParenLoc, EndLoc, 11758 Vars); 11759 } 11760