/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaOpenMP.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaOpenMP.cpp
Warning:	line 1216, column 9 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaOpenMP.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaOpenMP.cpp
/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaOpenMP.cpp

→
1//===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9/// This file implements semantic analysis for OpenMP directives and
10/// clauses.
11///
12//===----------------------------------------------------------------------===//

14#include "TreeTransform.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/CXXInheritance.h"
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclOpenMP.h"
21#include "clang/AST/OpenMPClause.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/DiagnosticSema.h"
27#include "clang/Basic/OpenMPKinds.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/TargetInfo.h"
30#include "clang/Sema/Initialization.h"
31#include "clang/Sema/Lookup.h"
32#include "clang/Sema/Scope.h"
33#include "clang/Sema/ScopeInfo.h"
34#include "clang/Sema/SemaInternal.h"
35#include "llvm/ADT/IndexedMap.h"
36#include "llvm/ADT/PointerEmbeddedInt.h"
37#include "llvm/ADT/STLExtras.h"
38#include "llvm/ADT/StringExtras.h"
39#include "llvm/Frontend/OpenMP/OMPConstants.h"
40#include <set>

42using namespace clang;
43using namespace llvm::omp;

45//===----------------------------------------------------------------------===//
46// Stack of data-sharing attributes for variables
47//===----------------------------------------------------------------------===//

49static const Expr *checkMapClauseExpressionBase(
  Sema &SemaRef, Expr *E,
  OMPClauseMappableExprCommon::MappableExprComponentList &CurComponents,
  OpenMPClauseKind CKind, OpenMPDirectiveKind DKind, bool NoDiagnose);

54namespace {
55/// Default data sharing attributes, which can be applied to directive.
56enum DefaultDataSharingAttributes {
DSA_unspecified = 0,       /// Data sharing attribute not specified.
DSA_none = 1 << 0,         /// Default data sharing attribute 'none'.
DSA_shared = 1 << 1,       /// Default data sharing attribute 'shared'.
DSA_firstprivate = 1 << 2, /// Default data sharing attribute 'firstprivate'.
61};

63/// Stack for tracking declarations used in OpenMP directives and
64/// clauses and their data-sharing attributes.
65class DSAStackTy {
66public:
struct DSAVarData {
  OpenMPDirectiveKind DKind = OMPD_unknown;
  OpenMPClauseKind CKind = OMPC_unknown;
  unsigned Modifier = 0;
  const Expr *RefExpr = nullptr;
  DeclRefExpr *PrivateCopy = nullptr;
  SourceLocation ImplicitDSALoc;
  bool AppliedToPointee = false;
  DSAVarData() = default;
  DSAVarData(OpenMPDirectiveKind DKind, OpenMPClauseKind CKind,
             const Expr *RefExpr, DeclRefExpr *PrivateCopy,
             SourceLocation ImplicitDSALoc, unsigned Modifier,
             bool AppliedToPointee)
      : DKind(DKind), CKind(CKind), Modifier(Modifier), RefExpr(RefExpr),
        PrivateCopy(PrivateCopy), ImplicitDSALoc(ImplicitDSALoc),
        AppliedToPointee(AppliedToPointee) {}
};
using OperatorOffsetTy =
    llvm::SmallVector<std::pair<Expr *, OverloadedOperatorKind>, 4>;
using DoacrossDependMapTy =
    llvm::DenseMap<OMPDependClause *, OperatorOffsetTy>;
/// Kind of the declaration used in the uses_allocators clauses.
enum class UsesAllocatorsDeclKind {
  /// Predefined allocator
  PredefinedAllocator,
  /// User-defined allocator
  UserDefinedAllocator,
  /// The declaration that represent allocator trait
  AllocatorTrait,
};

98private:
struct DSAInfo {
  OpenMPClauseKind Attributes = OMPC_unknown;
  unsigned Modifier = 0;
  /// Pointer to a reference expression and a flag which shows that the
  /// variable is marked as lastprivate(true) or not (false).
  llvm::PointerIntPair<const Expr *, 1, bool> RefExpr;
  DeclRefExpr *PrivateCopy = nullptr;
  /// true if the attribute is applied to the pointee, not the variable
  /// itself.
  bool AppliedToPointee = false;
};
using DeclSAMapTy = llvm::SmallDenseMap<const ValueDecl *, DSAInfo, 8>;
using UsedRefMapTy = llvm::SmallDenseMap<const ValueDecl *, const Expr *, 8>;
using LCDeclInfo = std::pair<unsigned, VarDecl *>;
using LoopControlVariablesMapTy =
    llvm::SmallDenseMap<const ValueDecl *, LCDeclInfo, 8>;
/// Struct that associates a component with the clause kind where they are
/// found.
struct MappedExprComponentTy {
  OMPClauseMappableExprCommon::MappableExprComponentLists Components;
  OpenMPClauseKind Kind = OMPC_unknown;
};
using MappedExprComponentsTy =
    llvm::DenseMap<const ValueDecl *, MappedExprComponentTy>;
using CriticalsWithHintsTy =
    llvm::StringMap<std::pair<const OMPCriticalDirective *, llvm::APSInt>>;
struct ReductionData {
  using BOKPtrType = llvm::PointerEmbeddedInt<BinaryOperatorKind, 16>;
  SourceRange ReductionRange;
  llvm::PointerUnion<const Expr *, BOKPtrType> ReductionOp;
  ReductionData() = default;
  void set(BinaryOperatorKind BO, SourceRange RR) {
    ReductionRange = RR;
    ReductionOp = BO;
  }
  void set(const Expr *RefExpr, SourceRange RR) {
    ReductionRange = RR;
    ReductionOp = RefExpr;
  }
};
using DeclReductionMapTy =
    llvm::SmallDenseMap<const ValueDecl *, ReductionData, 4>;
struct DefaultmapInfo {
  OpenMPDefaultmapClauseModifier ImplicitBehavior =
      OMPC_DEFAULTMAP_MODIFIER_unknown;
  SourceLocation SLoc;
  DefaultmapInfo() = default;
  DefaultmapInfo(OpenMPDefaultmapClauseModifier M, SourceLocation Loc)
      : ImplicitBehavior(M), SLoc(Loc) {}
};

struct SharingMapTy {
  DeclSAMapTy SharingMap;
  DeclReductionMapTy ReductionMap;
  UsedRefMapTy AlignedMap;
  UsedRefMapTy NontemporalMap;
  MappedExprComponentsTy MappedExprComponents;
  LoopControlVariablesMapTy LCVMap;
  DefaultDataSharingAttributes DefaultAttr = DSA_unspecified;
  SourceLocation DefaultAttrLoc;
  DefaultmapInfo DefaultmapMap[OMPC_DEFAULTMAP_unknown];
  OpenMPDirectiveKind Directive = OMPD_unknown;
  DeclarationNameInfo DirectiveName;
  Scope *CurScope = nullptr;
  DeclContext *Context = nullptr;
  SourceLocation ConstructLoc;
  /// Set of 'depend' clauses with 'sink|source' dependence kind. Required to
  /// get the data (loop counters etc.) about enclosing loop-based construct.
  /// This data is required during codegen.
  DoacrossDependMapTy DoacrossDepends;
  /// First argument (Expr *) contains optional argument of the
  /// 'ordered' clause, the second one is true if the regions has 'ordered'
  /// clause, false otherwise.
  llvm::Optional<std::pair<const Expr *, OMPOrderedClause *>> OrderedRegion;
  unsigned AssociatedLoops = 1;
  bool HasMutipleLoops = false;
  const Decl *PossiblyLoopCounter = nullptr;
  bool NowaitRegion = false;
  bool CancelRegion = false;
  bool LoopStart = false;
  bool BodyComplete = false;
  SourceLocation PrevScanLocation;
  SourceLocation PrevOrderedLocation;
  SourceLocation InnerTeamsRegionLoc;
  /// Reference to the taskgroup task_reduction reference expression.
  Expr *TaskgroupReductionRef = nullptr;
  llvm::DenseSet<QualType> MappedClassesQualTypes;
  SmallVector<Expr *, 4> InnerUsedAllocators;
  llvm::DenseSet<CanonicalDeclPtr<Decl>> ImplicitTaskFirstprivates;
  /// List of globals marked as declare target link in this target region
  /// (isOpenMPTargetExecutionDirective(Directive) == true).
  llvm::SmallVector<DeclRefExpr *, 4> DeclareTargetLinkVarDecls;
  /// List of decls used in inclusive/exclusive clauses of the scan directive.
  llvm::DenseSet<CanonicalDeclPtr<Decl>> UsedInScanDirective;
  llvm::DenseMap<CanonicalDeclPtr<const Decl>, UsesAllocatorsDeclKind>
      UsesAllocatorsDecls;
  Expr *DeclareMapperVar = nullptr;
  SharingMapTy(OpenMPDirectiveKind DKind, DeclarationNameInfo Name,
               Scope *CurScope, SourceLocation Loc)
      : Directive(DKind), DirectiveName(Name), CurScope(CurScope),
        ConstructLoc(Loc) {}
  SharingMapTy() = default;
};

using StackTy = SmallVector<SharingMapTy, 4>;

/// Stack of used declaration and their data-sharing attributes.
DeclSAMapTy Threadprivates;
const FunctionScopeInfo *CurrentNonCapturingFunctionScope = nullptr;
SmallVector<std::pair<StackTy, const FunctionScopeInfo *>, 4> Stack;
/// true, if check for DSA must be from parent directive, false, if
/// from current directive.
OpenMPClauseKind ClauseKindMode = OMPC_unknown;
Sema &SemaRef;
bool ForceCapturing = false;
/// true if all the variables in the target executable directives must be
/// captured by reference.
bool ForceCaptureByReferenceInTargetExecutable = false;
CriticalsWithHintsTy Criticals;
unsigned IgnoredStackElements = 0;

/// Iterators over the stack iterate in order from innermost to outermost
/// directive.
using const_iterator = StackTy::const_reverse_iterator;
const_iterator begin() const {
  return Stack.empty() ? const_iterator()
                       : Stack.back().first.rbegin() + IgnoredStackElements;
}
const_iterator end() const {
  return Stack.empty() ? const_iterator() : Stack.back().first.rend();
}
using iterator = StackTy::reverse_iterator;
iterator begin() {
  return Stack.empty() ? iterator()
                       : Stack.back().first.rbegin() + IgnoredStackElements;
}
iterator end() {
  return Stack.empty() ? iterator() : Stack.back().first.rend();
}

// Convenience operations to get at the elements of the stack.

bool isStackEmpty() const {
  return Stack.empty() ||
         Stack.back().second != CurrentNonCapturingFunctionScope ||
         Stack.back().first.size() <= IgnoredStackElements;
}
size_t getStackSize() const {
  return isStackEmpty() ? 0
                        : Stack.back().first.size() - IgnoredStackElements;
}

SharingMapTy *getTopOfStackOrNull() {
  size_t Size = getStackSize();
  if (Size == 0)
    return nullptr;
  return &Stack.back().first[Size - 1];
}
const SharingMapTy *getTopOfStackOrNull() const {
  return const_cast<DSAStackTy&>(*this).getTopOfStackOrNull();
}
SharingMapTy &getTopOfStack() {
  assert(!isStackEmpty() && "no current directive")((void)0);
  return *getTopOfStackOrNull();
}
const SharingMapTy &getTopOfStack() const {
  return const_cast<DSAStackTy&>(*this).getTopOfStack();
}

SharingMapTy *getSecondOnStackOrNull() {
  size_t Size = getStackSize();
  if (Size <= 1)
    return nullptr;
  return &Stack.back().first[Size - 2];
}
const SharingMapTy *getSecondOnStackOrNull() const {
  return const_cast<DSAStackTy&>(*this).getSecondOnStackOrNull();
}

/// Get the stack element at a certain level (previously returned by
/// \c getNestingLevel).
///
/// Note that nesting levels count from outermost to innermost, and this is
/// the reverse of our iteration order where new inner levels are pushed at
/// the front of the stack.
SharingMapTy &getStackElemAtLevel(unsigned Level) {
  assert(Level < getStackSize() && "no such stack element")((void)0);
  return Stack.back().first[Level];
}
const SharingMapTy &getStackElemAtLevel(unsigned Level) const {
  return const_cast<DSAStackTy&>(*this).getStackElemAtLevel(Level);
}

DSAVarData getDSA(const_iterator &Iter, ValueDecl *D) const;

/// Checks if the variable is a local for OpenMP region.
bool isOpenMPLocal(VarDecl *D, const_iterator Iter) const;

/// Vector of previously declared requires directives
SmallVector<const OMPRequiresDecl *, 2> RequiresDecls;
/// omp_allocator_handle_t type.
QualType OMPAllocatorHandleT;
/// omp_depend_t type.
QualType OMPDependT;
/// omp_event_handle_t type.
QualType OMPEventHandleT;
/// omp_alloctrait_t type.
QualType OMPAlloctraitT;
/// Expression for the predefined allocators.
Expr *OMPPredefinedAllocators[OMPAllocateDeclAttr::OMPUserDefinedMemAlloc] = {
    nullptr};
/// Vector of previously encountered target directives
SmallVector<SourceLocation, 2> TargetLocations;
SourceLocation AtomicLocation;

314public:
explicit DSAStackTy(Sema &S) : SemaRef(S) {}

/// Sets omp_allocator_handle_t type.
void setOMPAllocatorHandleT(QualType Ty) { OMPAllocatorHandleT = Ty; }
/// Gets omp_allocator_handle_t type.
QualType getOMPAllocatorHandleT() const { return OMPAllocatorHandleT; }
/// Sets omp_alloctrait_t type.
void setOMPAlloctraitT(QualType Ty) { OMPAlloctraitT = Ty; }
/// Gets omp_alloctrait_t type.
QualType getOMPAlloctraitT() const { return OMPAlloctraitT; }
/// Sets the given default allocator.
void setAllocator(OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind,
                  Expr *Allocator) {
  OMPPredefinedAllocators[AllocatorKind] = Allocator;
}
/// Returns the specified default allocator.
Expr *getAllocator(OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind) const {
  return OMPPredefinedAllocators[AllocatorKind];
}
/// Sets omp_depend_t type.
void setOMPDependT(QualType Ty) { OMPDependT = Ty; }
/// Gets omp_depend_t type.
QualType getOMPDependT() const { return OMPDependT; }

/// Sets omp_event_handle_t type.
void setOMPEventHandleT(QualType Ty) { OMPEventHandleT = Ty; }
/// Gets omp_event_handle_t type.
QualType getOMPEventHandleT() const { return OMPEventHandleT; }

bool isClauseParsingMode() const { return ClauseKindMode != OMPC_unknown; }
OpenMPClauseKind getClauseParsingMode() const {
  assert(isClauseParsingMode() && "Must be in clause parsing mode.")((void)0);
  return ClauseKindMode;
}
void setClauseParsingMode(OpenMPClauseKind K) { ClauseKindMode = K; }

bool isBodyComplete() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top && Top->BodyComplete;
}
void setBodyComplete() {
  getTopOfStack().BodyComplete = true;
}

bool isForceVarCapturing() const { return ForceCapturing; }
void setForceVarCapturing(bool V) { ForceCapturing = V; }

void setForceCaptureByReferenceInTargetExecutable(bool V) {
  ForceCaptureByReferenceInTargetExecutable = V;
}
bool isForceCaptureByReferenceInTargetExecutable() const {
  return ForceCaptureByReferenceInTargetExecutable;
}

void push(OpenMPDirectiveKind DKind, const DeclarationNameInfo &DirName,
          Scope *CurScope, SourceLocation Loc) {
  assert(!IgnoredStackElements &&((void)0)
         "cannot change stack while ignoring elements")((void)0);
  if (Stack.empty() ||
      Stack.back().second != CurrentNonCapturingFunctionScope)
    Stack.emplace_back(StackTy(), CurrentNonCapturingFunctionScope);
  Stack.back().first.emplace_back(DKind, DirName, CurScope, Loc);
  Stack.back().first.back().DefaultAttrLoc = Loc;
}

void pop() {
  assert(!IgnoredStackElements &&((void)0)
         "cannot change stack while ignoring elements")((void)0);
  assert(!Stack.back().first.empty() &&((void)0)
         "Data-sharing attributes stack is empty!")((void)0);
  Stack.back().first.pop_back();
}

/// RAII object to temporarily leave the scope of a directive when we want to
/// logically operate in its parent.
class ParentDirectiveScope {
  DSAStackTy &Self;
  bool Active;
public:
  ParentDirectiveScope(DSAStackTy &Self, bool Activate)
      : Self(Self), Active(false) {
    if (Activate)
      enable();
  }
  ~ParentDirectiveScope() { disable(); }
  void disable() {
    if (Active) {
      --Self.IgnoredStackElements;
      Active = false;
    }
  }
  void enable() {
    if (!Active) {
      ++Self.IgnoredStackElements;
      Active = true;
    }
  }
};

/// Marks that we're started loop parsing.
void loopInit() {
  assert(isOpenMPLoopDirective(getCurrentDirective()) &&((void)0)
         "Expected loop-based directive.")((void)0);
  getTopOfStack().LoopStart = true;
}
/// Start capturing of the variables in the loop context.
void loopStart() {
  assert(isOpenMPLoopDirective(getCurrentDirective()) &&((void)0)
         "Expected loop-based directive.")((void)0);
  getTopOfStack().LoopStart = false;
}
/// true, if variables are captured, false otherwise.
bool isLoopStarted() const {
  assert(isOpenMPLoopDirective(getCurrentDirective()) &&((void)0)
         "Expected loop-based directive.")((void)0);
  return !getTopOfStack().LoopStart;
}
/// Marks (or clears) declaration as possibly loop counter.
void resetPossibleLoopCounter(const Decl *D = nullptr) {
  getTopOfStack().PossiblyLoopCounter =
      D ? D->getCanonicalDecl() : D;
}
/// Gets the possible loop counter decl.
const Decl *getPossiblyLoopCunter() const {
  return getTopOfStack().PossiblyLoopCounter;
}
/// Start new OpenMP region stack in new non-capturing function.
void pushFunction() {
  assert(!IgnoredStackElements &&((void)0)
         "cannot change stack while ignoring elements")((void)0);
  const FunctionScopeInfo *CurFnScope = SemaRef.getCurFunction();
  assert(!isa<CapturingScopeInfo>(CurFnScope))((void)0);
  CurrentNonCapturingFunctionScope = CurFnScope;
}
/// Pop region stack for non-capturing function.
void popFunction(const FunctionScopeInfo *OldFSI) {
  assert(!IgnoredStackElements &&((void)0)
         "cannot change stack while ignoring elements")((void)0);
  if (!Stack.empty() && Stack.back().second == OldFSI) {
    assert(Stack.back().first.empty())((void)0);
    Stack.pop_back();
  }
  CurrentNonCapturingFunctionScope = nullptr;
  for (const FunctionScopeInfo *FSI : llvm::reverse(SemaRef.FunctionScopes)) {
    if (!isa<CapturingScopeInfo>(FSI)) {
      CurrentNonCapturingFunctionScope = FSI;
      break;
    }
  }
}

void addCriticalWithHint(const OMPCriticalDirective *D, llvm::APSInt Hint) {
  Criticals.try_emplace(D->getDirectiveName().getAsString(), D, Hint);
}
const std::pair<const OMPCriticalDirective *, llvm::APSInt>
getCriticalWithHint(const DeclarationNameInfo &Name) const {
  auto I = Criticals.find(Name.getAsString());
  if (I != Criticals.end())
    return I->second;
  return std::make_pair(nullptr, llvm::APSInt());
}
/// If 'aligned' declaration for given variable \a D was not seen yet,
/// add it and return NULL; otherwise return previous occurrence's expression
/// for diagnostics.
const Expr *addUniqueAligned(const ValueDecl *D, const Expr *NewDE);
/// If 'nontemporal' declaration for given variable \a D was not seen yet,
/// add it and return NULL; otherwise return previous occurrence's expression
/// for diagnostics.
const Expr *addUniqueNontemporal(const ValueDecl *D, const Expr *NewDE);

/// Register specified variable as loop control variable.
void addLoopControlVariable(const ValueDecl *D, VarDecl *Capture);
/// Check if the specified variable is a loop control variable for
/// current region.
/// \return The index of the loop control variable in the list of associated
/// for-loops (from outer to inner).
const LCDeclInfo isLoopControlVariable(const ValueDecl *D) const;
/// Check if the specified variable is a loop control variable for
/// parent region.
/// \return The index of the loop control variable in the list of associated
/// for-loops (from outer to inner).
const LCDeclInfo isParentLoopControlVariable(const ValueDecl *D) const;
/// Check if the specified variable is a loop control variable for
/// current region.
/// \return The index of the loop control variable in the list of associated
/// for-loops (from outer to inner).
const LCDeclInfo isLoopControlVariable(const ValueDecl *D,
                                       unsigned Level) const;
/// Get the loop control variable for the I-th loop (or nullptr) in
/// parent directive.
const ValueDecl *getParentLoopControlVariable(unsigned I) const;

/// Marks the specified decl \p D as used in scan directive.
void markDeclAsUsedInScanDirective(ValueDecl *D) {
  if (SharingMapTy *Stack = getSecondOnStackOrNull())
    Stack->UsedInScanDirective.insert(D);
}

/// Checks if the specified declaration was used in the inner scan directive.
bool isUsedInScanDirective(ValueDecl *D) const {
  if (const SharingMapTy *Stack = getTopOfStackOrNull())
    return Stack->UsedInScanDirective.count(D) > 0;
  return false;
}

/// Adds explicit data sharing attribute to the specified declaration.
void addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A,
            DeclRefExpr *PrivateCopy = nullptr, unsigned Modifier = 0,
            bool AppliedToPointee = false);

/// Adds additional information for the reduction items with the reduction id
/// represented as an operator.
void addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
                               BinaryOperatorKind BOK);
/// Adds additional information for the reduction items with the reduction id
/// represented as reduction identifier.
void addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
                               const Expr *ReductionRef);
/// Returns the location and reduction operation from the innermost parent
/// region for the given \p D.
const DSAVarData
getTopMostTaskgroupReductionData(const ValueDecl *D, SourceRange &SR,
                                 BinaryOperatorKind &BOK,
                                 Expr *&TaskgroupDescriptor) const;
/// Returns the location and reduction operation from the innermost parent
/// region for the given \p D.
const DSAVarData
getTopMostTaskgroupReductionData(const ValueDecl *D, SourceRange &SR,
                                 const Expr *&ReductionRef,
                                 Expr *&TaskgroupDescriptor) const;
/// Return reduction reference expression for the current taskgroup or
/// parallel/worksharing directives with task reductions.
Expr *getTaskgroupReductionRef() const {
  assert((getTopOfStack().Directive == OMPD_taskgroup ||((void)0)
          ((isOpenMPParallelDirective(getTopOfStack().Directive) ||((void)0)
            isOpenMPWorksharingDirective(getTopOfStack().Directive)) &&((void)0)
           !isOpenMPSimdDirective(getTopOfStack().Directive))) &&((void)0)
         "taskgroup reference expression requested for non taskgroup or "((void)0)
         "parallel/worksharing directive.")((void)0);
  return getTopOfStack().TaskgroupReductionRef;
}
/// Checks if the given \p VD declaration is actually a taskgroup reduction
/// descriptor variable at the \p Level of OpenMP regions.
bool isTaskgroupReductionRef(const ValueDecl *VD, unsigned Level) const {
  return getStackElemAtLevel(Level).TaskgroupReductionRef &&
         cast<DeclRefExpr>(getStackElemAtLevel(Level).TaskgroupReductionRef)
                 ->getDecl() == VD;
}

/// Returns data sharing attributes from top of the stack for the
/// specified declaration.
const DSAVarData getTopDSA(ValueDecl *D, bool FromParent);
/// Returns data-sharing attributes for the specified declaration.
const DSAVarData getImplicitDSA(ValueDecl *D, bool FromParent) const;
/// Returns data-sharing attributes for the specified declaration.
const DSAVarData getImplicitDSA(ValueDecl *D, unsigned Level) const;
/// Checks if the specified variables has data-sharing attributes which
/// match specified \a CPred predicate in any directive which matches \a DPred
/// predicate.
const DSAVarData
hasDSA(ValueDecl *D,
       const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
       const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
       bool FromParent) const;
/// Checks if the specified variables has data-sharing attributes which
/// match specified \a CPred predicate in any innermost directive which
/// matches \a DPred predicate.
const DSAVarData
hasInnermostDSA(ValueDecl *D,
                const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
                const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
                bool FromParent) const;
/// Checks if the specified variables has explicit data-sharing
/// attributes which match specified \a CPred predicate at the specified
/// OpenMP region.
bool
hasExplicitDSA(const ValueDecl *D,
               const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
               unsigned Level, bool NotLastprivate = false) const;

/// Returns true if the directive at level \Level matches in the
/// specified \a DPred predicate.
bool hasExplicitDirective(
    const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
    unsigned Level) const;

/// Finds a directive which matches specified \a DPred predicate.
bool hasDirective(
    const llvm::function_ref<bool(
        OpenMPDirectiveKind, const DeclarationNameInfo &, SourceLocation)>
        DPred,
    bool FromParent) const;

/// Returns currently analyzed directive.
OpenMPDirectiveKind getCurrentDirective() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->Directive : OMPD_unknown;
}
/// Returns directive kind at specified level.
OpenMPDirectiveKind getDirective(unsigned Level) const {
  assert(!isStackEmpty() && "No directive at specified level.")((void)0);
  return getStackElemAtLevel(Level).Directive;
}
/// Returns the capture region at the specified level.
OpenMPDirectiveKind getCaptureRegion(unsigned Level,
                                     unsigned OpenMPCaptureLevel) const {
  SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
  getOpenMPCaptureRegions(CaptureRegions, getDirective(Level));
  return CaptureRegions[OpenMPCaptureLevel];
}
/// Returns parent directive.
OpenMPDirectiveKind getParentDirective() const {
  const SharingMapTy *Parent = getSecondOnStackOrNull();
  return Parent ? Parent->Directive : OMPD_unknown;
}

/// Add requires decl to internal vector
void addRequiresDecl(OMPRequiresDecl *RD) {
  RequiresDecls.push_back(RD);
}

/// Checks if the defined 'requires' directive has specified type of clause.
template <typename ClauseType>
bool hasRequiresDeclWithClause() const {
  return llvm::any_of(RequiresDecls, [](const OMPRequiresDecl *D) {
    return llvm::any_of(D->clauselists(), [](const OMPClause *C) {
      return isa<ClauseType>(C);
    });
  });
}

/// Checks for a duplicate clause amongst previously declared requires
/// directives
bool hasDuplicateRequiresClause(ArrayRef<OMPClause *> ClauseList) const {
  bool IsDuplicate = false;
  for (OMPClause *CNew : ClauseList) {
    for (const OMPRequiresDecl *D : RequiresDecls) {
      for (const OMPClause *CPrev : D->clauselists()) {
        if (CNew->getClauseKind() == CPrev->getClauseKind()) {
          SemaRef.Diag(CNew->getBeginLoc(),
                       diag::err_omp_requires_clause_redeclaration)
              << getOpenMPClauseName(CNew->getClauseKind());
          SemaRef.Diag(CPrev->getBeginLoc(),
                       diag::note_omp_requires_previous_clause)
              << getOpenMPClauseName(CPrev->getClauseKind());
          IsDuplicate = true;
        }
      }
    }
  }
  return IsDuplicate;
}

/// Add location of previously encountered target to internal vector
void addTargetDirLocation(SourceLocation LocStart) {
  TargetLocations.push_back(LocStart);
}

/// Add location for the first encountered atomicc directive.
void addAtomicDirectiveLoc(SourceLocation Loc) {
  if (AtomicLocation.isInvalid())
    AtomicLocation = Loc;
}

/// Returns the location of the first encountered atomic directive in the
/// module.
SourceLocation getAtomicDirectiveLoc() const {
  return AtomicLocation;
}

// Return previously encountered target region locations.
ArrayRef<SourceLocation> getEncounteredTargetLocs() const {
  return TargetLocations;
}

/// Set default data sharing attribute to none.
void setDefaultDSANone(SourceLocation Loc) {
  getTopOfStack().DefaultAttr = DSA_none;
  getTopOfStack().DefaultAttrLoc = Loc;
}
/// Set default data sharing attribute to shared.
void setDefaultDSAShared(SourceLocation Loc) {
  getTopOfStack().DefaultAttr = DSA_shared;
  getTopOfStack().DefaultAttrLoc = Loc;
}
/// Set default data sharing attribute to firstprivate.
void setDefaultDSAFirstPrivate(SourceLocation Loc) {
  getTopOfStack().DefaultAttr = DSA_firstprivate;
  getTopOfStack().DefaultAttrLoc = Loc;
}
/// Set default data mapping attribute to Modifier:Kind
void setDefaultDMAAttr(OpenMPDefaultmapClauseModifier M,
                       OpenMPDefaultmapClauseKind Kind,
                       SourceLocation Loc) {
  DefaultmapInfo &DMI = getTopOfStack().DefaultmapMap[Kind];
  DMI.ImplicitBehavior = M;
  DMI.SLoc = Loc;
}
/// Check whether the implicit-behavior has been set in defaultmap
bool checkDefaultmapCategory(OpenMPDefaultmapClauseKind VariableCategory) {
  if (VariableCategory == OMPC_DEFAULTMAP_unknown)
    return getTopOfStack()
                   .DefaultmapMap[OMPC_DEFAULTMAP_aggregate]
                   .ImplicitBehavior != OMPC_DEFAULTMAP_MODIFIER_unknown ||
           getTopOfStack()
                   .DefaultmapMap[OMPC_DEFAULTMAP_scalar]
                   .ImplicitBehavior != OMPC_DEFAULTMAP_MODIFIER_unknown ||
           getTopOfStack()
                   .DefaultmapMap[OMPC_DEFAULTMAP_pointer]
                   .ImplicitBehavior != OMPC_DEFAULTMAP_MODIFIER_unknown;
  return getTopOfStack().DefaultmapMap[VariableCategory].ImplicitBehavior !=
         OMPC_DEFAULTMAP_MODIFIER_unknown;
}

