Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaOpenACC_8cpp_source.html below:

clang: lib/Sema/SemaOpenACC.cpp Source File

;

OpenACCDirectiveKind::Invalid:

OpenACCDirectiveKind::ParallelLoop:

OpenACCDirectiveKind::SerialLoop:

OpenACCDirectiveKind::KernelsLoop:

OpenACCDirectiveKind::Parallel:

OpenACCDirectiveKind::Serial:

OpenACCDirectiveKind::Kernels:

OpenACCDirectiveKind::Loop:

OpenACCDirectiveKind::Data:

OpenACCDirectiveKind::EnterData:

OpenACCDirectiveKind::ExitData:

OpenACCDirectiveKind::HostData:

OpenACCDirectiveKind::Wait:

S.

(StartLoc, diag::err_acc_construct_appertainment) << K;

CollectActiveReductionClauses(

(

*CurClause : CurClauses) {

(

*RedClause = dyn_cast<OpenACCReductionClause>(CurClause);

RedClause && !RedClause->getVarList().empty())

ActiveClauses.push_back(RedClause);

OpenACCDirectiveKind::Parallel:

OpenACCDirectiveKind::ParallelLoop:

OpenACCDirectiveKind::Serial:

OpenACCDirectiveKind::SerialLoop:

OpenACCDirectiveKind::Kernels:

OpenACCDirectiveKind::KernelsLoop:

OpenACCDirectiveKind::Loop:

OpenACCDirectiveKind::Data:

OpenACCDirectiveKind::HostData:

OpenACCDirectiveKind::EnterData:

OpenACCDirectiveKind::ExitData:

OpenACCDirectiveKind::Wait:

OpenACCDirectiveKind::Init:

OpenACCDirectiveKind::Shutdown:

OpenACCDirectiveKind::Set:

OpenACCDirectiveKind::Update:

llvm_unreachable(

);

OpenACCDirectiveKind::Invalid:

llvm_unreachable(

);

llvm_unreachable(

);

: SemaRef(S), OldActiveComputeConstructInfo(S.ActiveComputeConstructInfo),

DirKind(DK), OldLoopGangClauseOnKernel(S.LoopGangClauseOnKernel),

OldLoopWorkerClauseLoc(S.LoopWorkerClauseLoc),

OldLoopVectorClauseLoc(S.LoopVectorClauseLoc),

OldLoopWithoutSeqInfo(S.LoopWithoutSeqInfo),

ActiveReductionClauses(S.ActiveReductionClauses),

LoopRAII(SemaRef, PreserveLoopRAIIDepthInAssociatedStmtRAII(DirKind)) {

CollectActiveReductionClauses(S.ActiveReductionClauses, Clauses);

SemaRef.ActiveComputeConstructInfo.Kind = DirKind;

SemaRef.ActiveComputeConstructInfo.Clauses = Clauses;

SemaRef.ActiveComputeConstructInfo.Kind = DirKind;

SemaRef.ActiveComputeConstructInfo.Clauses = Clauses;

CollectActiveReductionClauses(S.ActiveReductionClauses, Clauses);

llvm::find_if(Clauses, llvm::IsaPred<OpenACCSeqClause>))

*Itr = llvm::find_if(Clauses, llvm::IsaPred<OpenACCGangClause>);

(Itr != Clauses.end())

(UnInstClauses.empty()) {

*Itr = llvm::find_if(Clauses, llvm::IsaPred<OpenACCWorkerClause>);

(Itr != Clauses.end())

*Itr2 = llvm::find_if(Clauses, llvm::IsaPred<OpenACCVectorClause>);

(Itr2 != Clauses.end())

CollectActiveReductionClauses(S.ActiveReductionClauses, Clauses);

llvm::find_if(Clauses, llvm::IsaPred<OpenACCSeqClause>))

UnInstClauses.empty()) {

*Itr = llvm::find_if(Clauses, llvm::IsaPred<OpenACCGangClause>);

(Itr != Clauses.end())

(UnInstClauses.empty()) {

*Itr = llvm::find_if(Clauses, llvm::IsaPred<OpenACCWorkerClause>);

(Itr != Clauses.end())

*Itr2 = llvm::find_if(Clauses, llvm::IsaPred<OpenACCVectorClause>);

(Itr2 != Clauses.end())

.LoopInfo.CurLevelHasLoopAlready =

;

.CollapseInfo.CollapseDepthSatisfied =

;

.TileInfo.TileDepthSatisfied =

;

*CollapseClauseItr =

llvm::find_if(Clauses, llvm::IsaPred<OpenACCCollapseClause>);

*UnInstCollapseClauseItr =

llvm::find_if(UnInstClauses, llvm::IsaPred<OpenACCCollapseClause>);

(Clauses.end() == CollapseClauseItr)

cast<OpenACCCollapseClause>(*CollapseClauseItr);

.CollapseInfo.ActiveCollapse = CollapseClause;

(UnInstCollapseClauseItr != UnInstClauses.end() &&

!cast<OpenACCCollapseClause>(*UnInstCollapseClauseItr)

->isInstantiationDependent())

.CollapseInfo.CollapseDepthSatisfied =

;

.CollapseInfo.CurCollapseCount =

cast<ConstantExpr>(LoopCount)->getResultAsAPSInt();

.CollapseInfo.DirectiveKind = DirKind;

(UnInstClauses.size() > 0)

*TileClauseItr =

llvm::find_if(Clauses, llvm::IsaPred<OpenACCTileClause>);

(Clauses.end() == TileClauseItr)

.TileInfo.ActiveTile = TileClause;

.TileInfo.TileDepthSatisfied =

;

.TileInfo.DirectiveKind = DirKind;

.ActiveComputeConstructInfo = OldActiveComputeConstructInfo;

.LoopGangClauseOnKernel = OldLoopGangClauseOnKernel;

.LoopWorkerClauseLoc = OldLoopWorkerClauseLoc;

.LoopVectorClauseLoc = OldLoopVectorClauseLoc;

.LoopWithoutSeqInfo = OldLoopWithoutSeqInfo;

.ActiveReductionClauses.swap(ActiveReductionClauses);

(DirLoc, diag::warn_acc_construct_unimplemented) << K;

);

getDiagKind()

{

(ClauseKind != OpenACCClauseKind::Invalid)

(DirectiveKind != OpenACCDirectiveKind::Invalid)

: ICEConvertDiagnoser(

,

DirectiveKind(DK), ClauseKind(CK), IntExpr(IntExpr) {}

S.

(

, diag::err_acc_int_expr_requires_integer)

<< getDiagKind() << ClauseKind << DirectiveKind <<

;

S.

(

, diag::err_acc_int_expr_incomplete_class_type)

S.

(

, diag::err_acc_int_expr_explicit_conversion)

S.

(Conv->

(), diag::note_acc_int_expr_conversion)

S.

(

, diag::err_acc_int_expr_multiple_conversions) <<

;

S.

(Conv->

(), diag::note_acc_int_expr_conversion)

llvm_unreachable(

);

} IntExprDiagnoser(DK, CK, IntExpr);

, IntExpr, IntExprDiagnoser);

IntExpr = IntExprResult.

();

(VarExpr->

(), diag::note_acc_expected_pointer_var);

(VarExpr->

(), diag::err_acc_var_not_pointer_type)

isa<ArraySectionExpr, ArraySubscriptExpr>(CurVarExpr)) {

(VarExpr->

(), diag::err_acc_not_a_var_ref_use_device);

(isa<ArraySectionExpr, ArraySubscriptExpr>(CurVarExpr)) {

(

*SubScrpt = dyn_cast<ArraySubscriptExpr>(CurVarExpr))

(

*DRE = dyn_cast<DeclRefExpr>(CurVarExpr)) {

(isa<VarDecl, NonTypeTemplateParmDecl>(

DRE->getFoundDecl()->getCanonicalDecl()))

(

*ME = dyn_cast<MemberExpr>(CurVarExpr)) {

(isa<FieldDecl>(ME->getMemberDecl()->getCanonicalDecl()))

(isa<DependentScopeDeclRefExpr>(CurVarExpr) ||

isa<CXXDependentScopeMemberExpr>(CurVarExpr)))

(isa<RecoveryExpr>(CurVarExpr))

(VarExpr->

(), diag::err_acc_not_a_var_ref_use_device);

(

->hasPlaceholderType() &&

!

->hasPlaceholderType(BuiltinType::ArraySection)) {

LowerBound =

.get();

(Length && Length->getType()->isNonOverloadPlaceholderType()) {

(!

->isTypeDependent()) {

(

->getExprLoc(), diag::err_acc_typecheck_subarray_value)

<<

->getSourceRange());

(

->getExprLoc(), diag::err_acc_subarray_function_type)

<< ResultTy <<

->getSourceRange();

diag::err_acc_subarray_incomplete_type,

(!

->hasPlaceholderType(BuiltinType::ArraySection)) {

Recovery.

() ? Recovery.

() :

;

LBRes.

() ? LBRes.

() : GetRecovery(LowerBound, Context.

);

(Length && !Length->isTypeDependent()) {

Length->getExprLoc(), Length);

LenRes.

() ? LenRes.

() : GetRecovery(Length, Context.

);

(!Length && (OriginalBaseTy.

() ||

(ColonLoc, diag::err_acc_subarray_no_length) << IsArray;

Length = Recovery.

() ? Recovery.

() :

;

std::optional<llvm::APSInt> BaseSize;

BaseSize = ArrayTy->

();

GetBoundValue = [&](

*

) -> std::optional<llvm::APSInt> {

std::optional<llvm::APSInt> LowerBoundValue = GetBoundValue(LowerBound);

std::optional<llvm::APSInt> LengthValue = GetBoundValue(Length);

(LowerBoundValue.has_value()) {

(LowerBoundValue->isNegative()) {

(LowerBound->

(), diag::err_acc_subarray_negative)

<<

0 <<

(*LowerBoundValue,

10);

LowerBoundValue.reset();

LowerBound = GetRecovery(LowerBound, LowerBound->

());

}

(BaseSize.has_value() &&

llvm::APSInt::compareValues(*LowerBoundValue, *BaseSize) >= 0) {

(LowerBound->

(), diag::err_acc_subarray_out_of_range)

<<

0 <<

(*LowerBoundValue,

10)

LowerBoundValue.reset();

LowerBound = GetRecovery(LowerBound, LowerBound->

());

(LengthValue.has_value()) {

(LengthValue->isNegative()) {

(Length->getExprLoc(), diag::err_acc_subarray_negative)

<<

1 <<

(*LengthValue,

10);

Length = GetRecovery(Length, Length->getType());

}

(BaseSize.has_value() &&

llvm::APSInt::compareValues(*LengthValue, *BaseSize) > 0) {

(Length->getExprLoc(), diag::err_acc_subarray_out_of_range)

Length = GetRecovery(Length, Length->getType());

AddAPSInt = [](llvm::APSInt LHS, llvm::APSInt RHS) -> llvm::APSInt {

(LHS.isSigned() == RHS.isSigned())

Width = std::max(LHS.getBitWidth(), RHS.getBitWidth()) + 1;

llvm::APSInt(LHS.sext(Width) + RHS.sext(Width),

);

(BaseSize.has_value() && LowerBoundValue.has_value() &&

LengthValue.has_value() &&

llvm::APSInt::compareValues(AddAPSInt(*LowerBoundValue, *LengthValue),

diag::err_acc_subarray_base_plus_length_out_of_range)

LowerBoundValue.reset();

LowerBound = GetRecovery(LowerBound, LowerBound->

());

Length = GetRecovery(Length, Length->getType());

(

->isTypeDependent() ||

(Length && Length->isInstantiationDependent()))

(!LoopInfo.TopLevelLoopSeen)

(CollapseInfo.CurCollapseCount && *CollapseInfo.CurCollapseCount > 0) {

(WhileLoc, diag::err_acc_invalid_in_loop)

<<

1 << CollapseInfo.DirectiveKind

assert(CollapseInfo.ActiveCollapse &&

);

(CollapseInfo.ActiveCollapse->getBeginLoc(),

diag::note_acc_active_clause_here)

CollapseInfo.CurCollapseCount = std::nullopt;

(TileInfo.CurTileCount && *TileInfo.CurTileCount > 0) {

(WhileLoc, diag::err_acc_invalid_in_loop)

<<

1 << TileInfo.DirectiveKind

assert(TileInfo.ActiveTile &&

);

(TileInfo.ActiveTile->getBeginLoc(), diag::note_acc_active_clause_here)

TileInfo.CurTileCount = std::nullopt;

(!LoopInfo.TopLevelLoopSeen)

(CollapseInfo.CurCollapseCount && *CollapseInfo.CurCollapseCount > 0) {

(DoLoc, diag::err_acc_invalid_in_loop)

<<

2 << CollapseInfo.DirectiveKind

assert(CollapseInfo.ActiveCollapse &&

);

(CollapseInfo.ActiveCollapse->getBeginLoc(),

diag::note_acc_active_clause_here)

CollapseInfo.CurCollapseCount = std::nullopt;

(TileInfo.CurTileCount && *TileInfo.CurTileCount > 0) {

(DoLoc, diag::err_acc_invalid_in_loop)

assert(TileInfo.ActiveTile &&

);

(TileInfo.ActiveTile->getBeginLoc(), diag::note_acc_active_clause_here)

TileInfo.CurTileCount = std::nullopt;

ForStmtBeginChecker &

) {

assert(

().OpenACC &&

);

LoopInfo.TopLevelLoopSeen =

;

(CollapseInfo.CurCollapseCount && *CollapseInfo.CurCollapseCount > 0) {

(LoopInfo.CurLevelHasLoopAlready) {

(ForLoc, diag::err_acc_clause_multiple_loops)

assert(CollapseInfo.ActiveCollapse &&

);

(CollapseInfo.ActiveCollapse->getBeginLoc(),

diag::note_acc_active_clause_here)

--(*CollapseInfo.CurCollapseCount);

(*CollapseInfo.CurCollapseCount == 0)

CollapseInfo.CollapseDepthSatisfied =

;

(TileInfo.CurTileCount && *TileInfo.CurTileCount > 0) {

(LoopInfo.CurLevelHasLoopAlready) {

(ForLoc, diag::err_acc_clause_multiple_loops)

assert(TileInfo.ActiveTile &&

);

(TileInfo.ActiveTile->getBeginLoc(),

diag::note_acc_active_clause_here)

--(*TileInfo.CurTileCount);

(*TileInfo.CurTileCount == 0)

TileInfo.TileDepthSatisfied =

;

LoopInfo.CurLevelHasLoopAlready =

;

isValidLoopVariableType(

LoopVarTy) {

(

*TD :

llvm::make_filter_range(RD->decls(), llvm::IsaPred<TypedefNameDecl>)) {

*TDND = cast<TypedefNameDecl>(TD)->getCanonicalDecl();

(TDND->getName() !=

)

(TDND->getUnderlyingType().isNull())

TDND->getUnderlyingType()->getAsCXXRecordDecl();

(!ItrCategoryDecl)

IsRandomAccessIteratorTag = [](

*RD) {

(RD->getName() !=

)

(IsRandomAccessIteratorTag(ItrCategoryDecl))

(IsRandomAccessIteratorTag(BS.getType()->getAsCXXRecordDecl()))

SemaOpenACC::ForStmtBeginChecker::check() {

AlreadyChecked =

;

(!RangeFor.has_value())

*RangeStmt = (*RangeFor)->getBeginStmt();

(!isValidLoopVariableType(VarType)) {

<<

.LoopWithoutSeqInfo.Kind << VarType;

diag::note_acc_construct_here)

<<

.LoopWithoutSeqInfo.Kind;

(Cond.has_value())

(

.has_value())

*SemaOpenACC::ForStmtBeginChecker::checkInit() {

.

(ForLoc, diag::err_acc_loop_variable)

<<

.LoopWithoutSeqInfo.Kind;

diag::note_acc_construct_here)

<<

.LoopWithoutSeqInfo.Kind;

DiagLoopVar = [&]() {

<<

.LoopWithoutSeqInfo.Kind;

diag::note_acc_construct_here)

<<

.LoopWithoutSeqInfo.Kind;

(

*ExprTemp = dyn_cast<ExprWithCleanups>(

))

= ExprTemp->getSubExpr();

(

*

= dyn_cast<Expr>(

))

(

*BO = dyn_cast<BinaryOperator>(

)) {

(!BO->isAssignmentOp())

DiagLoopVar();

(

*DRE = dyn_cast<DeclRefExpr>(LHS))

InitVar = DRE->getDecl();

}

(

*DS = dyn_cast<DeclStmt>(

)) {

(!DS->isSingleDecl())

DiagLoopVar();

InitVar = dyn_cast<ValueDecl>(DS->getSingleDecl());

(!isa<VarDecl>(InitVar))

DiagLoopVar();

!cast<VarDecl>(InitVar)->hasInit())

DiagLoopVar();

}

(

*CE = dyn_cast<CXXOperatorCallExpr>(

)) {

(CE->getOperator() != OO_Equal)

DiagLoopVar();

(

*DRE = dyn_cast<DeclRefExpr>(LHS)) {

InitVar = DRE->getDecl();

}

(

*ME = dyn_cast<MemberExpr>(LHS)) {

(isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))

InitVar = ME->getMemberDecl();

DiagLoopVar();

(!isValidLoopVariableType(VarType)) {

<<

.LoopWithoutSeqInfo.Kind << VarType;

diag::note_acc_construct_here)

<<

.LoopWithoutSeqInfo.Kind;

SemaOpenACC::ForStmtBeginChecker::checkCond() {

.

(ForLoc, diag::err_acc_loop_terminating_condition)

<<

.LoopWithoutSeqInfo.Kind;

<<

.LoopWithoutSeqInfo.Kind;

SemaOpenACC::ForStmtBeginChecker::checkInc(

*

) {

.

(ForLoc, diag::err_acc_loop_not_monotonic)

<<

.LoopWithoutSeqInfo.Kind;

<<

.LoopWithoutSeqInfo.Kind;

DiagIncVar = [

] {

.

((*Inc)->getBeginLoc(), diag::err_acc_loop_not_monotonic)

<<

.LoopWithoutSeqInfo.Kind;

<<

.LoopWithoutSeqInfo.Kind;

(

*ExprTemp = dyn_cast<ExprWithCleanups>(*Inc))

= ExprTemp->getSubExpr();

(

*

= dyn_cast<Expr>(*Inc))

(

*FE = dyn_cast<FullExpr>(

))

= FE->getSubExpr();

(

*DRE = dyn_cast<DeclRefExpr>(

))

dyn_cast<ValueDecl>(DRE->getDecl());

(

*ME = dyn_cast<MemberExpr>(

))

(isa<CXXThisExpr>(ME->getBase()->IgnoreParenImpCasts()))

ME->getMemberDecl();

(

*UO = dyn_cast<UnaryOperator>(*Inc)) {

(!UO->isIncrementDecrementOp())

DiagIncVar();

}

(

*BO = dyn_cast<BinaryOperator>(*Inc)) {

(BO->getOpcode()) {

DiagIncVar();

}

(

*CE = dyn_cast<CXXOperatorCallExpr>(*Inc)) {

(CE->getOperator()) {

DiagIncVar();

}

(

*ME = dyn_cast<CXXMemberCallExpr>(*Inc)) {

DiagIncVar();

DiagIncVar();

*Second,

*OldThird,

*Third) {

std::optional<const Stmt *> S;

(OldSecond == Second)

std::optional<const Stmt *>

;

(OldThird == Third)

InitChanged =

;

(OldFirst !=

) {

InitChanged =

;

(

*DS = dyn_cast<DeclStmt>(OldFirst))

(

*VD = dyn_cast_if_present<VarDecl>(

DS->isSingleDecl() ? DS->getSingleDecl() :

))

OldVDTy = VD->getType();

(

*DS = dyn_cast<DeclStmt>(

))

(

*VD = dyn_cast_if_present<VarDecl>(

DS->isSingleDecl() ? DS->getSingleDecl() :

))

NewVDTy = VD->getType();

ForStmtBeginChecker FSBC{*

, ForLoc,

, InitChanged, S,

};

(!LoopInfo.TopLevelLoopSeen) {

ForStmtBeginHelper(ForLoc, FSBC);

*Second,

*Third) {

ForStmtBeginChecker FSBC{*

, ForLoc,

,

,

(!LoopInfo.TopLevelLoopSeen) {

ForStmtBeginHelper(ForLoc, FSBC);

*OldRangeFor,

*RangeFor) {

std::optional<const CXXForRangeStmt *> RF;

(OldRangeFor == RangeFor)

RF = cast<CXXForRangeStmt>(RangeFor);

ForStmtBeginChecker FSBC{*

, ForLoc, RF};

(!LoopInfo.TopLevelLoopSeen) {

ForStmtBeginHelper(ForLoc, FSBC);

*RangeFor) {

ForStmtBeginChecker FSBC{*

, ForLoc, cast<CXXForRangeStmt>(RangeFor)};

(!LoopInfo.TopLevelLoopSeen) {

ForStmtBeginHelper(ForLoc, FSBC);

isa<ForStmt, NullStmt, ForStmt, CXXForRangeStmt, WhileStmt, DoStmt>(

(isa<OpenACCConstructStmt>(CurStmt))

(

*CS = dyn_cast<CompoundStmt>(CurStmt)) {

(

*ChildStmt : CS->children()) {

ChildStmtLoc = FindInterveningCodeInLoop(ChildStmt);

ChildStmtLoc;

LoopInfo.CurLevelHasLoopAlready =

;

IsActiveCollapse = CollapseInfo.CurCollapseCount &&

*CollapseInfo.CurCollapseCount > 0 &&

!CollapseInfo.ActiveCollapse->hasForce();

IsActiveTile = TileInfo.CurTileCount && *TileInfo.CurTileCount > 0;

(IsActiveCollapse || IsActiveTile) {

(OtherStmtLoc.

() && IsActiveCollapse) {

(OtherStmtLoc, diag::err_acc_intervening_code)

(CollapseInfo.ActiveCollapse->getBeginLoc(),

diag::note_acc_active_clause_here)

(OtherStmtLoc.

() && IsActiveTile) {

(OtherStmtLoc, diag::err_acc_intervening_code)

(TileInfo.ActiveTile->getBeginLoc(),

diag::note_acc_active_clause_here)

assert(!Clauses.empty() &&

);

llvm::raw_string_ostream OS{Output};

(Clauses.size() == 1) {

OS <<

<< Clauses[0] <<

;

[&] { OS <<

; });

OS <<

<< Clauses.back() <<

;

(CollapseInfo.CurCollapseCount && *CollapseInfo.CurCollapseCount > 0) {

(StartLoc, diag::err_acc_invalid_in_loop)

<<

0 << CollapseInfo.DirectiveKind

assert(CollapseInfo.ActiveCollapse &&

);

(CollapseInfo.ActiveCollapse->getBeginLoc(),

diag::note_acc_active_clause_here)

(TileInfo.CurTileCount && *TileInfo.CurTileCount > 0) {

(StartLoc, diag::err_acc_invalid_in_loop)

<<

0 << TileInfo.DirectiveKind

assert(TileInfo.ActiveTile &&

);

(TileInfo.ActiveTile->getBeginLoc(), diag::note_acc_active_clause_here)

llvm::find_if(Clauses,

(StartLoc, diag::err_acc_construct_one_clause_of)

<< GetListOfClauses(

llvm::find_if(Clauses,

(StartLoc, diag::err_acc_construct_one_clause_of)

<< GetListOfClauses({

llvm::find_if(Clauses,

(StartLoc, diag::err_acc_construct_one_clause_of)

<< GetListOfClauses({

llvm::find_if(Clauses, llvm::IsaPred<OpenACCUseDeviceClause>) ==

(StartLoc, diag::err_acc_construct_one_clause_of)

(StartLoc, diag::err_acc_construct_one_clause_of)

(StartLoc, diag::err_acc_construct_one_clause_of)

diagnoseConstructAppertainment(*

, K, StartLoc,

);

AssocStmt.

() ? AssocStmt.

() :

);

AssocStmt.

() ? AssocStmt.

() :

);

(), ActiveComputeConstructInfo.Kind, StartLoc, DirLoc,

EndLoc, Clauses, AssocStmt.

() ? AssocStmt.

() :

);

AssocStmt.

() ? AssocStmt.

() :

);

AssocStmt.

() ? AssocStmt.

() :

);

(), StartLoc, DirLoc, LParenLoc, Exprs.front(), MiscLoc,

Exprs.drop_front(), RParenLoc, EndLoc, Clauses);

llvm_unreachable(

);

llvm_unreachable(

);

);

(!isa<CXXForRangeStmt, ForStmt>(AssocStmt.

())) {

(DirectiveLoc, diag::note_acc_construct_here) << K;

(!CollapseInfo.CollapseDepthSatisfied || !TileInfo.TileDepthSatisfied) {

(!CollapseInfo.CollapseDepthSatisfied) {

(DirectiveLoc, diag::err_acc_insufficient_loops)

assert(CollapseInfo.ActiveCollapse &&

);

(CollapseInfo.ActiveCollapse->getBeginLoc(),

diag::note_acc_active_clause_here)

(!TileInfo.TileDepthSatisfied) {

(DirectiveLoc, diag::err_acc_insufficient_loops)

assert(TileInfo.ActiveTile &&

);

(TileInfo.ActiveTile->getBeginLoc(),

diag::note_acc_active_clause_here)

AssocStmt.

();

llvm_unreachable(

);

diagnoseConstructAppertainment(*

, K, StartLoc,

);

Defines some OpenACC-specific enums and functions.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

static NamedDecl * getDeclFromExpr(Expr *E)

This file declares semantic analysis for OpenACC constructs and clauses.

This file defines OpenACC AST classes for statement-level contructs.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

const ConstantArrayType * getAsConstantArrayType(QualType T) const

CanQualType ArraySectionTy

This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...

static QualType getBaseOriginalType(const Expr *Base)

Return original type of the base expression for array section.

QualType getElementType() const

Represents a base class of a C++ class.

Represents a C++ conversion function within a class.

Represents a C++ struct/union/class.

llvm::APInt getSize() const

Return the constant array size as an APInt.

bool isStdNamespace() const

DeclContext * getEnclosingNamespaceContext()

Retrieve the nearest enclosing namespace context.

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

const Decl * getSingleDecl() const

SourceLocation getLocation() const

SourceLocation getBeginLoc() const LLVM_READONLY

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

This represents one expression.

bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const

EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...

bool isTypeDependent() const

Determines whether the type of this expression depends on.

Expr * IgnoreParenImpCasts() LLVM_READONLY

Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...

bool containsErrors() const

Whether this expression contains subexpressions which had errors, e.g.

bool isInstantiationDependent() const

Whether this expression is instantiation-dependent, meaning that it depends in some way on.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

bool hasPlaceholderType() const

Returns whether this expression has a placeholder type.

static OpenACCAsteriskSizeExpr * Create(const ASTContext &C, SourceLocation Loc)

Represents a 'collapse' clause on a 'loop' construct.

const Expr * getLoopCount() const

static OpenACCCombinedConstruct * Create(const ASTContext &C, OpenACCDirectiveKind K, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses, Stmt *StructuredBlock)

static OpenACCComputeConstruct * Create(const ASTContext &C, OpenACCDirectiveKind K, SourceLocation BeginLoc, SourceLocation DirectiveLoc, SourceLocation EndLoc, ArrayRef< const OpenACCClause * > Clauses, Stmt *StructuredBlock)

static OpenACCDataConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses, Stmt *StructuredBlock)

A 'default' clause, has the optional 'none' or 'present' argument.

A 'device_type' or 'dtype' clause, takes a list of either an 'asterisk' or an identifier.

static OpenACCEnterDataConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses)

static OpenACCExitDataConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses)

static OpenACCHostDataConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses, Stmt *StructuredBlock)

An 'if' clause, which has a required condition expression.

static OpenACCInitConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses)

static OpenACCLoopConstruct * Create(const ASTContext &C, OpenACCDirectiveKind ParentKind, SourceLocation BeginLoc, SourceLocation DirLoc, SourceLocation EndLoc, ArrayRef< const OpenACCClause * > Clauses, Stmt *Loop)

A 'self' clause, which has an optional condition expression, or, in the event of an 'update' directiv...

static OpenACCSetConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses)

static OpenACCShutdownConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses)

llvm::ArrayRef< Expr * > getSizeExprs()

static OpenACCUpdateConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses)

static OpenACCWaitConstruct * Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation LParenLoc, Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef< Expr * > QueueIdExprs, SourceLocation RParenLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses)

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

QualType getNonReferenceType() const

If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

A generic diagnostic builder for errors which may or may not be deferred.

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

ASTContext & getASTContext() const

const LangOptions & getLangOpts() const

AssociatedStmtRAII(SemaOpenACC &, OpenACCDirectiveKind, SourceLocation, ArrayRef< const OpenACCClause * >, ArrayRef< OpenACCClause * >)

void SetTileInfoBeforeAssociatedStmt(ArrayRef< const OpenACCClause * > UnInstClauses, ArrayRef< OpenACCClause * > Clauses)

void SetCollapseInfoBeforeAssociatedStmt(ArrayRef< const OpenACCClause * > UnInstClauses, ArrayRef< OpenACCClause * > Clauses)

ExprResult ActOnVar(OpenACCClauseKind CK, Expr *VarExpr)

Called when encountering a 'var' for OpenACC, ensures it is actually a declaration reference to a var...

ComputeConstructInfo & getActiveComputeConstructInfo()

bool ActOnStartStmtDirective(OpenACCDirectiveKind K, SourceLocation StartLoc, ArrayRef< const OpenACCClause * > Clauses)

Called after the directive, including its clauses, have been parsed and parsing has consumed the 'ann...

ExprResult BuildOpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc)

ExprResult ActOnIntExpr(OpenACCDirectiveKind DK, OpenACCClauseKind CK, SourceLocation Loc, Expr *IntExpr)

Called when encountering an 'int-expr' for OpenACC, and manages conversions and diagnostics to 'int'.

void ActOnWhileStmt(SourceLocation WhileLoc)

SourceLocation LoopWorkerClauseLoc

If there is a current 'active' loop construct with a 'worker' clause on it (on any sort of construct)...

bool ActOnStartDeclDirective(OpenACCDirectiveKind K, SourceLocation StartLoc)

Called after the directive, including its clauses, have been parsed and parsing has consumed the 'ann...

bool CheckVarIsPointerType(OpenACCClauseKind ClauseKind, Expr *VarExpr)

Called to check the 'var' type is a variable of pointer type, necessary for 'deviceptr' and 'attach' ...

struct clang::SemaOpenACC::LoopGangOnKernelTy LoopGangClauseOnKernel

struct clang::SemaOpenACC::LoopWithoutSeqCheckingInfo LoopWithoutSeqInfo

StmtResult ActOnEndStmtDirective(OpenACCDirectiveKind K, SourceLocation StartLoc, SourceLocation DirLoc, SourceLocation LParenLoc, SourceLocation MiscLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc, SourceLocation EndLoc, ArrayRef< OpenACCClause * > Clauses, StmtResult AssocStmt)

Called after the directive has been completely parsed, including the declaration group or associated ...

DeclGroupRef ActOnEndDeclDirective()

Called after the directive has been completely parsed, including the declaration group or associated ...

SourceLocation LoopVectorClauseLoc

If there is a current 'active' loop construct with a 'vector' clause on it (on any sort of construct)...

void ActOnConstruct(OpenACCDirectiveKind K, SourceLocation DirLoc)

Called after the construct has been parsed, but clauses haven't been parsed.

ExprResult ActOnOpenACCAsteriskSizeExpr(SourceLocation AsteriskLoc)

void ActOnDoStmt(SourceLocation DoLoc)

void ActOnRangeForStmtBegin(SourceLocation ForLoc, const Stmt *OldRangeFor, const Stmt *RangeFor)

void ActOnForStmtEnd(SourceLocation ForLoc, StmtResult Body)

StmtResult ActOnAssociatedStmt(SourceLocation DirectiveLoc, OpenACCDirectiveKind K, ArrayRef< const OpenACCClause * > Clauses, StmtResult AssocStmt)

Called when we encounter an associated statement for our construct, this should check legality of the...

void ActOnForStmtBegin(SourceLocation ForLoc, const Stmt *First, const Stmt *Second, const Stmt *Third)

ExprResult ActOnArraySectionExpr(Expr *Base, SourceLocation LBLoc, Expr *LowerBound, SourceLocation ColonLocFirst, Expr *Length, SourceLocation RBLoc)

Checks and creates an Array Section used in an OpenACC construct/clause.

Sema - This implements semantic analysis and AST building for C.

void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)

ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)

Perform a contextual implicit conversion.

ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)

void PopExpressionEvaluationContext()

ExprResult DefaultLvalueConversion(Expr *E)

ExprResult CheckPlaceholderExpr(Expr *E)

Check for operands with placeholder types and complain if found.

@ PotentiallyEvaluated

The current expression is potentially evaluated at run time, which means that code may be generated t...

bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)

Ensure that the type T is a complete type.

void DiscardCleanupsInEvaluationContext()

ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())

Attempts to produce a RecoveryExpr after some AST node cannot be created.

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

SourceLocation getBeginLoc() const LLVM_READONLY

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isDependentSizedArrayType() const

bool isConstantArrayType() const

bool isPointerType() const

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

bool isEnumeralType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isNonOverloadPlaceholderType() const

Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.

bool isInstantiationDependentType() const

Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

const ArrayType * getAsArrayTypeUnsafe() const

A variant of getAs<> for array types which silently discards qualifiers from the outermost type.

bool isFunctionType() const

bool isAnyPointerType() const

bool isRecordType() const

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Represents a variable declaration or definition.

SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)

Returns the results of matching Matcher on Node.

bool Inc(InterpState &S, CodePtr OpPC)

1) Pops a pointer from the stack 2) Load the value from the pointer 3) Writes the value increased by ...

The JSON file list parser is used to communicate input to InstallAPI.

@ OK_Ordinary

An ordinary object is located at an address in memory.

OpenACCClauseKind

Represents the kind of an OpenACC clause.

@ DevicePtr

'deviceptr' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.

@ Collapse

'collapse' clause, allowed on 'loop' and Combined constructs.

@ DeviceNum

'device_num' clause, allowed on 'init', 'shutdown', and 'set' constructs.

@ Invalid

Represents an invalid clause, for the purposes of parsing.

@ Copy

'copy' clause, allowed on Compute and Combined Constructs, plus 'data' and 'declare'.

@ Create

'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...

@ DeviceType

'device_type' clause, allowed on Compute, 'data', 'init', 'shutdown', 'set', update',...

@ DefaultAsync

'default_async' clause, allowed on 'set' construct.

@ Attach

'attach' clause, allowed on Compute and Combined constructs, plus 'data' and 'enter data'.

@ If

'if' clause, allowed on all the Compute Constructs, Data Constructs, Executable Constructs,...

@ Default

'default' clause, allowed on parallel, serial, kernel (and compound) constructs.

@ UseDevice

'use_device' clause, allowed on 'host_data' construct.

@ NoCreate

'no_create' clause, allowed on allowed on Compute and Combined constructs, plus 'data'.

@ Reduction

'reduction' clause, allowed on Parallel, Serial, Loop, and the combined constructs.

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

@ CopyOut

'copyout' clause, allowed on Compute and Combined constructs, plus 'data', 'exit data',...

@ Host

'host' clause, allowed on 'update' construct.

@ Tile

'tile' clause, allowed on 'loop' and Combined constructs.

@ Present

'present' clause, allowed on Compute and Combined constructs, plus 'data' and 'declare'.

@ CopyIn

'copyin' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...

@ Device

'device' clause, allowed on the 'update' construct.

@ Detach

'detach' clause, allowed on the 'exit data' construct.

@ Delete

'delete' clause, allowed on the 'exit data' construct.

@ Result

The result type of a method or function.

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

const FunctionProtoType * T

EvalResult is a struct with detailed info about an evaluated expression.

APValue Val

Val - This is the value the expression can be folded to.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4