OpenMPClause.cpp | Explore in Territory

//===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the subclesses of Stmt class declared in OpenMPClause.h
//
//===----------------------------------------------------------------------===//

#include "clang/AST/OpenMPClause.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclOpenMP.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include <algorithm>
#include <cassert>
#include <optional>

usingnamespaceclang;
usingnamespacellvm;
usingnamespaceomp;

OMPClause::child_range OMPClause::children() { … }

OMPClause::child_range OMPClause::used_children() { … }

OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) { … }

const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) { … }

OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) { … }

const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) { … }

/// Gets the address of the original, non-captured, expression used in the
/// clause as the preinitializer.
static Stmt **getAddrOfExprAsWritten(Stmt *S) { … }

OMPClause::child_range OMPIfClause::used_children() { … }

OMPClause::child_range OMPGrainsizeClause::used_children() { … }

OMPClause::child_range OMPNumTasksClause::used_children() { … }

OMPClause::child_range OMPFinalClause::used_children() { … }

OMPClause::child_range OMPPriorityClause::used_children() { … }

OMPClause::child_range OMPNovariantsClause::used_children() { … }

OMPClause::child_range OMPNocontextClause::used_children() { … }

OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
                                           unsigned NumLoops,
                                           SourceLocation StartLoc,
                                           SourceLocation LParenLoc,
                                           SourceLocation EndLoc) { … }

OMPOrderedClause *OMPOrderedClause::CreateEmpty(const ASTContext &C,
                                                unsigned NumLoops) { … }

void OMPOrderedClause::setLoopNumIterations(unsigned NumLoop,
                                            Expr *NumIterations) { … }

ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const { … }

void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) { … }

Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) { … }

const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const { … }

OMPUpdateClause *OMPUpdateClause::Create(const ASTContext &C,
                                         SourceLocation StartLoc,
                                         SourceLocation EndLoc) { … }

OMPUpdateClause *
OMPUpdateClause::Create(const ASTContext &C, SourceLocation StartLoc,
                        SourceLocation LParenLoc, SourceLocation ArgumentLoc,
                        OpenMPDependClauseKind DK, SourceLocation EndLoc) { … }

OMPUpdateClause *OMPUpdateClause::CreateEmpty(const ASTContext &C,
                                              bool IsExtended) { … }

void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { … }

OMPPrivateClause *
OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
                         SourceLocation LParenLoc, SourceLocation EndLoc,
                         ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) { … }

OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
                                                unsigned N) { … }

void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { … }

void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) { … }

OMPFirstprivateClause *
OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
                              SourceLocation LParenLoc, SourceLocation EndLoc,
                              ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
                              ArrayRef<Expr *> InitVL, Stmt *PreInit) { … }

OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
                                                          unsigned N) { … }

void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) { … }

void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { … }

void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { … }

void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { … }

OMPLastprivateClause *OMPLastprivateClause::Create(
    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
    ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
    OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc,
    SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate) { … }

OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
                                                        unsigned N) { … }

OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
                                         SourceLocation StartLoc,
                                         SourceLocation LParenLoc,
                                         SourceLocation EndLoc,
                                         ArrayRef<Expr *> VL) { … }

OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) { … }

void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) { … }

void OMPLinearClause::setInits(ArrayRef<Expr *> IL) { … }

void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) { … }

void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) { … }

void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) { … }

OMPLinearClause *OMPLinearClause::Create(
    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
    OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
    SourceLocation ColonLoc, SourceLocation StepModifierLoc,
    SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> PL,
    ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit,
    Expr *PostUpdate) { … }

OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
                                              unsigned NumVars) { … }

OMPClause::child_range OMPLinearClause::used_children() { … }

OMPAlignedClause *
OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
                         SourceLocation LParenLoc, SourceLocation ColonLoc,
                         SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) { … }

OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
                                                unsigned NumVars) { … }

OMPAlignClause *OMPAlignClause::Create(const ASTContext &C, Expr *A,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc) { … }

void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { … }

void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { … }

void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { … }

OMPCopyinClause *OMPCopyinClause::Create(
    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
    ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) { … }

OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) { … }

void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { … }

void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { … }

void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { … }

OMPCopyprivateClause *OMPCopyprivateClause::Create(
    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
    ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) { … }

OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
                                                        unsigned N) { … }

void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) { … }

void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) { … }

void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) { … }

void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) { … }

void OMPReductionClause::setInscanCopyOps(ArrayRef<Expr *> Ops) { … }

void OMPReductionClause::setInscanCopyArrayTemps(
    ArrayRef<Expr *> CopyArrayTemps) { … }

void OMPReductionClause::setInscanCopyArrayElems(
    ArrayRef<Expr *> CopyArrayElems) { … }

OMPReductionClause *OMPReductionClause::Create(
    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation ModifierLoc, SourceLocation EndLoc, SourceLocation ColonLoc,
    OpenMPReductionClauseModifier Modifier, ArrayRef<Expr *> VL,
    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
    ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
    ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
    ArrayRef<Expr *> CopyOps, ArrayRef<Expr *> CopyArrayTemps,
    ArrayRef<Expr *> CopyArrayElems, Stmt *PreInit, Expr *PostUpdate) { … }

OMPReductionClause *
OMPReductionClause::CreateEmpty(const ASTContext &C, unsigned N,
                                OpenMPReductionClauseModifier Modifier) { … }

void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) { … }

void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) { … }

void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) { … }

void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) { … }

OMPTaskReductionClause *OMPTaskReductionClause::Create(
    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
    ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
    ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
    Expr *PostUpdate) { … }

OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C,
                                                            unsigned N) { … }

void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) { … }

void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) { … }

void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) { … }

void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) { … }

void OMPInReductionClause::setTaskgroupDescriptors(
    ArrayRef<Expr *> TaskgroupDescriptors) { … }

OMPInReductionClause *OMPInReductionClause::Create(
    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
    SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
    ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
    ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
    ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) { … }

OMPInReductionClause *OMPInReductionClause::CreateEmpty(const ASTContext &C,
                                                        unsigned N) { … }

OMPSizesClause *OMPSizesClause::Create(const ASTContext &C,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc,
                                       ArrayRef<Expr *> Sizes) { … }

OMPSizesClause *OMPSizesClause::CreateEmpty(const ASTContext &C,
                                            unsigned NumSizes) { … }

OMPPermutationClause *OMPPermutationClause::Create(const ASTContext &C,
                                                   SourceLocation StartLoc,
                                                   SourceLocation LParenLoc,
                                                   SourceLocation EndLoc,
                                                   ArrayRef<Expr *> Args) { … }

OMPPermutationClause *OMPPermutationClause::CreateEmpty(const ASTContext &C,
                                                        unsigned NumLoops) { … }

OMPFullClause *OMPFullClause::Create(const ASTContext &C,
                                     SourceLocation StartLoc,
                                     SourceLocation EndLoc) { … }

OMPFullClause *OMPFullClause::CreateEmpty(const ASTContext &C) { … }

OMPPartialClause *OMPPartialClause::Create(const ASTContext &C,
                                           SourceLocation StartLoc,
                                           SourceLocation LParenLoc,
                                           SourceLocation EndLoc,
                                           Expr *Factor) { … }

OMPPartialClause *OMPPartialClause::CreateEmpty(const ASTContext &C) { … }

OMPAllocateClause *
OMPAllocateClause::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, Expr *Allocator,
                          SourceLocation ColonLoc, SourceLocation EndLoc,
                          ArrayRef<Expr *> VL) { … }

OMPAllocateClause *OMPAllocateClause::CreateEmpty(const ASTContext &C,
                                                  unsigned N) { … }

OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
                                       SourceLocation StartLoc,
                                       SourceLocation LParenLoc,
                                       SourceLocation EndLoc,
                                       ArrayRef<Expr *> VL) { … }

OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) { … }

OMPDepobjClause *OMPDepobjClause::Create(const ASTContext &C,
                                         SourceLocation StartLoc,
                                         SourceLocation LParenLoc,
                                         SourceLocation RParenLoc,
                                         Expr *Depobj) { … }