DefaultDataSharingAttributes getDefaultDSA(unsigned Level) const {
  return getStackSize() <= Level ? DSA_unspecified
                                 : getStackElemAtLevel(Level).DefaultAttr;
}
DefaultDataSharingAttributes getDefaultDSA() const {
  return isStackEmpty() ? DSA_unspecified
                        : getTopOfStack().DefaultAttr;
}
SourceLocation getDefaultDSALocation() const {
  return isStackEmpty() ? SourceLocation()
                        : getTopOfStack().DefaultAttrLoc;
}
OpenMPDefaultmapClauseModifier
getDefaultmapModifier(OpenMPDefaultmapClauseKind Kind) const {
  return isStackEmpty()
             ? OMPC_DEFAULTMAP_MODIFIER_unknown
             : getTopOfStack().DefaultmapMap[Kind].ImplicitBehavior;
}
OpenMPDefaultmapClauseModifier
getDefaultmapModifierAtLevel(unsigned Level,
                             OpenMPDefaultmapClauseKind Kind) const {
  return getStackElemAtLevel(Level).DefaultmapMap[Kind].ImplicitBehavior;
}
bool isDefaultmapCapturedByRef(unsigned Level,
                               OpenMPDefaultmapClauseKind Kind) const {
  OpenMPDefaultmapClauseModifier M =
      getDefaultmapModifierAtLevel(Level, Kind);
  if (Kind == OMPC_DEFAULTMAP_scalar || Kind == OMPC_DEFAULTMAP_pointer) {
    return (M == OMPC_DEFAULTMAP_MODIFIER_alloc) ||
           (M == OMPC_DEFAULTMAP_MODIFIER_to) ||
           (M == OMPC_DEFAULTMAP_MODIFIER_from) ||
           (M == OMPC_DEFAULTMAP_MODIFIER_tofrom);
  }
  return true;
}
static bool mustBeFirstprivateBase(OpenMPDefaultmapClauseModifier M,
                                   OpenMPDefaultmapClauseKind Kind) {
  switch (Kind) {
  case OMPC_DEFAULTMAP_scalar:
  case OMPC_DEFAULTMAP_pointer:
    return (M == OMPC_DEFAULTMAP_MODIFIER_unknown) ||
           (M == OMPC_DEFAULTMAP_MODIFIER_firstprivate) ||
           (M == OMPC_DEFAULTMAP_MODIFIER_default);
  case OMPC_DEFAULTMAP_aggregate:
    return M == OMPC_DEFAULTMAP_MODIFIER_firstprivate;
  default:
    break;
  }
  llvm_unreachable("Unexpected OpenMPDefaultmapClauseKind enum")__builtin_unreachable();
}
bool mustBeFirstprivateAtLevel(unsigned Level,
                               OpenMPDefaultmapClauseKind Kind) const {
  OpenMPDefaultmapClauseModifier M =
      getDefaultmapModifierAtLevel(Level, Kind);
  return mustBeFirstprivateBase(M, Kind);
}
bool mustBeFirstprivate(OpenMPDefaultmapClauseKind Kind) const {
  OpenMPDefaultmapClauseModifier M = getDefaultmapModifier(Kind);
  return mustBeFirstprivateBase(M, Kind);
}

/// Checks if the specified variable is a threadprivate.
bool isThreadPrivate(VarDecl *D) {
  const DSAVarData DVar = getTopDSA(D, false);
  return isOpenMPThreadPrivate(DVar.CKind);
}

/// Marks current region as ordered (it has an 'ordered' clause).
void setOrderedRegion(bool IsOrdered, const Expr *Param,
                      OMPOrderedClause *Clause) {
  if (IsOrdered)
    getTopOfStack().OrderedRegion.emplace(Param, Clause);
  else
    getTopOfStack().OrderedRegion.reset();
}
/// Returns true, if region is ordered (has associated 'ordered' clause),
/// false - otherwise.
bool isOrderedRegion() const {
  if (const SharingMapTy *Top = getTopOfStackOrNull())
    return Top->OrderedRegion.hasValue();
  return false;
}
/// Returns optional parameter for the ordered region.
std::pair<const Expr *, OMPOrderedClause *> getOrderedRegionParam() const {
  if (const SharingMapTy *Top = getTopOfStackOrNull())
    if (Top->OrderedRegion.hasValue())
      return Top->OrderedRegion.getValue();
  return std::make_pair(nullptr, nullptr);
}
/// Returns true, if parent region is ordered (has associated
/// 'ordered' clause), false - otherwise.
bool isParentOrderedRegion() const {
  if (const SharingMapTy *Parent = getSecondOnStackOrNull())
    return Parent->OrderedRegion.hasValue();
  return false;
}
/// Returns optional parameter for the ordered region.
std::pair<const Expr *, OMPOrderedClause *>
getParentOrderedRegionParam() const {
  if (const SharingMapTy *Parent = getSecondOnStackOrNull())
    if (Parent->OrderedRegion.hasValue())
      return Parent->OrderedRegion.getValue();
  return std::make_pair(nullptr, nullptr);
}
/// Marks current region as nowait (it has a 'nowait' clause).
void setNowaitRegion(bool IsNowait = true) {
  getTopOfStack().NowaitRegion = IsNowait;
}
/// Returns true, if parent region is nowait (has associated
/// 'nowait' clause), false - otherwise.
bool isParentNowaitRegion() const {
  if (const SharingMapTy *Parent = getSecondOnStackOrNull())
    return Parent->NowaitRegion;
  return false;
}
/// Marks parent region as cancel region.
void setParentCancelRegion(bool Cancel = true) {
  if (SharingMapTy *Parent = getSecondOnStackOrNull())
    Parent->CancelRegion |= Cancel;
}
/// Return true if current region has inner cancel construct.
bool isCancelRegion() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->CancelRegion : false;
}

/// Mark that parent region already has scan directive.
void setParentHasScanDirective(SourceLocation Loc) {
  if (SharingMapTy *Parent = getSecondOnStackOrNull())
    Parent->PrevScanLocation = Loc;
}
/// Return true if current region has inner cancel construct.
bool doesParentHasScanDirective() const {
  const SharingMapTy *Top = getSecondOnStackOrNull();
  return Top ? Top->PrevScanLocation.isValid() : false;
}
/// Return true if current region has inner cancel construct.
SourceLocation getParentScanDirectiveLoc() const {
  const SharingMapTy *Top = getSecondOnStackOrNull();
  return Top ? Top->PrevScanLocation : SourceLocation();
}
/// Mark that parent region already has ordered directive.
void setParentHasOrderedDirective(SourceLocation Loc) {
  if (SharingMapTy *Parent = getSecondOnStackOrNull())
    Parent->PrevOrderedLocation = Loc;
}
/// Return true if current region has inner ordered construct.
bool doesParentHasOrderedDirective() const {
  const SharingMapTy *Top = getSecondOnStackOrNull();
  return Top ? Top->PrevOrderedLocation.isValid() : false;
}
/// Returns the location of the previously specified ordered directive.
SourceLocation getParentOrderedDirectiveLoc() const {
  const SharingMapTy *Top = getSecondOnStackOrNull();
  return Top ? Top->PrevOrderedLocation : SourceLocation();
}

/// Set collapse value for the region.
void setAssociatedLoops(unsigned Val) {
  getTopOfStack().AssociatedLoops = Val;
  if (Val > 1)
    getTopOfStack().HasMutipleLoops = true;
}
/// Return collapse value for region.
unsigned getAssociatedLoops() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->AssociatedLoops : 0;
}
/// Returns true if the construct is associated with multiple loops.
bool hasMutipleLoops() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->HasMutipleLoops : false;
}

/// Marks current target region as one with closely nested teams
/// region.
void setParentTeamsRegionLoc(SourceLocation TeamsRegionLoc) {
  if (SharingMapTy *Parent = getSecondOnStackOrNull())
    Parent->InnerTeamsRegionLoc = TeamsRegionLoc;
}
/// Returns true, if current region has closely nested teams region.
bool hasInnerTeamsRegion() const {
  return getInnerTeamsRegionLoc().isValid();
}
/// Returns location of the nested teams region (if any).
SourceLocation getInnerTeamsRegionLoc() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->InnerTeamsRegionLoc : SourceLocation();
}

Scope *getCurScope() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->CurScope : nullptr;
}
void setContext(DeclContext *DC) { getTopOfStack().Context = DC; }
SourceLocation getConstructLoc() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->ConstructLoc : SourceLocation();
}

/// Do the check specified in \a Check to all component lists and return true
/// if any issue is found.
bool checkMappableExprComponentListsForDecl(
    const ValueDecl *VD, bool CurrentRegionOnly,
    const llvm::function_ref<
        bool(OMPClauseMappableExprCommon::MappableExprComponentListRef,
             OpenMPClauseKind)>
        Check) const {
  if (isStackEmpty())
    return false;
  auto SI = begin();
  auto SE = end();

  if (SI == SE)
    return false;

  if (CurrentRegionOnly)
    SE = std::next(SI);
  else
    std::advance(SI, 1);

  for (; SI != SE; ++SI) {
    auto MI = SI->MappedExprComponents.find(VD);
    if (MI != SI->MappedExprComponents.end())
      for (OMPClauseMappableExprCommon::MappableExprComponentListRef L :
           MI->second.Components)
        if (Check(L, MI->second.Kind))
          return true;
  }
  return false;
}

/// Do the check specified in \a Check to all component lists at a given level
/// and return true if any issue is found.
bool checkMappableExprComponentListsForDeclAtLevel(
    const ValueDecl *VD, unsigned Level,
    const llvm::function_ref<
        bool(OMPClauseMappableExprCommon::MappableExprComponentListRef,
             OpenMPClauseKind)>
        Check) const {
  if (getStackSize() <= Level)
    return false;

  const SharingMapTy &StackElem = getStackElemAtLevel(Level);
  auto MI = StackElem.MappedExprComponents.find(VD);
  if (MI != StackElem.MappedExprComponents.end())
    for (OMPClauseMappableExprCommon::MappableExprComponentListRef L :
         MI->second.Components)
      if (Check(L, MI->second.Kind))
        return true;
  return false;
}

/// Create a new mappable expression component list associated with a given
/// declaration and initialize it with the provided list of components.
void addMappableExpressionComponents(
    const ValueDecl *VD,
    OMPClauseMappableExprCommon::MappableExprComponentListRef Components,
    OpenMPClauseKind WhereFoundClauseKind) {
  MappedExprComponentTy &MEC = getTopOfStack().MappedExprComponents[VD];
  // Create new entry and append the new components there.
  MEC.Components.resize(MEC.Components.size() + 1);
  MEC.Components.back().append(Components.begin(), Components.end());
  MEC.Kind = WhereFoundClauseKind;
}

unsigned getNestingLevel() const {
  assert(!isStackEmpty())((void)0);
  return getStackSize() - 1;
}
void addDoacrossDependClause(OMPDependClause *C,
                             const OperatorOffsetTy &OpsOffs) {
  SharingMapTy *Parent = getSecondOnStackOrNull();
  assert(Parent && isOpenMPWorksharingDirective(Parent->Directive))((void)0);
  Parent->DoacrossDepends.try_emplace(C, OpsOffs);
}
llvm::iterator_range<DoacrossDependMapTy::const_iterator>
getDoacrossDependClauses() const {
  const SharingMapTy &StackElem = getTopOfStack();
  if (isOpenMPWorksharingDirective(StackElem.Directive)) {
    const DoacrossDependMapTy &Ref = StackElem.DoacrossDepends;
    return llvm::make_range(Ref.begin(), Ref.end());
  }
  return llvm::make_range(StackElem.DoacrossDepends.end(),
                          StackElem.DoacrossDepends.end());
}

// Store types of classes which have been explicitly mapped
void addMappedClassesQualTypes(QualType QT) {
  SharingMapTy &StackElem = getTopOfStack();
  StackElem.MappedClassesQualTypes.insert(QT);
}

// Return set of mapped classes types
bool isClassPreviouslyMapped(QualType QT) const {
  const SharingMapTy &StackElem = getTopOfStack();
  return StackElem.MappedClassesQualTypes.count(QT) != 0;
}

/// Adds global declare target to the parent target region.
void addToParentTargetRegionLinkGlobals(DeclRefExpr *E) {
  assert(*OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(((void)0)
             E->getDecl()) == OMPDeclareTargetDeclAttr::MT_Link &&((void)0)
         "Expected declare target link global.")((void)0);
  for (auto &Elem : *this) {
    if (isOpenMPTargetExecutionDirective(Elem.Directive)) {
      Elem.DeclareTargetLinkVarDecls.push_back(E);
      return;
    }
  }
}

/// Returns the list of globals with declare target link if current directive
/// is target.
ArrayRef<DeclRefExpr *> getLinkGlobals() const {
  assert(isOpenMPTargetExecutionDirective(getCurrentDirective()) &&((void)0)
         "Expected target executable directive.")((void)0);
  return getTopOfStack().DeclareTargetLinkVarDecls;
}

/// Adds list of allocators expressions.
void addInnerAllocatorExpr(Expr *E) {
  getTopOfStack().InnerUsedAllocators.push_back(E);
}
/// Return list of used allocators.
ArrayRef<Expr *> getInnerAllocators() const {
  return getTopOfStack().InnerUsedAllocators;
}
/// Marks the declaration as implicitly firstprivate nin the task-based
/// regions.
void addImplicitTaskFirstprivate(unsigned Level, Decl *D) {
  getStackElemAtLevel(Level).ImplicitTaskFirstprivates.insert(D);
}
/// Checks if the decl is implicitly firstprivate in the task-based region.
bool isImplicitTaskFirstprivate(Decl *D) const {
  return getTopOfStack().ImplicitTaskFirstprivates.count(D) > 0;
}

/// Marks decl as used in uses_allocators clause as the allocator.
void addUsesAllocatorsDecl(const Decl *D, UsesAllocatorsDeclKind Kind) {
  getTopOfStack().UsesAllocatorsDecls.try_emplace(D, Kind);
}
/// Checks if specified decl is used in uses allocator clause as the
/// allocator.
Optional<UsesAllocatorsDeclKind> isUsesAllocatorsDecl(unsigned Level,
                                                      const Decl *D) const {
  const SharingMapTy &StackElem = getTopOfStack();
  auto I = StackElem.UsesAllocatorsDecls.find(D);
  if (I == StackElem.UsesAllocatorsDecls.end())
    return None;
  return I->getSecond();
}
Optional<UsesAllocatorsDeclKind> isUsesAllocatorsDecl(const Decl *D) const {
  const SharingMapTy &StackElem = getTopOfStack();
  auto I = StackElem.UsesAllocatorsDecls.find(D);
  if (I == StackElem.UsesAllocatorsDecls.end())
    return None;
  return I->getSecond();
}

void addDeclareMapperVarRef(Expr *Ref) {
  SharingMapTy &StackElem = getTopOfStack();
  StackElem.DeclareMapperVar = Ref;
}
const Expr *getDeclareMapperVarRef() const {
  const SharingMapTy *Top = getTopOfStackOrNull();
  return Top ? Top->DeclareMapperVar : nullptr;
}
1097};

1099bool isImplicitTaskingRegion(OpenMPDirectiveKind DKind) {
return isOpenMPParallelDirective(DKind) || isOpenMPTeamsDirective(DKind);
1101}

1103bool isImplicitOrExplicitTaskingRegion(OpenMPDirectiveKind DKind) {
return isImplicitTaskingRegion(DKind) || isOpenMPTaskingDirective(DKind) ||
       DKind == OMPD_unknown;
1106}

1108} // namespace

1110static const Expr *getExprAsWritten(const Expr *E) {
if (const auto *FE = dyn_cast<FullExpr>(E))
  E = FE->getSubExpr();

if (const auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
  E = MTE->getSubExpr();

while (const auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
  E = Binder->getSubExpr();

if (const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
  E = ICE->getSubExprAsWritten();
return E->IgnoreParens();
1123}

1125static Expr *getExprAsWritten(Expr *E) {
return const_cast<Expr *>(getExprAsWritten(const_cast<const Expr *>(E)));
1127}

1129static const ValueDecl *getCanonicalDecl(const ValueDecl *D) {
if (const auto *CED = dyn_cast<OMPCapturedExprDecl>(D))
  if (const auto *ME = dyn_cast<MemberExpr>(getExprAsWritten(CED->getInit())))
    D = ME->getMemberDecl();
const auto *VD = dyn_cast<VarDecl>(D);
const auto *FD = dyn_cast<FieldDecl>(D);
if (VD != nullptr) {
  VD = VD->getCanonicalDecl();
  D = VD;
} else {
  assert(FD)((void)0);
  FD = FD->getCanonicalDecl();
  D = FD;
}
return D;
1144}

1146static ValueDecl *getCanonicalDecl(ValueDecl *D) {
return const_cast<ValueDecl *>(
    getCanonicalDecl(const_cast<const ValueDecl *>(D)));
1149}

1151DSAStackTy::DSAVarData DSAStackTy::getDSA(const_iterator &Iter,
                                        ValueDecl *D) const {
D = getCanonicalDecl(D);
auto *VD = dyn_cast<VarDecl>(D);
11
←
Assuming 'D' is not a 'VarDecl'→
12
←
'VD' initialized to a null pointer value→
const auto *FD = dyn_cast<FieldDecl>(D);
13
←
Assuming 'D' is not a 'FieldDecl'→
DSAVarData DVar;
if (Iter == end()) {
14
←
Calling 'operator==<const (anonymous namespace)::DSAStackTy::SharingMapTy *, const (anonymous namespace)::DSAStackTy::SharingMapTy *>'→
17
←
Returning from 'operator==<const (anonymous namespace)::DSAStackTy::SharingMapTy *, const (anonymous namespace)::DSAStackTy::SharingMapTy *>'→
18
←
Taking false branch→
  // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
  // in a region but not in construct]
  //  File-scope or namespace-scope variables referenced in called routines
  //  in the region are shared unless they appear in a threadprivate
  //  directive.
  if (VD && !VD->isFunctionOrMethodVarDecl() && !isa<ParmVarDecl>(VD))
    DVar.CKind = OMPC_shared;

  // OpenMP [2.9.1.2, Data-sharing Attribute Rules for Variables Referenced
  // in a region but not in construct]
  //  Variables with static storage duration that are declared in called
  //  routines in the region are shared.
  if (VD && VD->hasGlobalStorage())
    DVar.CKind = OMPC_shared;

  // Non-static data members are shared by default.
  if (FD)
    DVar.CKind = OMPC_shared;

  return DVar;
}

// OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
// in a Construct, C/C++, predetermined, p.1]
// Variables with automatic storage duration that are declared in a scope
// inside the construct are private.
if (VD18.1
'VD' is null
1
'VD' is null
 && isOpenMPLocal(VD, Iter) && VD->isLocalVarDecl() &&
    (VD->getStorageClass() == SC_Auto || VD->getStorageClass() == SC_None)) {
  DVar.CKind = OMPC_private;
  return DVar;
}

DVar.DKind = Iter->Directive;
// Explicitly specified attributes and local variables with predetermined
// attributes.
if (Iter->SharingMap.count(D)) {
19
←
Assuming the condition is false→
20
←
Taking false branch→
  const DSAInfo &Data = Iter->SharingMap.lookup(D);
  DVar.RefExpr = Data.RefExpr.getPointer();
  DVar.PrivateCopy = Data.PrivateCopy;
  DVar.CKind = Data.Attributes;
  DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
  DVar.Modifier = Data.Modifier;
  DVar.AppliedToPointee = Data.AppliedToPointee;
  return DVar;
}

// OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
// in a Construct, C/C++, implicitly determined, p.1]
//  In a parallel or task construct, the data-sharing attributes of these
//  variables are determined by the default clause, if present.
switch (Iter->DefaultAttr) {
21
←
Control jumps to 'case DSA_firstprivate:'  at line 1215→
case DSA_shared:
  DVar.CKind = OMPC_shared;
  DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
  return DVar;
case DSA_none:
  return DVar;
case DSA_firstprivate:
  if (VD->getStorageDuration() == SD_Static &&
22
←
Called C++ object pointer is null
      VD->getDeclContext()->isFileContext()) {
    DVar.CKind = OMPC_unknown;
  } else {
    DVar.CKind = OMPC_firstprivate;
  }
  DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
  return DVar;
case DSA_unspecified:
  // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
  // in a Construct, implicitly determined, p.2]
  //  In a parallel construct, if no default clause is present, these
  //  variables are shared.
  DVar.ImplicitDSALoc = Iter->DefaultAttrLoc;
  if ((isOpenMPParallelDirective(DVar.DKind) &&
       !isOpenMPTaskLoopDirective(DVar.DKind)) ||
      isOpenMPTeamsDirective(DVar.DKind)) {
    DVar.CKind = OMPC_shared;
    return DVar;
  }

  // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
  // in a Construct, implicitly determined, p.4]
  //  In a task construct, if no default clause is present, a variable that in
  //  the enclosing context is determined to be shared by all implicit tasks
  //  bound to the current team is shared.
  if (isOpenMPTaskingDirective(DVar.DKind)) {
    DSAVarData DVarTemp;
    const_iterator I = Iter, E = end();
    do {
      ++I;
      // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables
      // Referenced in a Construct, implicitly determined, p.6]
      //  In a task construct, if no default clause is present, a variable
      //  whose data-sharing attribute is not determined by the rules above is
      //  firstprivate.
      DVarTemp = getDSA(I, D);
      if (DVarTemp.CKind != OMPC_shared) {
        DVar.RefExpr = nullptr;
        DVar.CKind = OMPC_firstprivate;
        return DVar;
      }
    } while (I != E && !isImplicitTaskingRegion(I->Directive));
    DVar.CKind =
        (DVarTemp.CKind == OMPC_unknown) ? OMPC_firstprivate : OMPC_shared;
    return DVar;
  }
}
// OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
// in a Construct, implicitly determined, p.3]
//  For constructs other than task, if no default clause is present, these
//  variables inherit their data-sharing attributes from the enclosing
//  context.
return getDSA(++Iter, D);
1270}

1272const Expr *DSAStackTy::addUniqueAligned(const ValueDecl *D,
                                       const Expr *NewDE) {
assert(!isStackEmpty() && "Data sharing attributes stack is empty")((void)0);
D = getCanonicalDecl(D);
SharingMapTy &StackElem = getTopOfStack();
auto It = StackElem.AlignedMap.find(D);
if (It == StackElem.AlignedMap.end()) {
  assert(NewDE && "Unexpected nullptr expr to be added into aligned map")((void)0);
  StackElem.AlignedMap[D] = NewDE;
  return nullptr;
}
assert(It->second && "Unexpected nullptr expr in the aligned map")((void)0);
return It->second;
1285}

1287const Expr *DSAStackTy::addUniqueNontemporal(const ValueDecl *D,
                                           const Expr *NewDE) {
assert(!isStackEmpty() && "Data sharing attributes stack is empty")((void)0);
D = getCanonicalDecl(D);
SharingMapTy &StackElem = getTopOfStack();
auto It = StackElem.NontemporalMap.find(D);
if (It == StackElem.NontemporalMap.end()) {
  assert(NewDE && "Unexpected nullptr expr to be added into aligned map")((void)0);
  StackElem.NontemporalMap[D] = NewDE;
  return nullptr;
}
assert(It->second && "Unexpected nullptr expr in the aligned map")((void)0);
return It->second;
1300}

1302void DSAStackTy::addLoopControlVariable(const ValueDecl *D, VarDecl *Capture) {
assert(!isStackEmpty() && "Data-sharing attributes stack is empty")((void)0);
D = getCanonicalDecl(D);
SharingMapTy &StackElem = getTopOfStack();
StackElem.LCVMap.try_emplace(
    D, LCDeclInfo(StackElem.LCVMap.size() + 1, Capture));
1308}

1310const DSAStackTy::LCDeclInfo
1311DSAStackTy::isLoopControlVariable(const ValueDecl *D) const {
assert(!isStackEmpty() && "Data-sharing attributes stack is empty")((void)0);
D = getCanonicalDecl(D);
const SharingMapTy &StackElem = getTopOfStack();
auto It = StackElem.LCVMap.find(D);
if (It != StackElem.LCVMap.end())
  return It->second;
return {0, nullptr};
1319}

1321const DSAStackTy::LCDeclInfo
1322DSAStackTy::isLoopControlVariable(const ValueDecl *D, unsigned Level) const {
assert(!isStackEmpty() && "Data-sharing attributes stack is empty")((void)0);
D = getCanonicalDecl(D);
for (unsigned I = Level + 1; I > 0; --I) {
  const SharingMapTy &StackElem = getStackElemAtLevel(I - 1);
  auto It = StackElem.LCVMap.find(D);
  if (It != StackElem.LCVMap.end())
    return It->second;
}
return {0, nullptr};
1332}

1334const DSAStackTy::LCDeclInfo
1335DSAStackTy::isParentLoopControlVariable(const ValueDecl *D) const {
const SharingMapTy *Parent = getSecondOnStackOrNull();
assert(Parent && "Data-sharing attributes stack is empty")((void)0);
D = getCanonicalDecl(D);
auto It = Parent->LCVMap.find(D);
if (It != Parent->LCVMap.end())
  return It->second;
return {0, nullptr};
1343}

1345const ValueDecl *DSAStackTy::getParentLoopControlVariable(unsigned I) const {
const SharingMapTy *Parent = getSecondOnStackOrNull();
assert(Parent && "Data-sharing attributes stack is empty")((void)0);
if (Parent->LCVMap.size() < I)
  return nullptr;
for (const auto &Pair : Parent->LCVMap)
  if (Pair.second.first == I)
    return Pair.first;
return nullptr;
1354}

1356void DSAStackTy::addDSA(const ValueDecl *D, const Expr *E, OpenMPClauseKind A,
                      DeclRefExpr *PrivateCopy, unsigned Modifier,
                      bool AppliedToPointee) {
D = getCanonicalDecl(D);
if (A == OMPC_threadprivate) {
  DSAInfo &Data = Threadprivates[D];
  Data.Attributes = A;
  Data.RefExpr.setPointer(E);
  Data.PrivateCopy = nullptr;
  Data.Modifier = Modifier;
} else {
  DSAInfo &Data = getTopOfStack().SharingMap[D];
  assert(Data.Attributes == OMPC_unknown || (A == Data.Attributes) ||((void)0)
         (A == OMPC_firstprivate && Data.Attributes == OMPC_lastprivate) ||((void)0)
         (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) ||((void)0)
         (isLoopControlVariable(D).first && A == OMPC_private))((void)0);
  Data.Modifier = Modifier;
  if (A == OMPC_lastprivate && Data.Attributes == OMPC_firstprivate) {
    Data.RefExpr.setInt(/*IntVal=*/true);
    return;
  }
  const bool IsLastprivate =
      A == OMPC_lastprivate || Data.Attributes == OMPC_lastprivate;
  Data.Attributes = A;
  Data.RefExpr.setPointerAndInt(E, IsLastprivate);
  Data.PrivateCopy = PrivateCopy;
  Data.AppliedToPointee = AppliedToPointee;
  if (PrivateCopy) {
    DSAInfo &Data = getTopOfStack().SharingMap[PrivateCopy->getDecl()];
    Data.Modifier = Modifier;
    Data.Attributes = A;
    Data.RefExpr.setPointerAndInt(PrivateCopy, IsLastprivate);
    Data.PrivateCopy = nullptr;
    Data.AppliedToPointee = AppliedToPointee;
  }
}
1392}

1394/// Build a variable declaration for OpenMP loop iteration variable.
1395static VarDecl *buildVarDecl(Sema &SemaRef, SourceLocation Loc, QualType Type,
                           StringRef Name, const AttrVec *Attrs = nullptr,
                           DeclRefExpr *OrigRef = nullptr) {
DeclContext *DC = SemaRef.CurContext;
IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
auto *Decl =
    VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type, TInfo, SC_None);
if (Attrs) {
  for (specific_attr_iterator<AlignedAttr> I(Attrs->begin()), E(Attrs->end());
       I != E; ++I)
    Decl->addAttr(*I);
}
Decl->setImplicit();
if (OrigRef) {
  Decl->addAttr(
      OMPReferencedVarAttr::CreateImplicit(SemaRef.Context, OrigRef));
}
return Decl;
1414}

1416static DeclRefExpr *buildDeclRefExpr(Sema &S, VarDecl *D, QualType Ty,
                                   SourceLocation Loc,
                                   bool RefersToCapture = false) {
D->setReferenced();
D->markUsed(S.Context);
return DeclRefExpr::Create(S.getASTContext(), NestedNameSpecifierLoc(),
                           SourceLocation(), D, RefersToCapture, Loc, Ty,
                           VK_LValue);
1424}

1426void DSAStackTy::addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
                                         BinaryOperatorKind BOK) {
D = getCanonicalDecl(D);
assert(!isStackEmpty() && "Data-sharing attributes stack is empty")((void)0);
assert(((void)0)
    getTopOfStack().SharingMap[D].Attributes == OMPC_reduction &&((void)0)
    "Additional reduction info may be specified only for reduction items.")((void)0);
ReductionData &ReductionData = getTopOfStack().ReductionMap[D];
assert(ReductionData.ReductionRange.isInvalid() &&((void)0)
       (getTopOfStack().Directive == OMPD_taskgroup ||((void)0)
        ((isOpenMPParallelDirective(getTopOfStack().Directive) ||((void)0)
          isOpenMPWorksharingDirective(getTopOfStack().Directive)) &&((void)0)
         !isOpenMPSimdDirective(getTopOfStack().Directive))) &&((void)0)
       "Additional reduction info may be specified only once for reduction "((void)0)
       "items.")((void)0);
ReductionData.set(BOK, SR);
Expr *&TaskgroupReductionRef =
    getTopOfStack().TaskgroupReductionRef;
if (!TaskgroupReductionRef) {
  VarDecl *VD = buildVarDecl(SemaRef, SR.getBegin(),
                             SemaRef.Context.VoidPtrTy, ".task_red.");
  TaskgroupReductionRef =
      buildDeclRefExpr(SemaRef, VD, SemaRef.Context.VoidPtrTy, SR.getBegin());
}
1450}

1452void DSAStackTy::addTaskgroupReductionData(const ValueDecl *D, SourceRange SR,
                                         const Expr *ReductionRef) {
D = getCanonicalDecl(D);
assert(!isStackEmpty() && "Data-sharing attributes stack is empty")((void)0);
assert(((void)0)
    getTopOfStack().SharingMap[D].Attributes == OMPC_reduction &&((void)0)
    "Additional reduction info may be specified only for reduction items.")((void)0);
ReductionData &ReductionData = getTopOfStack().ReductionMap[D];
assert(ReductionData.ReductionRange.isInvalid() &&((void)0)
       (getTopOfStack().Directive == OMPD_taskgroup ||((void)0)
        ((isOpenMPParallelDirective(getTopOfStack().Directive) ||((void)0)
          isOpenMPWorksharingDirective(getTopOfStack().Directive)) &&((void)0)
         !isOpenMPSimdDirective(getTopOfStack().Directive))) &&((void)0)
       "Additional reduction info may be specified only once for reduction "((void)0)
       "items.")((void)0);
ReductionData.set(ReductionRef, SR);
Expr *&TaskgroupReductionRef =
    getTopOfStack().TaskgroupReductionRef;
if (!TaskgroupReductionRef) {
  VarDecl *VD = buildVarDecl(SemaRef, SR.getBegin(),
                             SemaRef.Context.VoidPtrTy, ".task_red.");
  TaskgroupReductionRef =
      buildDeclRefExpr(SemaRef, VD, SemaRef.Context.VoidPtrTy, SR.getBegin());
}
1476}

1478const DSAStackTy::DSAVarData DSAStackTy::getTopMostTaskgroupReductionData(
  const ValueDecl *D, SourceRange &SR, BinaryOperatorKind &BOK,
  Expr *&TaskgroupDescriptor) const {
D = getCanonicalDecl(D);
assert(!isStackEmpty() && "Data-sharing attributes stack is empty.")((void)0);
for (const_iterator I = begin() + 1, E = end(); I != E; ++I) {
  const DSAInfo &Data = I->SharingMap.lookup(D);
  if (Data.Attributes != OMPC_reduction ||
      Data.Modifier != OMPC_REDUCTION_task)
    continue;
  const ReductionData &ReductionData = I->ReductionMap.lookup(D);
  if (!ReductionData.ReductionOp ||
      ReductionData.ReductionOp.is<const Expr *>())
    return DSAVarData();
  SR = ReductionData.ReductionRange;
  BOK = ReductionData.ReductionOp.get<ReductionData::BOKPtrType>();
  assert(I->TaskgroupReductionRef && "taskgroup reduction reference "((void)0)
                                     "expression for the descriptor is not "((void)0)
                                     "set.")((void)0);
  TaskgroupDescriptor = I->TaskgroupReductionRef;
  return DSAVarData(I->Directive, OMPC_reduction, Data.RefExpr.getPointer(),
                    Data.PrivateCopy, I->DefaultAttrLoc, OMPC_REDUCTION_task,
                    /*AppliedToPointee=*/false);
}
return DSAVarData();
1503}

1505const DSAStackTy::DSAVarData DSAStackTy::getTopMostTaskgroupReductionData(
  const ValueDecl *D, SourceRange &SR, const Expr *&ReductionRef,
  Expr *&TaskgroupDescriptor) const {
D = getCanonicalDecl(D);
assert(!isStackEmpty() && "Data-sharing attributes stack is empty.")((void)0);
for (const_iterator I = begin() + 1, E = end(); I != E; ++I) {
  const DSAInfo &Data = I->SharingMap.lookup(D);
  if (Data.Attributes != OMPC_reduction ||
      Data.Modifier != OMPC_REDUCTION_task)
    continue;
  const ReductionData &ReductionData = I->ReductionMap.lookup(D);
  if (!ReductionData.ReductionOp ||
      !ReductionData.ReductionOp.is<const Expr *>())
    return DSAVarData();
  SR = ReductionData.ReductionRange;
  ReductionRef = ReductionData.ReductionOp.get<const Expr *>();
  assert(I->TaskgroupReductionRef && "taskgroup reduction reference "((void)0)
                                     "expression for the descriptor is not "((void)0)
                                     "set.")((void)0);
  TaskgroupDescriptor = I->TaskgroupReductionRef;
  return DSAVarData(I->Directive, OMPC_reduction, Data.RefExpr.getPointer(),
                    Data.PrivateCopy, I->DefaultAttrLoc, OMPC_REDUCTION_task,
                    /*AppliedToPointee=*/false);
}
return DSAVarData();
1530}

1532bool DSAStackTy::isOpenMPLocal(VarDecl *D, const_iterator I) const {
D = D->getCanonicalDecl();
for (const_iterator E = end(); I != E; ++I) {
  if (isImplicitOrExplicitTaskingRegion(I->Directive) ||
      isOpenMPTargetExecutionDirective(I->Directive)) {
    if (I->CurScope) {
      Scope *TopScope = I->CurScope->getParent();
      Scope *CurScope = getCurScope();
      while (CurScope && CurScope != TopScope && !CurScope->isDeclScope(D))
        CurScope = CurScope->getParent();
      return CurScope != TopScope;
    }
    for (DeclContext *DC = D->getDeclContext(); DC; DC = DC->getParent())
      if (I->Context == DC)
        return true;
    return false;
  }
}
return false;
1551}

1553static bool isConstNotMutableType(Sema &SemaRef, QualType Type,
                                bool AcceptIfMutable = true,
                                bool *IsClassType = nullptr) {
ASTContext &Context = SemaRef.getASTContext();
Type = Type.getNonReferenceType().getCanonicalType();
bool IsConstant = Type.isConstant(Context);
Type = Context.getBaseElementType(Type);
const CXXRecordDecl *RD = AcceptIfMutable && SemaRef.getLangOpts().CPlusPlus
                              ? Type->getAsCXXRecordDecl()
                              : nullptr;
if (const auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(RD))
  if (const ClassTemplateDecl *CTD = CTSD->getSpecializedTemplate())
    RD = CTD->getTemplatedDecl();
if (IsClassType)
  *IsClassType = RD;
return IsConstant && !(SemaRef.getLangOpts().CPlusPlus && RD &&
                       RD->hasDefinition() && RD->hasMutableFields());
1570}

1572static bool rejectConstNotMutableType(Sema &SemaRef, const ValueDecl *D,
                                    QualType Type, OpenMPClauseKind CKind,
                                    SourceLocation ELoc,
                                    bool AcceptIfMutable = true,
                                    bool ListItemNotVar = false) {
ASTContext &Context = SemaRef.getASTContext();
bool IsClassType;
if (isConstNotMutableType(SemaRef, Type, AcceptIfMutable, &IsClassType)) {
  unsigned Diag = ListItemNotVar
                      ? diag::err_omp_const_list_item
                      : IsClassType ? diag::err_omp_const_not_mutable_variable
                                    : diag::err_omp_const_variable;
  SemaRef.Diag(ELoc, Diag) << getOpenMPClauseName(CKind);
  if (!ListItemNotVar && D) {
    const VarDecl *VD = dyn_cast<VarDecl>(D);
    bool IsDecl = !VD || VD->isThisDeclarationADefinition(Context) ==
                             VarDecl::DeclarationOnly;
    SemaRef.Diag(D->getLocation(),
                 IsDecl ? diag::note_previous_decl : diag::note_defined_here)
        << D;
  }
  return true;
}
return false;
1596}

1598const DSAStackTy::DSAVarData DSAStackTy::getTopDSA(ValueDecl *D,
                                                 bool FromParent) {
D = getCanonicalDecl(D);
DSAVarData DVar;

auto *VD = dyn_cast<VarDecl>(D);
auto TI = Threadprivates.find(D);
if (TI != Threadprivates.end()) {
  DVar.RefExpr = TI->getSecond().RefExpr.getPointer();
  DVar.CKind = OMPC_threadprivate;
  DVar.Modifier = TI->getSecond().Modifier;
  return DVar;
}
if (VD && VD->hasAttr<OMPThreadPrivateDeclAttr>()) {
  DVar.RefExpr = buildDeclRefExpr(
      SemaRef, VD, D->getType().getNonReferenceType(),
      VD->getAttr<OMPThreadPrivateDeclAttr>()->getLocation());
  DVar.CKind = OMPC_threadprivate;
  addDSA(D, DVar.RefExpr, OMPC_threadprivate);
  return DVar;
}
// OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
// in a Construct, C/C++, predetermined, p.1]
//  Variables appearing in threadprivate directives are threadprivate.
if ((VD && VD->getTLSKind() != VarDecl::TLS_None &&
     !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
       SemaRef.getLangOpts().OpenMPUseTLS &&
       SemaRef.getASTContext().getTargetInfo().isTLSSupported())) ||
    (VD && VD->getStorageClass() == SC_Register &&
     VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())) {
  DVar.RefExpr = buildDeclRefExpr(
      SemaRef, VD, D->getType().getNonReferenceType(), D->getLocation());
  DVar.CKind = OMPC_threadprivate;
  addDSA(D, DVar.RefExpr, OMPC_threadprivate);
  return DVar;
}
if (SemaRef.getLangOpts().OpenMPCUDAMode && VD &&
    VD->isLocalVarDeclOrParm() && !isStackEmpty() &&
    !isLoopControlVariable(D).first) {
  const_iterator IterTarget =
      std::find_if(begin(), end(), [](const SharingMapTy &Data) {
        return isOpenMPTargetExecutionDirective(Data.Directive);
      });
  if (IterTarget != end()) {
    const_iterator ParentIterTarget = IterTarget + 1;
    for (const_iterator Iter = begin();
         Iter != ParentIterTarget; ++Iter) {
      if (isOpenMPLocal(VD, Iter)) {
        DVar.RefExpr =
            buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
                             D->getLocation());
        DVar.CKind = OMPC_threadprivate;
        return DVar;
      }
    }
    if (!isClauseParsingMode() || IterTarget != begin()) {
      auto DSAIter = IterTarget->SharingMap.find(D);
      if (DSAIter != IterTarget->SharingMap.end() &&
          isOpenMPPrivate(DSAIter->getSecond().Attributes)) {
        DVar.RefExpr = DSAIter->getSecond().RefExpr.getPointer();
        DVar.CKind = OMPC_threadprivate;
        return DVar;
      }
      const_iterator End = end();
      if (!SemaRef.isOpenMPCapturedByRef(
              D, std::distance(ParentIterTarget, End),
              /*OpenMPCaptureLevel=*/0)) {
        DVar.RefExpr =
            buildDeclRefExpr(SemaRef, VD, D->getType().getNonReferenceType(),
                             IterTarget->ConstructLoc);
        DVar.CKind = OMPC_threadprivate;
        return DVar;
      }
    }
  }
}

if (isStackEmpty())
  // Not in OpenMP execution region and top scope was already checked.
  return DVar;

// OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
// in a Construct, C/C++, predetermined, p.4]
//  Static data members are shared.
// OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
// in a Construct, C/C++, predetermined, p.7]
//  Variables with static storage duration that are declared in a scope
//  inside the construct are shared.
if (VD && VD->isStaticDataMember()) {
  // Check for explicitly specified attributes.
  const_iterator I = begin();
  const_iterator EndI = end();
  if (FromParent && I != EndI)
    ++I;
  if (I != EndI) {
    auto It = I->SharingMap.find(D);
    if (It != I->SharingMap.end()) {
      const DSAInfo &Data = It->getSecond();
      DVar.RefExpr = Data.RefExpr.getPointer();
      DVar.PrivateCopy = Data.PrivateCopy;
      DVar.CKind = Data.Attributes;
      DVar.ImplicitDSALoc = I->DefaultAttrLoc;
      DVar.DKind = I->Directive;
      DVar.Modifier = Data.Modifier;
      DVar.AppliedToPointee = Data.AppliedToPointee;
      return DVar;
    }
  }

  DVar.CKind = OMPC_shared;
  return DVar;
}

auto &&MatchesAlways = [](OpenMPDirectiveKind) { return true; };
// The predetermined shared attribute for const-qualified types having no
// mutable members was removed after OpenMP 3.1.
if (SemaRef.LangOpts.OpenMP <= 31) {
  // OpenMP [2.9.1.1, Data-sharing Attribute Rules for Variables Referenced
  // in a Construct, C/C++, predetermined, p.6]
  //  Variables with const qualified type having no mutable member are
  //  shared.
  if (isConstNotMutableType(SemaRef, D->getType())) {
    // Variables with const-qualified type having no mutable member may be
    // listed in a firstprivate clause, even if they are static data members.
    DSAVarData DVarTemp = hasInnermostDSA(
        D,
        [](OpenMPClauseKind C, bool) {
          return C == OMPC_firstprivate || C == OMPC_shared;
        },
        MatchesAlways, FromParent);
    if (DVarTemp.CKind != OMPC_unknown && DVarTemp.RefExpr)
      return DVarTemp;

    DVar.CKind = OMPC_shared;
    return DVar;
  }
}

// Explicitly specified attributes and local variables with predetermined
// attributes.
const_iterator I = begin();
const_iterator EndI = end();
if (FromParent && I != EndI)
  ++I;
if (I == EndI)
  return DVar;
auto It = I->SharingMap.find(D);
if (It != I->SharingMap.end()) {
  const DSAInfo &Data = It->getSecond();
  DVar.RefExpr = Data.RefExpr.getPointer();
  DVar.PrivateCopy = Data.PrivateCopy;
  DVar.CKind = Data.Attributes;
  DVar.ImplicitDSALoc = I->DefaultAttrLoc;
  DVar.DKind = I->Directive;
  DVar.Modifier = Data.Modifier;
  DVar.AppliedToPointee = Data.AppliedToPointee;
}

return DVar;
1757}

1759const DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
                                                      bool FromParent) const {
if (isStackEmpty()) {
  const_iterator I;
  return getDSA(I, D);
}
D = getCanonicalDecl(D);
const_iterator StartI = begin();
const_iterator EndI = end();
if (FromParent && StartI != EndI)
  ++StartI;
return getDSA(StartI, D);
1771}

1773const DSAStackTy::DSAVarData DSAStackTy::getImplicitDSA(ValueDecl *D,
                                                      unsigned Level) const {
if (getStackSize() <= Level)
8
←
Assuming the condition is false→
9
←
Taking false branch→
  return DSAVarData();
D = getCanonicalDecl(D);
const_iterator StartI = std::next(begin(), getStackSize() - 1 - Level);
return getDSA(StartI, D);
10
←
Calling 'DSAStackTy::getDSA'→
1780}

1782const DSAStackTy::DSAVarData
1783DSAStackTy::hasDSA(ValueDecl *D,
                 const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
                 const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
                 bool FromParent) const {
if (isStackEmpty())
  return {};
D = getCanonicalDecl(D);
const_iterator I = begin();
const_iterator EndI = end();
if (FromParent && I != EndI)
  ++I;
for (; I != EndI; ++I) {
  if (!DPred(I->Directive) &&
      !isImplicitOrExplicitTaskingRegion(I->Directive))
    continue;
  const_iterator NewI = I;
  DSAVarData DVar = getDSA(NewI, D);
  if (I == NewI && CPred(DVar.CKind, DVar.AppliedToPointee))
    return DVar;
}
return {};
1804}

1806const DSAStackTy::DSAVarData DSAStackTy::hasInnermostDSA(
  ValueDecl *D, const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
  const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
  bool FromParent) const {
if (isStackEmpty())
  return {};
D = getCanonicalDecl(D);
const_iterator StartI = begin();
const_iterator EndI = end();
if (FromParent && StartI != EndI)
  ++StartI;
if (StartI == EndI || !DPred(StartI->Directive))
  return {};
const_iterator NewI = StartI;
DSAVarData DVar = getDSA(NewI, D);
return (NewI == StartI && CPred(DVar.CKind, DVar.AppliedToPointee))
           ? DVar
           : DSAVarData();
1824}

1826bool DSAStackTy::hasExplicitDSA(
  const ValueDecl *D,
  const llvm::function_ref<bool(OpenMPClauseKind, bool)> CPred,
  unsigned Level, bool NotLastprivate) const {
if (getStackSize() <= Level)
  return false;
D = getCanonicalDecl(D);
const SharingMapTy &StackElem = getStackElemAtLevel(Level);
auto I = StackElem.SharingMap.find(D);
if (I != StackElem.SharingMap.end() && I->getSecond().RefExpr.getPointer() &&
    CPred(I->getSecond().Attributes, I->getSecond().AppliedToPointee) &&
    (!NotLastprivate || !I->getSecond().RefExpr.getInt()))
  return true;
// Check predetermined rules for the loop control variables.
auto LI = StackElem.LCVMap.find(D);
if (LI != StackElem.LCVMap.end())
  return CPred(OMPC_private, /*AppliedToPointee=*/false);
return false;
1844}

1846bool DSAStackTy::hasExplicitDirective(
  const llvm::function_ref<bool(OpenMPDirectiveKind)> DPred,
  unsigned Level) const {
if (getStackSize() <= Level)
  return false;
const SharingMapTy &StackElem = getStackElemAtLevel(Level);
return DPred(StackElem.Directive);
1853}

1855bool DSAStackTy::hasDirective(
  const llvm::function_ref<bool(OpenMPDirectiveKind,
                                const DeclarationNameInfo &, SourceLocation)>
      DPred,
  bool FromParent) const {
// We look only in the enclosing region.
size_t Skip = FromParent ? 2 : 1;
for (const_iterator I = begin() + std::min(Skip, getStackSize()), E = end();
     I != E; ++I) {
  if (DPred(I->Directive, I->DirectiveName, I->ConstructLoc))
    return true;
}
return false;
1868}

1870void Sema::InitDataSharingAttributesStack() {
VarDataSharingAttributesStack = new DSAStackTy(*this);
1872}

1874#define DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
) static_cast<DSAStackTy *>(VarDataSharingAttributesStack)

1876void Sema::pushOpenMPFunctionRegion() {
DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->pushFunction();
1878}

1880void Sema::popOpenMPFunctionRegion(const FunctionScopeInfo *OldFSI) {
DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->popFunction(OldFSI);
1882}

1884static bool isOpenMPDeviceDelayedContext(Sema &S) {
assert(S.LangOpts.OpenMP && S.LangOpts.OpenMPIsDevice &&((void)0)
       "Expected OpenMP device compilation.")((void)0);
return !S.isInOpenMPTargetExecutionDirective();
1888}

1890namespace {
1891/// Status of the function emission on the host/device.
1892enum class FunctionEmissionStatus {
Emitted,
Discarded,
Unknown,
1896};
1897} // anonymous namespace

1899Sema::SemaDiagnosticBuilder Sema::diagIfOpenMPDeviceCode(SourceLocation Loc,
                                                       unsigned DiagID,
                                                       FunctionDecl *FD) {
assert(LangOpts.OpenMP && LangOpts.OpenMPIsDevice &&((void)0)
       "Expected OpenMP device compilation.")((void)0);

SemaDiagnosticBuilder::Kind Kind = SemaDiagnosticBuilder::K_Nop;
if (FD) {
  FunctionEmissionStatus FES = getEmissionStatus(FD);
  switch (FES) {
  case FunctionEmissionStatus::Emitted:
    Kind = SemaDiagnosticBuilder::K_Immediate;
    break;
  case FunctionEmissionStatus::Unknown:
    // TODO: We should always delay diagnostics here in case a target
    //       region is in a function we do not emit. However, as the
    //       current diagnostics are associated with the function containing
    //       the target region and we do not emit that one, we would miss out
    //       on diagnostics for the target region itself. We need to anchor
    //       the diagnostics with the new generated function *or* ensure we
    //       emit diagnostics associated with the surrounding function.
    Kind = isOpenMPDeviceDelayedContext(*this)
               ? SemaDiagnosticBuilder::K_Deferred
               : SemaDiagnosticBuilder::K_Immediate;
    break;
  case FunctionEmissionStatus::TemplateDiscarded:
  case FunctionEmissionStatus::OMPDiscarded:
    Kind = SemaDiagnosticBuilder::K_Nop;
    break;
  case FunctionEmissionStatus::CUDADiscarded:
    llvm_unreachable("CUDADiscarded unexpected in OpenMP device compilation")__builtin_unreachable();
    break;
  }
}

return SemaDiagnosticBuilder(Kind, Loc, DiagID, FD, *this);
1935}

1937Sema::SemaDiagnosticBuilder Sema::diagIfOpenMPHostCode(SourceLocation Loc,
                                                     unsigned DiagID,
                                                     FunctionDecl *FD) {
assert(LangOpts.OpenMP && !LangOpts.OpenMPIsDevice &&((void)0)
       "Expected OpenMP host compilation.")((void)0);

SemaDiagnosticBuilder::Kind Kind = SemaDiagnosticBuilder::K_Nop;
if (FD) {
  FunctionEmissionStatus FES = getEmissionStatus(FD);
  switch (FES) {
  case FunctionEmissionStatus::Emitted:
    Kind = SemaDiagnosticBuilder::K_Immediate;
    break;
  case FunctionEmissionStatus::Unknown:
    Kind = SemaDiagnosticBuilder::K_Deferred;
    break;
  case FunctionEmissionStatus::TemplateDiscarded:
  case FunctionEmissionStatus::OMPDiscarded:
  case FunctionEmissionStatus::CUDADiscarded:
    Kind = SemaDiagnosticBuilder::K_Nop;
    break;
  }
}

return SemaDiagnosticBuilder(Kind, Loc, DiagID, FD, *this);
1962}

1964static OpenMPDefaultmapClauseKind
1965getVariableCategoryFromDecl(const LangOptions &LO, const ValueDecl *VD) {
if (LO.OpenMP <= 45) {
  if (VD->getType().getNonReferenceType()->isScalarType())
    return OMPC_DEFAULTMAP_scalar;
  return OMPC_DEFAULTMAP_aggregate;
}
if (VD->getType().getNonReferenceType()->isAnyPointerType())
  return OMPC_DEFAULTMAP_pointer;
if (VD->getType().getNonReferenceType()->isScalarType())
  return OMPC_DEFAULTMAP_scalar;
return OMPC_DEFAULTMAP_aggregate;
1976}

1978bool Sema::isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level,
                               unsigned OpenMPCaptureLevel) const {
assert(LangOpts.OpenMP && "OpenMP is not allowed")((void)0);

ASTContext &Ctx = getASTContext();
bool IsByRef = true;

// Find the directive that is associated with the provided scope.
D = cast<ValueDecl>(D->getCanonicalDecl());
QualType Ty = D->getType();

bool IsVariableUsedInMapClause = false;
if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level)) {
  // This table summarizes how a given variable should be passed to the device
  // given its type and the clauses where it appears. This table is based on
  // the description in OpenMP 4.5 [2.10.4, target Construct] and
  // OpenMP 4.5 [2.15.5, Data-mapping Attribute Rules and Clauses].
  //
  // =========================================================================
  // | type |  defaultmap   | pvt | first | is_device_ptr |    map   | res.  |
  // |      |(tofrom:scalar)|     |  pvt  |               |          |       |
  // =========================================================================
  // | scl  |               |     |       |       -       |          | bycopy|
  // | scl  |               |  -  |   x   |       -       |     -    | bycopy|
  // | scl  |               |  x  |   -   |       -       |     -    | null  |
  // | scl  |       x       |     |       |       -       |          | byref |
  // | scl  |       x       |  -  |   x   |       -       |     -    | bycopy|
  // | scl  |       x       |  x  |   -   |       -       |     -    | null  |
  // | scl  |               |  -  |   -   |       -       |     x    | byref |
  // | scl  |       x       |  -  |   -   |       -       |     x    | byref |
  //
  // | agg  |      n.a.     |     |       |       -       |          | byref |
  // | agg  |      n.a.     |  -  |   x   |       -       |     -    | byref |
  // | agg  |      n.a.     |  x  |   -   |       -       |     -    | null  |
  // | agg  |      n.a.     |  -  |   -   |       -       |     x    | byref |
  // | agg  |      n.a.     |  -  |   -   |       -       |    x[]   | byref |
  //
  // | ptr  |      n.a.     |     |       |       -       |          | bycopy|
  // | ptr  |      n.a.     |  -  |   x   |       -       |     -    | bycopy|
  // | ptr  |      n.a.     |  x  |   -   |       -       |     -    | null  |
  // | ptr  |      n.a.     |  -  |   -   |       -       |     x    | byref |
  // | ptr  |      n.a.     |  -  |   -   |       -       |    x[]   | bycopy|
  // | ptr  |      n.a.     |  -  |   -   |       x       |          | bycopy|
  // | ptr  |      n.a.     |  -  |   -   |       x       |     x    | bycopy|
  // | ptr  |      n.a.     |  -  |   -   |       x       |    x[]   | bycopy|
  // =========================================================================
  // Legend:
  //  scl - scalar
  //  ptr - pointer
  //  agg - aggregate
  //  x - applies
  //  - - invalid in this combination
  //  [] - mapped with an array section
  //  byref - should be mapped by reference
  //  byval - should be mapped by value
  //  null - initialize a local variable to null on the device
  //
  // Observations:
  //  - All scalar declarations that show up in a map clause have to be passed
  //    by reference, because they may have been mapped in the enclosing data
  //    environment.
  //  - If the scalar value does not fit the size of uintptr, it has to be
  //    passed by reference, regardless the result in the table above.
  //  - For pointers mapped by value that have either an implicit map or an
  //    array section, the runtime library may pass the NULL value to the
  //    device instead of the value passed to it by the compiler.

  if (Ty->isReferenceType())
    Ty = Ty->castAs<ReferenceType>()->getPointeeType();

  // Locate map clauses and see if the variable being captured is referred to
  // in any of those clauses. Here we only care about variables, not fields,
  // because fields are part of aggregates.
  bool IsVariableAssociatedWithSection = false;

  DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->checkMappableExprComponentListsForDeclAtLevel(
      D, Level,
      [&IsVariableUsedInMapClause, &IsVariableAssociatedWithSection, D](
          OMPClauseMappableExprCommon::MappableExprComponentListRef
              MapExprComponents,
          OpenMPClauseKind WhereFoundClauseKind) {
        // Only the map clause information influences how a variable is
        // captured. E.g. is_device_ptr does not require changing the default
        // behavior.
        if (WhereFoundClauseKind != OMPC_map)
          return false;

        auto EI = MapExprComponents.rbegin();
        auto EE = MapExprComponents.rend();

        assert(EI != EE && "Invalid map expression!")((void)0);

        if (isa<DeclRefExpr>(EI->getAssociatedExpression()))
          IsVariableUsedInMapClause |= EI->getAssociatedDeclaration() == D;

        ++EI;
        if (EI == EE)
          return false;

        if (isa<ArraySubscriptExpr>(EI->getAssociatedExpression()) ||
            isa<OMPArraySectionExpr>(EI->getAssociatedExpression()) ||
            isa<MemberExpr>(EI->getAssociatedExpression()) ||
            isa<OMPArrayShapingExpr>(EI->getAssociatedExpression())) {
          IsVariableAssociatedWithSection = true;
          // There is nothing more we need to know about this variable.
          return true;
        }

        // Keep looking for more map info.
        return false;
      });

  if (IsVariableUsedInMapClause) {
    // If variable is identified in a map clause it is always captured by
    // reference except if it is a pointer that is dereferenced somehow.
    IsByRef = !(Ty->isPointerType() && IsVariableAssociatedWithSection);
  } else {
    // By default, all the data that has a scalar type is mapped by copy
    // (except for reduction variables).
    // Defaultmap scalar is mutual exclusive to defaultmap pointer
    IsByRef = (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isForceCaptureByReferenceInTargetExecutable() &&
               !Ty->isAnyPointerType()) ||
              !Ty->isScalarType() ||
              DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isDefaultmapCapturedByRef(
                  Level, getVariableCategoryFromDecl(LangOpts, D)) ||
              DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
                  D,
                  [](OpenMPClauseKind K, bool AppliedToPointee) {
                    return K == OMPC_reduction && !AppliedToPointee;
                  },
                  Level);
  }
}

if (IsByRef && Ty.getNonReferenceType()->isScalarType()) {
  IsByRef =
      ((IsVariableUsedInMapClause &&
        DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCaptureRegion(Level, OpenMPCaptureLevel) ==
            OMPD_target) ||
       !(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
             D,
             [](OpenMPClauseKind K, bool AppliedToPointee) -> bool {
               return K == OMPC_firstprivate ||
                      (K == OMPC_reduction && AppliedToPointee);
             },
             Level, /*NotLastprivate=*/true) ||
         DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isUsesAllocatorsDecl(Level, D))) &&
      // If the variable is artificial and must be captured by value - try to
      // capture by value.
      !(isa<OMPCapturedExprDecl>(D) && !D->hasAttr<OMPCaptureNoInitAttr>() &&
        !cast<OMPCapturedExprDecl>(D)->getInit()->isGLValue()) &&
      // If the variable is implicitly firstprivate and scalar - capture by
      // copy
      !(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDefaultDSA() == DSA_firstprivate &&
        !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
            D, [](OpenMPClauseKind K, bool) { return K != OMPC_unknown; },
            Level) &&
        !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isLoopControlVariable(D, Level).first);
}

// When passing data by copy, we need to make sure it fits the uintptr size
// and alignment, because the runtime library only deals with uintptr types.
// If it does not fit the uintptr size, we need to pass the data by reference
// instead.
if (!IsByRef &&
    (Ctx.getTypeSizeInChars(Ty) >
         Ctx.getTypeSizeInChars(Ctx.getUIntPtrType()) ||
     Ctx.getDeclAlign(D) > Ctx.getTypeAlignInChars(Ctx.getUIntPtrType()))) {
  IsByRef = true;
}

return IsByRef;
2150}

2152unsigned Sema::getOpenMPNestingLevel() const {
assert(getLangOpts().OpenMP)((void)0);
return DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getNestingLevel();
2155}

2157bool Sema::isInOpenMPTargetExecutionDirective() const {
return (isOpenMPTargetExecutionDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()) &&
        !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isClauseParsingMode()) ||
       DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasDirective(
           [](OpenMPDirectiveKind K, const DeclarationNameInfo &,
              SourceLocation) -> bool {
             return isOpenMPTargetExecutionDirective(K);
           },
           false);
2166}

2168VarDecl *Sema::isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo,
                                  unsigned StopAt) {
assert(LangOpts.OpenMP && "OpenMP is not allowed")((void)0);
D = getCanonicalDecl(D);

auto *VD = dyn_cast<VarDecl>(D);
// Do not capture constexpr variables.
if (VD && VD->isConstexpr())
  return nullptr;

// If we want to determine whether the variable should be captured from the
// perspective of the current capturing scope, and we've already left all the
// capturing scopes of the top directive on the stack, check from the
// perspective of its parent directive (if any) instead.
DSAStackTy::ParentDirectiveScope InParentDirectiveRAII(
    *DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), CheckScopeInfo && DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isBodyComplete());