OMPDepobjClause *OMPDepobjClause::CreateEmpty(const ASTContext &C) { … }

OMPDependClause *
OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
                        SourceLocation LParenLoc, SourceLocation EndLoc,
                        DependDataTy Data, Expr *DepModifier,
                        ArrayRef<Expr *> VL, unsigned NumLoops) { … }

OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
                                              unsigned NumLoops) { … }

void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) { … }

Expr *OMPDependClause::getLoopData(unsigned NumLoop) { … }

const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const { … }

void OMPDependClause::setModifier(Expr *DepModifier) { … }
Expr *OMPDependClause::getModifier() { … }

unsigned OMPClauseMappableExprCommon::getComponentsTotalNumber(
    MappableExprComponentListsRef ComponentLists) { … }

unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber(
    ArrayRef<const ValueDecl *> Declarations) { … }

OMPMapClause *OMPMapClause::Create(
    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
    ArrayRef<ValueDecl *> Declarations,
    MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
    Expr *IteratorModifier, ArrayRef<OpenMPMapModifierKind> MapModifiers,
    ArrayRef<SourceLocation> MapModifiersLoc,
    NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId,
    OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc) { … }

OMPMapClause *
OMPMapClause::CreateEmpty(const ASTContext &C,
                          const OMPMappableExprListSizeTy &Sizes) { … }

OMPToClause *OMPToClause::Create(
    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
    ArrayRef<ValueDecl *> Declarations,
    MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
    ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
    ArrayRef<SourceLocation> MotionModifiersLoc,
    NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) { … }

OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C,
                                      const OMPMappableExprListSizeTy &Sizes) { … }

OMPFromClause *OMPFromClause::Create(
    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
    ArrayRef<ValueDecl *> Declarations,
    MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
    ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
    ArrayRef<SourceLocation> MotionModifiersLoc,
    NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) { … }

OMPFromClause *
OMPFromClause::CreateEmpty(const ASTContext &C,
                           const OMPMappableExprListSizeTy &Sizes) { … }

void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) { … }

void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) { … }

OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
    ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
    ArrayRef<ValueDecl *> Declarations,
    MappableExprComponentListsRef ComponentLists) { … }

OMPUseDevicePtrClause *
OMPUseDevicePtrClause::CreateEmpty(const ASTContext &C,
                                   const OMPMappableExprListSizeTy &Sizes) { … }

OMPUseDeviceAddrClause *
OMPUseDeviceAddrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
                               ArrayRef<Expr *> Vars,
                               ArrayRef<ValueDecl *> Declarations,
                               MappableExprComponentListsRef ComponentLists) { … }

OMPUseDeviceAddrClause *
OMPUseDeviceAddrClause::CreateEmpty(const ASTContext &C,
                                    const OMPMappableExprListSizeTy &Sizes) { … }

OMPIsDevicePtrClause *
OMPIsDevicePtrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
                             ArrayRef<Expr *> Vars,
                             ArrayRef<ValueDecl *> Declarations,
                             MappableExprComponentListsRef ComponentLists) { … }

OMPIsDevicePtrClause *
OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C,
                                  const OMPMappableExprListSizeTy &Sizes) { … }

OMPHasDeviceAddrClause *
OMPHasDeviceAddrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
                               ArrayRef<Expr *> Vars,
                               ArrayRef<ValueDecl *> Declarations,
                               MappableExprComponentListsRef ComponentLists) { … }

OMPHasDeviceAddrClause *
OMPHasDeviceAddrClause::CreateEmpty(const ASTContext &C,
                                    const OMPMappableExprListSizeTy &Sizes) { … }

OMPNontemporalClause *OMPNontemporalClause::Create(const ASTContext &C,
                                                   SourceLocation StartLoc,
                                                   SourceLocation LParenLoc,
                                                   SourceLocation EndLoc,
                                                   ArrayRef<Expr *> VL) { … }

OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(const ASTContext &C,
                                                        unsigned N) { … }

void OMPNontemporalClause::setPrivateRefs(ArrayRef<Expr *> VL) { … }