// If we are attempting to capture a global variable in a directive with
// 'target' we return true so that this global is also mapped to the device.
//
if (VD && !VD->hasLocalStorage() &&
    (getCurCapturedRegion() || getCurBlock() || getCurLambda())) {
  if (isInOpenMPTargetExecutionDirective()) {
    DSAStackTy::DSAVarData DVarTop =
        DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getTopDSA(D, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isClauseParsingMode());
    if (DVarTop.CKind != OMPC_unknown && DVarTop.RefExpr)
      return VD;
    // If the declaration is enclosed in a 'declare target' directive,
    // then it should not be captured.
    //
    if (OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
      return nullptr;
    CapturedRegionScopeInfo *CSI = nullptr;
    for (FunctionScopeInfo *FSI : llvm::drop_begin(
             llvm::reverse(FunctionScopes),
             CheckScopeInfo ? (FunctionScopes.size() - (StopAt + 1)) : 0)) {
      if (!isa<CapturingScopeInfo>(FSI))
        return nullptr;
      if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(FSI))
        if (RSI->CapRegionKind == CR_OpenMP) {
          CSI = RSI;
          break;
        }
    }
    assert(CSI && "Failed to find CapturedRegionScopeInfo")((void)0);
    SmallVector<OpenMPDirectiveKind, 4> Regions;
    getOpenMPCaptureRegions(Regions,
                            DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDirective(CSI->OpenMPLevel));
    if (Regions[CSI->OpenMPCaptureLevel] != OMPD_task)
      return VD;
  }
  if (isInOpenMPDeclareTargetContext()) {
    // Try to mark variable as declare target if it is used in capturing
    // regions.
    if (LangOpts.OpenMP <= 45 &&
        !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
      checkDeclIsAllowedInOpenMPTarget(nullptr, VD);
    return nullptr;
  }
}

if (CheckScopeInfo) {
  bool OpenMPFound = false;
  for (unsigned I = StopAt + 1; I > 0; --I) {
    FunctionScopeInfo *FSI = FunctionScopes[I - 1];
    if(!isa<CapturingScopeInfo>(FSI))
      return nullptr;
    if (auto *RSI = dyn_cast<CapturedRegionScopeInfo>(FSI))
      if (RSI->CapRegionKind == CR_OpenMP) {
        OpenMPFound = true;
        break;
      }
  }
  if (!OpenMPFound)
    return nullptr;
}

if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective() != OMPD_unknown &&
    (!DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isClauseParsingMode() ||
     DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getParentDirective() != OMPD_unknown)) {
  auto &&Info = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isLoopControlVariable(D);
  if (Info.first ||
      (VD && VD->hasLocalStorage() &&
       isImplicitOrExplicitTaskingRegion(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective())) ||
      (VD && DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isForceVarCapturing()))
    return VD ? VD : Info.second;
  DSAStackTy::DSAVarData DVarTop =
      DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getTopDSA(D, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isClauseParsingMode());
  if (DVarTop.CKind != OMPC_unknown && isOpenMPPrivate(DVarTop.CKind) &&
      (!VD || VD->hasLocalStorage() || !DVarTop.AppliedToPointee))
    return VD ? VD : cast<VarDecl>(DVarTop.PrivateCopy->getDecl());
  // Threadprivate variables must not be captured.
  if (isOpenMPThreadPrivate(DVarTop.CKind))
    return nullptr;
  // The variable is not private or it is the variable in the directive with
  // default(none) clause and not used in any clause.
  DSAStackTy::DSAVarData DVarPrivate = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasDSA(
      D,
      [](OpenMPClauseKind C, bool AppliedToPointee) {
        return isOpenMPPrivate(C) && !AppliedToPointee;
      },
      [](OpenMPDirectiveKind) { return true; },
      DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isClauseParsingMode());
  // Global shared must not be captured.
  if (VD && !VD->hasLocalStorage() && DVarPrivate.CKind == OMPC_unknown &&
      ((DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDefaultDSA() != DSA_none &&
        DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDefaultDSA() != DSA_firstprivate) ||
       DVarTop.CKind == OMPC_shared))
    return nullptr;
  if (DVarPrivate.CKind != OMPC_unknown ||
      (VD && (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDefaultDSA() == DSA_none ||
              DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDefaultDSA() == DSA_firstprivate)))
    return VD ? VD : cast<VarDecl>(DVarPrivate.PrivateCopy->getDecl());
}
return nullptr;
2283}

2285void Sema::adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
                                      unsigned Level) const {
FunctionScopesIndex -= getOpenMPCaptureLevels(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDirective(Level));
2288}

2290void Sema::startOpenMPLoop() {
assert(LangOpts.OpenMP && "OpenMP must be enabled.")((void)0);
if (isOpenMPLoopDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()))
  DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->loopInit();
2294}

2296void Sema::startOpenMPCXXRangeFor() {
assert(LangOpts.OpenMP && "OpenMP must be enabled.")((void)0);
if (isOpenMPLoopDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective())) {
  DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->resetPossibleLoopCounter();
  DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->loopStart();
}
2302}

2304OpenMPClauseKind Sema::isOpenMPPrivateDecl(ValueDecl *D, unsigned Level,
                                         unsigned CapLevel) const {
assert(LangOpts.OpenMP && "OpenMP is not allowed")((void)0);
if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDirective(
        [](OpenMPDirectiveKind K) { return isOpenMPTaskingDirective(K); },
        Level)) {
  bool IsTriviallyCopyable =
      D->getType().getNonReferenceType().isTriviallyCopyableType(Context) &&
      !D->getType()
           .getNonReferenceType()
           .getCanonicalType()
           ->getAsCXXRecordDecl();
  OpenMPDirectiveKind DKind = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDirective(Level);
  SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
  getOpenMPCaptureRegions(CaptureRegions, DKind);
  if (isOpenMPTaskingDirective(CaptureRegions[CapLevel]) &&
      (IsTriviallyCopyable ||
       !isOpenMPTaskLoopDirective(CaptureRegions[CapLevel]))) {
    if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
            D,
            [](OpenMPClauseKind K, bool) { return K == OMPC_firstprivate; },
            Level, /*NotLastprivate=*/true))
      return OMPC_firstprivate;
    DSAStackTy::DSAVarData DVar = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getImplicitDSA(D, Level);
    if (DVar.CKind != OMPC_shared &&
        !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isLoopControlVariable(D, Level).first && !DVar.RefExpr) {
      DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->addImplicitTaskFirstprivate(Level, D);
      return OMPC_firstprivate;
    }
  }
}
if (isOpenMPLoopDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective())) {
  if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getAssociatedLoops() > 0 &&
      !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isLoopStarted()) {
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->resetPossibleLoopCounter(D);
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->loopStart();
    return OMPC_private;
  }
  if ((DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getPossiblyLoopCunter() == D->getCanonicalDecl() ||
       DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isLoopControlVariable(D).first) &&
      !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
          D, [](OpenMPClauseKind K, bool) { return K != OMPC_private; },
          Level) &&
      !isOpenMPSimdDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()))
    return OMPC_private;
}
if (const auto *VD = dyn_cast<VarDecl>(D)) {
  if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isThreadPrivate(const_cast<VarDecl *>(VD)) &&
      DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isForceVarCapturing() &&
      !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
          D, [](OpenMPClauseKind K, bool) { return K == OMPC_copyin; },
          Level))
    return OMPC_private;
}
// User-defined allocators are private since they must be defined in the
// context of target region.
if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDirective(isOpenMPTargetExecutionDirective, Level) &&
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isUsesAllocatorsDecl(Level, D).getValueOr(
        DSAStackTy::UsesAllocatorsDeclKind::AllocatorTrait) ==
        DSAStackTy::UsesAllocatorsDeclKind::UserDefinedAllocator)
  return OMPC_private;
return (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
            D, [](OpenMPClauseKind K, bool) { return K == OMPC_private; },
            Level) ||
        (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isClauseParsingMode() &&
         DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getClauseParsingMode() == OMPC_private) ||
        // Consider taskgroup reduction descriptor variable a private
        // to avoid possible capture in the region.
        (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDirective(
             [](OpenMPDirectiveKind K) {
               return K == OMPD_taskgroup ||
                      ((isOpenMPParallelDirective(K) ||
                        isOpenMPWorksharingDirective(K)) &&
                       !isOpenMPSimdDirective(K));
             },
             Level) &&
         DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isTaskgroupReductionRef(D, Level)))
           ? OMPC_private
           : OMPC_unknown;
2383}

2385void Sema::setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D,
                              unsigned Level) {
assert(LangOpts.OpenMP && "OpenMP is not allowed")((void)0);
D = getCanonicalDecl(D);
OpenMPClauseKind OMPC = OMPC_unknown;
for (unsigned I = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getNestingLevel() + 1; I > Level; --I) {
  const unsigned NewLevel = I - 1;
  if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDSA(
          D,
          [&OMPC](const OpenMPClauseKind K, bool AppliedToPointee) {
            if (isOpenMPPrivate(K) && !AppliedToPointee) {
              OMPC = K;
              return true;
            }
            return false;
          },
          NewLevel))
    break;
  if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->checkMappableExprComponentListsForDeclAtLevel(
          D, NewLevel,
          [](OMPClauseMappableExprCommon::MappableExprComponentListRef,
             OpenMPClauseKind) { return true; })) {
    OMPC = OMPC_map;
    break;
  }
  if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDirective(isOpenMPTargetExecutionDirective,
                                     NewLevel)) {
    OMPC = OMPC_map;
    if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->mustBeFirstprivateAtLevel(
            NewLevel, getVariableCategoryFromDecl(LangOpts, D)))
      OMPC = OMPC_firstprivate;
    break;
  }
}
if (OMPC != OMPC_unknown)
  FD->addAttr(OMPCaptureKindAttr::CreateImplicit(Context, unsigned(OMPC)));
2421}

2423bool Sema::isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level,
                                    unsigned CaptureLevel) const {
assert(LangOpts.OpenMP && "OpenMP is not allowed")((void)0);
// Return true if the current level is no longer enclosed in a target region.

SmallVector<OpenMPDirectiveKind, 4> Regions;
getOpenMPCaptureRegions(Regions, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDirective(Level));
const auto *VD = dyn_cast<VarDecl>(D);
return VD && !VD->hasLocalStorage() &&
       DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasExplicitDirective(isOpenMPTargetExecutionDirective,
                                      Level) &&
       Regions[CaptureLevel] != OMPD_task;
2435}

2437bool Sema::isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level,
                                    unsigned CaptureLevel) const {
assert(LangOpts.OpenMP && "OpenMP is not allowed")((void)0);
// Return true if the current level is no longer enclosed in a target region.

if (const auto *VD1.1
'VD' is non-null
1
'VD' is non-null
 = dyn_cast<VarDecl>(D)) {
1
Assuming 'D' is a 'VarDecl'→
2
←
Taking true branch→
  if (!VD->hasLocalStorage()) {
3
←
Taking true branch→
    if (isInOpenMPTargetExecutionDirective())
4
←
Taking false branch→
      return true;
    DSAStackTy::DSAVarData TopDVar =
        DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getTopDSA(D, /*FromParent=*/false);
    unsigned NumLevels =
        getOpenMPCaptureLevels(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDirective(Level));
    if (Level == 0)
5
←
Assuming 'Level' is not equal to 0→
6
←
Taking false branch→
      return (NumLevels == CaptureLevel + 1) && TopDVar.CKind != OMPC_shared;
    do {
      --Level;
      DSAStackTy::DSAVarData DVar = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getImplicitDSA(D, Level);
7
←
Calling 'DSAStackTy::getImplicitDSA'→
      if (DVar.CKind != OMPC_shared)
        return true;
    } while (Level > 0);
  }
}
return true;
2461}

2463void Sema::DestroyDataSharingAttributesStack() { delete DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
); }

2465void Sema::ActOnOpenMPBeginDeclareVariant(SourceLocation Loc,
                                        OMPTraitInfo &TI) {
OMPDeclareVariantScopes.push_back(OMPDeclareVariantScope(TI));
2468}

2470void Sema::ActOnOpenMPEndDeclareVariant() {
assert(isInOpenMPDeclareVariantScope() &&((void)0)
       "Not in OpenMP declare variant scope!")((void)0);

OMPDeclareVariantScopes.pop_back();
2475}

2477void Sema::finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,
                                       const FunctionDecl *Callee,
                                       SourceLocation Loc) {
assert(LangOpts.OpenMP && "Expected OpenMP compilation mode.")((void)0);
Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
    OMPDeclareTargetDeclAttr::getDeviceType(Caller->getMostRecentDecl());
// Ignore host functions during device analyzis.
if (LangOpts.OpenMPIsDevice &&
    (!DevTy || *DevTy == OMPDeclareTargetDeclAttr::DT_Host))
  return;
// Ignore nohost functions during host analyzis.
if (!LangOpts.OpenMPIsDevice && DevTy &&
    *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost)
  return;
const FunctionDecl *FD = Callee->getMostRecentDecl();
DevTy = OMPDeclareTargetDeclAttr::getDeviceType(FD);
if (LangOpts.OpenMPIsDevice && DevTy &&
    *DevTy == OMPDeclareTargetDeclAttr::DT_Host) {
  // Diagnose host function called during device codegen.
  StringRef HostDevTy =
      getOpenMPSimpleClauseTypeName(OMPC_device_type, OMPC_DEVICE_TYPE_host);
  Diag(Loc, diag::err_omp_wrong_device_function_call) << HostDevTy << 0;
  Diag(*OMPDeclareTargetDeclAttr::getLocation(FD),
       diag::note_omp_marked_device_type_here)
      << HostDevTy;
  return;
}
    if (!LangOpts.OpenMPIsDevice && DevTy &&
        *DevTy == OMPDeclareTargetDeclAttr::DT_NoHost) {
      // Diagnose nohost function called during host codegen.
      StringRef NoHostDevTy = getOpenMPSimpleClauseTypeName(
          OMPC_device_type, OMPC_DEVICE_TYPE_nohost);
      Diag(Loc, diag::err_omp_wrong_device_function_call) << NoHostDevTy << 1;
      Diag(*OMPDeclareTargetDeclAttr::getLocation(FD),
           diag::note_omp_marked_device_type_here)
          << NoHostDevTy;
    }
2514}

2516void Sema::StartOpenMPDSABlock(OpenMPDirectiveKind DKind,
                             const DeclarationNameInfo &DirName,
                             Scope *CurScope, SourceLocation Loc) {
DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->push(DKind, DirName, CurScope, Loc);
PushExpressionEvaluationContext(
    ExpressionEvaluationContext::PotentiallyEvaluated);
2522}

2524void Sema::StartOpenMPClause(OpenMPClauseKind K) {
DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setClauseParsingMode(K);
2526}

2528void Sema::EndOpenMPClause() {
DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setClauseParsingMode(/*K=*/OMPC_unknown);
CleanupVarDeclMarking();
2531}

2533static std::pair<ValueDecl *, bool>
2534getPrivateItem(Sema &S, Expr *&RefExpr, SourceLocation &ELoc,
             SourceRange &ERange, bool AllowArraySection = false);

2537/// Check consistency of the reduction clauses.
2538static void checkReductionClauses(Sema &S, DSAStackTy *Stack,
                                ArrayRef<OMPClause *> Clauses) {
bool InscanFound = false;
SourceLocation InscanLoc;
// OpenMP 5.0, 2.19.5.4 reduction Clause, Restrictions.
// A reduction clause without the inscan reduction-modifier may not appear on
// a construct on which a reduction clause with the inscan reduction-modifier
// appears.
for (OMPClause *C : Clauses) {
  if (C->getClauseKind() != OMPC_reduction)
    continue;
  auto *RC = cast<OMPReductionClause>(C);
  if (RC->getModifier() == OMPC_REDUCTION_inscan) {
    InscanFound = true;
    InscanLoc = RC->getModifierLoc();
    continue;
  }
  if (RC->getModifier() == OMPC_REDUCTION_task) {
    // OpenMP 5.0, 2.19.5.4 reduction Clause.
    // A reduction clause with the task reduction-modifier may only appear on
    // a parallel construct, a worksharing construct or a combined or
    // composite construct for which any of the aforementioned constructs is a
    // constituent construct and simd or loop are not constituent constructs.
    OpenMPDirectiveKind CurDir = Stack->getCurrentDirective();
    if (!(isOpenMPParallelDirective(CurDir) ||
          isOpenMPWorksharingDirective(CurDir)) ||
        isOpenMPSimdDirective(CurDir))
      S.Diag(RC->getModifierLoc(),
             diag::err_omp_reduction_task_not_parallel_or_worksharing);
    continue;
  }
}
if (InscanFound) {
  for (OMPClause *C : Clauses) {
    if (C->getClauseKind() != OMPC_reduction)
      continue;
    auto *RC = cast<OMPReductionClause>(C);
    if (RC->getModifier() != OMPC_REDUCTION_inscan) {
      S.Diag(RC->getModifier() == OMPC_REDUCTION_unknown
                 ? RC->getBeginLoc()
                 : RC->getModifierLoc(),
             diag::err_omp_inscan_reduction_expected);
      S.Diag(InscanLoc, diag::note_omp_previous_inscan_reduction);
      continue;
    }
    for (Expr *Ref : RC->varlists()) {
      assert(Ref && "NULL expr in OpenMP nontemporal clause.")((void)0);
      SourceLocation ELoc;
      SourceRange ERange;
      Expr *SimpleRefExpr = Ref;
      auto Res = getPrivateItem(S, SimpleRefExpr, ELoc, ERange,
                                /*AllowArraySection=*/true);
      ValueDecl *D = Res.first;
      if (!D)
        continue;
      if (!Stack->isUsedInScanDirective(getCanonicalDecl(D))) {
        S.Diag(Ref->getExprLoc(),
               diag::err_omp_reduction_not_inclusive_exclusive)
            << Ref->getSourceRange();
      }
    }
  }
}
2601}

2603static void checkAllocateClauses(Sema &S, DSAStackTy *Stack,
                               ArrayRef<OMPClause *> Clauses);
2605static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
                               bool WithInit);

2608static void reportOriginalDsa(Sema &SemaRef, const DSAStackTy *Stack,
                            const ValueDecl *D,
                            const DSAStackTy::DSAVarData &DVar,
                            bool IsLoopIterVar = false);

2613void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
// OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
//  A variable of class type (or array thereof) that appears in a lastprivate
//  clause requires an accessible, unambiguous default constructor for the
//  class type, unless the list item is also specified in a firstprivate
//  clause.
if (const auto *D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
  for (OMPClause *C : D->clauses()) {
    if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
      SmallVector<Expr *, 8> PrivateCopies;
      for (Expr *DE : Clause->varlists()) {
        if (DE->isValueDependent() || DE->isTypeDependent()) {
          PrivateCopies.push_back(nullptr);
          continue;
        }
        auto *DRE = cast<DeclRefExpr>(DE->IgnoreParens());
        auto *VD = cast<VarDecl>(DRE->getDecl());
        QualType Type = VD->getType().getNonReferenceType();
        const DSAStackTy::DSAVarData DVar =
            DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getTopDSA(VD, /*FromParent=*/false);
        if (DVar.CKind == OMPC_lastprivate) {
          // Generate helper private variable and initialize it with the
          // default value. The address of the original variable is replaced
          // by the address of the new private variable in CodeGen. This new
          // variable is not added to IdResolver, so the code in the OpenMP
          // region uses original variable for proper diagnostics.
          VarDecl *VDPrivate = buildVarDecl(
              *this, DE->getExprLoc(), Type.getUnqualifiedType(),
              VD->getName(), VD->hasAttrs() ? &VD->getAttrs() : nullptr, DRE);
          ActOnUninitializedDecl(VDPrivate);
          if (VDPrivate->isInvalidDecl()) {
            PrivateCopies.push_back(nullptr);
            continue;
          }
          PrivateCopies.push_back(buildDeclRefExpr(
              *this, VDPrivate, DE->getType(), DE->getExprLoc()));
        } else {
          // The variable is also a firstprivate, so initialization sequence
          // for private copy is generated already.
          PrivateCopies.push_back(nullptr);
        }
      }
      Clause->setPrivateCopies(PrivateCopies);
      continue;
    }
    // Finalize nontemporal clause by handling private copies, if any.
    if (auto *Clause = dyn_cast<OMPNontemporalClause>(C)) {
      SmallVector<Expr *, 8> PrivateRefs;
      for (Expr *RefExpr : Clause->varlists()) {
        assert(RefExpr && "NULL expr in OpenMP nontemporal clause.")((void)0);
        SourceLocation ELoc;
        SourceRange ERange;
        Expr *SimpleRefExpr = RefExpr;
        auto Res = getPrivateItem(*this, SimpleRefExpr, ELoc, ERange);
        if (Res.second)
          // It will be analyzed later.
          PrivateRefs.push_back(RefExpr);
        ValueDecl *D = Res.first;
        if (!D)
          continue;

        const DSAStackTy::DSAVarData DVar =
            DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getTopDSA(D, /*FromParent=*/false);
        PrivateRefs.push_back(DVar.PrivateCopy ? DVar.PrivateCopy
                                               : SimpleRefExpr);
      }
      Clause->setPrivateRefs(PrivateRefs);
      continue;
    }
    if (auto *Clause = dyn_cast<OMPUsesAllocatorsClause>(C)) {
      for (unsigned I = 0, E = Clause->getNumberOfAllocators(); I < E; ++I) {
        OMPUsesAllocatorsClause::Data D = Clause->getAllocatorData(I);
        auto *DRE = dyn_cast<DeclRefExpr>(D.Allocator->IgnoreParenImpCasts());
        if (!DRE)
          continue;
        ValueDecl *VD = DRE->getDecl();
        if (!VD || !isa<VarDecl>(VD))
          continue;
        DSAStackTy::DSAVarData DVar =
            DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getTopDSA(VD, /*FromParent=*/false);
        // OpenMP [2.12.5, target Construct]
        // Memory allocators that appear in a uses_allocators clause cannot
        // appear in other data-sharing attribute clauses or data-mapping
        // attribute clauses in the same construct.
        Expr *MapExpr = nullptr;
        if (DVar.RefExpr ||
            DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->checkMappableExprComponentListsForDecl(
                VD, /*CurrentRegionOnly=*/true,
                [VD, &MapExpr](
                    OMPClauseMappableExprCommon::MappableExprComponentListRef
                        MapExprComponents,
                    OpenMPClauseKind C) {
                  auto MI = MapExprComponents.rbegin();
                  auto ME = MapExprComponents.rend();
                  if (MI != ME &&
                      MI->getAssociatedDeclaration()->getCanonicalDecl() ==
                          VD->getCanonicalDecl()) {
                    MapExpr = MI->getAssociatedExpression();
                    return true;
                  }
                  return false;
                })) {
          Diag(D.Allocator->getExprLoc(),
               diag::err_omp_allocator_used_in_clauses)
              << D.Allocator->getSourceRange();
          if (DVar.RefExpr)
            reportOriginalDsa(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), VD, DVar);
          else
            Diag(MapExpr->getExprLoc(), diag::note_used_here)
                << MapExpr->getSourceRange();
        }
      }
      continue;
    }
  }
  // Check allocate clauses.
  if (!CurContext->isDependentContext())
    checkAllocateClauses(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), D->clauses());
  checkReductionClauses(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), D->clauses());
}

DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->pop();
DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();
2737}

2739static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
                                   Expr *NumIterations, Sema &SemaRef,
                                   Scope *S, DSAStackTy *Stack);

2743namespace {

2745class VarDeclFilterCCC final : public CorrectionCandidateCallback {
2746private:
Sema &SemaRef;

2749public:
explicit VarDeclFilterCCC(Sema &S) : SemaRef(S) {}
bool ValidateCandidate(const TypoCorrection &Candidate) override {
  NamedDecl *ND = Candidate.getCorrectionDecl();
  if (const auto *VD = dyn_cast_or_null<VarDecl>(ND)) {
    return VD->hasGlobalStorage() &&
           SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
                                 SemaRef.getCurScope());
  }
  return false;
}

std::unique_ptr<CorrectionCandidateCallback> clone() override {
  return std::make_unique<VarDeclFilterCCC>(*this);
}

2765};

2767class VarOrFuncDeclFilterCCC final : public CorrectionCandidateCallback {
2768private:
Sema &SemaRef;

2771public:
explicit VarOrFuncDeclFilterCCC(Sema &S) : SemaRef(S) {}
bool ValidateCandidate(const TypoCorrection &Candidate) override {
  NamedDecl *ND = Candidate.getCorrectionDecl();
  if (ND && ((isa<VarDecl>(ND) && ND->getKind() == Decl::Var) ||
             isa<FunctionDecl>(ND))) {
    return SemaRef.isDeclInScope(ND, SemaRef.getCurLexicalContext(),
                                 SemaRef.getCurScope());
  }
  return false;
}

std::unique_ptr<CorrectionCandidateCallback> clone() override {
  return std::make_unique<VarOrFuncDeclFilterCCC>(*this);
}
2786};

2788} // namespace

2790ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope,
                                       CXXScopeSpec &ScopeSpec,
                                       const DeclarationNameInfo &Id,
                                       OpenMPDirectiveKind Kind) {
LookupResult Lookup(*this, Id, LookupOrdinaryName);
LookupParsedName(Lookup, CurScope, &ScopeSpec, true);

if (Lookup.isAmbiguous())
  return ExprError();

VarDecl *VD;
if (!Lookup.isSingleResult()) {
  VarDeclFilterCCC CCC(*this);
  if (TypoCorrection Corrected =
          CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr, CCC,
                      CTK_ErrorRecovery)) {
    diagnoseTypo(Corrected,
                 PDiag(Lookup.empty()
                           ? diag::err_undeclared_var_use_suggest
                           : diag::err_omp_expected_var_arg_suggest)
                     << Id.getName());
    VD = Corrected.getCorrectionDeclAs<VarDecl>();
  } else {
    Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use
                                     : diag::err_omp_expected_var_arg)
        << Id.getName();
    return ExprError();
  }
} else if (!(VD = Lookup.getAsSingle<VarDecl>())) {
  Diag(Id.getLoc(), diag::err_omp_expected_var_arg) << Id.getName();
  Diag(Lookup.getFoundDecl()->getLocation(), diag::note_declared_at);
  return ExprError();
}
Lookup.suppressDiagnostics();

// OpenMP [2.9.2, Syntax, C/C++]
//   Variables must be file-scope, namespace-scope, or static block-scope.
if (Kind == OMPD_threadprivate && !VD->hasGlobalStorage()) {
  Diag(Id.getLoc(), diag::err_omp_global_var_arg)
      << getOpenMPDirectiveName(Kind) << !VD->isStaticLocal();
  bool IsDecl =
      VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
  Diag(VD->getLocation(),
       IsDecl ? diag::note_previous_decl : diag::note_defined_here)
      << VD;
  return ExprError();
}

VarDecl *CanonicalVD = VD->getCanonicalDecl();
NamedDecl *ND = CanonicalVD;
// OpenMP [2.9.2, Restrictions, C/C++, p.2]
//   A threadprivate directive for file-scope variables must appear outside
//   any definition or declaration.
if (CanonicalVD->getDeclContext()->isTranslationUnit() &&
    !getCurLexicalContext()->isTranslationUnit()) {
  Diag(Id.getLoc(), diag::err_omp_var_scope)
      << getOpenMPDirectiveName(Kind) << VD;
  bool IsDecl =
      VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
  Diag(VD->getLocation(),
       IsDecl ? diag::note_previous_decl : diag::note_defined_here)
      << VD;
  return ExprError();
}
// OpenMP [2.9.2, Restrictions, C/C++, p.3]
//   A threadprivate directive for static class member variables must appear
//   in the class definition, in the same scope in which the member
//   variables are declared.
if (CanonicalVD->isStaticDataMember() &&
    !CanonicalVD->getDeclContext()->Equals(getCurLexicalContext())) {
  Diag(Id.getLoc(), diag::err_omp_var_scope)
      << getOpenMPDirectiveName(Kind) << VD;
  bool IsDecl =
      VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
  Diag(VD->getLocation(),
       IsDecl ? diag::note_previous_decl : diag::note_defined_here)
      << VD;
  return ExprError();
}
// OpenMP [2.9.2, Restrictions, C/C++, p.4]
//   A threadprivate directive for namespace-scope variables must appear
//   outside any definition or declaration other than the namespace
//   definition itself.
if (CanonicalVD->getDeclContext()->isNamespace() &&
    (!getCurLexicalContext()->isFileContext() ||
     !getCurLexicalContext()->Encloses(CanonicalVD->getDeclContext()))) {
  Diag(Id.getLoc(), diag::err_omp_var_scope)
      << getOpenMPDirectiveName(Kind) << VD;
  bool IsDecl =
      VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
  Diag(VD->getLocation(),
       IsDecl ? diag::note_previous_decl : diag::note_defined_here)
      << VD;
  return ExprError();
}
// OpenMP [2.9.2, Restrictions, C/C++, p.6]
//   A threadprivate directive for static block-scope variables must appear
//   in the scope of the variable and not in a nested scope.
if (CanonicalVD->isLocalVarDecl() && CurScope &&
    !isDeclInScope(ND, getCurLexicalContext(), CurScope)) {
  Diag(Id.getLoc(), diag::err_omp_var_scope)
      << getOpenMPDirectiveName(Kind) << VD;
  bool IsDecl =
      VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
  Diag(VD->getLocation(),
       IsDecl ? diag::note_previous_decl : diag::note_defined_here)
      << VD;
  return ExprError();
}

// OpenMP [2.9.2, Restrictions, C/C++, p.2-6]
//   A threadprivate directive must lexically precede all references to any
//   of the variables in its list.
if (Kind == OMPD_threadprivate && VD->isUsed() &&
    !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isThreadPrivate(VD)) {
  Diag(Id.getLoc(), diag::err_omp_var_used)
      << getOpenMPDirectiveName(Kind) << VD;
  return ExprError();
}

QualType ExprType = VD->getType().getNonReferenceType();
return DeclRefExpr::Create(Context, NestedNameSpecifierLoc(),
                           SourceLocation(), VD,
                           /*RefersToEnclosingVariableOrCapture=*/false,
                           Id.getLoc(), ExprType, VK_LValue);
2915}

2917Sema::DeclGroupPtrTy
2918Sema::ActOnOpenMPThreadprivateDirective(SourceLocation Loc,
                                      ArrayRef<Expr *> VarList) {
if (OMPThreadPrivateDecl *D = CheckOMPThreadPrivateDecl(Loc, VarList)) {
  CurContext->addDecl(D);
  return DeclGroupPtrTy::make(DeclGroupRef(D));
}
return nullptr;
2925}

2927namespace {
2928class LocalVarRefChecker final
  : public ConstStmtVisitor<LocalVarRefChecker, bool> {
Sema &SemaRef;

2932public:
bool VisitDeclRefExpr(const DeclRefExpr *E) {
  if (const auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
    if (VD->hasLocalStorage()) {
      SemaRef.Diag(E->getBeginLoc(),
                   diag::err_omp_local_var_in_threadprivate_init)
          << E->getSourceRange();
      SemaRef.Diag(VD->getLocation(), diag::note_defined_here)
          << VD << VD->getSourceRange();
      return true;
    }
  }
  return false;
}
bool VisitStmt(const Stmt *S) {
  for (const Stmt *Child : S->children()) {
    if (Child && Visit(Child))
      return true;
  }
  return false;
}
explicit LocalVarRefChecker(Sema &SemaRef) : SemaRef(SemaRef) {}
2954};
2955} // namespace

2957OMPThreadPrivateDecl *
2958Sema::CheckOMPThreadPrivateDecl(SourceLocation Loc, ArrayRef<Expr *> VarList) {
SmallVector<Expr *, 8> Vars;
for (Expr *RefExpr : VarList) {
  auto *DE = cast<DeclRefExpr>(RefExpr);
  auto *VD = cast<VarDecl>(DE->getDecl());
  SourceLocation ILoc = DE->getExprLoc();

  // Mark variable as used.
  VD->setReferenced();
  VD->markUsed(Context);

  QualType QType = VD->getType();
  if (QType->isDependentType() || QType->isInstantiationDependentType()) {
    // It will be analyzed later.
    Vars.push_back(DE);
    continue;
  }

  // OpenMP [2.9.2, Restrictions, C/C++, p.10]
  //   A threadprivate variable must not have an incomplete type.
  if (RequireCompleteType(ILoc, VD->getType(),
                          diag::err_omp_threadprivate_incomplete_type)) {
    continue;
  }

  // OpenMP [2.9.2, Restrictions, C/C++, p.10]
  //   A threadprivate variable must not have a reference type.
  if (VD->getType()->isReferenceType()) {
    Diag(ILoc, diag::err_omp_ref_type_arg)
        << getOpenMPDirectiveName(OMPD_threadprivate) << VD->getType();
    bool IsDecl =
        VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
    Diag(VD->getLocation(),
         IsDecl ? diag::note_previous_decl : diag::note_defined_here)
        << VD;
    continue;
  }

  // Check if this is a TLS variable. If TLS is not being supported, produce
  // the corresponding diagnostic.
  if ((VD->getTLSKind() != VarDecl::TLS_None &&
       !(VD->hasAttr<OMPThreadPrivateDeclAttr>() &&
         getLangOpts().OpenMPUseTLS &&
         getASTContext().getTargetInfo().isTLSSupported())) ||
      (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
       !VD->isLocalVarDecl())) {
    Diag(ILoc, diag::err_omp_var_thread_local)
        << VD << ((VD->getTLSKind() != VarDecl::TLS_None) ? 0 : 1);
    bool IsDecl =
        VD->isThisDeclarationADefinition(Context) == VarDecl::DeclarationOnly;
    Diag(VD->getLocation(),
         IsDecl ? diag::note_previous_decl : diag::note_defined_here)
        << VD;
    continue;
  }

  // Check if initial value of threadprivate variable reference variable with
  // local storage (it is not supported by runtime).
  if (const Expr *Init = VD->getAnyInitializer()) {
    LocalVarRefChecker Checker(*this);
    if (Checker.Visit(Init))
      continue;
  }

  Vars.push_back(RefExpr);
  DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->addDSA(VD, DE, OMPC_threadprivate);
  VD->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
      Context, SourceRange(Loc, Loc)));
  if (ASTMutationListener *ML = Context.getASTMutationListener())
    ML->DeclarationMarkedOpenMPThreadPrivate(VD);
}
OMPThreadPrivateDecl *D = nullptr;
if (!Vars.empty()) {
  D = OMPThreadPrivateDecl::Create(Context, getCurLexicalContext(), Loc,
                                   Vars);
  D->setAccess(AS_public);
}
return D;
3036}

3038static OMPAllocateDeclAttr::AllocatorTypeTy
3039getAllocatorKind(Sema &S, DSAStackTy *Stack, Expr *Allocator) {
if (!Allocator)
  return OMPAllocateDeclAttr::OMPNullMemAlloc;
if (Allocator->isTypeDependent() || Allocator->isValueDependent() ||
    Allocator->isInstantiationDependent() ||
    Allocator->containsUnexpandedParameterPack())
  return OMPAllocateDeclAttr::OMPUserDefinedMemAlloc;
auto AllocatorKindRes = OMPAllocateDeclAttr::OMPUserDefinedMemAlloc;
const Expr *AE = Allocator->IgnoreParenImpCasts();
for (int I = 0; I < OMPAllocateDeclAttr::OMPUserDefinedMemAlloc; ++I) {
  auto AllocatorKind = static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(I);
  const Expr *DefAllocator = Stack->getAllocator(AllocatorKind);
  llvm::FoldingSetNodeID AEId, DAEId;
  AE->Profile(AEId, S.getASTContext(), /*Canonical=*/true);
  DefAllocator->Profile(DAEId, S.getASTContext(), /*Canonical=*/true);
  if (AEId == DAEId) {
    AllocatorKindRes = AllocatorKind;
    break;
  }
}
return AllocatorKindRes;
3060}

3062static bool checkPreviousOMPAllocateAttribute(
  Sema &S, DSAStackTy *Stack, Expr *RefExpr, VarDecl *VD,
  OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind, Expr *Allocator) {
if (!VD->hasAttr<OMPAllocateDeclAttr>())
  return false;
const auto *A = VD->getAttr<OMPAllocateDeclAttr>();
Expr *PrevAllocator = A->getAllocator();
OMPAllocateDeclAttr::AllocatorTypeTy PrevAllocatorKind =
    getAllocatorKind(S, Stack, PrevAllocator);
bool AllocatorsMatch = AllocatorKind == PrevAllocatorKind;
if (AllocatorsMatch &&
    AllocatorKind == OMPAllocateDeclAttr::OMPUserDefinedMemAlloc &&
    Allocator && PrevAllocator) {
  const Expr *AE = Allocator->IgnoreParenImpCasts();
  const Expr *PAE = PrevAllocator->IgnoreParenImpCasts();
  llvm::FoldingSetNodeID AEId, PAEId;
  AE->Profile(AEId, S.Context, /*Canonical=*/true);
  PAE->Profile(PAEId, S.Context, /*Canonical=*/true);
  AllocatorsMatch = AEId == PAEId;
}
if (!AllocatorsMatch) {
  SmallString<256> AllocatorBuffer;
  llvm::raw_svector_ostream AllocatorStream(AllocatorBuffer);
  if (Allocator)
    Allocator->printPretty(AllocatorStream, nullptr, S.getPrintingPolicy());
  SmallString<256> PrevAllocatorBuffer;
  llvm::raw_svector_ostream PrevAllocatorStream(PrevAllocatorBuffer);
  if (PrevAllocator)
    PrevAllocator->printPretty(PrevAllocatorStream, nullptr,
                               S.getPrintingPolicy());

  SourceLocation AllocatorLoc =
      Allocator ? Allocator->getExprLoc() : RefExpr->getExprLoc();
  SourceRange AllocatorRange =
      Allocator ? Allocator->getSourceRange() : RefExpr->getSourceRange();
  SourceLocation PrevAllocatorLoc =
      PrevAllocator ? PrevAllocator->getExprLoc() : A->getLocation();
  SourceRange PrevAllocatorRange =
      PrevAllocator ? PrevAllocator->getSourceRange() : A->getRange();
  S.Diag(AllocatorLoc, diag::warn_omp_used_different_allocator)
      << (Allocator ? 1 : 0) << AllocatorStream.str()
      << (PrevAllocator ? 1 : 0) << PrevAllocatorStream.str()
      << AllocatorRange;
  S.Diag(PrevAllocatorLoc, diag::note_omp_previous_allocator)
      << PrevAllocatorRange;
  return true;
}
return false;
3110}

3112static void
3113applyOMPAllocateAttribute(Sema &S, VarDecl *VD,
                        OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind,
                        Expr *Allocator, SourceRange SR) {
if (VD->hasAttr<OMPAllocateDeclAttr>())
  return;
if (Allocator &&
    (Allocator->isTypeDependent() || Allocator->isValueDependent() ||
     Allocator->isInstantiationDependent() ||
     Allocator->containsUnexpandedParameterPack()))
  return;
auto *A = OMPAllocateDeclAttr::CreateImplicit(S.Context, AllocatorKind,
                                              Allocator, SR);
VD->addAttr(A);
if (ASTMutationListener *ML = S.Context.getASTMutationListener())
  ML->DeclarationMarkedOpenMPAllocate(VD, A);
3128}

3130Sema::DeclGroupPtrTy Sema::ActOnOpenMPAllocateDirective(
  SourceLocation Loc, ArrayRef<Expr *> VarList,
  ArrayRef<OMPClause *> Clauses, DeclContext *Owner) {
assert(Clauses.size() <= 1 && "Expected at most one clause.")((void)0);
Expr *Allocator = nullptr;
if (Clauses.empty()) {
  // OpenMP 5.0, 2.11.3 allocate Directive, Restrictions.
  // allocate directives that appear in a target region must specify an
  // allocator clause unless a requires directive with the dynamic_allocators
  // clause is present in the same compilation unit.
  if (LangOpts.OpenMPIsDevice &&
      !DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasRequiresDeclWithClause<OMPDynamicAllocatorsClause>())
    targetDiag(Loc, diag::err_expected_allocator_clause);
} else {
  Allocator = cast<OMPAllocatorClause>(Clauses.back())->getAllocator();
}
OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind =
    getAllocatorKind(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), Allocator);
SmallVector<Expr *, 8> Vars;
for (Expr *RefExpr : VarList) {
  auto *DE = cast<DeclRefExpr>(RefExpr);
  auto *VD = cast<VarDecl>(DE->getDecl());

  // Check if this is a TLS variable or global register.
  if (VD->getTLSKind() != VarDecl::TLS_None ||
      VD->hasAttr<OMPThreadPrivateDeclAttr>() ||
      (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
       !VD->isLocalVarDecl()))
    continue;

  // If the used several times in the allocate directive, the same allocator
  // must be used.
  if (checkPreviousOMPAllocateAttribute(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), RefExpr, VD,
                                        AllocatorKind, Allocator))
    continue;

  // OpenMP, 2.11.3 allocate Directive, Restrictions, C / C++
  // If a list item has a static storage type, the allocator expression in the
  // allocator clause must be a constant expression that evaluates to one of
  // the predefined memory allocator values.
  if (Allocator && VD->hasGlobalStorage()) {
    if (AllocatorKind == OMPAllocateDeclAttr::OMPUserDefinedMemAlloc) {
      Diag(Allocator->getExprLoc(),
           diag::err_omp_expected_predefined_allocator)
          << Allocator->getSourceRange();
      bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
                    VarDecl::DeclarationOnly;
      Diag(VD->getLocation(),
           IsDecl ? diag::note_previous_decl : diag::note_defined_here)
          << VD;
      continue;
    }
  }

  Vars.push_back(RefExpr);
  applyOMPAllocateAttribute(*this, VD, AllocatorKind, Allocator,
                            DE->getSourceRange());
}
if (Vars.empty())
  return nullptr;
if (!Owner)
  Owner = getCurLexicalContext();
auto *D = OMPAllocateDecl::Create(Context, Owner, Loc, Vars, Clauses);
D->setAccess(AS_public);
Owner->addDecl(D);
return DeclGroupPtrTy::make(DeclGroupRef(D));
3196}

3198Sema::DeclGroupPtrTy
3199Sema::ActOnOpenMPRequiresDirective(SourceLocation Loc,
                                 ArrayRef<OMPClause *> ClauseList) {
OMPRequiresDecl *D = nullptr;
if (!CurContext->isFileContext()) {
  Diag(Loc, diag::err_omp_invalid_scope) << "requires";
} else {
  D = CheckOMPRequiresDecl(Loc, ClauseList);
  if (D) {
    CurContext->addDecl(D);
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->addRequiresDecl(D);
  }
}
return DeclGroupPtrTy::make(DeclGroupRef(D));
3212}

3214void Sema::ActOnOpenMPAssumesDirective(SourceLocation Loc,
                                     OpenMPDirectiveKind DKind,
                                     ArrayRef<StringRef> Assumptions,
                                     bool SkippedClauses) {
if (!SkippedClauses && Assumptions.empty())
  Diag(Loc, diag::err_omp_no_clause_for_directive)
      << llvm::omp::getAllAssumeClauseOptions()
      << llvm::omp::getOpenMPDirectiveName(DKind);

auto *AA = AssumptionAttr::Create(Context, llvm::join(Assumptions, ","), Loc);
if (DKind == llvm::omp::Directive::OMPD_begin_assumes) {
  OMPAssumeScoped.push_back(AA);
  return;
}

// Global assumes without assumption clauses are ignored.
if (Assumptions.empty())
  return;

assert(DKind == llvm::omp::Directive::OMPD_assumes &&((void)0)
       "Unexpected omp assumption directive!")((void)0);
OMPAssumeGlobal.push_back(AA);

// The OMPAssumeGlobal scope above will take care of new declarations but
// we also want to apply the assumption to existing ones, e.g., to
// declarations in included headers. To this end, we traverse all existing
// declaration contexts and annotate function declarations here.
SmallVector<DeclContext *, 8> DeclContexts;
auto *Ctx = CurContext;
while (Ctx->getLexicalParent())
  Ctx = Ctx->getLexicalParent();
DeclContexts.push_back(Ctx);
while (!DeclContexts.empty()) {
  DeclContext *DC = DeclContexts.pop_back_val();
  for (auto *SubDC : DC->decls()) {
    if (SubDC->isInvalidDecl())
      continue;
    if (auto *CTD = dyn_cast<ClassTemplateDecl>(SubDC)) {
      DeclContexts.push_back(CTD->getTemplatedDecl());
      for (auto *S : CTD->specializations())
        DeclContexts.push_back(S);
      continue;
    }
    if (auto *DC = dyn_cast<DeclContext>(SubDC))
      DeclContexts.push_back(DC);
    if (auto *F = dyn_cast<FunctionDecl>(SubDC)) {
      F->addAttr(AA);
      continue;
    }
  }
}
3265}

3267void Sema::ActOnOpenMPEndAssumesDirective() {
assert(isInOpenMPAssumeScope() && "Not in OpenMP assumes scope!")((void)0);
OMPAssumeScoped.pop_back();
3270}

3272OMPRequiresDecl *Sema::CheckOMPRequiresDecl(SourceLocation Loc,
                                          ArrayRef<OMPClause *> ClauseList) {
/// For target specific clauses, the requires directive cannot be
/// specified after the handling of any of the target regions in the
/// current compilation unit.
ArrayRef<SourceLocation> TargetLocations =
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getEncounteredTargetLocs();
SourceLocation AtomicLoc = DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getAtomicDirectiveLoc();
if (!TargetLocations.empty() || !AtomicLoc.isInvalid()) {
  for (const OMPClause *CNew : ClauseList) {
    // Check if any of the requires clauses affect target regions.
    if (isa<OMPUnifiedSharedMemoryClause>(CNew) ||
        isa<OMPUnifiedAddressClause>(CNew) ||
        isa<OMPReverseOffloadClause>(CNew) ||
        isa<OMPDynamicAllocatorsClause>(CNew)) {
      Diag(Loc, diag::err_omp_directive_before_requires)
          << "target" << getOpenMPClauseName(CNew->getClauseKind());
      for (SourceLocation TargetLoc : TargetLocations) {
        Diag(TargetLoc, diag::note_omp_requires_encountered_directive)
            << "target";
      }
    } else if (!AtomicLoc.isInvalid() &&
               isa<OMPAtomicDefaultMemOrderClause>(CNew)) {
      Diag(Loc, diag::err_omp_directive_before_requires)
          << "atomic" << getOpenMPClauseName(CNew->getClauseKind());
      Diag(AtomicLoc, diag::note_omp_requires_encountered_directive)
          << "atomic";
    }
  }
}

if (!DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->hasDuplicateRequiresClause(ClauseList))
  return OMPRequiresDecl::Create(Context, getCurLexicalContext(), Loc,
                                 ClauseList);
return nullptr;
3307}

3309static void reportOriginalDsa(Sema &SemaRef, const DSAStackTy *Stack,
                            const ValueDecl *D,
                            const DSAStackTy::DSAVarData &DVar,
                            bool IsLoopIterVar) {
if (DVar.RefExpr) {
  SemaRef.Diag(DVar.RefExpr->getExprLoc(), diag::note_omp_explicit_dsa)
      << getOpenMPClauseName(DVar.CKind);
  return;
}
enum {
  PDSA_StaticMemberShared,
  PDSA_StaticLocalVarShared,
  PDSA_LoopIterVarPrivate,
  PDSA_LoopIterVarLinear,
  PDSA_LoopIterVarLastprivate,
  PDSA_ConstVarShared,
  PDSA_GlobalVarShared,
  PDSA_TaskVarFirstprivate,
  PDSA_LocalVarPrivate,
  PDSA_Implicit
} Reason = PDSA_Implicit;
bool ReportHint = false;
auto ReportLoc = D->getLocation();
auto *VD = dyn_cast<VarDecl>(D);
if (IsLoopIterVar) {
  if (DVar.CKind == OMPC_private)
    Reason = PDSA_LoopIterVarPrivate;
  else if (DVar.CKind == OMPC_lastprivate)
    Reason = PDSA_LoopIterVarLastprivate;
  else
    Reason = PDSA_LoopIterVarLinear;
} else if (isOpenMPTaskingDirective(DVar.DKind) &&
           DVar.CKind == OMPC_firstprivate) {
  Reason = PDSA_TaskVarFirstprivate;
  ReportLoc = DVar.ImplicitDSALoc;
} else if (VD && VD->isStaticLocal())
  Reason = PDSA_StaticLocalVarShared;
else if (VD && VD->isStaticDataMember())
  Reason = PDSA_StaticMemberShared;
else if (VD && VD->isFileVarDecl())
  Reason = PDSA_GlobalVarShared;
else if (D->getType().isConstant(SemaRef.getASTContext()))
  Reason = PDSA_ConstVarShared;
else if (VD && VD->isLocalVarDecl() && DVar.CKind == OMPC_private) {
  ReportHint = true;
  Reason = PDSA_LocalVarPrivate;
}
if (Reason != PDSA_Implicit) {
  SemaRef.Diag(ReportLoc, diag::note_omp_predetermined_dsa)
      << Reason << ReportHint
      << getOpenMPDirectiveName(Stack->getCurrentDirective());
} else if (DVar.ImplicitDSALoc.isValid()) {
  SemaRef.Diag(DVar.ImplicitDSALoc, diag::note_omp_implicit_dsa)
      << getOpenMPClauseName(DVar.CKind);
}
3364}

3366static OpenMPMapClauseKind
3367getMapClauseKindFromModifier(OpenMPDefaultmapClauseModifier M,
                           bool IsAggregateOrDeclareTarget) {
OpenMPMapClauseKind Kind = OMPC_MAP_unknown;
switch (M) {
case OMPC_DEFAULTMAP_MODIFIER_alloc:
  Kind = OMPC_MAP_alloc;
  break;
case OMPC_DEFAULTMAP_MODIFIER_to:
  Kind = OMPC_MAP_to;
  break;
case OMPC_DEFAULTMAP_MODIFIER_from:
  Kind = OMPC_MAP_from;
  break;
case OMPC_DEFAULTMAP_MODIFIER_tofrom:
  Kind = OMPC_MAP_tofrom;
  break;
case OMPC_DEFAULTMAP_MODIFIER_present:
  // OpenMP 5.1 [2.21.7.3] defaultmap clause, Description]
  // If implicit-behavior is present, each variable referenced in the
  // construct in the category specified by variable-category is treated as if
  // it had been listed in a map clause with the map-type of alloc and
  // map-type-modifier of present.
  Kind = OMPC_MAP_alloc;
  break;
case OMPC_DEFAULTMAP_MODIFIER_firstprivate:
case OMPC_DEFAULTMAP_MODIFIER_last:
  llvm_unreachable("Unexpected defaultmap implicit behavior")__builtin_unreachable();
case OMPC_DEFAULTMAP_MODIFIER_none:
case OMPC_DEFAULTMAP_MODIFIER_default:
case OMPC_DEFAULTMAP_MODIFIER_unknown:
  // IsAggregateOrDeclareTarget could be true if:
  // 1. the implicit behavior for aggregate is tofrom
  // 2. it's a declare target link
  if (IsAggregateOrDeclareTarget) {
    Kind = OMPC_MAP_tofrom;
    break;
  }
  llvm_unreachable("Unexpected defaultmap implicit behavior")__builtin_unreachable();
}
assert(Kind != OMPC_MAP_unknown && "Expect map kind to be known")((void)0);
return Kind;
3408}

3410namespace {
3411class DSAAttrChecker final : public StmtVisitor<DSAAttrChecker, void> {
DSAStackTy *Stack;
Sema &SemaRef;
bool ErrorFound = false;
bool TryCaptureCXXThisMembers = false;
CapturedStmt *CS = nullptr;
const static unsigned DefaultmapKindNum = OMPC_DEFAULTMAP_pointer + 1;
llvm::SmallVector<Expr *, 4> ImplicitFirstprivate;
llvm::SmallVector<Expr *, 4> ImplicitMap[DefaultmapKindNum][OMPC_MAP_delete];
llvm::SmallVector<OpenMPMapModifierKind, NumberOfOMPMapClauseModifiers>
    ImplicitMapModifier[DefaultmapKindNum];
Sema::VarsWithInheritedDSAType VarsWithInheritedDSA;
llvm::SmallDenseSet<const ValueDecl *, 4> ImplicitDeclarations;

void VisitSubCaptures(OMPExecutableDirective *S) {
  // Check implicitly captured variables.
  if (!S->hasAssociatedStmt() || !S->getAssociatedStmt())
    return;
  if (S->getDirectiveKind() == OMPD_atomic ||
      S->getDirectiveKind() == OMPD_critical ||
      S->getDirectiveKind() == OMPD_section ||
      S->getDirectiveKind() == OMPD_master ||
      S->getDirectiveKind() == OMPD_masked ||
      isOpenMPLoopTransformationDirective(S->getDirectiveKind())) {
    Visit(S->getAssociatedStmt());
    return;
  }
  visitSubCaptures(S->getInnermostCapturedStmt());
  // Try to capture inner this->member references to generate correct mappings
  // and diagnostics.
  if (TryCaptureCXXThisMembers ||
      (isOpenMPTargetExecutionDirective(Stack->getCurrentDirective()) &&
       llvm::any_of(S->getInnermostCapturedStmt()->captures(),
                    [](const CapturedStmt::Capture &C) {
                      return C.capturesThis();
                    }))) {
    bool SavedTryCaptureCXXThisMembers = TryCaptureCXXThisMembers;
    TryCaptureCXXThisMembers = true;
    Visit(S->getInnermostCapturedStmt()->getCapturedStmt());
    TryCaptureCXXThisMembers = SavedTryCaptureCXXThisMembers;
  }
  // In tasks firstprivates are not captured anymore, need to analyze them
  // explicitly.
  if (isOpenMPTaskingDirective(S->getDirectiveKind()) &&
      !isOpenMPTaskLoopDirective(S->getDirectiveKind())) {
    for (OMPClause *C : S->clauses())
      if (auto *FC = dyn_cast<OMPFirstprivateClause>(C)) {
        for (Expr *Ref : FC->varlists())
          Visit(Ref);
      }
  }
}

3464public:
void VisitDeclRefExpr(DeclRefExpr *E) {
  if (TryCaptureCXXThisMembers || E->isTypeDependent() ||
      E->isValueDependent() || E->containsUnexpandedParameterPack() ||
      E->isInstantiationDependent())
    return;
  if (auto *VD = dyn_cast<VarDecl>(E->getDecl())) {
    // Check the datasharing rules for the expressions in the clauses.
    if (!CS) {
      if (auto *CED = dyn_cast<OMPCapturedExprDecl>(VD))
        if (!CED->hasAttr<OMPCaptureNoInitAttr>()) {
          Visit(CED->getInit());
          return;
        }
    } else if (VD->isImplicit() || isa<OMPCapturedExprDecl>(VD))
      // Do not analyze internal variables and do not enclose them into
      // implicit clauses.
      return;
    VD = VD->getCanonicalDecl();
    // Skip internally declared variables.
    if (VD->hasLocalStorage() && CS && !CS->capturesVariable(VD) &&
        !Stack->isImplicitTaskFirstprivate(VD))
      return;
    // Skip allocators in uses_allocators clauses.
    if (Stack->isUsesAllocatorsDecl(VD).hasValue())
      return;

    DSAStackTy::DSAVarData DVar = Stack->getTopDSA(VD, /*FromParent=*/false);
    // Check if the variable has explicit DSA set and stop analysis if it so.
    if (DVar.RefExpr || !ImplicitDeclarations.insert(VD).second)
      return;

    // Skip internally declared static variables.
    llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
        OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD);
    if (VD->hasGlobalStorage() && CS && !CS->capturesVariable(VD) &&
        (Stack->hasRequiresDeclWithClause<OMPUnifiedSharedMemoryClause>() ||
         !Res || *Res != OMPDeclareTargetDeclAttr::MT_Link) &&
        !Stack->isImplicitTaskFirstprivate(VD))
      return;

    SourceLocation ELoc = E->getExprLoc();
    OpenMPDirectiveKind DKind = Stack->getCurrentDirective();
    // The default(none) clause requires that each variable that is referenced
    // in the construct, and does not have a predetermined data-sharing
    // attribute, must have its data-sharing attribute explicitly determined
    // by being listed in a data-sharing attribute clause.
    if (DVar.CKind == OMPC_unknown &&
        (Stack->getDefaultDSA() == DSA_none ||
         Stack->getDefaultDSA() == DSA_firstprivate) &&
        isImplicitOrExplicitTaskingRegion(DKind) &&
        VarsWithInheritedDSA.count(VD) == 0) {
      bool InheritedDSA = Stack->getDefaultDSA() == DSA_none;
      if (!InheritedDSA && Stack->getDefaultDSA() == DSA_firstprivate) {
        DSAStackTy::DSAVarData DVar =
            Stack->getImplicitDSA(VD, /*FromParent=*/false);
        InheritedDSA = DVar.CKind == OMPC_unknown;
      }
      if (InheritedDSA)
        VarsWithInheritedDSA[VD] = E;
      return;
    }

    // OpenMP 5.0 [2.19.7.2, defaultmap clause, Description]
    // If implicit-behavior is none, each variable referenced in the
    // construct that does not have a predetermined data-sharing attribute
    // and does not appear in a to or link clause on a declare target
    // directive must be listed in a data-mapping attribute clause, a
    // data-haring attribute clause (including a data-sharing attribute
    // clause on a combined construct where target. is one of the
    // constituent constructs), or an is_device_ptr clause.
    OpenMPDefaultmapClauseKind ClauseKind =
        getVariableCategoryFromDecl(SemaRef.getLangOpts(), VD);
    if (SemaRef.getLangOpts().OpenMP >= 50) {
      bool IsModifierNone = Stack->getDefaultmapModifier(ClauseKind) ==
                            OMPC_DEFAULTMAP_MODIFIER_none;
      if (DVar.CKind == OMPC_unknown && IsModifierNone &&
          VarsWithInheritedDSA.count(VD) == 0 && !Res) {
        // Only check for data-mapping attribute and is_device_ptr here
        // since we have already make sure that the declaration does not
        // have a data-sharing attribute above
        if (!Stack->checkMappableExprComponentListsForDecl(
                VD, /*CurrentRegionOnly=*/true,
                [VD](OMPClauseMappableExprCommon::MappableExprComponentListRef
                         MapExprComponents,
                     OpenMPClauseKind) {
                  auto MI = MapExprComponents.rbegin();
                  auto ME = MapExprComponents.rend();
                  return MI != ME && MI->getAssociatedDeclaration() == VD;
                })) {
          VarsWithInheritedDSA[VD] = E;
          return;
        }
      }
    }
    if (SemaRef.getLangOpts().OpenMP > 50) {
      bool IsModifierPresent = Stack->getDefaultmapModifier(ClauseKind) ==
                               OMPC_DEFAULTMAP_MODIFIER_present;
      if (IsModifierPresent) {
        if (llvm::find(ImplicitMapModifier[ClauseKind],
                       OMPC_MAP_MODIFIER_present) ==
            std::end(ImplicitMapModifier[ClauseKind])) {
          ImplicitMapModifier[ClauseKind].push_back(
              OMPC_MAP_MODIFIER_present);
        }
      }
    }

    if (isOpenMPTargetExecutionDirective(DKind) &&
        !Stack->isLoopControlVariable(VD).first) {
      if (!Stack->checkMappableExprComponentListsForDecl(
              VD, /*CurrentRegionOnly=*/true,
              [this](OMPClauseMappableExprCommon::MappableExprComponentListRef
                         StackComponents,
                     OpenMPClauseKind) {
                if (SemaRef.LangOpts.OpenMP >= 50)
                  return !StackComponents.empty();
                // Variable is used if it has been marked as an array, array
                // section, array shaping or the variable iself.
                return StackComponents.size() == 1 ||
                       std::all_of(
                           std::next(StackComponents.rbegin()),
                           StackComponents.rend(),
                           [](const OMPClauseMappableExprCommon::
                                  MappableComponent &MC) {
                             return MC.getAssociatedDeclaration() ==
                                        nullptr &&
                                    (isa<OMPArraySectionExpr>(
                                         MC.getAssociatedExpression()) ||
                                     isa<OMPArrayShapingExpr>(
                                         MC.getAssociatedExpression()) ||
                                     isa<ArraySubscriptExpr>(
                                         MC.getAssociatedExpression()));
                           });
              })) {
        bool IsFirstprivate = false;
        // By default lambdas are captured as firstprivates.
        if (const auto *RD =
                VD->getType().getNonReferenceType()->getAsCXXRecordDecl())
          IsFirstprivate = RD->isLambda();
        IsFirstprivate =
            IsFirstprivate || (Stack->mustBeFirstprivate(ClauseKind) && !Res);
        if (IsFirstprivate) {
          ImplicitFirstprivate.emplace_back(E);
        } else {
          OpenMPDefaultmapClauseModifier M =
              Stack->getDefaultmapModifier(ClauseKind);
          OpenMPMapClauseKind Kind = getMapClauseKindFromModifier(
              M, ClauseKind == OMPC_DEFAULTMAP_aggregate || Res);
          ImplicitMap[ClauseKind][Kind].emplace_back(E);
        }
        return;
      }
    }

    // OpenMP [2.9.3.6, Restrictions, p.2]
    //  A list item that appears in a reduction clause of the innermost
    //  enclosing worksharing or parallel construct may not be accessed in an
    //  explicit task.
    DVar = Stack->hasInnermostDSA(
        VD,
        [](OpenMPClauseKind C, bool AppliedToPointee) {
          return C == OMPC_reduction && !AppliedToPointee;
        },
        [](OpenMPDirectiveKind K) {
          return isOpenMPParallelDirective(K) ||
                 isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
        },
        /*FromParent=*/true);
    if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
      ErrorFound = true;
      SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
      reportOriginalDsa(SemaRef, Stack, VD, DVar);
      return;
    }

    // Define implicit data-sharing attributes for task.
    DVar = Stack->getImplicitDSA(VD, /*FromParent=*/false);
    if (((isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared) ||
         (Stack->getDefaultDSA() == DSA_firstprivate &&
          DVar.CKind == OMPC_firstprivate && !DVar.RefExpr)) &&
        !Stack->isLoopControlVariable(VD).first) {
      ImplicitFirstprivate.push_back(E);
      return;
    }

    // Store implicitly used globals with declare target link for parent
    // target.
    if (!isOpenMPTargetExecutionDirective(DKind) && Res &&
        *Res == OMPDeclareTargetDeclAttr::MT_Link) {
      Stack->addToParentTargetRegionLinkGlobals(E);
      return;
    }
  }
}
void VisitMemberExpr(MemberExpr *E) {
  if (E->isTypeDependent() || E->isValueDependent() ||
      E->containsUnexpandedParameterPack() || E->isInstantiationDependent())
    return;
  auto *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
  OpenMPDirectiveKind DKind = Stack->getCurrentDirective();
  if (auto *TE = dyn_cast<CXXThisExpr>(E->getBase()->IgnoreParenCasts())) {
    if (!FD)
      return;
    DSAStackTy::DSAVarData DVar = Stack->getTopDSA(FD, /*FromParent=*/false);
    // Check if the variable has explicit DSA set and stop analysis if it
    // so.
    if (DVar.RefExpr || !ImplicitDeclarations.insert(FD).second)
      return;

    if (isOpenMPTargetExecutionDirective(DKind) &&
        !Stack->isLoopControlVariable(FD).first &&
        !Stack->checkMappableExprComponentListsForDecl(
            FD, /*CurrentRegionOnly=*/true,
            [](OMPClauseMappableExprCommon::MappableExprComponentListRef
                   StackComponents,
               OpenMPClauseKind) {
              return isa<CXXThisExpr>(
                  cast<MemberExpr>(
                      StackComponents.back().getAssociatedExpression())
                      ->getBase()
                      ->IgnoreParens());
            })) {
      // OpenMP 4.5 [2.15.5.1, map Clause, Restrictions, C/C++, p.3]
      //  A bit-field cannot appear in a map clause.
      //
      if (FD->isBitField())
        return;

      // Check to see if the member expression is referencing a class that
      // has already been explicitly mapped
      if (Stack->isClassPreviouslyMapped(TE->getType()))
        return;

      OpenMPDefaultmapClauseModifier Modifier =
          Stack->getDefaultmapModifier(OMPC_DEFAULTMAP_aggregate);
      OpenMPDefaultmapClauseKind ClauseKind =
          getVariableCategoryFromDecl(SemaRef.getLangOpts(), FD);
      OpenMPMapClauseKind Kind = getMapClauseKindFromModifier(
          Modifier, /*IsAggregateOrDeclareTarget*/ true);
      ImplicitMap[ClauseKind][Kind].emplace_back(E);
      return;
    }

    SourceLocation ELoc = E->getExprLoc();
    // OpenMP [2.9.3.6, Restrictions, p.2]
    //  A list item that appears in a reduction clause of the innermost
    //  enclosing worksharing or parallel construct may not be accessed in
    //  an  explicit task.
    DVar = Stack->hasInnermostDSA(
        FD,
        [](OpenMPClauseKind C, bool AppliedToPointee) {
          return C == OMPC_reduction && !AppliedToPointee;
        },
        [](OpenMPDirectiveKind K) {
          return isOpenMPParallelDirective(K) ||
                 isOpenMPWorksharingDirective(K) || isOpenMPTeamsDirective(K);
        },
        /*FromParent=*/true);
    if (isOpenMPTaskingDirective(DKind) && DVar.CKind == OMPC_reduction) {
      ErrorFound = true;
      SemaRef.Diag(ELoc, diag::err_omp_reduction_in_task);
      reportOriginalDsa(SemaRef, Stack, FD, DVar);
      return;
    }

    // Define implicit data-sharing attributes for task.
    DVar = Stack->getImplicitDSA(FD, /*FromParent=*/false);
    if (isOpenMPTaskingDirective(DKind) && DVar.CKind != OMPC_shared &&
        !Stack->isLoopControlVariable(FD).first) {
      // Check if there is a captured expression for the current field in the
      // region. Do not mark it as firstprivate unless there is no captured
      // expression.
      // TODO: try to make it firstprivate.
      if (DVar.CKind != OMPC_unknown)
        ImplicitFirstprivate.push_back(E);
    }
    return;
  }
  if (isOpenMPTargetExecutionDirective(DKind)) {
    OMPClauseMappableExprCommon::MappableExprComponentList CurComponents;
    if (!checkMapClauseExpressionBase(SemaRef, E, CurComponents, OMPC_map,
                                      Stack->getCurrentDirective(),
                                      /*NoDiagnose=*/true))
      return;
    const auto *VD = cast<ValueDecl>(
        CurComponents.back().getAssociatedDeclaration()->getCanonicalDecl());
    if (!Stack->checkMappableExprComponentListsForDecl(
            VD, /*CurrentRegionOnly=*/true,
            [&CurComponents](
                OMPClauseMappableExprCommon::MappableExprComponentListRef
                    StackComponents,
                OpenMPClauseKind) {
              auto CCI = CurComponents.rbegin();
              auto CCE = CurComponents.rend();
              for (const auto &SC : llvm::reverse(StackComponents)) {
                // Do both expressions have the same kind?
                if (CCI->getAssociatedExpression()->getStmtClass() !=
                    SC.getAssociatedExpression()->getStmtClass())
                  if (!((isa<OMPArraySectionExpr>(
                             SC.getAssociatedExpression()) ||
                         isa<OMPArrayShapingExpr>(
                             SC.getAssociatedExpression())) &&
                        isa<ArraySubscriptExpr>(
                            CCI->getAssociatedExpression())))
                    return false;

                const Decl *CCD = CCI->getAssociatedDeclaration();
                const Decl *SCD = SC.getAssociatedDeclaration();
                CCD = CCD ? CCD->getCanonicalDecl() : nullptr;
                SCD = SCD ? SCD->getCanonicalDecl() : nullptr;
                if (SCD != CCD)
                  return false;
                std::advance(CCI, 1);
                if (CCI == CCE)
                  break;
              }
              return true;
            })) {
      Visit(E->getBase());
    }
  } else if (!TryCaptureCXXThisMembers) {
    Visit(E->getBase());
  }
}
void VisitOMPExecutableDirective(OMPExecutableDirective *S) {
  for (OMPClause *C : S->clauses()) {
    // Skip analysis of arguments of implicitly defined firstprivate clause
    // for task|target directives.
    // Skip analysis of arguments of implicitly defined map clause for target
    // directives.
    if (C && !((isa<OMPFirstprivateClause>(C) || isa<OMPMapClause>(C)) &&
               C->isImplicit() &&
               !isOpenMPTaskingDirective(Stack->getCurrentDirective()))) {
      for (Stmt *CC : C->children()) {
        if (CC)
          Visit(CC);
      }
    }
  }
  // Check implicitly captured variables.
  VisitSubCaptures(S);
}