OMPInclusiveClause *OMPInclusiveClause::Create(const ASTContext &C,
                                               SourceLocation StartLoc,
                                               SourceLocation LParenLoc,
                                               SourceLocation EndLoc,
                                               ArrayRef<Expr *> VL) { … }

OMPInclusiveClause *OMPInclusiveClause::CreateEmpty(const ASTContext &C,
                                                    unsigned N) { … }

OMPExclusiveClause *OMPExclusiveClause::Create(const ASTContext &C,
                                               SourceLocation StartLoc,
                                               SourceLocation LParenLoc,
                                               SourceLocation EndLoc,
                                               ArrayRef<Expr *> VL) { … }

OMPExclusiveClause *OMPExclusiveClause::CreateEmpty(const ASTContext &C,
                                                    unsigned N) { … }

void OMPUsesAllocatorsClause::setAllocatorsData(
    ArrayRef<OMPUsesAllocatorsClause::Data> Data) { … }

OMPUsesAllocatorsClause::Data
OMPUsesAllocatorsClause::getAllocatorData(unsigned I) const { … }

OMPUsesAllocatorsClause *
OMPUsesAllocatorsClause::Create(const ASTContext &C, SourceLocation StartLoc,
                                SourceLocation LParenLoc, SourceLocation EndLoc,
                                ArrayRef<OMPUsesAllocatorsClause::Data> Data) { … }

OMPUsesAllocatorsClause *
OMPUsesAllocatorsClause::CreateEmpty(const ASTContext &C, unsigned N) { … }

OMPAffinityClause *
OMPAffinityClause::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, SourceLocation ColonLoc,
                          SourceLocation EndLoc, Expr *Modifier,
                          ArrayRef<Expr *> Locators) { … }

OMPAffinityClause *OMPAffinityClause::CreateEmpty(const ASTContext &C,
                                                  unsigned N) { … }

OMPInitClause *OMPInitClause::Create(const ASTContext &C, Expr *InteropVar,
                                     OMPInteropInfo &InteropInfo,
                                     SourceLocation StartLoc,
                                     SourceLocation LParenLoc,
                                     SourceLocation VarLoc,
                                     SourceLocation EndLoc) { … }

OMPInitClause *OMPInitClause::CreateEmpty(const ASTContext &C, unsigned N) { … }

OMPBindClause *
OMPBindClause::Create(const ASTContext &C, OpenMPBindClauseKind K,
                      SourceLocation KLoc, SourceLocation StartLoc,
                      SourceLocation LParenLoc, SourceLocation EndLoc) { … }

OMPBindClause *OMPBindClause::CreateEmpty(const ASTContext &C) { … }

OMPDoacrossClause *
OMPDoacrossClause::Create(const ASTContext &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, SourceLocation EndLoc,
                          OpenMPDoacrossClauseModifier DepType,
                          SourceLocation DepLoc, SourceLocation ColonLoc,
                          ArrayRef<Expr *> VL, unsigned NumLoops) { … }

OMPDoacrossClause *OMPDoacrossClause::CreateEmpty(const ASTContext &C,
                                                  unsigned N,
                                                  unsigned NumLoops) { … }

void OMPDoacrossClause::setLoopData(unsigned NumLoop, Expr *Cnt) { … }

Expr *OMPDoacrossClause::getLoopData(unsigned NumLoop) { … }

const Expr *OMPDoacrossClause::getLoopData(unsigned NumLoop) const { … }

OMPAbsentClause *OMPAbsentClause::Create(const ASTContext &C,
                                         ArrayRef<OpenMPDirectiveKind> DKVec,
                                         SourceLocation Loc,
                                         SourceLocation LLoc,
                                         SourceLocation RLoc) { … }

OMPAbsentClause *OMPAbsentClause::CreateEmpty(const ASTContext &C, unsigned K) { … }

OMPContainsClause *OMPContainsClause::Create(
    const ASTContext &C, ArrayRef<OpenMPDirectiveKind> DKVec,
    SourceLocation Loc, SourceLocation LLoc, SourceLocation RLoc) { … }