void VisitOMPTileDirective(OMPTileDirective *S) {
  // #pragma omp tile does not introduce data sharing.
  VisitStmt(S);
}

void VisitOMPUnrollDirective(OMPUnrollDirective *S) {
  // #pragma omp unroll does not introduce data sharing.
  VisitStmt(S);
}

void VisitStmt(Stmt *S) {
  for (Stmt *C : S->children()) {
    if (C) {
      // Check implicitly captured variables in the task-based directives to
      // check if they must be firstprivatized.
      Visit(C);
    }
  }
}

void visitSubCaptures(CapturedStmt *S) {
  for (const CapturedStmt::Capture &Cap : S->captures()) {
    if (!Cap.capturesVariable() && !Cap.capturesVariableByCopy())
      continue;
    VarDecl *VD = Cap.getCapturedVar();
    // Do not try to map the variable if it or its sub-component was mapped
    // already.
    if (isOpenMPTargetExecutionDirective(Stack->getCurrentDirective()) &&
        Stack->checkMappableExprComponentListsForDecl(
            VD, /*CurrentRegionOnly=*/true,
            [](OMPClauseMappableExprCommon::MappableExprComponentListRef,
               OpenMPClauseKind) { return true; }))
      continue;
    DeclRefExpr *DRE = buildDeclRefExpr(
        SemaRef, VD, VD->getType().getNonLValueExprType(SemaRef.Context),
        Cap.getLocation(), /*RefersToCapture=*/true);
    Visit(DRE);
  }
}
bool isErrorFound() const { return ErrorFound; }
ArrayRef<Expr *> getImplicitFirstprivate() const {
  return ImplicitFirstprivate;
}
ArrayRef<Expr *> getImplicitMap(OpenMPDefaultmapClauseKind DK,
                                OpenMPMapClauseKind MK) const {
  return ImplicitMap[DK][MK];
}
ArrayRef<OpenMPMapModifierKind>
getImplicitMapModifier(OpenMPDefaultmapClauseKind Kind) const {
  return ImplicitMapModifier[Kind];
}
const Sema::VarsWithInheritedDSAType &getVarsWithInheritedDSA() const {
  return VarsWithInheritedDSA;
}

DSAAttrChecker(DSAStackTy *S, Sema &SemaRef, CapturedStmt *CS)
    : Stack(S), SemaRef(SemaRef), ErrorFound(false), CS(CS) {
  // Process declare target link variables for the target directives.
  if (isOpenMPTargetExecutionDirective(S->getCurrentDirective())) {
    for (DeclRefExpr *E : Stack->getLinkGlobals())
      Visit(E);
  }
}
3871};
3872} // namespace

3874void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
switch (DKind) {
case OMPD_parallel:
case OMPD_parallel_for:
case OMPD_parallel_for_simd:
case OMPD_parallel_sections:
case OMPD_parallel_master:
case OMPD_teams:
case OMPD_teams_distribute:
case OMPD_teams_distribute_simd: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params);
  break;
}
case OMPD_target_teams:
case OMPD_target_parallel:
case OMPD_target_parallel_for:
case OMPD_target_parallel_for_simd:
case OMPD_target_teams_distribute:
case OMPD_target_teams_distribute_simd: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  QualType Args[] = {VoidPtrTy};
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = true;
  QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32Ty),
      std::make_pair(".part_id.", KmpInt32PtrTy),
      std::make_pair(".privates.", VoidPtrTy),
      std::make_pair(
          ".copy_fn.",
          Context.getPointerType(CopyFnType).withConst().withRestrict()),
      std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params, /*OpenMPCaptureLevel=*/0);
  // Mark this captured region as inlined, because we don't use outlined
  // function directly.
  getCurCapturedRegion()->TheCapturedDecl->addAttr(
      AlwaysInlineAttr::CreateImplicit(
          Context, {}, AttributeCommonInfo::AS_Keyword,
          AlwaysInlineAttr::Keyword_forceinline));
  Sema::CapturedParamNameType ParamsTarget[] = {
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'target' with no implicit parameters.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsTarget, /*OpenMPCaptureLevel=*/1);
  Sema::CapturedParamNameType ParamsTeamsOrParallel[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'teams' or 'parallel'.  Both regions have
  // the same implicit parameters.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsTeamsOrParallel, /*OpenMPCaptureLevel=*/2);
  break;
}
case OMPD_target:
case OMPD_target_simd: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  QualType Args[] = {VoidPtrTy};
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = true;
  QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32Ty),
      std::make_pair(".part_id.", KmpInt32PtrTy),
      std::make_pair(".privates.", VoidPtrTy),
      std::make_pair(
          ".copy_fn.",
          Context.getPointerType(CopyFnType).withConst().withRestrict()),
      std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params, /*OpenMPCaptureLevel=*/0);
  // Mark this captured region as inlined, because we don't use outlined
  // function directly.
  getCurCapturedRegion()->TheCapturedDecl->addAttr(
      AlwaysInlineAttr::CreateImplicit(
          Context, {}, AttributeCommonInfo::AS_Keyword,
          AlwaysInlineAttr::Keyword_forceinline));
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           std::make_pair(StringRef(), QualType()),
                           /*OpenMPCaptureLevel=*/1);
  break;
}
case OMPD_atomic:
case OMPD_critical:
case OMPD_section:
case OMPD_master:
case OMPD_masked:
case OMPD_tile:
case OMPD_unroll:
  break;
case OMPD_simd:
case OMPD_for:
case OMPD_for_simd:
case OMPD_sections:
case OMPD_single:
case OMPD_taskgroup:
case OMPD_distribute:
case OMPD_distribute_simd:
case OMPD_ordered:
case OMPD_target_data:
case OMPD_dispatch: {
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params);
  break;
}
case OMPD_task: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  QualType Args[] = {VoidPtrTy};
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = true;
  QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32Ty),
      std::make_pair(".part_id.", KmpInt32PtrTy),
      std::make_pair(".privates.", VoidPtrTy),
      std::make_pair(
          ".copy_fn.",
          Context.getPointerType(CopyFnType).withConst().withRestrict()),
      std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params);
  // Mark this captured region as inlined, because we don't use outlined
  // function directly.
  getCurCapturedRegion()->TheCapturedDecl->addAttr(
      AlwaysInlineAttr::CreateImplicit(
          Context, {}, AttributeCommonInfo::AS_Keyword,
          AlwaysInlineAttr::Keyword_forceinline));
  break;
}
case OMPD_taskloop:
case OMPD_taskloop_simd:
case OMPD_master_taskloop:
case OMPD_master_taskloop_simd: {
  QualType KmpInt32Ty =
      Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1)
          .withConst();
  QualType KmpUInt64Ty =
      Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0)
          .withConst();
  QualType KmpInt64Ty =
      Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1)
          .withConst();
  QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  QualType Args[] = {VoidPtrTy};
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = true;
  QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32Ty),
      std::make_pair(".part_id.", KmpInt32PtrTy),
      std::make_pair(".privates.", VoidPtrTy),
      std::make_pair(
          ".copy_fn.",
          Context.getPointerType(CopyFnType).withConst().withRestrict()),
      std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
      std::make_pair(".lb.", KmpUInt64Ty),
      std::make_pair(".ub.", KmpUInt64Ty),
      std::make_pair(".st.", KmpInt64Ty),
      std::make_pair(".liter.", KmpInt32Ty),
      std::make_pair(".reductions.", VoidPtrTy),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params);
  // Mark this captured region as inlined, because we don't use outlined
  // function directly.
  getCurCapturedRegion()->TheCapturedDecl->addAttr(
      AlwaysInlineAttr::CreateImplicit(
          Context, {}, AttributeCommonInfo::AS_Keyword,
          AlwaysInlineAttr::Keyword_forceinline));
  break;
}
case OMPD_parallel_master_taskloop:
case OMPD_parallel_master_taskloop_simd: {
  QualType KmpInt32Ty =
      Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1)
          .withConst();
  QualType KmpUInt64Ty =
      Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/0)
          .withConst();
  QualType KmpInt64Ty =
      Context.getIntTypeForBitwidth(/*DestWidth=*/64, /*Signed=*/1)
          .withConst();
  QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  Sema::CapturedParamNameType ParamsParallel[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'parallel'.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsParallel, /*OpenMPCaptureLevel=*/0);
  QualType Args[] = {VoidPtrTy};
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = true;
  QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32Ty),
      std::make_pair(".part_id.", KmpInt32PtrTy),
      std::make_pair(".privates.", VoidPtrTy),
      std::make_pair(
          ".copy_fn.",
          Context.getPointerType(CopyFnType).withConst().withRestrict()),
      std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
      std::make_pair(".lb.", KmpUInt64Ty),
      std::make_pair(".ub.", KmpUInt64Ty),
      std::make_pair(".st.", KmpInt64Ty),
      std::make_pair(".liter.", KmpInt32Ty),
      std::make_pair(".reductions.", VoidPtrTy),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params, /*OpenMPCaptureLevel=*/1);
  // Mark this captured region as inlined, because we don't use outlined
  // function directly.
  getCurCapturedRegion()->TheCapturedDecl->addAttr(
      AlwaysInlineAttr::CreateImplicit(
          Context, {}, AttributeCommonInfo::AS_Keyword,
          AlwaysInlineAttr::Keyword_forceinline));
  break;
}
case OMPD_distribute_parallel_for_simd:
case OMPD_distribute_parallel_for: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(".previous.lb.", Context.getSizeType().withConst()),
      std::make_pair(".previous.ub.", Context.getSizeType().withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params);
  break;
}
case OMPD_target_teams_distribute_parallel_for:
case OMPD_target_teams_distribute_parallel_for_simd: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();

  QualType Args[] = {VoidPtrTy};
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = true;
  QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32Ty),
      std::make_pair(".part_id.", KmpInt32PtrTy),
      std::make_pair(".privates.", VoidPtrTy),
      std::make_pair(
          ".copy_fn.",
          Context.getPointerType(CopyFnType).withConst().withRestrict()),
      std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params, /*OpenMPCaptureLevel=*/0);
  // Mark this captured region as inlined, because we don't use outlined
  // function directly.
  getCurCapturedRegion()->TheCapturedDecl->addAttr(
      AlwaysInlineAttr::CreateImplicit(
          Context, {}, AttributeCommonInfo::AS_Keyword,
          AlwaysInlineAttr::Keyword_forceinline));
  Sema::CapturedParamNameType ParamsTarget[] = {
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'target' with no implicit parameters.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsTarget, /*OpenMPCaptureLevel=*/1);

  Sema::CapturedParamNameType ParamsTeams[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'target' with no implicit parameters.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsTeams, /*OpenMPCaptureLevel=*/2);

  Sema::CapturedParamNameType ParamsParallel[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(".previous.lb.", Context.getSizeType().withConst()),
      std::make_pair(".previous.ub.", Context.getSizeType().withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'teams' or 'parallel'.  Both regions have
  // the same implicit parameters.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsParallel, /*OpenMPCaptureLevel=*/3);
  break;
}

case OMPD_teams_distribute_parallel_for:
case OMPD_teams_distribute_parallel_for_simd: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();

  Sema::CapturedParamNameType ParamsTeams[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'target' with no implicit parameters.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsTeams, /*OpenMPCaptureLevel=*/0);

  Sema::CapturedParamNameType ParamsParallel[] = {
      std::make_pair(".global_tid.", KmpInt32PtrTy),
      std::make_pair(".bound_tid.", KmpInt32PtrTy),
      std::make_pair(".previous.lb.", Context.getSizeType().withConst()),
      std::make_pair(".previous.ub.", Context.getSizeType().withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  // Start a captured region for 'teams' or 'parallel'.  Both regions have
  // the same implicit parameters.
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           ParamsParallel, /*OpenMPCaptureLevel=*/1);
  break;
}
case OMPD_target_update:
case OMPD_target_enter_data:
case OMPD_target_exit_data: {
  QualType KmpInt32Ty = Context.getIntTypeForBitwidth(32, 1).withConst();
  QualType VoidPtrTy = Context.VoidPtrTy.withConst().withRestrict();
  QualType KmpInt32PtrTy =
      Context.getPointerType(KmpInt32Ty).withConst().withRestrict();
  QualType Args[] = {VoidPtrTy};
  FunctionProtoType::ExtProtoInfo EPI;
  EPI.Variadic = true;
  QualType CopyFnType = Context.getFunctionType(Context.VoidTy, Args, EPI);
  Sema::CapturedParamNameType Params[] = {
      std::make_pair(".global_tid.", KmpInt32Ty),
      std::make_pair(".part_id.", KmpInt32PtrTy),
      std::make_pair(".privates.", VoidPtrTy),
      std::make_pair(
          ".copy_fn.",
          Context.getPointerType(CopyFnType).withConst().withRestrict()),
      std::make_pair(".task_t.", Context.VoidPtrTy.withConst()),
      std::make_pair(StringRef(), QualType()) // __context with shared vars
  };
  ActOnCapturedRegionStart(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getConstructLoc(), CurScope, CR_OpenMP,
                           Params);
  // Mark this captured region as inlined, because we don't use outlined
  // function directly.
  getCurCapturedRegion()->TheCapturedDecl->addAttr(
      AlwaysInlineAttr::CreateImplicit(
          Context, {}, AttributeCommonInfo::AS_Keyword,
          AlwaysInlineAttr::Keyword_forceinline));
  break;
}
case OMPD_threadprivate:
case OMPD_allocate:
case OMPD_taskyield:
case OMPD_barrier:
case OMPD_taskwait:
case OMPD_cancellation_point:
case OMPD_cancel:
case OMPD_flush:
case OMPD_depobj:
case OMPD_scan:
case OMPD_declare_reduction:
case OMPD_declare_mapper:
case OMPD_declare_simd:
case OMPD_declare_target:
case OMPD_end_declare_target:
case OMPD_requires:
case OMPD_declare_variant:
case OMPD_begin_declare_variant:
case OMPD_end_declare_variant:
  llvm_unreachable("OpenMP Directive is not allowed")__builtin_unreachable();
case OMPD_unknown:
default:
  llvm_unreachable("Unknown OpenMP directive")__builtin_unreachable();
}
DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setContext(CurContext);
4288}

4290int Sema::getNumberOfConstructScopes(unsigned Level) const {
return getOpenMPCaptureLevels(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getDirective(Level));
4292}

4294int Sema::getOpenMPCaptureLevels(OpenMPDirectiveKind DKind) {
SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
getOpenMPCaptureRegions(CaptureRegions, DKind);
return CaptureRegions.size();
4298}

4300static OMPCapturedExprDecl *buildCaptureDecl(Sema &S, IdentifierInfo *Id,
                                           Expr *CaptureExpr, bool WithInit,
                                           bool AsExpression) {
assert(CaptureExpr)((void)0);
ASTContext &C = S.getASTContext();
Expr *Init = AsExpression ? CaptureExpr : CaptureExpr->IgnoreImpCasts();
QualType Ty = Init->getType();
if (CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue()) {
  if (S.getLangOpts().CPlusPlus) {
    Ty = C.getLValueReferenceType(Ty);
  } else {
    Ty = C.getPointerType(Ty);
    ExprResult Res =
        S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_AddrOf, Init);
    if (!Res.isUsable())
      return nullptr;
    Init = Res.get();
  }
  WithInit = true;
}
auto *CED = OMPCapturedExprDecl::Create(C, S.CurContext, Id, Ty,
                                        CaptureExpr->getBeginLoc());
if (!WithInit)
  CED->addAttr(OMPCaptureNoInitAttr::CreateImplicit(C));
S.CurContext->addHiddenDecl(CED);
Sema::TentativeAnalysisScope Trap(S);
S.AddInitializerToDecl(CED, Init, /*DirectInit=*/false);
return CED;
4328}

4330static DeclRefExpr *buildCapture(Sema &S, ValueDecl *D, Expr *CaptureExpr,
                               bool WithInit) {
OMPCapturedExprDecl *CD;
if (VarDecl *VD = S.isOpenMPCapturedDecl(D))
  CD = cast<OMPCapturedExprDecl>(VD);
else
  CD = buildCaptureDecl(S, D->getIdentifier(), CaptureExpr, WithInit,
                        /*AsExpression=*/false);
return buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
                        CaptureExpr->getExprLoc());
4340}

4342static ExprResult buildCapture(Sema &S, Expr *CaptureExpr, DeclRefExpr *&Ref) {
CaptureExpr = S.DefaultLvalueConversion(CaptureExpr).get();
if (!Ref) {
  OMPCapturedExprDecl *CD = buildCaptureDecl(
      S, &S.getASTContext().Idents.get(".capture_expr."), CaptureExpr,
      /*WithInit=*/true, /*AsExpression=*/true);
  Ref = buildDeclRefExpr(S, CD, CD->getType().getNonReferenceType(),
                         CaptureExpr->getExprLoc());
}
ExprResult Res = Ref;
if (!S.getLangOpts().CPlusPlus &&
    CaptureExpr->getObjectKind() == OK_Ordinary && CaptureExpr->isGLValue() &&
    Ref->getType()->isPointerType()) {
  Res = S.CreateBuiltinUnaryOp(CaptureExpr->getExprLoc(), UO_Deref, Ref);
  if (!Res.isUsable())
    return ExprError();
}
return S.DefaultLvalueConversion(Res.get());
4360}

4362namespace {
4363// OpenMP directives parsed in this section are represented as a
4364// CapturedStatement with an associated statement.  If a syntax error
4365// is detected during the parsing of the associated statement, the
4366// compiler must abort processing and close the CapturedStatement.
4367//
4368// Combined directives such as 'target parallel' have more than one
4369// nested CapturedStatements.  This RAII ensures that we unwind out
4370// of all the nested CapturedStatements when an error is found.
4371class CaptureRegionUnwinderRAII {
4372private:
Sema &S;
bool &ErrorFound;
OpenMPDirectiveKind DKind = OMPD_unknown;

4377public:
CaptureRegionUnwinderRAII(Sema &S, bool &ErrorFound,
                          OpenMPDirectiveKind DKind)
    : S(S), ErrorFound(ErrorFound), DKind(DKind) {}
~CaptureRegionUnwinderRAII() {
  if (ErrorFound) {
    int ThisCaptureLevel = S.getOpenMPCaptureLevels(DKind);
    while (--ThisCaptureLevel >= 0)
      S.ActOnCapturedRegionError();
  }
}
4388};
4389} // namespace

4391void Sema::tryCaptureOpenMPLambdas(ValueDecl *V) {
// Capture variables captured by reference in lambdas for target-based
// directives.
if (!CurContext->isDependentContext() &&
    (isOpenMPTargetExecutionDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()) ||
     isOpenMPTargetDataManagementDirective(
         DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()))) {
  QualType Type = V->getType();
  if (const auto *RD = Type.getCanonicalType()
                           .getNonReferenceType()
                           ->getAsCXXRecordDecl()) {
    bool SavedForceCaptureByReferenceInTargetExecutable =
        DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->isForceCaptureByReferenceInTargetExecutable();
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setForceCaptureByReferenceInTargetExecutable(
        /*V=*/true);
    if (RD->isLambda()) {
      llvm::DenseMap<const VarDecl *, FieldDecl *> Captures;
      FieldDecl *ThisCapture;
      RD->getCaptureFields(Captures, ThisCapture);
      for (const LambdaCapture &LC : RD->captures()) {
        if (LC.getCaptureKind() == LCK_ByRef) {
          VarDecl *VD = LC.getCapturedVar();
          DeclContext *VDC = VD->getDeclContext();
          if (!VDC->Encloses(CurContext))
            continue;
          MarkVariableReferenced(LC.getLocation(), VD);
        } else if (LC.getCaptureKind() == LCK_This) {
          QualType ThisTy = getCurrentThisType();
          if (!ThisTy.isNull() &&
              Context.typesAreCompatible(ThisTy, ThisCapture->getType()))
            CheckCXXThisCapture(LC.getLocation());
        }
      }
    }
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setForceCaptureByReferenceInTargetExecutable(
        SavedForceCaptureByReferenceInTargetExecutable);
  }
}
4429}

4431static bool checkOrderedOrderSpecified(Sema &S,
                                     const ArrayRef<OMPClause *> Clauses) {
const OMPOrderedClause *Ordered = nullptr;
const OMPOrderClause *Order = nullptr;

for (const OMPClause *Clause : Clauses) {
  if (Clause->getClauseKind() == OMPC_ordered)
    Ordered = cast<OMPOrderedClause>(Clause);
  else if (Clause->getClauseKind() == OMPC_order) {
    Order = cast<OMPOrderClause>(Clause);
    if (Order->getKind() != OMPC_ORDER_concurrent)
      Order = nullptr;
  }
  if (Ordered && Order)
    break;
}

if (Ordered && Order) {
  S.Diag(Order->getKindKwLoc(),
         diag::err_omp_simple_clause_incompatible_with_ordered)
      << getOpenMPClauseName(OMPC_order)
      << getOpenMPSimpleClauseTypeName(OMPC_order, OMPC_ORDER_concurrent)
      << SourceRange(Order->getBeginLoc(), Order->getEndLoc());
  S.Diag(Ordered->getBeginLoc(), diag::note_omp_ordered_param)
      << 0 << SourceRange(Ordered->getBeginLoc(), Ordered->getEndLoc());
  return true;
}
return false;
4459}

4461StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
                                    ArrayRef<OMPClause *> Clauses) {
if (DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective() == OMPD_atomic ||
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective() == OMPD_critical ||
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective() == OMPD_section ||
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective() == OMPD_master ||
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective() == OMPD_masked)
  return S;

bool ErrorFound = false;
CaptureRegionUnwinderRAII CaptureRegionUnwinder(
    *this, ErrorFound, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective());
if (!S.isUsable()) {
  ErrorFound = true;
  return StmtError();
}

SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
getOpenMPCaptureRegions(CaptureRegions, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective());
OMPOrderedClause *OC = nullptr;
OMPScheduleClause *SC = nullptr;
SmallVector<const OMPLinearClause *, 4> LCs;
SmallVector<const OMPClauseWithPreInit *, 4> PICs;
// This is required for proper codegen.
for (OMPClause *Clause : Clauses) {
  if (!LangOpts.OpenMPSimd &&
      isOpenMPTaskingDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()) &&
      Clause->getClauseKind() == OMPC_in_reduction) {
    // Capture taskgroup task_reduction descriptors inside the tasking regions
    // with the corresponding in_reduction items.
    auto *IRC = cast<OMPInReductionClause>(Clause);
    for (Expr *E : IRC->taskgroup_descriptors())
      if (E)
        MarkDeclarationsReferencedInExpr(E);
  }
  if (isOpenMPPrivate(Clause->getClauseKind()) ||
      Clause->getClauseKind() == OMPC_copyprivate ||
      (getLangOpts().OpenMPUseTLS &&
       getASTContext().getTargetInfo().isTLSSupported() &&
       Clause->getClauseKind() == OMPC_copyin)) {
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setForceVarCapturing(Clause->getClauseKind() == OMPC_copyin);
    // Mark all variables in private list clauses as used in inner region.
    for (Stmt *VarRef : Clause->children()) {
      if (auto *E = cast_or_null<Expr>(VarRef)) {
        MarkDeclarationsReferencedInExpr(E);
      }
    }
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setForceVarCapturing(/*V=*/false);
  } else if (isOpenMPLoopTransformationDirective(
                 DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective())) {
    assert(CaptureRegions.empty() &&((void)0)
           "No captured regions in loop transformation directives.")((void)0);
  } else if (CaptureRegions.size() > 1 ||
             CaptureRegions.back() != OMPD_unknown) {
    if (auto *C = OMPClauseWithPreInit::get(Clause))
      PICs.push_back(C);
    if (auto *C = OMPClauseWithPostUpdate::get(Clause)) {
      if (Expr *E = C->getPostUpdateExpr())
        MarkDeclarationsReferencedInExpr(E);
    }
  }
  if (Clause->getClauseKind() == OMPC_schedule)
    SC = cast<OMPScheduleClause>(Clause);
  else if (Clause->getClauseKind() == OMPC_ordered)
    OC = cast<OMPOrderedClause>(Clause);
  else if (Clause->getClauseKind() == OMPC_linear)
    LCs.push_back(cast<OMPLinearClause>(Clause));
}
// Capture allocator expressions if used.
for (Expr *E : DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getInnerAllocators())
  MarkDeclarationsReferencedInExpr(E);
// OpenMP, 2.7.1 Loop Construct, Restrictions
// The nonmonotonic modifier cannot be specified if an ordered clause is
// specified.
if (SC &&
    (SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic ||
     SC->getSecondScheduleModifier() ==
         OMPC_SCHEDULE_MODIFIER_nonmonotonic) &&
    OC) {
  Diag(SC->getFirstScheduleModifier() == OMPC_SCHEDULE_MODIFIER_nonmonotonic
           ? SC->getFirstScheduleModifierLoc()
           : SC->getSecondScheduleModifierLoc(),
       diag::err_omp_simple_clause_incompatible_with_ordered)
      << getOpenMPClauseName(OMPC_schedule)
      << getOpenMPSimpleClauseTypeName(OMPC_schedule,
                                       OMPC_SCHEDULE_MODIFIER_nonmonotonic)
      << SourceRange(OC->getBeginLoc(), OC->getEndLoc());
  ErrorFound = true;
}
// OpenMP 5.0, 2.9.2 Worksharing-Loop Construct, Restrictions.
// If an order(concurrent) clause is present, an ordered clause may not appear
// on the same directive.
if (checkOrderedOrderSpecified(*this, Clauses))
  ErrorFound = true;
if (!LCs.empty() && OC && OC->getNumForLoops()) {
  for (const OMPLinearClause *C : LCs) {
    Diag(C->getBeginLoc(), diag::err_omp_linear_ordered)
        << SourceRange(OC->getBeginLoc(), OC->getEndLoc());
  }
  ErrorFound = true;
}
if (isOpenMPWorksharingDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()) &&
    isOpenMPSimdDirective(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective()) && OC &&
    OC->getNumForLoops()) {
  Diag(OC->getBeginLoc(), diag::err_omp_ordered_simd)
      << getOpenMPDirectiveName(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->getCurrentDirective());
  ErrorFound = true;
}
if (ErrorFound) {
  return StmtError();
}
StmtResult SR = S;
unsigned CompletedRegions = 0;
for (OpenMPDirectiveKind ThisCaptureRegion : llvm::reverse(CaptureRegions)) {
  // Mark all variables in private list clauses as used in inner region.
  // Required for proper codegen of combined directives.
  // TODO: add processing for other clauses.
  if (ThisCaptureRegion != OMPD_unknown) {
    for (const clang::OMPClauseWithPreInit *C : PICs) {
      OpenMPDirectiveKind CaptureRegion = C->getCaptureRegion();
      // Find the particular capture region for the clause if the
      // directive is a combined one with multiple capture regions.
      // If the directive is not a combined one, the capture region
      // associated with the clause is OMPD_unknown and is generated
      // only once.
      if (CaptureRegion == ThisCaptureRegion ||
          CaptureRegion == OMPD_unknown) {
        if (auto *DS = cast_or_null<DeclStmt>(C->getPreInitStmt())) {
          for (Decl *D : DS->decls())
            MarkVariableReferenced(D->getLocation(), cast<VarDecl>(D));
        }
      }
    }
  }
  if (ThisCaptureRegion == OMPD_target) {
    // Capture allocator traits in the target region. They are used implicitly
    // and, thus, are not captured by default.
    for (OMPClause *C : Clauses) {
      if (const auto *UAC = dyn_cast<OMPUsesAllocatorsClause>(C)) {
        for (unsigned I = 0, End = UAC->getNumberOfAllocators(); I < End;
             ++I) {
          OMPUsesAllocatorsClause::Data D = UAC->getAllocatorData(I);
          if (Expr *E = D.AllocatorTraits)
            MarkDeclarationsReferencedInExpr(E);
        }
        continue;
      }
    }
  }
  if (ThisCaptureRegion == OMPD_parallel) {
    // Capture temp arrays for inscan reductions and locals in aligned
    // clauses.
    for (OMPClause *C : Clauses) {
      if (auto *RC = dyn_cast<OMPReductionClause>(C)) {
        if (RC->getModifier() != OMPC_REDUCTION_inscan)
          continue;
        for (Expr *E : RC->copy_array_temps())
          MarkDeclarationsReferencedInExpr(E);
      }
      if (auto *AC = dyn_cast<OMPAlignedClause>(C)) {
        for (Expr *E : AC->varlists())
          MarkDeclarationsReferencedInExpr(E);
      }
    }
  }
  if (++CompletedRegions == CaptureRegions.size())
    DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
)->setBodyComplete();
  SR = ActOnCapturedRegionEnd(SR.get());
}
return SR;
4631}

4633static bool checkCancelRegion(Sema &SemaRef, OpenMPDirectiveKind CurrentRegion,
                            OpenMPDirectiveKind CancelRegion,
                            SourceLocation StartLoc) {
// CancelRegion is only needed for cancel and cancellation_point.
if (CurrentRegion != OMPD_cancel && CurrentRegion != OMPD_cancellation_point)
  return false;

if (CancelRegion == OMPD_parallel || CancelRegion == OMPD_for ||
    CancelRegion == OMPD_sections || CancelRegion == OMPD_taskgroup)
  return false;

SemaRef.Diag(StartLoc, diag::err_omp_wrong_cancel_region)
    << getOpenMPDirectiveName(CancelRegion);
return true;
4647}

4649static bool checkNestingOfRegions(Sema &SemaRef, const DSAStackTy *Stack,
                                OpenMPDirectiveKind CurrentRegion,
                                const DeclarationNameInfo &CurrentName,
                                OpenMPDirectiveKind CancelRegion,
                                SourceLocation StartLoc) {
if (Stack->getCurScope()) {
  OpenMPDirectiveKind ParentRegion = Stack->getParentDirective();
  OpenMPDirectiveKind OffendingRegion = ParentRegion;
  bool NestingProhibited = false;
  bool CloseNesting = true;
  bool OrphanSeen = false;
  enum {
    NoRecommend,
    ShouldBeInParallelRegion,
    ShouldBeInOrderedRegion,
    ShouldBeInTargetRegion,
    ShouldBeInTeamsRegion,
    ShouldBeInLoopSimdRegion,
  } Recommend = NoRecommend;
  if (isOpenMPSimdDirective(ParentRegion) &&
      ((SemaRef.LangOpts.OpenMP <= 45 && CurrentRegion != OMPD_ordered) ||
       (SemaRef.LangOpts.OpenMP >= 50 && CurrentRegion != OMPD_ordered &&
        CurrentRegion != OMPD_simd && CurrentRegion != OMPD_atomic &&
        CurrentRegion != OMPD_scan))) {
    // OpenMP [2.16, Nesting of Regions]
    // OpenMP constructs may not be nested inside a simd region.
    // OpenMP [2.8.1,simd Construct, Restrictions]
    // An ordered construct with the simd clause is the only OpenMP
    // construct that can appear in the simd region.
    // Allowing a SIMD construct nested in another SIMD construct is an
    // extension. The OpenMP 4.5 spec does not allow it. Issue a warning
    // message.
    // OpenMP 5.0 [2.9.3.1, simd Construct, Restrictions]
    // The only OpenMP constructs that can be encountered during execution of
    // a simd region are the atomic construct, the loop construct, the simd
    // construct and the ordered construct with the simd clause.
    SemaRef.Diag(StartLoc, (CurrentRegion != OMPD_simd)
                               ? diag::err_omp_prohibited_region_simd
                               : diag::warn_omp_nesting_simd)
        << (SemaRef.LangOpts.OpenMP >= 50 ? 1 : 0);
    return CurrentRegion != OMPD_simd;
  }
  if (ParentRegion == OMPD_atomic) {
    // OpenMP [2.16, Nesting of Regions]
    // OpenMP constructs may not be nested inside an atomic region.
    SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_atomic);
    return true;
  }
  if (CurrentRegion == OMPD_section) {
    // OpenMP [2.7.2, sections Construct, Restrictions]
    // Orphaned section directives are prohibited. That is, the section
    // directives must appear within the sections construct and must not be
    // encountered elsewhere in the sections region.
    if (ParentRegion != OMPD_sections &&
        ParentRegion != OMPD_parallel_sections) {
      SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive)
          << (ParentRegion != OMPD_unknown)
          << getOpenMPDirectiveName(ParentRegion);
      return true;
    }
    return false;
  }
  // Allow some constructs (except teams and cancellation constructs) to be
  // orphaned (they could be used in functions, called from OpenMP regions
  // with the required preconditions).
  if (ParentRegion == OMPD_unknown &&
      !isOpenMPNestingTeamsDirective(CurrentRegion) &&
      CurrentRegion != OMPD_cancellation_point &&
      CurrentRegion != OMPD_cancel && CurrentRegion != OMPD_scan)
    return false;
  if (CurrentRegion == OMPD_cancellation_point ||
      CurrentRegion == OMPD_cancel) {
    // OpenMP [2.16, Nesting of Regions]
    // A cancellation point construct for which construct-type-clause is
    // taskgroup must be nested inside a task construct. A cancellation
    // point construct for which construct-type-clause is not taskgroup must
    // be closely nested inside an OpenMP construct that matches the type
    // specified in construct-type-clause.
    // A cancel construct for which construct-type-clause is taskgroup must be
    // nested inside a task construct. A cancel construct for which
    // construct-type-clause is not taskgroup must be closely nested inside an
    // OpenMP construct that matches the type specified in
    // construct-type-clause.
    NestingProhibited =
        !((CancelRegion == OMPD_parallel &&
           (ParentRegion == OMPD_parallel ||
            ParentRegion == OMPD_target_parallel)) ||
          (CancelRegion == OMPD_for &&
           (ParentRegion == OMPD_for || ParentRegion == OMPD_parallel_for ||
            ParentRegion == OMPD_target_parallel_for ||
            ParentRegion == OMPD_distribute_parallel_for ||
            ParentRegion == OMPD_teams_distribute_parallel_for ||
            ParentRegion == OMPD_target_teams_distribute_parallel_for)) ||
          (CancelRegion == OMPD_taskgroup &&
           (ParentRegion == OMPD_task ||
            (SemaRef.getLangOpts().OpenMP >= 50 &&
             (ParentRegion == OMPD_taskloop ||
              ParentRegion == OMPD_master_taskloop ||
              ParentRegion == OMPD_parallel_master_taskloop)))) ||
          (CancelRegion == OMPD_sections &&
           (ParentRegion == OMPD_section || ParentRegion == OMPD_sections ||
            ParentRegion == OMPD_parallel_sections)));
    OrphanSeen = ParentRegion == OMPD_unknown;
  } else if (CurrentRegion == OMPD_master || CurrentRegion == OMPD_masked) {
    // OpenMP 5.1 [2.22, Nesting of Regions]
    // A masked region may not be closely nested inside a worksharing, loop,
    // atomic, task, or taskloop region.
    NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
                        isOpenMPTaskingDirective(ParentRegion);
  } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {
    // OpenMP [2.16, Nesting of Regions]
    // A critical region may not be nested (closely or otherwise) inside a
    // critical region with the same name. Note that this restriction is not
    // sufficient to prevent deadlock.
    SourceLocation PreviousCriticalLoc;
    bool DeadLock = Stack->hasDirective(
        [CurrentName, &PreviousCriticalLoc](OpenMPDirectiveKind K,
                                            const DeclarationNameInfo &DNI,
                                            SourceLocation Loc) {
          if (K == OMPD_critical && DNI.getName() == CurrentName.getName()) {
            PreviousCriticalLoc = Loc;
            return true;
          }
          return false;
        },
        false /* skip top directive */);
    if (DeadLock) {
      SemaRef.Diag(StartLoc,
                   diag::err_omp_prohibited_region_critical_same_name)
          << CurrentName.getName();
      if (PreviousCriticalLoc.isValid())
        SemaRef.Diag(PreviousCriticalLoc,
                     diag::note_omp_previous_critical_region);
      return true;
    }
  } else if (CurrentRegion == OMPD_barrier) {
    // OpenMP 5.1 [2.22, Nesting of Regions]
    // A barrier region may not be closely nested inside a worksharing, loop,
    // task, taskloop, critical, ordered, atomic, or masked region.
    NestingProhibited =
        isOpenMPWorksharingDirective(ParentRegion) ||
        isOpenMPTaskingDirective(ParentRegion) ||
        ParentRegion == OMPD_master || ParentRegion == OMPD_masked ||
        ParentRegion == OMPD_parallel_master ||
        ParentRegion == OMPD_critical || ParentRegion == OMPD_ordered;
  } else if (isOpenMPWorksharingDirective(CurrentRegion) &&
             !isOpenMPParallelDirective(CurrentRegion) &&
             !isOpenMPTeamsDirective(CurrentRegion)) {
    // OpenMP 5.1 [2.22, Nesting of Regions]
    // A loop region that binds to a parallel region or a worksharing region
    // may not be closely nested inside a worksharing, loop, task, taskloop,
    // critical, ordered, atomic, or masked region.
    NestingProhibited =
        isOpenMPWorksharingDirective(ParentRegion) ||
        isOpenMPTaskingDirective(ParentRegion) ||
        ParentRegion == OMPD_master || ParentRegion == OMPD_masked ||
        ParentRegion == OMPD_parallel_master ||
        ParentRegion == OMPD_critical || ParentRegion == OMPD_ordered;
    Recommend = ShouldBeInParallelRegion;
  } else if (CurrentRegion == OMPD_ordered) {
    // OpenMP [2.16, Nesting of Regions]
    // An ordered region may not be closely nested inside a critical,
    // atomic, or explicit task region.
    // An ordered region must be closely nested inside a loop region (or
    // parallel loop region) with an ordered clause.
    // OpenMP [2.8.1,simd Construct, Restrictions]
    // An ordered construct with the simd clause is the only OpenMP construct
    // that can appear in the simd region.
    NestingProhibited = ParentRegion == OMPD_critical ||
                        isOpenMPTaskingDirective(ParentRegion) ||
                        !(isOpenMPSimdDirective(ParentRegion) ||
                          Stack->isParentOrderedRegion());
    Recommend = ShouldBeInOrderedRegion;
  } else if (isOpenMPNestingTeamsDirective(CurrentRegion)) {
    // OpenMP [2.16, Nesting of Regions]
    // If specified, a teams construct must be contained within a target
    // construct.
    NestingProhibited =
        (SemaRef.LangOpts.OpenMP <= 45 && ParentRegion != OMPD_target) ||
        (SemaRef.LangOpts.OpenMP >= 50 && ParentRegion != OMPD_unknown &&
         ParentRegion != OMPD_target);
    OrphanSeen = ParentRegion == OMPD_unknown;
    Recommend = ShouldBeInTargetRegion;
  } else if (CurrentRegion == OMPD_scan) {
    // OpenMP [2.16, Nesting of Regions]
    // If specified, a teams construct must be contained within a target
    // construct.
    NestingProhibited =
        SemaRef.LangOpts.OpenMP < 50 ||
        (ParentRegion != OMPD_simd && ParentRegion != OMPD_for &&
         ParentRegion != OMPD_for_simd && ParentRegion != OMPD_parallel_for &&
         ParentRegion != OMPD_parallel_for_simd);
    OrphanSeen = ParentRegion == OMPD_unknown;
    Recommend = ShouldBeInLoopSimdRegion;
  }
  if (!NestingProhibited &&
      !isOpenMPTargetExecutionDirective(CurrentRegion) &&
      !isOpenMPTargetDataManagementDirective(CurrentRegion) &&
      (ParentRegion == OMPD_teams || ParentRegion == OMPD_target_teams)) {
    // OpenMP [2.16, Nesting of Regions]
    // distribute, parallel, parallel sections, parallel workshare, and the
    // parallel loop and parallel loop SIMD constructs are the only OpenMP
    // constructs that can be closely nested in the teams region.
    NestingProhibited = !isOpenMPParallelDirective(CurrentRegion) &&
                        !isOpenMPDistributeDirective(CurrentRegion);
    Recommend = ShouldBeInParallelRegion;
  }
  if (!NestingProhibited &&
      isOpenMPNestingDistributeDirective(CurrentRegion)) {
    // OpenMP 4.5 [2.17 Nesting of Regions]
    // The region associated with the distribute construct must be strictly
    // nested inside a teams region
    NestingProhibited =
        (ParentRegion != OMPD_teams && ParentRegion != OMPD_target_teams);
    Recommend = ShouldBeInTeamsRegion;
  }
  if (!NestingProhibited &&
      (isOpenMPTargetExecutionDirective(CurrentRegion) ||
       isOpenMPTargetDataManagementDirective(CurrentRegion))) {
    // OpenMP 4.5 [2.17 Nesting of Regions]
    // If a target, target update, target data, target enter data, or
    // target exit data construct is encountered during execution of a
    // target region, the behavior is unspecified.
    NestingProhibited = Stack->hasDirective(
        [&OffendingRegion](OpenMPDirectiveKind K, const DeclarationNameInfo &,
                           SourceLocation) {
          if (isOpenMPTargetExecutionDirective(K)) {
            OffendingRegion = K;
            return true;
          }
          return false;
        },
        false /* don't skip top directive */);
    CloseNesting = false;
  }
  if (NestingProhibited) {
    if (OrphanSeen) {
      SemaRef.Diag(StartLoc, diag::err_omp_orphaned_device_directive)
          << getOpenMPDirectiveName(CurrentRegion) << Recommend;
    } else {
      SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region)
          << CloseNesting << getOpenMPDirectiveName(OffendingRegion)
          << Recommend << getOpenMPDirectiveName(CurrentRegion);
    }
    return true;
  }
}
return false;
4897}

4899struct Kind2Unsigned {
using argument_type = OpenMPDirectiveKind;
unsigned operator()(argument_type DK) { return unsigned(DK); }
4902};
4903static bool checkIfClauses(Sema &S, OpenMPDirectiveKind Kind,
                         ArrayRef<OMPClause *> Clauses,
                         ArrayRef<OpenMPDirectiveKind> AllowedNameModifiers) {
bool ErrorFound = false;
unsigned NamedModifiersNumber = 0;
llvm::IndexedMap<const OMPIfClause *, Kind2Unsigned> FoundNameModifiers;
FoundNameModifiers.resize(llvm::omp::Directive_enumSize + 1);
SmallVector<SourceLocation, 4> NameModifierLoc;
for (const OMPClause *C : Clauses) {
  if (const auto *IC = dyn_cast_or_null<OMPIfClause>(C)) {
    // At most one if clause without a directive-name-modifier can appear on
    // the directive.
    OpenMPDirectiveKind CurNM = IC->getNameModifier();
    if (FoundNameModifiers[CurNM]) {
      S.Diag(C->getBeginLoc(), diag::err_omp_more_one_clause)
          << getOpenMPDirectiveName(Kind) << getOpenMPClauseName(OMPC_if)
          << (CurNM != OMPD_unknown) << getOpenMPDirectiveName(CurNM);
      ErrorFound = true;
    } else if (CurNM != OMPD_unknown) {
      NameModifierLoc.push_back(IC->getNameModifierLoc());
      ++NamedModifiersNumber;
    }
    FoundNameModifiers[CurNM] = IC;
    if (CurNM == OMPD_unknown)
      continue;
    // Check if the specified name modifier is allowed for the current
    // directive.
    // At most one if clause with the particular directive-name-modifier can
    // appear on the directive.
    bool MatchFound = false;
    for (auto NM : AllowedNameModifiers) {
      if (CurNM == NM) {
        MatchFound = true;
        break;
      }
    }
    if (!MatchFound) {
      S.Diag(IC->getNameModifierLoc(),
             diag::err_omp_wrong_if_directive_name_modifier)
          << getOpenMPDirectiveName(CurNM) << getOpenMPDirectiveName(Kind);
      ErrorFound = true;
    }
  }
}
// If any if clause on the directive includes a directive-name-modifier then
// all if clauses on the directive must include a directive-name-modifier.
if (FoundNameModifiers[OMPD_unknown] && NamedModifiersNumber > 0) {
  if (NamedModifiersNumber == AllowedNameModifiers.size()) {
    S.Diag(FoundNameModifiers[OMPD_unknown]->getBeginLoc(),
           diag::err_omp_no_more_if_clause);
  } else {
    std::string Values;
    std::string Sep(", ");
    unsigned AllowedCnt = 0;
    unsigned TotalAllowedNum =
        AllowedNameModifiers.size() - NamedModifiersNumber;
    for (unsigned Cnt = 0, End = AllowedNameModifiers.size(); Cnt < End;
         ++Cnt) {
      OpenMPDirectiveKind NM = AllowedNameModifiers[Cnt];
      if (!FoundNameModifiers[NM]) {
        Values += "'";
        Values += getOpenMPDirectiveName(NM);
        Values += "'";
        if (AllowedCnt + 2 == TotalAllowedNum)
          Values += " or ";
        else if (AllowedCnt + 1 != TotalAllowedNum)
          Values += Sep;
        ++AllowedCnt;
      }
    }
    S.Diag(FoundNameModifiers[OMPD_unknown]->getCondition()->getBeginLoc(),
           diag::err_omp_unnamed_if_clause)
        << (TotalAllowedNum > 1) << Values;
  }
  for (SourceLocation Loc : NameModifierLoc) {
    S.Diag(Loc, diag::note_omp_previous_named_if_clause);
  }
  ErrorFound = true;
}
return ErrorFound;
4983}

4985static std::pair<ValueDecl *, bool> getPrivateItem(Sema &S, Expr *&RefExpr,
                                                 SourceLocation &ELoc,
                                                 SourceRange &ERange,
                                                 bool AllowArraySection) {
if (RefExpr->isTypeDependent() || RefExpr->isValueDependent() ||
    RefExpr->containsUnexpandedParameterPack())
  return std::make_pair(nullptr, true);

// OpenMP [3.1, C/C++]
//  A list item is a variable name.
// OpenMP  [2.9.3.3, Restrictions, p.1]
//  A variable that is part of another variable (as an array or
//  structure element) cannot appear in a private clause.
RefExpr = RefExpr->IgnoreParens();
enum {
  NoArrayExpr = -1,
  ArraySubscript = 0,
  OMPArraySection = 1
} IsArrayExpr = NoArrayExpr;
if (AllowArraySection) {
  if (auto *ASE = dyn_cast_or_null<ArraySubscriptExpr>(RefExpr)) {
    Expr *Base = ASE->getBase()->IgnoreParenImpCasts();
    while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
      Base = TempASE->getBase()->IgnoreParenImpCasts();
    RefExpr = Base;
    IsArrayExpr = ArraySubscript;
  } else if (auto *OASE = dyn_cast_or_null<OMPArraySectionExpr>(RefExpr)) {
    Expr *Base = OASE->getBase()->IgnoreParenImpCasts();
    while (auto *TempOASE = dyn_cast<OMPArraySectionExpr>(Base))
      Base = TempOASE->getBase()->IgnoreParenImpCasts();
    while (auto *TempASE = dyn_cast<ArraySubscriptExpr>(Base))
      Base = TempASE->getBase()->IgnoreParenImpCasts();
    RefExpr = Base;
    IsArrayExpr = OMPArraySection;
  }
}
ELoc = RefExpr->getExprLoc();
ERange = RefExpr->getSourceRange();
RefExpr = RefExpr->IgnoreParenImpCasts();
auto *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);
auto *ME = dyn_cast_or_null<MemberExpr>(RefExpr);
if ((!DE || !isa<VarDecl>(DE->getDecl())) &&
    (S.getCurrentThisType().isNull() || !ME ||
     !isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()) ||
     !isa<FieldDecl>(ME->getMemberDecl()))) {
  if (IsArrayExpr != NoArrayExpr) {
    S.Diag(ELoc, diag::err_omp_expected_base_var_name) << IsArrayExpr
                                                       << ERange;
  } else {
    S.Diag(ELoc,
           AllowArraySection
               ? diag::err_omp_expected_var_name_member_expr_or_array_item
               : diag::err_omp_expected_var_name_member_expr)
        << (S.getCurrentThisType().isNull() ? 0 : 1) << ERange;
  }
  return std::make_pair(nullptr, false);
}
return std::make_pair(
    getCanonicalDecl(DE ? DE->getDecl() : ME->getMemberDecl()), false);
5044}

5046namespace {
5047/// Checks if the allocator is used in uses_allocators clause to be allowed in
5048/// target regions.
5049class AllocatorChecker final : public ConstStmtVisitor<AllocatorChecker, bool> {
DSAStackTy *S = nullptr;

5052public:
bool VisitDeclRefExpr(const DeclRefExpr *E) {
  return S->isUsesAllocatorsDecl(E->getDecl())
             .getValueOr(
                 DSAStackTy::UsesAllocatorsDeclKind::AllocatorTrait) ==
         DSAStackTy::UsesAllocatorsDeclKind::AllocatorTrait;
}
bool VisitStmt(const Stmt *S) {
  for (const Stmt *Child : S->children()) {
    if (Child && Visit(Child))
      return true;
  }
  return false;
}
explicit AllocatorChecker(DSAStackTy *S) : S(S) {}
5067};
5068} // namespace

5070static void checkAllocateClauses(Sema &S, DSAStackTy *Stack,
                               ArrayRef<OMPClause *> Clauses) {
assert(!S.CurContext->isDependentContext() &&((void)0)
       "Expected non-dependent context.")((void)0);
auto AllocateRange =
    llvm::make_filter_range(Clauses, OMPAllocateClause::classof);
llvm::DenseMap<CanonicalDeclPtr<Decl>, CanonicalDeclPtr<VarDecl>>
    DeclToCopy;
auto PrivateRange = llvm::make_filter_range(Clauses, [](const OMPClause *C) {
  return isOpenMPPrivate(C->getClauseKind());
});
for (OMPClause *Cl : PrivateRange) {
  MutableArrayRef<Expr *>::iterator I, It, Et;
  if (Cl->getClauseKind() == OMPC_private) {
    auto *PC = cast<OMPPrivateClause>(Cl);
    I = PC->private_copies().begin();
    It = PC->varlist_begin();
    Et = PC->varlist_end();
  } else if (Cl->getClauseKind() == OMPC_firstprivate) {
    auto *PC = cast<OMPFirstprivateClause>(Cl);
    I = PC->private_copies().begin();
    It = PC->varlist_begin();
    Et = PC->varlist_end();
  } else if (Cl->getClauseKind() == OMPC_lastprivate) {
    auto *PC = cast<OMPLastprivateClause>(Cl);
    I = PC->private_copies().begin();
    It = PC->varlist_begin();
    Et = PC->varlist_end();
  } else if (Cl->getClauseKind() == OMPC_linear) {
    auto *PC = cast<OMPLinearClause>(Cl);
    I = PC->privates().begin();
    It = PC->varlist_begin();
    Et = PC->varlist_end();
  } else if (Cl->getClauseKind() == OMPC_reduction) {
    auto *PC = cast<OMPReductionClause>(Cl);
    I = PC->privates().begin();
    It = PC->varlist_begin();
    Et = PC->varlist_end();
  } else if (Cl->getClauseKind() == OMPC_task_reduction) {
    auto *PC = cast<OMPTaskReductionClause>(Cl);
    I = PC->privates().begin();
    It = PC->varlist_begin();
    Et = PC->varlist_end();
  } else if (Cl->getClauseKind() == OMPC_in_reduction) {
    auto *PC = cast<OMPInReductionClause>(Cl);
    I = PC->privates().begin();
    It = PC->varlist_begin();
    Et = PC->varlist_end();
  } else {
    llvm_unreachable("Expected private clause.")__builtin_unreachable();
  }
  for (Expr *E : llvm::make_range(It, Et)) {
    if (!*I) {
      ++I;
      continue;
    }
    SourceLocation ELoc;
    SourceRange ERange;
    Expr *SimpleRefExpr = E;
    auto Res = getPrivateItem(S, SimpleRefExpr, ELoc, ERange,
                              /*AllowArraySection=*/true);
    DeclToCopy.try_emplace(Res.first,
                           cast<VarDecl>(cast<DeclRefExpr>(*I)->getDecl()));
    ++I;
  }
}
for (OMPClause *C : AllocateRange) {
  auto *AC = cast<OMPAllocateClause>(C);
  if (S.getLangOpts().OpenMP >= 50 &&
      !Stack->hasRequiresDeclWithClause<OMPDynamicAllocatorsClause>() &&
      isOpenMPTargetExecutionDirective(Stack->getCurrentDirective()) &&
      AC->getAllocator()) {
    Expr *Allocator = AC->getAllocator();
    // OpenMP, 2.12.5 target Construct
    // Memory allocators that do not appear in a uses_allocators clause cannot
    // appear as an allocator in an allocate clause or be used in the target
    // region unless a requires directive with the dynamic_allocators clause
    // is present in the same compilation unit.
    AllocatorChecker Checker(Stack);
    if (Checker.Visit(Allocator))
      S.Diag(Allocator->getExprLoc(),
             diag::err_omp_allocator_not_in_uses_allocators)
          << Allocator->getSourceRange();
  }
  OMPAllocateDeclAttr::AllocatorTypeTy AllocatorKind =
      getAllocatorKind(S, Stack, AC->getAllocator());
  // OpenMP, 2.11.4 allocate Clause, Restrictions.
  // For task, taskloop or target directives, allocation requests to memory
  // allocators with the trait access set to thread result in unspecified
  // behavior.
  if (AllocatorKind == OMPAllocateDeclAttr::OMPThreadMemAlloc &&
      (isOpenMPTaskingDirective(Stack->getCurrentDirective()) ||
       isOpenMPTargetExecutionDirective(Stack->getCurrentDirective()))) {
    S.Diag(AC->getAllocator()->getExprLoc(),
           diag::warn_omp_allocate_thread_on_task_target_directive)
        << getOpenMPDirectiveName(Stack->getCurrentDirective());
  }
  for (Expr *E : AC->varlists()) {
    SourceLocation ELoc;
    SourceRange ERange;
    Expr *SimpleRefExpr = E;
    auto Res = getPrivateItem(S, SimpleRefExpr, ELoc, ERange);
    ValueDecl *VD = Res.first;
    DSAStackTy::DSAVarData Data = Stack->getTopDSA(VD, /*FromParent=*/false);
    if (!isOpenMPPrivate(Data.CKind)) {
      S.Diag(E->getExprLoc(),
             diag::err_omp_expected_private_copy_for_allocate);
      continue;
    }
    VarDecl *PrivateVD = DeclToCopy[VD];
    if (checkPreviousOMPAllocateAttribute(S, Stack, E, PrivateVD,
                                          AllocatorKind, AC->getAllocator()))
      continue;
    applyOMPAllocateAttribute(S, PrivateVD, AllocatorKind, AC->getAllocator(),
                              E->getSourceRange());
  }
}
5187}

5189namespace {
5190/// Rewrite statements and expressions for Sema \p Actions CurContext.
5191///
5192/// Used to wrap already parsed statements/expressions into a new CapturedStmt
5193/// context. DeclRefExpr used inside the new context are changed to refer to the
5194/// captured variable instead.
5195class CaptureVars : public TreeTransform<CaptureVars> {
using BaseTransform = TreeTransform<CaptureVars>;

5198public:
CaptureVars(Sema &Actions) : BaseTransform(Actions) {}

bool AlwaysRebuild() { return true; }
5202};
5203} // namespace

5205static VarDecl *precomputeExpr(Sema &Actions,
                             SmallVectorImpl<Stmt *> &BodyStmts, Expr *E,
                             StringRef Name) {
Expr *NewE = AssertSuccess(CaptureVars(Actions).TransformExpr(E));
VarDecl *NewVar = buildVarDecl(Actions, {}, NewE->getType(), Name, nullptr,
                               dyn_cast<DeclRefExpr>(E->IgnoreImplicit()));
auto *NewDeclStmt = cast<DeclStmt>(AssertSuccess(
    Actions.ActOnDeclStmt(Actions.ConvertDeclToDeclGroup(NewVar), {}, {})));
Actions.AddInitializerToDecl(NewDeclStmt->getSingleDecl(), NewE, false);
BodyStmts.push_back(NewDeclStmt);
return NewVar;
5216}