OMPContainsClause *OMPContainsClause::CreateEmpty(const ASTContext &C,
                                                  unsigned K) { … }

OMPNumTeamsClause *OMPNumTeamsClause::Create(
    const ASTContext &C, OpenMPDirectiveKind CaptureRegion,
    SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc,
    ArrayRef<Expr *> VL, Stmt *PreInit) { … }

OMPNumTeamsClause *OMPNumTeamsClause::CreateEmpty(const ASTContext &C,
                                                  unsigned N) { … }

OMPThreadLimitClause *OMPThreadLimitClause::Create(
    const ASTContext &C, OpenMPDirectiveKind CaptureRegion,
    SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc,
    ArrayRef<Expr *> VL, Stmt *PreInit) { … }

OMPThreadLimitClause *OMPThreadLimitClause::CreateEmpty(const ASTContext &C,
                                                        unsigned N) { … }

//===----------------------------------------------------------------------===//
//  OpenMP clauses printing methods
//===----------------------------------------------------------------------===//

void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) { … }

void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) { … }

void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) { … }

void OMPClausePrinter::VisitOMPAlignClause(OMPAlignClause *Node) { … }

void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) { … }

void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) { … }

void OMPClausePrinter::VisitOMPSizesClause(OMPSizesClause *Node) { … }

void OMPClausePrinter::VisitOMPPermutationClause(OMPPermutationClause *Node) { … }

void OMPClausePrinter::VisitOMPFullClause(OMPFullClause *Node) { … }

void OMPClausePrinter::VisitOMPPartialClause(OMPPartialClause *Node) { … }

void OMPClausePrinter::VisitOMPAllocatorClause(OMPAllocatorClause *Node) { … }

void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) { … }

void OMPClausePrinter::VisitOMPDetachClause(OMPDetachClause *Node) { … }

void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) { … }

void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) { … }

void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) { … }

void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause(
    OMPUnifiedSharedMemoryClause *) { … }

void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) { … }

void OMPClausePrinter::VisitOMPDynamicAllocatorsClause(
    OMPDynamicAllocatorsClause *) { … }

void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause(
    OMPAtomicDefaultMemOrderClause *Node) { … }

void OMPClausePrinter::VisitOMPAtClause(OMPAtClause *Node) { … }

void OMPClausePrinter::VisitOMPSeverityClause(OMPSeverityClause *Node) { … }

void OMPClausePrinter::VisitOMPMessageClause(OMPMessageClause *Node) { … }

void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) { … }

void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) { … }

void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) { … }

void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) { … }

void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) { … }

void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) { … }

void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { … }

void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { … }

void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *Node) { … }

void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) { … }

void OMPClausePrinter::VisitOMPCompareClause(OMPCompareClause *) { … }

void OMPClausePrinter::VisitOMPFailClause(OMPFailClause *Node) { … }

void OMPClausePrinter::VisitOMPAbsentClause(OMPAbsentClause *Node) { … }

void OMPClausePrinter::VisitOMPHoldsClause(OMPHoldsClause *Node) { … }

void OMPClausePrinter::VisitOMPContainsClause(OMPContainsClause *Node) { … }

void OMPClausePrinter::VisitOMPNoOpenMPClause(OMPNoOpenMPClause *) { … }

void OMPClausePrinter::VisitOMPNoOpenMPRoutinesClause(
    OMPNoOpenMPRoutinesClause *) { … }

void OMPClausePrinter::VisitOMPNoParallelismClause(OMPNoParallelismClause *) { … }

void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) { … }

void OMPClausePrinter::VisitOMPAcqRelClause(OMPAcqRelClause *) { … }

void OMPClausePrinter::VisitOMPAcquireClause(OMPAcquireClause *) { … }

void OMPClausePrinter::VisitOMPReleaseClause(OMPReleaseClause *) { … }

void OMPClausePrinter::VisitOMPRelaxedClause(OMPRelaxedClause *) { … }

void OMPClausePrinter::VisitOMPWeakClause(OMPWeakClause *) { … }

void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) { … }

void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { … }

void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) { … }

void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) { … }

void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) { … }

void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) { … }