5218/// Create a closure that computes the number of iterations of a loop.
5219///
5220/// \param Actions   The Sema object.
5221/// \param LogicalTy Type for the logical iteration number.
5222/// \param Rel       Comparison operator of the loop condition.
5223/// \param StartExpr Value of the loop counter at the first iteration.
5224/// \param StopExpr  Expression the loop counter is compared against in the loop
5225/// condition. \param StepExpr      Amount of increment after each iteration.
5226///
5227/// \return Closure (CapturedStmt) of the distance calculation.
5228static CapturedStmt *buildDistanceFunc(Sema &Actions, QualType LogicalTy,
                                     BinaryOperator::Opcode Rel,
                                     Expr *StartExpr, Expr *StopExpr,
                                     Expr *StepExpr) {
ASTContext &Ctx = Actions.getASTContext();
TypeSourceInfo *LogicalTSI = Ctx.getTrivialTypeSourceInfo(LogicalTy);

// Captured regions currently don't support return values, we use an
// out-parameter instead. All inputs are implicit captures.
// TODO: Instead of capturing each DeclRefExpr occurring in
// StartExpr/StopExpr/Step, these could also be passed as a value capture.
QualType ResultTy = Ctx.getLValueReferenceType(LogicalTy);
Sema::CapturedParamNameType Params[] = {{"Distance", ResultTy},
                                        {StringRef(), QualType()}};
Actions.ActOnCapturedRegionStart({}, nullptr, CR_Default, Params);

Stmt *Body;
{
  Sema::CompoundScopeRAII CompoundScope(Actions);
  CapturedDecl *CS = cast<CapturedDecl>(Actions.CurContext);

  // Get the LValue expression for the result.
  ImplicitParamDecl *DistParam = CS->getParam(0);
  DeclRefExpr *DistRef = Actions.BuildDeclRefExpr(
      DistParam, LogicalTy, VK_LValue, {}, nullptr, nullptr, {}, nullptr);

  SmallVector<Stmt *, 4> BodyStmts;

  // Capture all referenced variable references.
  // TODO: Instead of computing NewStart/NewStop/NewStep inside the
  // CapturedStmt, we could compute them before and capture the result, to be
  // used jointly with the LoopVar function.
  VarDecl *NewStart = precomputeExpr(Actions, BodyStmts, StartExpr, ".start");
  VarDecl *NewStop = precomputeExpr(Actions, BodyStmts, StopExpr, ".stop");
  VarDecl *NewStep = precomputeExpr(Actions, BodyStmts, StepExpr, ".step");
  auto BuildVarRef = [&](VarDecl *VD) {
    return buildDeclRefExpr(Actions, VD, VD->getType(), {});
  };

  IntegerLiteral *Zero = IntegerLiteral::Create(
      Ctx, llvm::APInt(Ctx.getIntWidth(LogicalTy), 0), LogicalTy, {});
  Expr *Dist;
  if (Rel == BO_NE) {
    // When using a != comparison, the increment can be +1 or -1. This can be
    // dynamic at runtime, so we need to check for the direction.
    Expr *IsNegStep = AssertSuccess(
        Actions.BuildBinOp(nullptr, {}, BO_LT, BuildVarRef(NewStep), Zero));

    // Positive increment.
    Expr *ForwardRange = AssertSuccess(Actions.BuildBinOp(
        nullptr, {}, BO_Sub, BuildVarRef(NewStop), BuildVarRef(NewStart)));
    ForwardRange = AssertSuccess(
        Actions.BuildCStyleCastExpr({}, LogicalTSI, {}, ForwardRange));
    Expr *ForwardDist = AssertSuccess(Actions.BuildBinOp(
        nullptr, {}, BO_Div, ForwardRange, BuildVarRef(NewStep)));

    // Negative increment.
    Expr *BackwardRange = AssertSuccess(Actions.BuildBinOp(
        nullptr, {}, BO_Sub, BuildVarRef(NewStart), BuildVarRef(NewStop)));
    BackwardRange = AssertSuccess(
        Actions.BuildCStyleCastExpr({}, LogicalTSI, {}, BackwardRange));
    Expr *NegIncAmount = AssertSuccess(
        Actions.BuildUnaryOp(nullptr, {}, UO_Minus, BuildVarRef(NewStep)));
    Expr *BackwardDist = AssertSuccess(
        Actions.BuildBinOp(nullptr, {}, BO_Div, BackwardRange, NegIncAmount));

    // Use the appropriate case.
    Dist = AssertSuccess(Actions.ActOnConditionalOp(
        {}, {}, IsNegStep, BackwardDist, ForwardDist));
  } else {
    assert((Rel == BO_LT || Rel == BO_LE || Rel == BO_GE || Rel == BO_GT) &&((void)0)
           "Expected one of these relational operators")((void)0);

    // We can derive the direction from any other comparison operator. It is
    // non well-formed OpenMP if Step increments/decrements in the other
    // directions. Whether at least the first iteration passes the loop
    // condition.
    Expr *HasAnyIteration = AssertSuccess(Actions.BuildBinOp(
        nullptr, {}, Rel, BuildVarRef(NewStart), BuildVarRef(NewStop)));

    // Compute the range between first and last counter value.
    Expr *Range;
    if (Rel == BO_GE || Rel == BO_GT)
      Range = AssertSuccess(Actions.BuildBinOp(
          nullptr, {}, BO_Sub, BuildVarRef(NewStart), BuildVarRef(NewStop)));
    else
      Range = AssertSuccess(Actions.BuildBinOp(
          nullptr, {}, BO_Sub, BuildVarRef(NewStop), BuildVarRef(NewStart)));

    // Ensure unsigned range space.
    Range =
        AssertSuccess(Actions.BuildCStyleCastExpr({}, LogicalTSI, {}, Range));

    if (Rel == BO_LE || Rel == BO_GE) {
      // Add one to the range if the relational operator is inclusive.
      Range =
          AssertSuccess(Actions.BuildUnaryOp(nullptr, {}, UO_PreInc, Range));
    }

    // Divide by the absolute step amount.
    Expr *Divisor = BuildVarRef(NewStep);
    if (Rel == BO_GE || Rel == BO_GT)
      Divisor =
          AssertSuccess(Actions.BuildUnaryOp(nullptr, {}, UO_Minus, Divisor));
    Dist = AssertSuccess(
        Actions.BuildBinOp(nullptr, {}, BO_Div, Range, Divisor));

    // If there is not at least one iteration, the range contains garbage. Fix
    // to zero in this case.
    Dist = AssertSuccess(
        Actions.ActOnConditionalOp({}, {}, HasAnyIteration, Dist, Zero));
  }

  // Assign the result to the out-parameter.
  Stmt *ResultAssign = AssertSuccess(Actions.BuildBinOp(
      Actions.getCurScope(), {}, BO_Assign, DistRef, Dist));
  BodyStmts.push_back(ResultAssign);

  Body = AssertSuccess(Actions.ActOnCompoundStmt({}, {}, BodyStmts, false));
}

return cast<CapturedStmt>(
    AssertSuccess(Actions.ActOnCapturedRegionEnd(Body)));
5351}

5353/// Create a closure that computes the loop variable from the logical iteration
5354/// number.
5355///
5356/// \param Actions   The Sema object.
5357/// \param LoopVarTy Type for the loop variable used for result value.
5358/// \param LogicalTy Type for the logical iteration number.
5359/// \param StartExpr Value of the loop counter at the first iteration.
5360/// \param Step      Amount of increment after each iteration.
5361/// \param Deref     Whether the loop variable is a dereference of the loop
5362/// counter variable.
5363///
5364/// \return Closure (CapturedStmt) of the loop value calculation.
5365static CapturedStmt *buildLoopVarFunc(Sema &Actions, QualType LoopVarTy,
                                    QualType LogicalTy,
                                    DeclRefExpr *StartExpr, Expr *Step,
                                    bool Deref) {
ASTContext &Ctx = Actions.getASTContext();

// Pass the result as an out-parameter. Passing as return value would require
// the OpenMPIRBuilder to know additional C/C++ semantics, such as how to
// invoke a copy constructor.
QualType TargetParamTy = Ctx.getLValueReferenceType(LoopVarTy);
Sema::CapturedParamNameType Params[] = {{"LoopVar", TargetParamTy},
                                        {"Logical", LogicalTy},
                                        {StringRef(), QualType()}};
Actions.ActOnCapturedRegionStart({}, nullptr, CR_Default, Params);

// Capture the initial iterator which represents the LoopVar value at the
// zero's logical iteration. Since the original ForStmt/CXXForRangeStmt update
// it in every iteration, capture it by value before it is modified.
VarDecl *StartVar = cast<VarDecl>(StartExpr->getDecl());
bool Invalid = Actions.tryCaptureVariable(StartVar, {},
                                          Sema::TryCapture_ExplicitByVal, {});
(void)Invalid;
assert(!Invalid && "Expecting capture-by-value to work.")((void)0);

Expr *Body;
{
  Sema::CompoundScopeRAII CompoundScope(Actions);
  auto *CS = cast<CapturedDecl>(Actions.CurContext);

  ImplicitParamDecl *TargetParam = CS->getParam(0);
  DeclRefExpr *TargetRef = Actions.BuildDeclRefExpr(
      TargetParam, LoopVarTy, VK_LValue, {}, nullptr, nullptr, {}, nullptr);
  ImplicitParamDecl *IndvarParam = CS->getParam(1);
  DeclRefExpr *LogicalRef = Actions.BuildDeclRefExpr(
      IndvarParam, LogicalTy, VK_LValue, {}, nullptr, nullptr, {}, nullptr);

  // Capture the Start expression.
  CaptureVars Recap(Actions);
  Expr *NewStart = AssertSuccess(Recap.TransformExpr(StartExpr));
  Expr *NewStep = AssertSuccess(Recap.TransformExpr(Step));

  Expr *Skip = AssertSuccess(
      Actions.BuildBinOp(nullptr, {}, BO_Mul, NewStep, LogicalRef));
  // TODO: Explicitly cast to the iterator's difference_type instead of
  // relying on implicit conversion.
  Expr *Advanced =
      AssertSuccess(Actions.BuildBinOp(nullptr, {}, BO_Add, NewStart, Skip));

  if (Deref) {
    // For range-based for-loops convert the loop counter value to a concrete
    // loop variable value by dereferencing the iterator.
    Advanced =
        AssertSuccess(Actions.BuildUnaryOp(nullptr, {}, UO_Deref, Advanced));
  }

  // Assign the result to the output parameter.
  Body = AssertSuccess(Actions.BuildBinOp(Actions.getCurScope(), {},
                                          BO_Assign, TargetRef, Advanced));
}
return cast<CapturedStmt>(
    AssertSuccess(Actions.ActOnCapturedRegionEnd(Body)));
5426}

5428StmtResult Sema::ActOnOpenMPCanonicalLoop(Stmt *AStmt) {
ASTContext &Ctx = getASTContext();

// Extract the common elements of ForStmt and CXXForRangeStmt:
// Loop variable, repeat condition, increment
Expr *Cond, *Inc;
VarDecl *LIVDecl, *LUVDecl;
if (auto *For = dyn_cast<ForStmt>(AStmt)) {
  Stmt *Init = For->getInit();
  if (auto *LCVarDeclStmt = dyn_cast<DeclStmt>(Init)) {
    // For statement declares loop variable.
    LIVDecl = cast<VarDecl>(LCVarDeclStmt->getSingleDecl());
  } else if (auto *LCAssign = dyn_cast<BinaryOperator>(Init)) {
    // For statement reuses variable.
    assert(LCAssign->getOpcode() == BO_Assign &&((void)0)
           "init part must be a loop variable assignment")((void)0);
    auto *CounterRef = cast<DeclRefExpr>(LCAssign->getLHS());
    LIVDecl = cast<VarDecl>(CounterRef->getDecl());
  } else
    llvm_unreachable("Cannot determine loop variable")__builtin_unreachable();
  LUVDecl = LIVDecl;

  Cond = For->getCond();
  Inc = For->getInc();
} else if (auto *RangeFor = dyn_cast<CXXForRangeStmt>(AStmt)) {
  DeclStmt *BeginStmt = RangeFor->getBeginStmt();
  LIVDecl = cast<VarDecl>(BeginStmt->getSingleDecl());
  LUVDecl = RangeFor->getLoopVariable();

  Cond = RangeFor->getCond();
  Inc = RangeFor->getInc();
} else
  llvm_unreachable("unhandled kind of loop")__builtin_unreachable();

QualType CounterTy = LIVDecl->getType();
QualType LVTy = LUVDecl->getType();

// Analyze the loop condition.
Expr *LHS, *RHS;
BinaryOperator::Opcode CondRel;
Cond = Cond->IgnoreImplicit();
if (auto *CondBinExpr = dyn_cast<BinaryOperator>(Cond)) {
  LHS = CondBinExpr->getLHS();
  RHS = CondBinExpr->getRHS();
  CondRel = CondBinExpr->getOpcode();
} else if (auto *CondCXXOp = dyn_cast<CXXOperatorCallExpr>(Cond)) {
  assert(CondCXXOp->getNumArgs() == 2 && "Comparison should have 2 operands")((void)0);
  LHS = CondCXXOp->getArg(0);
  RHS = CondCXXOp->getArg(1);
  switch (CondCXXOp->getOperator()) {
  case OO_ExclaimEqual:
    CondRel = BO_NE;
    break;
  case OO_Less:
    CondRel = BO_LT;
    break;
  case OO_LessEqual:
    CondRel = BO_LE;
    break;
  case OO_Greater:
    CondRel = BO_GT;
    break;
  case OO_GreaterEqual:
    CondRel = BO_GE;
    break;
  default:
    llvm_unreachable("unexpected iterator operator")__builtin_unreachable();
  }
} else
  llvm_unreachable("unexpected loop condition")__builtin_unreachable();

// Normalize such that the loop counter is on the LHS.
if (!isa<DeclRefExpr>(LHS->IgnoreImplicit()) ||
    cast<DeclRefExpr>(LHS->IgnoreImplicit())->getDecl() != LIVDecl) {
  std::swap(LHS, RHS);
  CondRel = BinaryOperator::reverseComparisonOp(CondRel);
}
auto *CounterRef = cast<DeclRefExpr>(LHS->IgnoreImplicit());

// Decide the bit width for the logical iteration counter. By default use the
// unsigned ptrdiff_t integer size (for iterators and pointers).
// TODO: For iterators, use iterator::difference_type,
// std::iterator_traits<>::difference_type or decltype(it - end).
QualType LogicalTy = Ctx.getUnsignedPointerDiffType();
if (CounterTy->isIntegerType()) {
  unsigned BitWidth = Ctx.getIntWidth(CounterTy);
  LogicalTy = Ctx.getIntTypeForBitwidth(BitWidth, false);
}

// Analyze the loop increment.
Expr *Step;
if (auto *IncUn = dyn_cast<UnaryOperator>(Inc)) {
  int Direction;
  switch (IncUn->getOpcode()) {
  case UO_PreInc:
  case UO_PostInc:
    Direction = 1;
    break;
  case UO_PreDec:
  case UO_PostDec:
    Direction = -1;
    break;
  default:
    llvm_unreachable("unhandled unary increment operator")__builtin_unreachable();
  }
  Step = IntegerLiteral::Create(
      Ctx, llvm::APInt(Ctx.getIntWidth(LogicalTy), Direction), LogicalTy, {});
} else if (auto *IncBin = dyn_cast<BinaryOperator>(Inc)) {
  if (IncBin->getOpcode() == BO_AddAssign) {
    Step = IncBin->getRHS();
  } else if (IncBin->getOpcode() == BO_SubAssign) {
    Step =
        AssertSuccess(BuildUnaryOp(nullptr, {}, UO_Minus, IncBin->getRHS()));
  } else
    llvm_unreachable("unhandled binary increment operator")__builtin_unreachable();
} else if (auto *CondCXXOp = dyn_cast<CXXOperatorCallExpr>(Inc)) {
  switch (CondCXXOp->getOperator()) {
  case OO_PlusPlus:
    Step = IntegerLiteral::Create(
        Ctx, llvm::APInt(Ctx.getIntWidth(LogicalTy), 1), LogicalTy, {});
    break;
  case OO_MinusMinus:
    Step = IntegerLiteral::Create(
        Ctx, llvm::APInt(Ctx.getIntWidth(LogicalTy), -1), LogicalTy, {});
    break;
  case OO_PlusEqual:
    Step = CondCXXOp->getArg(1);
    break;
  case OO_MinusEqual:
    Step = AssertSuccess(
        BuildUnaryOp(nullptr, {}, UO_Minus, CondCXXOp->getArg(1)));
    break;
  default:
    llvm_unreachable("unhandled overloaded increment operator")__builtin_unreachable();
  }
} else
  llvm_unreachable("unknown increment expression")__builtin_unreachable();

CapturedStmt *DistanceFunc =
    buildDistanceFunc(*this, LogicalTy, CondRel, LHS, RHS, Step);
CapturedStmt *LoopVarFunc = buildLoopVarFunc(
    *this, LVTy, LogicalTy, CounterRef, Step, isa<CXXForRangeStmt>(AStmt));
DeclRefExpr *LVRef = BuildDeclRefExpr(LUVDecl, LUVDecl->getType(), VK_LValue,
                                      {}, nullptr, nullptr, {}, nullptr);
return OMPCanonicalLoop::create(getASTContext(), AStmt, DistanceFunc,
                                LoopVarFunc, LVRef);
5574}

5576static ExprResult buildUserDefinedMapperRef(Sema &SemaRef, Scope *S,
                                          CXXScopeSpec &MapperIdScopeSpec,
                                          const DeclarationNameInfo &MapperId,
                                          QualType Type,
                                          Expr *UnresolvedMapper);

5582/// Perform DFS through the structure/class data members trying to find
5583/// member(s) with user-defined 'default' mapper and generate implicit map
5584/// clauses for such members with the found 'default' mapper.
5585static void
5586processImplicitMapsWithDefaultMappers(Sema &S, DSAStackTy *Stack,
                                    SmallVectorImpl<OMPClause *> &Clauses) {
// Check for the deault mapper for data members.
if (S.getLangOpts().OpenMP < 50)
  return;
SmallVector<OMPClause *, 4> ImplicitMaps;
for (int Cnt = 0, EndCnt = Clauses.size(); Cnt < EndCnt; ++Cnt) {
  auto *C = dyn_cast<OMPMapClause>(Clauses[Cnt]);
  if (!C)
    continue;
  SmallVector<Expr *, 4> SubExprs;
  auto *MI = C->mapperlist_begin();
  for (auto I = C->varlist_begin(), End = C->varlist_end(); I != End;
       ++I, ++MI) {
    // Expression is mapped using mapper - skip it.
    if (*MI)
      continue;
    Expr *E = *I;
    // Expression is dependent - skip it, build the mapper when it gets
    // instantiated.
    if (E->isTypeDependent() || E->isValueDependent() ||
        E->containsUnexpandedParameterPack())
      continue;
    // Array section - need to check for the mapping of the array section
    // element.
    QualType CanonType = E->getType().getCanonicalType();
    if (CanonType->isSpecificBuiltinType(BuiltinType::OMPArraySection)) {
      const auto *OASE = cast<OMPArraySectionExpr>(E->IgnoreParenImpCasts());
      QualType BaseType =
          OMPArraySectionExpr::getBaseOriginalType(OASE->getBase());
      QualType ElemType;
      if (const auto *ATy = BaseType->getAsArrayTypeUnsafe())
        ElemType = ATy->getElementType();
      else
        ElemType = BaseType->getPointeeType();
      CanonType = ElemType;
    }

    // DFS over data members in structures/classes.
    SmallVector<std::pair<QualType, FieldDecl *>, 4> Types(
        1, {CanonType, nullptr});
    llvm::DenseMap<const Type *, Expr *> Visited;
    SmallVector<std::pair<FieldDecl *, unsigned>, 4> ParentChain(
        1, {nullptr, 1});
    while (!Types.empty()) {
      QualType BaseType;
      FieldDecl *CurFD;
      std::tie(BaseType, CurFD) = Types.pop_back_val();
      while (ParentChain.back().second == 0)
        ParentChain.pop_back();
      --ParentChain.back().second;
      if (BaseType.isNull())
        continue;
      // Only structs/classes are allowed to have mappers.
      const RecordDecl *RD = BaseType.getCanonicalType()->getAsRecordDecl();
      if (!RD)
        continue;
      auto It = Visited.find(BaseType.getTypePtr());
      if (It == Visited.end()) {
        // Try to find the associated user-defined mapper.
        CXXScopeSpec MapperIdScopeSpec;
        DeclarationNameInfo DefaultMapperId;
        DefaultMapperId.setName(S.Context.DeclarationNames.getIdentifier(
            &S.Context.Idents.get("default")));
        DefaultMapperId.setLoc(E->getExprLoc());
        ExprResult ER = buildUserDefinedMapperRef(
            S, Stack->getCurScope(), MapperIdScopeSpec, DefaultMapperId,
            BaseType, /*UnresolvedMapper=*/nullptr);
        if (ER.isInvalid())
          continue;
        It = Visited.try_emplace(BaseType.getTypePtr(), ER.get()).first;
      }
      // Found default mapper.
      if (It->second) {
        auto *OE = new (S.Context) OpaqueValueExpr(E->getExprLoc(), CanonType,
                                                   VK_LValue, OK_Ordinary, E);
        OE->setIsUnique(/*V=*/true);
        Expr *BaseExpr = OE;
        for (const auto &P : ParentChain) {
          if (P.first) {
            BaseExpr = S.BuildMemberExpr(
                BaseExpr, /*IsArrow=*/false, E->getExprLoc(),
                NestedNameSpecifierLoc(), SourceLocation(), P.first,
                DeclAccessPair::make(P.first, P.first->getAccess()),
                /*HadMultipleCandidates=*/false, DeclarationNameInfo(),
                P.first->getType(), VK_LValue, OK_Ordinary);
            BaseExpr = S.DefaultLvalueConversion(BaseExpr).get();
          }
        }
        if (CurFD)
          BaseExpr = S.BuildMemberExpr(
              BaseExpr, /*IsArrow=*/false, E->getExprLoc(),
              NestedNameSpecifierLoc(), SourceLocation(), CurFD,
              DeclAccessPair::make(CurFD, CurFD->getAccess()),
              /*HadMultipleCandidates=*/false, DeclarationNameInfo(),
              CurFD->getType(), VK_LValue, OK_Ordinary);
        SubExprs.push_back(BaseExpr);
        continue;
      }
      // Check for the "default" mapper for data memebers.
      bool FirstIter = true;
      for (FieldDecl *FD : RD->fields()) {
        if (!FD)
          continue;
        QualType FieldTy = FD->getType();
        if (FieldTy.isNull() ||
            !(FieldTy->isStructureOrClassType() || FieldTy->isUnionType()))
          continue;
        if (FirstIter) {
          FirstIter = false;
          ParentChain.emplace_back(CurFD, 1);
        } else {
          ++ParentChain.back().second;
        }
        Types.emplace_back(FieldTy, FD);
      }
    }
  }
  if (SubExprs.empty())
    continue;
  CXXScopeSpec MapperIdScopeSpec;
  DeclarationNameInfo MapperId;
  if (OMPClause *NewClause = S.ActOnOpenMPMapClause(
          C->getMapTypeModifiers(), C->getMapTypeModifiersLoc(),
          MapperIdScopeSpec, MapperId, C->getMapType(),
          /*IsMapTypeImplicit=*/true, SourceLocation(), SourceLocation(),
          SubExprs, OMPVarListLocTy()))
    Clauses.push_back(NewClause);
}
5715}

5717StmtResult Sema::ActOnOpenMPExecutableDirective(
  OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
  OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
  Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
StmtResult Res = StmtError();
// First check CancelRegion which is then used in checkNestingOfRegions.
if (checkCancelRegion(*this, Kind, CancelRegion, StartLoc) ||
    checkNestingOfRegions(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), Kind, DirName, CancelRegion,
                          StartLoc))
  return StmtError();

llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit;
VarsWithInheritedDSAType VarsWithInheritedDSA;
bool ErrorFound = false;
ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
if (AStmt && !CurContext->isDependentContext() && Kind != OMPD_atomic &&
    Kind != OMPD_critical && Kind != OMPD_section && Kind != OMPD_master &&
    Kind != OMPD_masked && !isOpenMPLoopTransformationDirective(Kind)) {
  assert(isa<CapturedStmt>(AStmt) && "Captured statement expected")((void)0);

  // Check default data sharing attributes for referenced variables.
  DSAAttrChecker DSAChecker(DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
), *this, cast<CapturedStmt>(AStmt));
  int ThisCaptureLevel = getOpenMPCaptureLevels(Kind);
  Stmt *S = AStmt;
  while (--ThisCaptureLevel >= 0)
    S = cast<CapturedStmt>(S)->getCapturedStmt();
  DSAChecker.Visit(S);
  if (!isOpenMPTargetDataManagementDirective(Kind) &&
      !isOpenMPTaskingDirective(Kind)) {
    // Visit subcaptures to generate implicit clauses for captured vars.
    auto *CS = cast<CapturedStmt>(AStmt);
    SmallVector<OpenMPDirectiveKind, 4> CaptureRegions;
    getOpenMPCaptureRegions(CaptureRegions, Kind);
    // Ignore outer tasking regions for target directives.
    if (CaptureRegions.size() > 1 && CaptureRegions.front() == OMPD_task)
      CS = cast<CapturedStmt>(CS->getCapturedStmt());
    DSAChecker.visitSubCaptures(CS);
  }
  if (DSAChecker.isErrorFound())
    return StmtError();
  // Generate list of implicitly defined firstprivate variables.
  VarsWithInheritedDSA = DSAChecker.getVarsWithInheritedDSA();

  SmallVector<Expr *, 4> ImplicitFirstprivates(
      DSAChecker.getImplicitFirstprivate().begin(),
      DSAChecker.getImplicitFirstprivate().end());
  const unsigned DefaultmapKindNum = OMPC_DEFAULTMAP_pointer + 1;
  SmallVector<Expr *, 4> ImplicitMaps[DefaultmapKindNum][OMPC_MAP_delete];
  SmallVector<OpenMPMapModifierKind, NumberOfOMPMapClauseModifiers>
      ImplicitMapModifiers[DefaultmapKindNum];
  SmallVector<SourceLocation, NumberOfOMPMapClauseModifiers>
      ImplicitMapModifiersLoc[DefaultmapKindNum];
  // Get the original location of present modifier from Defaultmap clause.
  SourceLocation PresentModifierLocs[DefaultmapKindNum];
  for (OMPClause *C : Clauses) {
    if (auto *DMC = dyn_cast<OMPDefaultmapClause>(C))
      if (DMC->getDefaultmapModifier() == OMPC_DEFAULTMAP_MODIFIER_present)
        PresentModifierLocs[DMC->getDefaultmapKind()] =
            DMC->getDefaultmapModifierLoc();
  }
  for (unsigned VC = 0; VC < DefaultmapKindNum; ++VC) {
    auto Kind = static_cast<OpenMPDefaultmapClauseKind>(VC);
    for (unsigned I = 0; I < OMPC_MAP_delete; ++I) {
      ArrayRef<Expr *> ImplicitMap = DSAChecker.getImplicitMap(
          Kind, static_cast<OpenMPMapClauseKind>(I));
      ImplicitMaps[VC][I].append(ImplicitMap.begin(), ImplicitMap.end());
    }
    ArrayRef<OpenMPMapModifierKind> ImplicitModifier =
        DSAChecker.getImplicitMapModifier(Kind);
    ImplicitMapModifiers[VC].append(ImplicitModifier.begin(),
                                    ImplicitModifier.end());
    std::fill_n(std::back_inserter(ImplicitMapModifiersLoc[VC]),
                ImplicitModifier.size(), PresentModifierLocs[VC]);
  }
  // Mark taskgroup task_reduction descriptors as implicitly firstprivate.
  for (OMPClause *C : Clauses) {
    if (auto *IRC = dyn_cast<OMPInReductionClause>(C)) {
      for (Expr *E : IRC->taskgroup_descriptors())
        if (E)
          ImplicitFirstprivates.emplace_back(E);
    }
    // OpenMP 5.0, 2.10.1 task Construct
    // [detach clause]... The event-handle will be considered as if it was
    // specified on a firstprivate clause.
    if (auto *DC = dyn_cast<OMPDetachClause>(C))
      ImplicitFirstprivates.push_back(DC->getEventHandler());
  }
  if (!ImplicitFirstprivates.empty()) {
    if (OMPClause *Implicit = ActOnOpenMPFirstprivateClause(
            ImplicitFirstprivates, SourceLocation(), SourceLocation(),
            SourceLocation())) {
      ClausesWithImplicit.push_back(Implicit);
      ErrorFound = cast<OMPFirstprivateClause>(Implicit)->varlist_size() !=
                   ImplicitFirstprivates.size();
    } else {
      ErrorFound = true;
    }
  }
  for (unsigned I = 0, E = DefaultmapKindNum; I < E; ++I) {
    int ClauseKindCnt = -1;
    for (ArrayRef<Expr *> ImplicitMap : ImplicitMaps[I]) {
      ++ClauseKindCnt;
      if (ImplicitMap.empty())
        continue;
      CXXScopeSpec MapperIdScopeSpec;
      DeclarationNameInfo MapperId;
      auto Kind = static_cast<OpenMPMapClauseKind>(ClauseKindCnt);
      if (OMPClause *Implicit = ActOnOpenMPMapClause(
              ImplicitMapModifiers[I], ImplicitMapModifiersLoc[I],
              MapperIdScopeSpec, MapperId, Kind, /*IsMapTypeImplicit=*/true,
              SourceLocation(), SourceLocation(), ImplicitMap,
              OMPVarListLocTy())) {
        ClausesWithImplicit.emplace_back(Implicit);
        ErrorFound |= cast<OMPMapClause>(Implicit)->varlist_size() !=
                      ImplicitMap.size();
      } else {
        ErrorFound = true;
      }
    }
  }
  // Build expressions for implicit maps of data members with 'default'
  // mappers.
  if (LangOpts.OpenMP >= 50)
    processImplicitMapsWithDefaultMappers(*this, DSAStackstatic_cast<DSAStackTy *>(VarDataSharingAttributesStack
),
                                          ClausesWithImplicit);
}

llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
switch (Kind) {
case OMPD_parallel:
  Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
                                     EndLoc);
  AllowedNameModifiers.push_back(OMPD_parallel);
  break;
case OMPD_simd:
  Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
                                 VarsWithInheritedDSA);
  if (LangOpts.OpenMP >= 50)
    AllowedNameModifiers.push_back(OMPD_simd);
  break;
case OMPD_tile:
  Res =
      ActOnOpenMPTileDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
  break;
case OMPD_unroll:
  Res = ActOnOpenMPUnrollDirective(ClausesWithImplicit, AStmt, StartLoc,
                                   EndLoc);
  break;
case OMPD_for:
  Res = ActOnOpenMPForDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc,
                                VarsWithInheritedDSA);
  break;
case OMPD_for_simd:
  Res = ActOnOpenMPForSimdDirective(ClausesWithImplicit, AStmt, StartLoc,
                                    EndLoc, VarsWithInheritedDSA);
  if (LangOpts.OpenMP >= 50)
    AllowedNameModifiers.push_back(OMPD_simd);
  break;
case OMPD_sections:
  Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc,
                                     EndLoc);
  break;
case OMPD_section:
  assert(ClausesWithImplicit.empty() &&((void)0)
         "No clauses are allowed for 'omp section' directive")((void)0);
  Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc);
  break;
case OMPD_single:
  Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc,
                                   EndLoc);
  break;
case OMPD_master:
  assert(ClausesWithImplicit.empty() &&((void)0)
         "No clauses are allowed for 'omp master' directive")((void)0);
  Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc);
  break;
case OMPD_masked:
  Res = ActOnOpenMPMaskedDirective(ClausesWithImplicit, AStmt, StartLoc,
                                   EndLoc);
  break;