void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) { … }

void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) { … }

void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) { … }

void OMPClausePrinter::VisitOMPInitClause(OMPInitClause *Node) { … }

void OMPClausePrinter::VisitOMPUseClause(OMPUseClause *Node) { … }

void OMPClausePrinter::VisitOMPDestroyClause(OMPDestroyClause *Node) { … }

void OMPClausePrinter::VisitOMPNovariantsClause(OMPNovariantsClause *Node) { … }

void OMPClausePrinter::VisitOMPNocontextClause(OMPNocontextClause *Node) { … }

template<typename T>
void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) { … }

void OMPClausePrinter::VisitOMPAllocateClause(OMPAllocateClause *Node) { … }

void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) { … }

void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) { … }

void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) { … }

void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) { … }

void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) { … }

void OMPClausePrinter::VisitOMPTaskReductionClause(
    OMPTaskReductionClause *Node) { … }

void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) { … }

void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) { … }

void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) { … }

void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) { … }

void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) { … }

void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) { … }

void OMPClausePrinter::VisitOMPDepobjClause(OMPDepobjClause *Node) { … }

void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) { … }

template <typename T>
static void PrintMapper(raw_ostream &OS, T *Node,
                        const PrintingPolicy &Policy) { … }

template <typename T>
static void PrintIterator(raw_ostream &OS, T *Node,
                          const PrintingPolicy &Policy) { … }

void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) { … }

template <typename T> void OMPClausePrinter::VisitOMPMotionClause(T *Node) { … }

void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) { … }

void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) { … }

void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) { … }

void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) { … }

void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) { … }

void OMPClausePrinter::VisitOMPUseDeviceAddrClause(
    OMPUseDeviceAddrClause *Node) { … }

void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) { … }

void OMPClausePrinter::VisitOMPHasDeviceAddrClause(OMPHasDeviceAddrClause *Node) { … }

void OMPClausePrinter::VisitOMPNontemporalClause(OMPNontemporalClause *Node) { … }

void OMPClausePrinter::VisitOMPOrderClause(OMPOrderClause *Node) { … }

void OMPClausePrinter::VisitOMPInclusiveClause(OMPInclusiveClause *Node) { … }

void OMPClausePrinter::VisitOMPExclusiveClause(OMPExclusiveClause *Node) { … }

void OMPClausePrinter::VisitOMPUsesAllocatorsClause(
    OMPUsesAllocatorsClause *Node) { … }

void OMPClausePrinter::VisitOMPAffinityClause(OMPAffinityClause *Node) { … }

void OMPClausePrinter::VisitOMPFilterClause(OMPFilterClause *Node) { … }

void OMPClausePrinter::VisitOMPBindClause(OMPBindClause *Node) { … }

void OMPClausePrinter::VisitOMPXDynCGroupMemClause(
    OMPXDynCGroupMemClause *Node) { … }

void OMPClausePrinter::VisitOMPDoacrossClause(OMPDoacrossClause *Node) { … }

void OMPClausePrinter::VisitOMPXAttributeClause(OMPXAttributeClause *Node) { … }

void OMPClausePrinter::VisitOMPXBareClause(OMPXBareClause *Node) { … }

void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx,
                                         VariantMatchInfo &VMI) const { … }

void OMPTraitInfo::print(llvm::raw_ostream &OS,
                         const PrintingPolicy &Policy) const { … }

std::string OMPTraitInfo::getMangledName() const { … }

OMPTraitInfo::OMPTraitInfo(StringRef MangledName) { … }

llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
                                     const OMPTraitInfo &TI) { … }
llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
                                     const OMPTraitInfo *TI) { … }

TargetOMPContext::TargetOMPContext(
    ASTContext &ASTCtx, std::function<void(StringRef)> &&DiagUnknownTrait,
    const FunctionDecl *CurrentFunctionDecl,
    ArrayRef<llvm::omp::TraitProperty> ConstructTraits)
    : … { … }

bool TargetOMPContext::matchesISATrait(StringRef RawString) const { … }
llvm/clang/lib/AST/OpenMPClause.cpp
