Diff 23760

include/clang/AST/DataRecursiveASTVisitor.h

Show First 20 Lines • Show All 2,513 Lines • ▼ Show 20 Lines	bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
}		}
return true;		return true;
}		}

template <typename Derived>		template <typename Derived>
bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(		bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(
OMPLastprivateClause *C) {		OMPLastprivateClause *C) {
TRY_TO(VisitOMPClauseList(C));		TRY_TO(VisitOMPClauseList(C));
		for (auto *E : C->private_copies()) {
		TRY_TO(TraverseStmt(E));
		}
		for (auto *E : C->source_exprs()) {
		TRY_TO(TraverseStmt(E));
		}
		for (auto *E : C->destination_exprs()) {
		TRY_TO(TraverseStmt(E));
		}
		for (auto *E : C->assignment_ops()) {
		TRY_TO(TraverseStmt(E));
		}
return true;		return true;
}		}

template <typename Derived>		template <typename Derived>
bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {		bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
TRY_TO(VisitOMPClauseList(C));		TRY_TO(VisitOMPClauseList(C));
return true;		return true;
}		}
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

include/clang/AST/OpenMPClause.h

	Show First 20 Lines • Show All 1,130 Lines • ▼ Show 20 Lines

	/// \brief This represents clause 'lastprivate' in the '#pragma omp ...'			/// \brief This represents clause 'lastprivate' in the '#pragma omp ...'
	/// directives.			/// directives.
	///			///
	/// \code			/// \code
	/// #pragma omp simd lastprivate(a,b)			/// #pragma omp simd lastprivate(a,b)
	/// \endcode			/// \endcode
	/// In this example directive '#pragma omp simd' has clause 'lastprivate'			/// In this example directive '#pragma omp simd' has clause 'lastprivate'
	/// with the variables 'a' and 'b'.			/// with the variables 'a' and 'b'.
	///
	class OMPLastprivateClause : public OMPVarListClause<OMPLastprivateClause> {			class OMPLastprivateClause : public OMPVarListClause<OMPLastprivateClause> {
				rjmccallUnsubmitted Not Done Reply Inline Actions This isn't external documentation, it's implementation documentation, so it should be written with instead of / and it should go inside the class definition. But otherwise, thank you for writing it. :) rjmccall: This isn't external documentation, it's implementation documentation, so it should be written…
				ABataevAuthorUnsubmitted Not Done Reply Inline Actions Ok, Done. ABataev: Ok, Done.
				// There are 4 additional tail-allocated arrays at the end of the class:
				// 1. Contains list of pseudo variables with the default initialization for
				// each non-firstprivate variables. Used in codegen for initialization of
				// lastprivate copies.
				// 2. List of helper expressions for proper generation of assignment operation
				// required for lastprivate clause. This list represents private variables
				// (for arrays, single array element).
				// 3. List of helper expressions for proper generation of assignment operation
				// required for lastprivate clause. This list represents original variables
				// (for arrays, single array element).
				// 4. List of helper expressions that represents assignment operation:
				// \code
				// DstExprs = SrcExprs;
				// \endcode
				// Required for proper codegen of final assignment performed by the
				// lastprivate clause.
				//
				friend class OMPClauseReader;

	/// \brief Build clause with number of variables \a N.			/// \brief Build clause with number of variables \a N.
	///			///
	/// \param StartLoc Starting location of the clause.			/// \param StartLoc Starting location of the clause.
	/// \param LParenLoc Location of '('.			/// \param LParenLoc Location of '('.
	/// \param EndLoc Ending location of the clause.			/// \param EndLoc Ending location of the clause.
	/// \param N Number of the variables in the clause.			/// \param N Number of the variables in the clause.
	///			///
	OMPLastprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,			OMPLastprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
	SourceLocation EndLoc, unsigned N)			SourceLocation EndLoc, unsigned N)
	: OMPVarListClause<OMPLastprivateClause>(OMPC_lastprivate, StartLoc,			: OMPVarListClause<OMPLastprivateClause>(OMPC_lastprivate, StartLoc,
	LParenLoc, EndLoc, N) {}			LParenLoc, EndLoc, N) {}

	/// \brief Build an empty clause.			/// \brief Build an empty clause.
	///			///
	/// \param N Number of variables.			/// \param N Number of variables.
	///			///
	explicit OMPLastprivateClause(unsigned N)			explicit OMPLastprivateClause(unsigned N)
	: OMPVarListClause<OMPLastprivateClause>(			: OMPVarListClause<OMPLastprivateClause>(
	OMPC_lastprivate, SourceLocation(), SourceLocation(),			OMPC_lastprivate, SourceLocation(), SourceLocation(),
	SourceLocation(), N) {}			SourceLocation(), N) {}

				/// \brief Get the list of helper expressions for initialization of private
				/// copies for lastprivate variables.
				MutableArrayRef<Expr *> getPrivateCopies() {
				return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
				}
				ArrayRef<const Expr *> getPrivateCopies() const {
				return llvm::makeArrayRef(varlist_end(), varlist_size());
				}
				rjmccallUnsubmitted Not Done Reply Inline Actions As always, when you've got tail-allocated arrays like this, please leave a comment describing their layout somewhere near the top of the class body. rjmccall: As always, when you've got tail-allocated arrays like this, please leave a comment describing…

				/// \brief Set list of helper expressions, required for proper codegen of the
				/// clause. These expressions represent private variables (for arrays, single
				/// array element) in the final assignment statement performed by the
				/// lastprivate clause.
				void setSourceExprs(ArrayRef<Expr *> SrcExprs);

				/// \brief Get the list of helper source expressions.
				MutableArrayRef<Expr *> getSourceExprs() {
				return MutableArrayRef<Expr *>(getPrivateCopies().end(), varlist_size());
				}
				ArrayRef<const Expr *> getSourceExprs() const {
				return llvm::makeArrayRef(getPrivateCopies().end(), varlist_size());
				}

				/// \brief Set list of helper expressions, required for proper codegen of the
				/// clause. These expressions represent original variables (for arrays, single
				/// array element) in the final assignment statement performed by the
				/// lastprivate clause.
				void setDestinationExprs(ArrayRef<Expr *> DstExprs);

				/// \brief Get the list of helper destination expressions.
				MutableArrayRef<Expr *> getDestinationExprs() {
				return MutableArrayRef<Expr *>(getSourceExprs().end(), varlist_size());
				}
				ArrayRef<const Expr *> getDestinationExprs() const {
				return llvm::makeArrayRef(getSourceExprs().end(), varlist_size());
				}

				/// \brief Set list of helper assignment expressions, required for proper
				/// codegen of the clause. These expressions are assignment expressions that
				/// assign private copy of the variable to original variable.
				void setAssignmentOps(ArrayRef<Expr *> AssignmentOps);

				/// \brief Get the list of helper assignment expressions.
				MutableArrayRef<Expr *> getAssignmentOps() {
				return MutableArrayRef<Expr *>(getDestinationExprs().end(), varlist_size());
				}
				ArrayRef<const Expr *> getAssignmentOps() const {
				return llvm::makeArrayRef(getDestinationExprs().end(), varlist_size());
				}

	public:			public:
	/// \brief Creates clause with a list of variables \a VL.			/// \brief Creates clause with a list of variables \a VL.
	///			///
	/// \param C AST context.			/// \param C AST context.
	/// \param StartLoc Starting location of the clause.			/// \param StartLoc Starting location of the clause.
	/// \param LParenLoc Location of '('.			/// \param LParenLoc Location of '('.
	/// \param EndLoc Ending location of the clause.			/// \param EndLoc Ending location of the clause.
	/// \param VL List of references to the variables.			/// \param VL List of references to the variables.
				/// \param SrcExprs List of helper expressions for proper generation of
				/// assignment operation required for lastprivate clause. This list represents
				/// private variables (for arrays, single array element).
				/// \param DstExprs List of helper expressions for proper generation of
				/// assignment operation required for lastprivate clause. This list represents
				/// original variables (for arrays, single array element).
				/// \param AssignmentOps List of helper expressions that represents assignment
				/// operation:
				/// \code
				/// DstExprs = SrcExprs;
				/// \endcode
				/// Required for proper codegen of final assignment performed by the
				/// lastprivate clause.
				///
	///			///
	static OMPLastprivateClause *			static OMPLastprivateClause *
	Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,			Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
	SourceLocation EndLoc, ArrayRef<Expr *> VL);			SourceLocation EndLoc, ArrayRef<Expr > VL, ArrayRef<Expr > SrcExprs,
				ArrayRef<Expr > DstExprs, ArrayRef<Expr > AssignmentOps);
	/// \brief Creates an empty clause with the place for \a N variables.			/// \brief Creates an empty clause with the place for \a N variables.
	///			///
	/// \param C AST context.			/// \param C AST context.
	/// \param N The number of variables.			/// \param N The number of variables.
	///			///
	static OMPLastprivateClause *CreateEmpty(const ASTContext &C, unsigned N);			static OMPLastprivateClause *CreateEmpty(const ASTContext &C, unsigned N);

				typedef MutableArrayRef<Expr *>::iterator helper_expr_iterator;
				typedef ArrayRef<const Expr *>::iterator helper_expr_const_iterator;
				typedef llvm::iterator_range<helper_expr_iterator> helper_expr_range;
				typedef llvm::iterator_range<helper_expr_const_iterator>
				helper_expr_const_range;

				/// \brief Set list of helper expressions, required for generation of private
				/// copies of original lastprivate variables.
				void setPrivateCopies(ArrayRef<Expr *> PrivateCopies);

				helper_expr_const_range private_copies() const {
				return helper_expr_const_range(getPrivateCopies().begin(),
				getPrivateCopies().end());
				}
				helper_expr_range private_copies() {
				return helper_expr_range(getPrivateCopies().begin(),
				getPrivateCopies().end());
				}
				helper_expr_const_range source_exprs() const {
				return helper_expr_const_range(getSourceExprs().begin(),
				getSourceExprs().end());
				}
				helper_expr_range source_exprs() {
				return helper_expr_range(getSourceExprs().begin(), getSourceExprs().end());
				}
				helper_expr_const_range destination_exprs() const {
				return helper_expr_const_range(getDestinationExprs().begin(),
				getDestinationExprs().end());
				}
				helper_expr_range destination_exprs() {
				return helper_expr_range(getDestinationExprs().begin(),
				getDestinationExprs().end());
				}
				helper_expr_const_range assignment_ops() const {
				return helper_expr_const_range(getAssignmentOps().begin(),
				getAssignmentOps().end());
				}
				helper_expr_range assignment_ops() {
				return helper_expr_range(getAssignmentOps().begin(),
				getAssignmentOps().end());
				}

	StmtRange children() {			StmtRange children() {
	return StmtRange(reinterpret_cast<Stmt **>(varlist_begin()),			return StmtRange(reinterpret_cast<Stmt **>(varlist_begin()),
	reinterpret_cast<Stmt **>(varlist_end()));			reinterpret_cast<Stmt **>(varlist_end()));
	}			}

	static bool classof(const OMPClause *T) {			static bool classof(const OMPClause *T) {
	return T->getClauseKind() == OMPC_lastprivate;			return T->getClauseKind() == OMPC_lastprivate;
	}			}
	▲ Show 20 Lines • Show All 777 Lines • Show Last 20 Lines

include/clang/AST/RecursiveASTVisitor.h

Show First 20 Lines • Show All 2,543 Lines • ▼ Show 20 Lines	bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
}		}
return true;		return true;
}		}

template <typename Derived>		template <typename Derived>
bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(		bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(
OMPLastprivateClause *C) {		OMPLastprivateClause *C) {
TRY_TO(VisitOMPClauseList(C));		TRY_TO(VisitOMPClauseList(C));
		for (auto *E : C->private_copies()) {
		TRY_TO(TraverseStmt(E));
		}
		for (auto *E : C->source_exprs()) {
		TRY_TO(TraverseStmt(E));
		}
		for (auto *E : C->destination_exprs()) {
		TRY_TO(TraverseStmt(E));
		}
		for (auto *E : C->assignment_ops()) {
		TRY_TO(TraverseStmt(E));
		}
return true;		return true;
}		}

template <typename Derived>		template <typename Derived>
bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {		bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
TRY_TO(VisitOMPClauseList(C));		TRY_TO(VisitOMPClauseList(C));
return true;		return true;
}		}
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

lib/AST/Stmt.cpp

	Show First 20 Lines • Show All 1,240 Lines • ▼ Show 20 Lines
	OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,			OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
	unsigned N) {			unsigned N) {
	void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),			void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
	llvm::alignOf<Expr *>()) +			llvm::alignOf<Expr *>()) +
	3 * sizeof(Expr ) N);			3 * sizeof(Expr ) N);
	return new (Mem) OMPFirstprivateClause(N);			return new (Mem) OMPFirstprivateClause(N);
	}			}

	OMPLastprivateClause *OMPLastprivateClause::Create(const ASTContext &C,			void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
	SourceLocation StartLoc,			assert(PrivateCopies.size() == varlist_size() &&
	SourceLocation LParenLoc,			"Number of private copies is not the same as the preallocated buffer");
	SourceLocation EndLoc,			std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
	ArrayRef<Expr *> VL) {			}

				void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
				assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
				"not the same as the "
				"preallocated buffer");
				std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
				}

				void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
				assert(DstExprs.size() == varlist_size() && "Number of destination "
				"expressions is not the same as "
				"the preallocated buffer");
				std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
				}

				void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
				assert(AssignmentOps.size() == varlist_size() &&
				"Number of assignment expressions is not the same as the preallocated "
				"buffer");
				std::copy(AssignmentOps.begin(), AssignmentOps.end(),
				getDestinationExprs().end());
				}

				OMPLastprivateClause *OMPLastprivateClause::Create(
				const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
				SourceLocation EndLoc, ArrayRef<Expr > VL, ArrayRef<Expr > SrcExprs,
				ArrayRef<Expr > DstExprs, ArrayRef<Expr > AssignmentOps) {
	void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),			void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
	llvm::alignOf<Expr *>()) +			llvm::alignOf<Expr *>()) +
	sizeof(Expr ) VL.size());			5 * sizeof(Expr ) VL.size());
	OMPLastprivateClause *Clause =			OMPLastprivateClause *Clause =
	new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());			new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
	Clause->setVarRefs(VL);			Clause->setVarRefs(VL);
				Clause->setSourceExprs(SrcExprs);
				Clause->setDestinationExprs(DstExprs);
				Clause->setAssignmentOps(AssignmentOps);
	return Clause;			return Clause;
	}			}

	OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,			OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
	unsigned N) {			unsigned N) {
	void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),			void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
	llvm::alignOf<Expr *>()) +			llvm::alignOf<Expr *>()) +
	sizeof(Expr ) N);			5 * sizeof(Expr ) N);
	return new (Mem) OMPLastprivateClause(N);			return new (Mem) OMPLastprivateClause(N);
	}			}

	OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,			OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
	SourceLocation StartLoc,			SourceLocation StartLoc,
	SourceLocation LParenLoc,			SourceLocation LParenLoc,
	SourceLocation EndLoc,			SourceLocation EndLoc,
	ArrayRef<Expr *> VL) {			ArrayRef<Expr *> VL) {
	▲ Show 20 Lines • Show All 842 Lines • Show Last 20 Lines

lib/AST/StmtProfile.cpp

Show First 20 Lines • Show All 340 Lines • ▼ Show 20 Lines	OMPClauseProfiler::VisitOMPFirstprivateClause(const OMPFirstprivateClause *C) {
}		}
for (auto *E : C->inits()) {		for (auto *E : C->inits()) {
Profiler->VisitStmt(E);		Profiler->VisitStmt(E);
}		}
}		}
void		void
OMPClauseProfiler::VisitOMPLastprivateClause(const OMPLastprivateClause *C) {		OMPClauseProfiler::VisitOMPLastprivateClause(const OMPLastprivateClause *C) {
VisitOMPClauseList(C);		VisitOMPClauseList(C);
		for (auto *E : C->source_exprs()) {
		Profiler->VisitStmt(E);
		}
		for (auto *E : C->destination_exprs()) {
		Profiler->VisitStmt(E);
		}
		for (auto *E : C->assignment_ops()) {
		Profiler->VisitStmt(E);
		}
}		}
void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) {		void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) {
VisitOMPClauseList(C);		VisitOMPClauseList(C);
}		}
void OMPClauseProfiler::VisitOMPReductionClause(		void OMPClauseProfiler::VisitOMPReductionClause(
const OMPReductionClause *C) {		const OMPReductionClause *C) {
Profiler->VisitNestedNameSpecifier(		Profiler->VisitNestedNameSpecifier(
C->getQualifierLoc().getNestedNameSpecifier());		C->getQualifierLoc().getNestedNameSpecifier());
▲ Show 20 Lines • Show All 1,135 Lines • Show Last 20 Lines

lib/CodeGen/CGStmtOpenMP.cpp

Show First 20 Lines • Show All 257 Lines • ▼ Show 20 Lines	for (auto IInit : C->private_copies()) {
assert(IsRegistered && "private var already registered as private");		assert(IsRegistered && "private var already registered as private");
// Silence the warning about unused variable.		// Silence the warning about unused variable.
(void)IsRegistered;		(void)IsRegistered;
++IRef;		++IRef;
}		}
}		}
}		}

		bool CodeGenFunction::EmitOMPLastprivateClauseInit(
		const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope) {
		auto LastprivateFilter = [](const OMPClause *C) -> bool {
		return C->getClauseKind() == OMPC_lastprivate;
		};
		bool HasAtLeastOneLastprivate = false;
		llvm::DenseSet<const VarDecl *> AlreadyEmittedVars;
		for (OMPExecutableDirective::filtered_clause_iterator<decltype(
		LastprivateFilter)> I(D.clauses(), LastprivateFilter);
		I; ++I) {
		auto C = cast<OMPLastprivateClause>(I);
		auto IRef = C->varlist_begin();
		auto IDestRef = C->destination_exprs().begin();
		for (auto *IInit : C->private_copies()) {
		// Keep the address of the original variable for future update at the end
		// of the loop.
		auto OrigVD = cast<VarDecl>(cast<DeclRefExpr>(IRef)->getDecl());
		if (AlreadyEmittedVars.insert(OrigVD->getCanonicalDecl()).second) {
		auto DestVD = cast<VarDecl>(cast<DeclRefExpr>(IDestRef)->getDecl());
		PrivateScope.addPrivate(DestVD, [this, OrigVD, IRef]() -> llvm::Value *{
		DeclRefExpr DRE(
		const_cast<VarDecl *>(OrigVD),
		/RefersToEnclosingVariableOrCapture=/CapturedStmtInfo->lookup(
		OrigVD) != nullptr,
		rjmccallUnsubmitted Not Done Reply Inline Actions Is this DRE actually different from IDestRef? rjmccall:* Is this DRE actually different from *IDestRef?
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions Yes, it is different. IDestRef points to some pseudo-variable, but we need it to point to the address of the original variable. ABataev: Yes, it is different. IDestRef points to some pseudo-variable, but we need it to point to the…
		(IRef)->getType(), VK_LValue, (IRef)->getExprLoc());
		return EmitLValue(&DRE).getAddress();
		});
		// Check if the variable is also a firstprivate: in this case IInit is
		// not generated. Initialization of this variable will happen in codegen
		// for 'firstprivate' clause.
		rjmccallUnsubmitted Not Done Reply Inline Actions Word wrap. rjmccall: Word wrap.
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions Arghhh, automatic reformatting, thanks. ABataev: Arghhh, automatic reformatting, thanks.
		if (!IInit)
		continue;
		auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IInit)->getDecl());
		bool IsRegistered =
		PrivateScope.addPrivate(OrigVD, [&]() -> llvm::Value *{
		// Emit private VarDecl with copy init.
		EmitDecl(*VD);
		return GetAddrOfLocalVar(VD);
		});
		assert(IsRegistered && "lastprivate var already registered as private");
		HasAtLeastOneLastprivate = HasAtLeastOneLastprivate \|\| IsRegistered;
		}
		++IRef, ++IDestRef;
		}
		}
		return HasAtLeastOneLastprivate;
		}

		void CodeGenFunction::EmitOMPLastprivateClauseFinal(
		const OMPExecutableDirective &D, llvm::Value *IsLastIterCond) {
		// Emit following code:
		// if (<IsLastIterCond>) {
		// orig_var1 = private_orig_var1;
		// ...
		// orig_varn = private_orig_varn;
		// }
		auto *ThenBB = createBasicBlock(".omp.lastprivate.then");
		auto *DoneBB = createBasicBlock(".omp.lastprivate.done");
		Builder.CreateCondBr(IsLastIterCond, ThenBB, DoneBB);
		EmitBlock(ThenBB);
		{
		auto LastprivateFilter = [](const OMPClause *C) -> bool {
		return C->getClauseKind() == OMPC_lastprivate;
		};
		llvm::DenseSet<const VarDecl *> AlreadyEmittedVars;
		for (OMPExecutableDirective::filtered_clause_iterator<decltype(
		LastprivateFilter)> I(D.clauses(), LastprivateFilter);
		I; ++I) {
		auto C = cast<OMPLastprivateClause>(I);
		auto IRef = C->varlist_begin();
		auto ISrcRef = C->source_exprs().begin();
		auto IDestRef = C->destination_exprs().begin();
		for (auto *AssignOp : C->assignment_ops()) {
		auto PrivateVD = cast<VarDecl>(cast<DeclRefExpr>(IRef)->getDecl());
		if (AlreadyEmittedVars.insert(PrivateVD->getCanonicalDecl()).second) {
		auto SrcVD = cast<VarDecl>(cast<DeclRefExpr>(ISrcRef)->getDecl());
		rjmccallUnsubmitted Not Done Reply Inline Actions This is: if (AlreadyEmittedVars.insert(PrivateVD).second) { Also, in general, you should only ever use canonical declarations as hash keys. The only time that's unnecessary is when you know you're dealing with something that can't be redeclared (e.g. a non-extern local variable or a non-static data member). In principle, it would also be unnecessary whenever it's structurally impossible for different places to see different declarations. For example, in C you don't need to canonicalize here because (1) the lastprivate clauses have to be adjacent without any intervening declarations and (2) they must be written in exactly the same way, and so (3) they perform the exact same lookup and must find the exact same redeclaration. But in C++, differently-qualified names can find different redeclarations because of using declarations, so you really do need to always canonicalize. For example, this would do it: namespace A { int x; } namespace B { using A::x; } namespace A { int x = 4; } ... #pragma omp for lastprivate(A::x, B::x) Plus, who knows, somebody might add some crazy language extension which basically recreates this problem in C (I could easily imagine it coming up with modules, for example). So it's safest to just always use canonical declarations as keys. This is something you need to worry about in Sema, too; it looks like getTopDSA has the same problem, where you could theoretically apply inconsistent rules to the same entity using different redeclarations. rjmccall: This is: if (AlreadyEmittedVars.insert(PrivateVD).second) { Also, in general, you should…
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions John, thanks for pointing out to this important problem! I will fix it ASAP. ABataev: John, thanks for pointing out to this important problem! I will fix it ASAP.
		auto DestVD = cast<VarDecl>(cast<DeclRefExpr>(IDestRef)->getDecl());
		// Get the address of the original variable.
		auto *OriginalAddr = GetAddrOfLocalVar(DestVD);
		// Get the address of the private variable.
		auto *PrivateAddr = GetAddrOfLocalVar(PrivateVD);
		EmitOMPCopy(this, (IRef)->getType(), OriginalAddr, PrivateAddr,
		DestVD, SrcVD, AssignOp);
		}
		++IRef;
		++ISrcRef;
		++IDestRef;
		}
		}
		}
		EmitBlock(DoneBB, /IsFinished=/true);
		}

void CodeGenFunction::EmitOMPReductionClauseInit(		void CodeGenFunction::EmitOMPReductionClauseInit(
const OMPExecutableDirective &D,		const OMPExecutableDirective &D,
CodeGenFunction::OMPPrivateScope &PrivateScope) {		CodeGenFunction::OMPPrivateScope &PrivateScope) {
auto ReductionFilter = [](const OMPClause *C) -> bool {		auto ReductionFilter = [](const OMPClause *C) -> bool {
return C->getClauseKind() == OMPC_reduction;		return C->getClauseKind() == OMPC_reduction;
};		};
for (OMPExecutableDirective::filtered_clause_iterator<decltype(		for (OMPExecutableDirective::filtered_clause_iterator<decltype(
ReductionFilter)> I(D.clauses(), ReductionFilter);		ReductionFilter)> I(D.clauses(), ReductionFilter);
▲ Show 20 Lines • Show All 542 Lines • ▼ Show 20 Lines
/// \brief Emit a helper variable and return corresponding lvalue.		/// \brief Emit a helper variable and return corresponding lvalue.
static LValue EmitOMPHelperVar(CodeGenFunction &CGF,		static LValue EmitOMPHelperVar(CodeGenFunction &CGF,
const DeclRefExpr *Helper) {		const DeclRefExpr *Helper) {
auto VDecl = cast<VarDecl>(Helper->getDecl());		auto VDecl = cast<VarDecl>(Helper->getDecl());
CGF.EmitVarDecl(*VDecl);		CGF.EmitVarDecl(*VDecl);
return CGF.EmitLValue(Helper);		return CGF.EmitLValue(Helper);
}		}

void CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) {		bool CodeGenFunction::EmitOMPWorksharingLoop(const OMPLoopDirective &S) {
		rjmccallUnsubmitted Not Done Reply Inline Actions . rjmccall: .
// Emit the loop iteration variable.		// Emit the loop iteration variable.
auto IVExpr = cast<DeclRefExpr>(S.getIterationVariable());		auto IVExpr = cast<DeclRefExpr>(S.getIterationVariable());
auto IVDecl = cast<VarDecl>(IVExpr->getDecl());		auto IVDecl = cast<VarDecl>(IVExpr->getDecl());
EmitVarDecl(*IVDecl);		EmitVarDecl(*IVDecl);

// Emit the iterations count variable.		// Emit the iterations count variable.
// If it is not a variable, Sema decided to calculate iterations count on each		// If it is not a variable, Sema decided to calculate iterations count on each
// iteration (e.g., it is foldable into a constant).		// iteration (e.g., it is foldable into a constant).
if (auto LIExpr = dyn_cast<DeclRefExpr>(S.getLastIteration())) {		if (auto LIExpr = dyn_cast<DeclRefExpr>(S.getLastIteration())) {
EmitVarDecl(*cast<VarDecl>(LIExpr->getDecl()));		EmitVarDecl(*cast<VarDecl>(LIExpr->getDecl()));
// Emit calculation of the iterations count.		// Emit calculation of the iterations count.
EmitIgnoredExpr(S.getCalcLastIteration());		EmitIgnoredExpr(S.getCalcLastIteration());
}		}

auto &RT = CGM.getOpenMPRuntime();		auto &RT = CGM.getOpenMPRuntime();

		bool HasLastprivateClause;
// Check pre-condition.		// Check pre-condition.
{		{
// Skip the entire loop if we don't meet the precondition.		// Skip the entire loop if we don't meet the precondition.
RegionCounter Cnt = getPGORegionCounter(&S);		RegionCounter Cnt = getPGORegionCounter(&S);
auto ThenBlock = createBasicBlock("omp.precond.then");		auto ThenBlock = createBasicBlock("omp.precond.then");
auto ContBlock = createBasicBlock("omp.precond.end");		auto ContBlock = createBasicBlock("omp.precond.end");
EmitBranchOnBoolExpr(S.getPreCond(), ThenBlock, ContBlock, Cnt.getCount());		EmitBranchOnBoolExpr(S.getPreCond(), ThenBlock, ContBlock, Cnt.getCount());
EmitBlock(ThenBlock);		EmitBlock(ThenBlock);
Show All 12 Lines	// Emit 'then' code.

OMPPrivateScope LoopScope(*this);		OMPPrivateScope LoopScope(*this);
if (EmitOMPFirstprivateClause(S, LoopScope)) {		if (EmitOMPFirstprivateClause(S, LoopScope)) {
// Emit implicit barrier to synchronize threads and avoid data races on		// Emit implicit barrier to synchronize threads and avoid data races on
// initialization of firstprivate variables.		// initialization of firstprivate variables.
CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(),		CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(),
OMPD_unknown);		OMPD_unknown);
}		}
		HasLastprivateClause = EmitOMPLastprivateClauseInit(S, LoopScope);
EmitPrivateLoopCounters(*this, LoopScope, S.counters());		EmitPrivateLoopCounters(*this, LoopScope, S.counters());
(void)LoopScope.Privatize();		(void)LoopScope.Privatize();

// Detect the loop schedule kind and chunk.		// Detect the loop schedule kind and chunk.
auto ScheduleKind = OMPC_SCHEDULE_unknown;		auto ScheduleKind = OMPC_SCHEDULE_unknown;
llvm::Value *Chunk = nullptr;		llvm::Value *Chunk = nullptr;
if (auto C = cast_or_null<OMPScheduleClause>(		if (auto C = cast_or_null<OMPScheduleClause>(
S.getSingleClause(OMPC_schedule))) {		S.getSingleClause(OMPC_schedule))) {
Show All 31 Lines	// Emit 'then' code.
RT.emitForFinish(*this, S.getLocStart(), ScheduleKind);		RT.emitForFinish(*this, S.getLocStart(), ScheduleKind);
} else {		} else {
// Emit the outer loop, which requests its work chunk [LB..UB] from		// Emit the outer loop, which requests its work chunk [LB..UB] from
// runtime and runs the inner loop to process it.		// runtime and runs the inner loop to process it.
EmitOMPForOuterLoop(ScheduleKind, S, LoopScope, LB.getAddress(),		EmitOMPForOuterLoop(ScheduleKind, S, LoopScope, LB.getAddress(),
UB.getAddress(), ST.getAddress(), IL.getAddress(),		UB.getAddress(), ST.getAddress(), IL.getAddress(),
Chunk);		Chunk);
}		}
		// Emit final copy of the lastprivate variables if IsLastIter != 0.
		if (HasLastprivateClause)
		EmitOMPLastprivateClauseFinal(
		S, Builder.CreateIsNotNull(EmitLoadOfScalar(IL, S.getLocStart())));
}		}
// We're now done with the loop, so jump to the continuation block.		// We're now done with the loop, so jump to the continuation block.
EmitBranch(ContBlock);		EmitBranch(ContBlock);
EmitBlock(ContBlock, true);		EmitBlock(ContBlock, true);
}		}
		return HasLastprivateClause;
}		}

void CodeGenFunction::EmitOMPForDirective(const OMPForDirective &S) {		void CodeGenFunction::EmitOMPForDirective(const OMPForDirective &S) {
LexicalScope Scope(*this, S.getSourceRange());		LexicalScope Scope(*this, S.getSourceRange());
auto &&CodeGen =		bool HasLastprivates = false;
[&S](CodeGenFunction &CGF) { CGF.EmitOMPWorksharingLoop(S); };		auto &&CodeGen = [&S, &HasLastprivates](CodeGenFunction &CGF) {
		HasLastprivates = CGF.EmitOMPWorksharingLoop(S);
		};
CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen);		CGM.getOpenMPRuntime().emitInlinedDirective(*this, CodeGen);

// Emit an implicit barrier at the end.		// Emit an implicit barrier at the end.
if (!S.getSingleClause(OMPC_nowait)) {		if (!S.getSingleClause(OMPC_nowait) \|\| HasLastprivates) {
CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(), OMPD_for);		CGM.getOpenMPRuntime().emitBarrierCall(*this, S.getLocStart(), OMPD_for);
}		}
}		}

void CodeGenFunction::EmitOMPForSimdDirective(const OMPForSimdDirective &) {		void CodeGenFunction::EmitOMPForSimdDirective(const OMPForSimdDirective &) {
llvm_unreachable("CodeGen for 'omp for simd' is not supported yet.");		llvm_unreachable("CodeGen for 'omp for simd' is not supported yet.");
}		}

▲ Show 20 Lines • Show All 594 Lines • Show Last 20 Lines

lib/CodeGen/CodeGenFunction.h

Show First 20 Lines • Show All 2,062 Lines • ▼ Show 20 Lines	#endif
void EmitOMPAtomicSimpleUpdateExpr(		void EmitOMPAtomicSimpleUpdateExpr(
LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,		LValue X, RValue E, BinaryOperatorKind BO, bool IsXLHSInRHSPart,
llvm::AtomicOrdering AO, SourceLocation Loc,		llvm::AtomicOrdering AO, SourceLocation Loc,
const llvm::function_ref<RValue(RValue)> &CommonGen);		const llvm::function_ref<RValue(RValue)> &CommonGen);
bool EmitOMPFirstprivateClause(const OMPExecutableDirective &D,		bool EmitOMPFirstprivateClause(const OMPExecutableDirective &D,
OMPPrivateScope &PrivateScope);		OMPPrivateScope &PrivateScope);
void EmitOMPPrivateClause(const OMPExecutableDirective &D,		void EmitOMPPrivateClause(const OMPExecutableDirective &D,
OMPPrivateScope &PrivateScope);		OMPPrivateScope &PrivateScope);
		/// \brief Emit initial code for lastprivate variables. If some variable is
		/// not also firstprivate, then the default initialization is used. Otherwise
		/// initialization of this variable is performed by EmitOMPFirstprivateClause
		/// method.
		///
		/// \param D Directive that may have 'lastprivate' directives.
		/// \param PrivateScope Private scope for capturing lastprivate variables for
		/// proper codegen in internal captured statement.
		///
		/// \returns true if there is at least one lastprivate variable, false
		/// otherwise.
		bool EmitOMPLastprivateClauseInit(const OMPExecutableDirective &D,
		OMPPrivateScope &PrivateScope);
		/// \brief Emit final copying of lastprivate values to original variables at
		/// the end of the worksharing or simd directive.
		///
		/// \param D Directive that has at least one 'lastprivate' directives.
		/// \param IsLastIterCond Boolean condition that must be set to 'i1 true' if
		/// it is the last iteration of the loop code in associated directive, or to
		/// 'i1 false' otherwise.
		void EmitOMPLastprivateClauseFinal(const OMPExecutableDirective &D,
		llvm::Value *IsLastIterCond);
/// \brief Emit initial code for reduction variables. Creates reduction copies		/// \brief Emit initial code for reduction variables. Creates reduction copies
/// and initializes them with the values according to OpenMP standard.		/// and initializes them with the values according to OpenMP standard.
///		///
/// \param D Directive (possibly) with the 'reduction' clause.		/// \param D Directive (possibly) with the 'reduction' clause.
/// \param PrivateScope Private scope for capturing reduction variables for		/// \param PrivateScope Private scope for capturing reduction variables for
/// proper codegen in internal captured statement.		/// proper codegen in internal captured statement.
///		///
void EmitOMPReductionClauseInit(const OMPExecutableDirective &D,		void EmitOMPReductionClauseInit(const OMPExecutableDirective &D,
Show All 32 Lines	EmitOMPInnerLoop(const Stmt &S, bool RequiresCleanup, const Expr *LoopCond,
const llvm::function_ref<void(CodeGenFunction &)> &BodyGen);		const llvm::function_ref<void(CodeGenFunction &)> &BodyGen);

private:		private:

/// Helpers for the OpenMP loop directives.		/// Helpers for the OpenMP loop directives.
void EmitOMPLoopBody(const OMPLoopDirective &Directive,		void EmitOMPLoopBody(const OMPLoopDirective &Directive,
bool SeparateIter = false);		bool SeparateIter = false);
void EmitOMPSimdFinal(const OMPLoopDirective &S);		void EmitOMPSimdFinal(const OMPLoopDirective &S);
void EmitOMPWorksharingLoop(const OMPLoopDirective &S);		/// \brief Emit code for the worksharing loop-based directive.
		/// \return true, if this construct has any lastprivate clause, false -
		/// otherwise.
		bool EmitOMPWorksharingLoop(const OMPLoopDirective &S);
void EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind,		void EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind,
const OMPLoopDirective &S,		const OMPLoopDirective &S,
OMPPrivateScope &LoopScope, llvm::Value *LB,		OMPPrivateScope &LoopScope, llvm::Value *LB,
llvm::Value UB, llvm::Value ST, llvm::Value *IL,		llvm::Value UB, llvm::Value ST, llvm::Value *IL,
llvm::Value *Chunk);		llvm::Value *Chunk);

public:		public:

▲ Show 20 Lines • Show All 830 Lines • Show Last 20 Lines

lib/Sema/SemaOpenMP.cpp

Show First 20 Lines • Show All 567 Lines • ▼ Show 20 Lines

void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {		void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
// OpenMP [2.14.3.5, Restrictions, C/C++, p.1]		// OpenMP [2.14.3.5, Restrictions, C/C++, p.1]
// A variable of class type (or array thereof) that appears in a lastprivate		// A variable of class type (or array thereof) that appears in a lastprivate
// clause requires an accessible, unambiguous default constructor for the		// clause requires an accessible, unambiguous default constructor for the
// class type, unless the list item is also specified in a firstprivate		// class type, unless the list item is also specified in a firstprivate
// clause.		// clause.
if (auto D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {		if (auto D = dyn_cast_or_null<OMPExecutableDirective>(CurDirective)) {
for (auto C : D->clauses()) {		for (auto *C : D->clauses()) {
if (auto Clause = dyn_cast<OMPLastprivateClause>(C)) {		if (auto *Clause = dyn_cast<OMPLastprivateClause>(C)) {
for (auto VarRef : Clause->varlists()) {		SmallVector<Expr *, 8> PrivateCopies;
if (VarRef->isValueDependent() \|\| VarRef->isTypeDependent())		for (auto *DE : Clause->varlists()) {
		if (DE->isValueDependent() \|\| DE->isTypeDependent()) {
		PrivateCopies.push_back(nullptr);
continue;		continue;
auto VD = cast<VarDecl>(cast<DeclRefExpr>(VarRef)->getDecl());		}
		auto *VD = cast<VarDecl>(cast<DeclRefExpr>(DE)->getDecl());
auto DVar = DSAStack->getTopDSA(VD, false);		auto DVar = DSAStack->getTopDSA(VD, false);
if (DVar.CKind == OMPC_lastprivate) {		if (DVar.CKind == OMPC_lastprivate) {
SourceLocation ELoc = VarRef->getExprLoc();		// Generate helper private variable and initialize it with the
auto Type = VarRef->getType();		// default value. The address of the original variable is replaced
if (Type->isArrayType())		// by the address of the new private variable in CodeGen. This new
Type = QualType(Type->getArrayElementTypeNoTypeQual(), 0);		// variable is not added to IdResolver, so the code in the OpenMP
CXXRecordDecl *RD =		// region uses original variable for proper diagnostics.
getLangOpts().CPlusPlus ? Type->getAsCXXRecordDecl() : nullptr;		auto *VDPrivate = VarDecl::Create(
// FIXME This code must be replaced by actual constructing of the		Context, CurContext, DE->getLocStart(), DE->getExprLoc(),
// lastprivate variable.		VD->getIdentifier(), VD->getType(), VD->getTypeSourceInfo(),
if (RD) {		SC_Auto);
		rjmccallUnsubmitted Not Done Reply Inline Actions Word wrap. rjmccall: Word wrap.
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions Thanks, fixed ABataev: Thanks, fixed
CXXConstructorDecl *CD = LookupDefaultConstructor(RD);		ActOnUninitializedDecl(VDPrivate, /TypeMayContainAuto=/false);
PartialDiagnostic PD =		if (VDPrivate->isInvalidDecl())
PartialDiagnostic(PartialDiagnostic::NullDiagnostic());
if (!CD \|\|
CheckConstructorAccess(
ELoc, CD, InitializedEntity::InitializeTemporary(Type),
CD->getAccess(), PD) == AR_inaccessible \|\|
CD->isDeleted()) {
Diag(ELoc, diag::err_omp_required_method)
<< getOpenMPClauseName(OMPC_lastprivate) << 0;
bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
VarDecl::DeclarationOnly;
Diag(VD->getLocation(), IsDecl ? diag::note_previous_decl
: diag::note_defined_here)
<< VD;
Diag(RD->getLocation(), diag::note_previous_decl) << RD;
continue;		continue;
}		CurContext->addDecl(VDPrivate);
MarkFunctionReferenced(ELoc, CD);		PrivateCopies.push_back(DeclRefExpr::Create(
DiagnoseUseOfDecl(CD, ELoc);		Context, NestedNameSpecifierLoc(), SourceLocation(), VDPrivate,
		/RefersToEnclosingVariableOrCapture=/false, SourceLocation(),
		DE->getType(), VK_LValue));
		} else {
		// The variable is also a firstprivate, so initialization sequence
		// for private copy is generated already.
		PrivateCopies.push_back(nullptr);
}		}
}		}
		// Set initializers to private copies if no errors were found.
		if (PrivateCopies.size() == Clause->varlist_size()) {
		rjmccallUnsubmitted Not Done Reply Inline Actions Spacing. Also, s/was/were/ in the comment. rjmccall: Spacing. Also, s/was/were/ in the comment.
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions Fixed ABataev: Fixed
		Clause->setPrivateCopies(PrivateCopies);
}		}
}		}
}		}
}		}

DSAStack->pop();		DSAStack->pop();
DiscardCleanupsInEvaluationContext();		DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();		PopExpressionEvaluationContext();
▲ Show 20 Lines • Show All 4,343 Lines • ▼ Show 20 Lines	return OMPFirstprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
Vars, PrivateCopies, Inits);		Vars, PrivateCopies, Inits);
}		}

OMPClause Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr > VarList,		OMPClause Sema::ActOnOpenMPLastprivateClause(ArrayRef<Expr > VarList,
SourceLocation StartLoc,		SourceLocation StartLoc,
SourceLocation LParenLoc,		SourceLocation LParenLoc,
SourceLocation EndLoc) {		SourceLocation EndLoc) {
SmallVector<Expr *, 8> Vars;		SmallVector<Expr *, 8> Vars;
		SmallVector<Expr *, 8> SrcExprs;
		SmallVector<Expr *, 8> DstExprs;
		SmallVector<Expr *, 8> AssignmentOps;
for (auto &RefExpr : VarList) {		for (auto &RefExpr : VarList) {
assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");		assert(RefExpr && "NULL expr in OpenMP lastprivate clause.");
if (isa<DependentScopeDeclRefExpr>(RefExpr)) {		if (isa<DependentScopeDeclRefExpr>(RefExpr)) {
// It will be analyzed later.		// It will be analyzed later.
Vars.push_back(RefExpr);		Vars.push_back(RefExpr);
		SrcExprs.push_back(nullptr);
		DstExprs.push_back(nullptr);
		AssignmentOps.push_back(nullptr);
continue;		continue;
}		}

SourceLocation ELoc = RefExpr->getExprLoc();		SourceLocation ELoc = RefExpr->getExprLoc();
// OpenMP [2.1, C/C++]		// OpenMP [2.1, C/C++]
// A list item is a variable name.		// A list item is a variable name.
// OpenMP [2.14.3.5, Restrictions, p.1]		// OpenMP [2.14.3.5, Restrictions, p.1]
// A variable that is part of another variable (as an array or structure		// A variable that is part of another variable (as an array or structure
// element) cannot appear in a lastprivate clause.		// element) cannot appear in a lastprivate clause.
DeclRefExpr *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);		DeclRefExpr *DE = dyn_cast_or_null<DeclRefExpr>(RefExpr);
if (!DE \|\| !isa<VarDecl>(DE->getDecl())) {		if (!DE \|\| !isa<VarDecl>(DE->getDecl())) {
Diag(ELoc, diag::err_omp_expected_var_name) << RefExpr->getSourceRange();		Diag(ELoc, diag::err_omp_expected_var_name) << RefExpr->getSourceRange();
continue;		continue;
}		}
Decl *D = DE->getDecl();		Decl *D = DE->getDecl();
VarDecl *VD = cast<VarDecl>(D);		VarDecl *VD = cast<VarDecl>(D);

QualType Type = VD->getType();		QualType Type = VD->getType();
if (Type->isDependentType() \|\| Type->isInstantiationDependentType()) {		if (Type->isDependentType() \|\| Type->isInstantiationDependentType()) {
// It will be analyzed later.		// It will be analyzed later.
Vars.push_back(DE);		Vars.push_back(DE);
		SrcExprs.push_back(nullptr);
		DstExprs.push_back(nullptr);
		AssignmentOps.push_back(nullptr);
continue;		continue;
}		}

// OpenMP [2.14.3.5, Restrictions, C/C++, p.2]		// OpenMP [2.14.3.5, Restrictions, C/C++, p.2]
// A variable that appears in a lastprivate clause must not have an		// A variable that appears in a lastprivate clause must not have an
// incomplete type or a reference type.		// incomplete type or a reference type.
if (RequireCompleteType(ELoc, Type,		if (RequireCompleteType(ELoc, Type,
diag::err_omp_lastprivate_incomplete_type)) {		diag::err_omp_lastprivate_incomplete_type)) {
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines	for (auto &RefExpr : VarList) {
// OpenMP [2.14.3.5, Restrictions, C++, p.1,2]		// OpenMP [2.14.3.5, Restrictions, C++, p.1,2]
// A variable of class type (or array thereof) that appears in a		// A variable of class type (or array thereof) that appears in a
// lastprivate clause requires an accessible, unambiguous default		// lastprivate clause requires an accessible, unambiguous default
// constructor for the class type, unless the list item is also specified		// constructor for the class type, unless the list item is also specified
// in a firstprivate clause.		// in a firstprivate clause.
// A variable of class type (or array thereof) that appears in a		// A variable of class type (or array thereof) that appears in a
// lastprivate clause requires an accessible, unambiguous copy assignment		// lastprivate clause requires an accessible, unambiguous copy assignment
// operator for the class type.		// operator for the class type.
while (Type.getNonReferenceType()->isArrayType())		Type = Context.getBaseElementType(Type).getNonReferenceType();
Type = cast<ArrayType>(Type.getNonReferenceType().getTypePtr())		auto SrcVD = BuildVarDecl(this, DE->getLocStart(),
->getElementType();		Type.getUnqualifiedType(), ".lastprivate.src");
CXXRecordDecl *RD = getLangOpts().CPlusPlus		auto *PseudoSrcExpr = BuildDeclRefExpr(SrcVD, Type.getUnqualifiedType(),
? Type.getNonReferenceType()->getAsCXXRecordDecl()		VK_LValue, DE->getExprLoc()).get();
: nullptr;		auto *DstVD =
// FIXME This code must be replaced by actual copying and destructing of the		BuildVarDecl(*this, DE->getLocStart(), Type, ".lastprivate.dst");
// lastprivate variable.		auto *PseudoDstExpr =
if (RD) {		BuildDeclRefExpr(DstVD, Type, VK_LValue, DE->getExprLoc()).get();
CXXMethodDecl *MD = LookupCopyingAssignment(RD, 0, false, 0);		// For arrays generate assignment operation for single element and replace
DeclAccessPair FoundDecl = DeclAccessPair::make(MD, MD->getAccess());		// it by the original array element in CodeGen.
if (MD) {		auto AssignmentOp = BuildBinOp(/S=/nullptr, DE->getExprLoc(), BO_Assign,
if (CheckMemberAccess(ELoc, RD, FoundDecl) == AR_inaccessible \|\|		PseudoDstExpr, PseudoSrcExpr);
MD->isDeleted()) {		if (AssignmentOp.isInvalid())
Diag(ELoc, diag::err_omp_required_method)
<< getOpenMPClauseName(OMPC_lastprivate) << 2;
bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
VarDecl::DeclarationOnly;
Diag(VD->getLocation(),
IsDecl ? diag::note_previous_decl : diag::note_defined_here)
<< VD;
Diag(RD->getLocation(), diag::note_previous_decl) << RD;
continue;		continue;
}		AssignmentOp = ActOnFinishFullExpr(AssignmentOp.get(), DE->getExprLoc(),
MarkFunctionReferenced(ELoc, MD);		/DiscardedValue=/true);
DiagnoseUseOfDecl(MD, ELoc);		if (AssignmentOp.isInvalid())
}

CXXDestructorDecl *DD = RD->getDestructor();
if (DD) {
PartialDiagnostic PD =
PartialDiagnostic(PartialDiagnostic::NullDiagnostic());
if (CheckDestructorAccess(ELoc, DD, PD) == AR_inaccessible \|\|
DD->isDeleted()) {
Diag(ELoc, diag::err_omp_required_method)
<< getOpenMPClauseName(OMPC_lastprivate) << 4;
bool IsDecl = VD->isThisDeclarationADefinition(Context) ==
VarDecl::DeclarationOnly;
Diag(VD->getLocation(),
IsDecl ? diag::note_previous_decl : diag::note_defined_here)
<< VD;
Diag(RD->getLocation(), diag::note_previous_decl) << RD;
continue;		continue;
}
MarkFunctionReferenced(ELoc, DD);
DiagnoseUseOfDecl(DD, ELoc);
}
}

if (DVar.CKind != OMPC_firstprivate)		if (DVar.CKind != OMPC_firstprivate)
DSAStack->addDSA(VD, DE, OMPC_lastprivate);		DSAStack->addDSA(VD, DE, OMPC_lastprivate);
Vars.push_back(DE);		Vars.push_back(DE);
		SrcExprs.push_back(PseudoSrcExpr);
		DstExprs.push_back(PseudoDstExpr);
		AssignmentOps.push_back(AssignmentOp.get());
}		}

if (Vars.empty())		if (Vars.empty())
return nullptr;		return nullptr;

return OMPLastprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,		return OMPLastprivateClause::Create(Context, StartLoc, LParenLoc, EndLoc,
Vars);		Vars, SrcExprs, DstExprs, AssignmentOps);
}		}

OMPClause Sema::ActOnOpenMPSharedClause(ArrayRef<Expr > VarList,		OMPClause Sema::ActOnOpenMPSharedClause(ArrayRef<Expr > VarList,
SourceLocation StartLoc,		SourceLocation StartLoc,
SourceLocation LParenLoc,		SourceLocation LParenLoc,
SourceLocation EndLoc) {		SourceLocation EndLoc) {
SmallVector<Expr *, 8> Vars;		SmallVector<Expr *, 8> Vars;
for (auto &RefExpr : VarList) {		for (auto &RefExpr : VarList) {
▲ Show 20 Lines • Show All 999 Lines • Show Last 20 Lines

lib/Serialization/ASTReaderStmt.cpp

	Show First 20 Lines • Show All 1,883 Lines • ▼ Show 20 Lines
	void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {			void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
	C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));			C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
	unsigned NumVars = C->varlist_size();			unsigned NumVars = C->varlist_size();
	SmallVector<Expr *, 16> Vars;			SmallVector<Expr *, 16> Vars;
	Vars.reserve(NumVars);			Vars.reserve(NumVars);
	for (unsigned i = 0; i != NumVars; ++i)			for (unsigned i = 0; i != NumVars; ++i)
	Vars.push_back(Reader->Reader.ReadSubExpr());			Vars.push_back(Reader->Reader.ReadSubExpr());
	C->setVarRefs(Vars);			C->setVarRefs(Vars);
				Vars.clear();
				for (unsigned i = 0; i != NumVars; ++i)
				Vars.push_back(Reader->Reader.ReadSubExpr());
				C->setPrivateCopies(Vars);
				Vars.clear();
				for (unsigned i = 0; i != NumVars; ++i)
				Vars.push_back(Reader->Reader.ReadSubExpr());
				C->setSourceExprs(Vars);
				Vars.clear();
				for (unsigned i = 0; i != NumVars; ++i)
				Vars.push_back(Reader->Reader.ReadSubExpr());
				C->setDestinationExprs(Vars);
				Vars.clear();
				for (unsigned i = 0; i != NumVars; ++i)
				Vars.push_back(Reader->Reader.ReadSubExpr());
				C->setAssignmentOps(Vars);
	}			}

	void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {			void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
	C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));			C->setLParenLoc(Reader->ReadSourceLocation(Record, Idx));
	unsigned NumVars = C->varlist_size();			unsigned NumVars = C->varlist_size();
	SmallVector<Expr *, 16> Vars;			SmallVector<Expr *, 16> Vars;
	Vars.reserve(NumVars);			Vars.reserve(NumVars);
	for (unsigned i = 0; i != NumVars; ++i)			for (unsigned i = 0; i != NumVars; ++i)
	▲ Show 20 Lines • Show All 1,130 Lines • Show Last 20 Lines

lib/Serialization/ASTWriterStmt.cpp

Show First 20 Lines • Show All 1,792 Lines • ▼ Show 20 Lines	void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
}		}
}		}

void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) {		void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
Record.push_back(C->varlist_size());		Record.push_back(C->varlist_size());
Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);		Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
for (auto *VE : C->varlists())		for (auto *VE : C->varlists())
Writer->Writer.AddStmt(VE);		Writer->Writer.AddStmt(VE);
		for (auto *E : C->private_copies())
		Writer->Writer.AddStmt(E);
		for (auto *E : C->source_exprs())
		Writer->Writer.AddStmt(E);
		for (auto *E : C->destination_exprs())
		Writer->Writer.AddStmt(E);
		for (auto *E : C->assignment_ops())
		Writer->Writer.AddStmt(E);
}		}

void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {		void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {
Record.push_back(C->varlist_size());		Record.push_back(C->varlist_size());
Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);		Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
for (auto *VE : C->varlists())		for (auto *VE : C->varlists())
Writer->Writer.AddStmt(VE);		Writer->Writer.AddStmt(VE);
}		}
▲ Show 20 Lines • Show All 380 Lines • Show Last 20 Lines

test/OpenMP/for_lastprivate_codegen.cpp

Property	Old Value	New Value
svn:eol-style	null	native
svn:keywords	null	Author Date Id Rev URL
svn:mime-type	null	text/plain

				// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -emit-llvm %s -o - \| FileCheck %s
				// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-pch -o %t %s
				// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-unknown-unknown -std=c++11 -include-pch %t -verify %s -emit-llvm -o - \| FileCheck %s
				// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -std=c++11 -DLAMBDA -triple %itanium_abi_triple -emit-llvm %s -o - \| FileCheck -check-prefix=LAMBDA %s
				// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -fblocks -DBLOCKS -triple %itanium_abi_triple -emit-llvm %s -o - \| FileCheck -check-prefix=BLOCKS %s
				// expected-no-diagnostics
				#ifndef HEADER
				#define HEADER

				template <class T>
				struct S {
				T f;
				S(T a) : f(a) {}
				S() : f() {}
				S<T> &operator=(const S<T> &);
				operator T() { return T(); }
				~S() {}
				};

				volatile int g = 1212;

				// CHECK: [[S_FLOAT_TY:%.+]] = type { float }
				// CHECK: [[CAP_MAIN_TY:%.+]] = type { i{{[0-9]+}}, [2 x i{{[0-9]+}}], [2 x [[S_FLOAT_TY]]], [[S_FLOAT_TY]] }
				// CHECK: [[S_INT_TY:%.+]] = type { i{{[0-9]+}} }
				// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i{{[0-9]+}}, [2 x i{{[0-9]+}}], [2 x [[S_INT_TY]]], [[S_INT_TY]] }
				// CHECK: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*
				template <typename T>
				T tmain() {
				S<T> test;
				T t_var = T();
				T vec[] = {1, 2};
				S<T> s_arr[] = {1, 2};
				S<T> var(3);
				#pragma omp parallel
				#pragma omp for lastprivate(t_var, vec, s_arr, var)
				for (int i = 0; i < 2; ++i) {
				vec[i] = t_var;
				s_arr[i] = var;
				}
				return T();
				}

				int main() {
				#ifdef LAMBDA
				// LAMBDA: [[G:@.+]] = global i{{[0-9]+}} 1212,
				// LAMBDA-LABEL: @main
				// LAMBDA: call void [[OUTER_LAMBDA:@.+]](
				[&]() {
				// LAMBDA: define{{.}} internal{{.}} void [[OUTER_LAMBDA]](
				// LAMBDA: call void {{.+}}* @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}})
				#pragma omp parallel
				#pragma omp for lastprivate(g)
				for (int i = 0; i < 2; ++i) {
				// LAMBDA: define{{.}} internal{{.}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]])
				// LAMBDA: alloca i{{[0-9]+}},
				// LAMBDA: alloca i{{[0-9]+}},
				// LAMBDA: alloca i{{[0-9]+}},
				// LAMBDA: alloca i{{[0-9]+}},
				// LAMBDA: alloca i{{[0-9]+}},
				// LAMBDA: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}},
				// LAMBDA: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]],
				// LAMBDA: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
				// LAMBDA: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
				// LAMBDA: [[G_PRIVATE_ADDR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG:%.+]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// LAMBDA: store i{{[0-9]+}}* [[G_PRIVATE_ADDR]], i{{[0-9]+}}** [[G_PRIVATE_ADDR_REF]]
				// LAMBDA: call void [[INNER_LAMBDA:@.+]](%{{.+}}* [[ARG]])
				// LAMBDA: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}})
				g = 1;
				// Check for final copying of private values back to original vars.
				// LAMBDA: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
				// LAMBDA: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
				// LAMBDA: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
				// LAMBDA: [[LAST_THEN]]
				// Actual copying.

				// original g=private_g;
				// LAMBDA: [[G_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
				// LAMBDA: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G]],
				// LAMBDA: br label %[[LAST_DONE]]
				// LAMBDA: [[LAST_DONE]]
				// LAMBDA: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* %{{.+}}
				// LAMBDA: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
				// LAMBDA: call i32 @__kmpc_cancel_barrier(%{{.+}}* @{{.+}}, i{{[0-9]+}} [[GTID]])
				[&]() {
				// LAMBDA: define {{.+}} void [[INNER_LAMBDA]](%{{.+}}* [[ARG_PTR:%.+]])
				// LAMBDA: store %{{.+}}* [[ARG_PTR]], %{{.+}}** [[ARG_PTR_REF:%.+]],
				g = 2;
				// LAMBDA: [[ARG_PTR:%.+]] = load %{{.+}}, %{{.+}}* [[ARG_PTR_REF]]
				// LAMBDA: [[G_PTR_REF:%.+]] = getelementptr inbounds %{{.+}}, %{{.+}}* [[ARG_PTR]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// LAMBDA: [[G_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[G_PTR_REF]]
				// LAMBDA: store volatile i{{[0-9]+}} 2, i{{[0-9]+}}* [[G_REF]]
				}();
				}
				}();
				return 0;
				#elif defined(BLOCKS)
				// BLOCKS: [[G:@.+]] = global i{{[0-9]+}} 1212,
				// BLOCKS-LABEL: @main
				// BLOCKS: call void {{%.+}}(i8*
				^{
				// BLOCKS: define{{.}} internal{{.}} void {{.+}}(i8*
				// BLOCKS: call void {{.+}}* @__kmpc_fork_call({{.+}}, i32 1, {{.+}}* [[OMP_REGION:@.+]] to {{.+}}, i8* %{{.+}})
				#pragma omp parallel
				#pragma omp for lastprivate(g)
				for (int i = 0; i < 2; ++i) {
				// BLOCKS: define{{.}} internal{{.}} void [[OMP_REGION]](i32* %{{.+}}, i32* %{{.+}}, %{{.+}}* [[ARG:%.+]])
				// BLOCKS: alloca i{{[0-9]+}},
				// BLOCKS: alloca i{{[0-9]+}},
				// BLOCKS: alloca i{{[0-9]+}},
				// BLOCKS: alloca i{{[0-9]+}},
				// BLOCKS: alloca i{{[0-9]+}},
				// BLOCKS: [[G_PRIVATE_ADDR:%.+]] = alloca i{{[0-9]+}},
				// BLOCKS: store %{{.+}}* [[ARG]], %{{.+}}** [[ARG_REF:%.+]],
				// BLOCKS: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
				// BLOCKS: store volatile i{{[0-9]+}} 1, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
				// BLOCKS-NOT: [[G]]{{[[^:word:]]}}
				// BLOCKS: i{{[0-9]+}}* [[G_PRIVATE_ADDR]]
				// BLOCKS-NOT: [[G]]{{[[^:word:]]}}
				// BLOCKS: call void {{%.+}}(i8*
				// BLOCKS: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}})
				g = 1;
				// Check for final copying of private values back to original vars.
				// BLOCKS: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
				// BLOCKS: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
				// BLOCKS: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
				// BLOCKS: [[LAST_THEN]]
				// Actual copying.

				// original g=private_g;
				// BLOCKS: [[G_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[G_PRIVATE_ADDR]],
				// BLOCKS: store volatile i{{[0-9]+}} [[G_VAL]], i{{[0-9]+}}* [[G]],
				// BLOCKS: br label %[[LAST_DONE]]
				// BLOCKS: [[LAST_DONE]]
				// BLOCKS: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* %{{.+}}
				// BLOCKS: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
				// BLOCKS: call i32 @__kmpc_cancel_barrier(%{{.+}}* @{{.+}}, i{{[0-9]+}} [[GTID]])
				g = 1;
				^{
				// BLOCKS: define {{.+}} void {{@.+}}(i8*
				g = 2;
				// BLOCKS-NOT: [[G]]{{[[^:word:]]}}
				// BLOCKS: store volatile i{{[0-9]+}} 2, i{{[0-9]+}}*
				// BLOCKS-NOT: [[G]]{{[[^:word:]]}}
				// BLOCKS: ret
				}();
				}
				}();
				return 0;
				#else
				S<float> test;
				int t_var = 0;
				int vec[] = {1, 2};
				S<float> s_arr[] = {1, 2};
				S<float> var(3);
				#pragma omp parallel
				#pragma omp for lastprivate(t_var, vec, s_arr, var)
				for (int i = 0; i < 2; ++i) {
				vec[i] = t_var;
				s_arr[i] = var;
				}
				return tmain<int>();
				#endif
				}

				// CHECK: define i{{[0-9]+}} @main()
				// CHECK: [[TEST:%.+]] = alloca [[S_FLOAT_TY]],
				// CHECK: call {{.}} [[S_FLOAT_TY_DEF_CONSTR:@.+]]([[S_FLOAT_TY]] [[TEST]])
				// CHECK: %{{.+}} = bitcast [[CAP_MAIN_TY]]*
				// CHECK: call void (%{{.+}}, i{{[0-9]+}}, void (i{{[0-9]+}}, i{{[0-9]+}}, ...), ...)* @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}, i{{[0-9]+}}, ...)* bitcast (void (i{{[0-9]+}}, i{{[0-9]+}}, [[CAP_MAIN_TY]]) [[MAIN_MICROTASK:@.+]] to void
				// CHECK: = call {{.+}} [[TMAIN_INT:@.+]]()
				// CHECK: call void [[S_FLOAT_TY_DESTR:@.+]]([[S_FLOAT_TY]]*
				// CHECK: ret
				//
				// CHECK: define internal void [[MAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_MAIN_TY]]* %{{.+}})
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}},
				// CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}],
				// CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_FLOAT_TY]]],
				// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]],
				// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]]

				// Check for default initialization.
				// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PTR_REF]],
				// CHECK-NOT: [[T_VAR_PRIV]]
				// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1
				// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}], [2 x i{{[0-9]+}}]* [[VEC_PTR_REF:%.+]],
				// CHECK-NOT: [[VEC_PRIV]]
				// CHECK: [[S_ARR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
				// CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_REF_PTR]],
				// CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_FLOAT_TY]]*
				// CHECK: call {{.}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]] [[S_ARR_PRIV_ITEM]])
				// CHECK: [[VAR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3
				// CHECK: [[VAR_REF:%.+]] = load [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[VAR_REF_PTR]],
				// CHECK: call {{.}} [[S_FLOAT_TY_DEF_CONSTR]]([[S_FLOAT_TY]] [[VAR_PRIV]])
				// CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
				// <Skip loop body>
				// CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}})

				// Check for final copying of private values back to original vars.
				// CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
				// CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
				// CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
				// CHECK: [[LAST_THEN]]
				// Actual copying.

				// original t_var=private_t_var;
				// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]],
				// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_REF]],

				// original vec[]=private_vec[];
				// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*
				// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*
				// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],

				// original s_arr[]=private_s_arr[];
				// CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = bitcast [2 x [[S_FLOAT_TY]]]* [[S_ARR_PRIV]] to [[S_FLOAT_TY]]*
				// CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
				// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]]
				// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
				// CHECK: [[S_ARR_BODY]]
				// CHECK: call {{.}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]] {{.+}}, [[S_FLOAT_TY]]* {{.+}})
				// CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]]
				// CHECK: [[S_ARR_BODY_DONE]]

				// original var=private_var;
				// CHECK: call {{.}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]] [[VAR_REF]], [[S_FLOAT_TY]]* {{.*}} [[VAR_PRIV]])
				// CHECK: br label %[[LAST_DONE]]
				// CHECK: [[LAST_DONE]]
				// CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]* [[VAR_PRIV]])
				// CHECK-DAG: call void [[S_FLOAT_TY_DESTR]]([[S_FLOAT_TY]]*
				// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_ADDR_REF]]
				// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
				// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
				// CHECK: ret void

				// CHECK: define {{.*}} i{{[0-9]+}} [[TMAIN_INT]]()
				// CHECK: [[TEST:%.+]] = alloca [[S_INT_TY]],
				// CHECK: call {{.}} [[S_INT_TY_DEF_CONSTR:@.+]]([[S_INT_TY]] [[TEST]])
				// CHECK: call void (%{{.+}}, i{{[0-9]+}}, void (i{{[0-9]+}}, i{{[0-9]+}}, ...), ...)* @__kmpc_fork_call(%{{.+}}* @{{.+}}, i{{[0-9]+}} 1, void (i{{[0-9]+}}, i{{[0-9]+}}, ...)* bitcast (void (i{{[0-9]+}}, i{{[0-9]+}}, [[CAP_TMAIN_TY]]) [[TMAIN_MICROTASK:@.+]] to void
				// CHECK: call void [[S_INT_TY_DESTR:@.+]]([[S_INT_TY]]*
				// CHECK: ret
				//
				// CHECK: define internal void [[TMAIN_MICROTASK]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, [[CAP_TMAIN_TY]]* %{{.+}})
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: alloca i{{[0-9]+}},
				// CHECK: [[T_VAR_PRIV:%.+]] = alloca i{{[0-9]+}},
				// CHECK: [[VEC_PRIV:%.+]] = alloca [2 x i{{[0-9]+}}],
				// CHECK: [[S_ARR_PRIV:%.+]] = alloca [2 x [[S_INT_TY]]],
				// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]],
				// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_REF:%.+]]

				// Check for default initialization.
				// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PTR_REF]],
				// CHECK-NOT: [[T_VAR_PRIV]]
				// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1
				// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}], [2 x i{{[0-9]+}}]* [[VEC_PTR_REF:%.+]],
				// CHECK-NOT: [[VEC_PRIV]]
				// CHECK: [[S_ARR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 2
				// CHECK: [[S_ARR_REF:%.+]] = load [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_REF_PTR]],
				// CHECK: [[S_ARR_PRIV_ITEM:%.+]] = phi [[S_INT_TY]]*
				// CHECK: call {{.}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]] [[S_ARR_PRIV_ITEM]])
				// CHECK: [[VAR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3
				// CHECK: [[VAR_REF:%.+]] = load [[S_INT_TY]], [[S_INT_TY]]* [[VAR_REF_PTR]],
				// CHECK: call {{.}} [[S_INT_TY_DEF_CONSTR]]([[S_INT_TY]] [[VAR_PRIV]])
				// CHECK: call {{.+}} @__kmpc_for_static_init_4(%{{.+}}* @{{.+}}, i32 %{{.+}}, i32 34, i32* [[IS_LAST_ADDR:%.+]], i32* %{{.+}}, i32* %{{.+}}, i32* %{{.+}}, i32 1, i32 1)
				// <Skip loop body>
				// CHECK: call void @__kmpc_for_static_fini(%{{.+}}* @{{.+}}, i32 %{{.+}})

				// Check for final copying of private values back to original vars.
				// CHECK: [[IS_LAST_VAL:%.+]] = load i32, i32* [[IS_LAST_ADDR]],
				// CHECK: [[IS_LAST_ITER:%.+]] = icmp ne i32 [[IS_LAST_VAL]], 0
				// CHECK: br i1 [[IS_LAST_ITER:%.+]], label %[[LAST_THEN:.+]], label %[[LAST_DONE:.+]]
				// CHECK: [[LAST_THEN]]
				// Actual copying.

				// original t_var=private_t_var;
				// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PRIV]],
				// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_REF]],

				// original vec[]=private_vec[];
				// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*
				// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*
				// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],

				// original s_arr[]=private_s_arr[];
				// CHECK: [[S_ARR_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_REF]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = bitcast [2 x [[S_INT_TY]]]* [[S_ARR_PRIV]] to [[S_INT_TY]]*
				// CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
				// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]]
				// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
				// CHECK: [[S_ARR_BODY]]
				// CHECK: call {{.}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]] {{.+}}, [[S_INT_TY]]* {{.+}})
				// CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]]
				// CHECK: [[S_ARR_BODY_DONE]]

				// original var=private_var;
				// CHECK: call {{.}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]] [[VAR_REF]], [[S_INT_TY]]* {{.*}} [[VAR_PRIV]])
				// CHECK: br label %[[LAST_DONE]]
				// CHECK: [[LAST_DONE]]
				// CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]* [[VAR_PRIV]])
				// CHECK-DAG: call void [[S_INT_TY_DESTR]]([[S_INT_TY]]*
				// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_ADDR_REF]]
				// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_REF]]
				// CHECK: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
				// CHECK: ret void
				#endif

test/OpenMP/for_lastprivate_messages.cpp

Show All 9 Lines
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}		struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;		extern S1 a;
class S2 {		class S2 {
mutable int a;		mutable int a;

public:		public:
S2() : a(0) {}		S2() : a(0) {}
S2(S2 &s2) : a(s2.a) {}		S2(S2 &s2) : a(s2.a) {}
		const S2 &operator =(const S2&) const;
		S2 &operator =(const S2&);
static float S2s; // expected-note {{static data member is predetermined as shared}}		static float S2s; // expected-note {{static data member is predetermined as shared}}
static const float S2sc;		static const float S2sc;
};		};
const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}		const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}
const S2 b;		const S2 b;
const S2 ba[5];		const S2 ba[5];
class S3 { // expected-note 2 {{'S3' declared here}}		class S3 {
int a;		int a;
S3 &operator=(const S3 &s3);		S3 &operator=(const S3 &s3); // expected-note 2 {{implicitly declared private here}}

public:		public:
S3() : a(0) {}		S3() : a(0) {}
S3(S3 &s3) : a(s3.a) {}		S3(S3 &s3) : a(s3.a) {}
};		};
const S3 c; // expected-note {{global variable is predetermined as shared}}		const S3 c; // expected-note {{global variable is predetermined as shared}}
const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}		const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}
extern const int f; // expected-note {{global variable is predetermined as shared}}		extern const int f; // expected-note {{global variable is predetermined as shared}}
class S4 { // expected-note 3 {{'S4' declared here}}		class S4 {
int a;		int a;
S4();		S4(); // expected-note 3 {{implicitly declared private here}}
S4(const S4 &s4);		S4(const S4 &s4);

public:		public:
S4(int v) : a(v) {}		S4(int v) : a(v) {}
};		};
class S5 { // expected-note {{'S5' declared here}}		class S5 {
int a;		int a;
S5() : a(0) {}		S5() : a(0) {} // expected-note {{implicitly declared private here}}

public:		public:
S5(const S5 &s5) : a(s5.a) {}		S5(const S5 &s5) : a(s5.a) {}
S5(int v) : a(v) {}		S5(int v) : a(v) {}
};		};
class S6 {		class S6 {
int a;		int a;
S6() : a(0) {}		S6() : a(0) {}

public:		public:
S6(const S6 &s6) : a(s6.a) {}		S6(const S6 &s6) : a(s6.a) {}
S6(int v) : a(v) {}		S6(int v) : a(v) {}
};		};

S3 h;		S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}		#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class I, class C>		template <class I, class C>
int foomain(int argc, char **argv) {		int foomain(int argc, char **argv) {
I e(4); // expected-note {{'e' defined here}}		I e(4);
I g(5); // expected-note {{'g' defined here}}		I g(5);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp for lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
Show All 27 Lines
#pragma omp for lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}		#pragma omp for lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(argv[1]) // expected-error {{expected variable name}}		#pragma omp for lastprivate(argv[1]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp for lastprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp for'}}		#pragma omp for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp for'}}
Show All 19 Lines	#pragma omp for lastprivate(i)
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
return 0;		return 0;
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
const int d = 5; // expected-note {{constant variable is predetermined as shared}}		const int d = 5; // expected-note {{constant variable is predetermined as shared}}
const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}		const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
S4 e(4); // expected-note {{'e' defined here}}		S4 e(4);
S5 g(5); // expected-note {{'g' defined here}}		S5 g(5);
S3 m; // expected-note 2 {{'m' defined here}}		S3 m;
S6 n(2);		S6 n(2);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp for lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
#pragma omp for lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}		#pragma omp for lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp for'}}		#pragma omp for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp for'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp for lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp for lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}		#pragma omp for private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
Show All 11 Lines
#pragma omp for lastprivate(xa) // expected-error {{lastprivate variable must be shared}}		#pragma omp for lastprivate(xa) // expected-error {{lastprivate variable must be shared}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}		#pragma omp for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp for firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for lastprivate(n) firstprivate(n) // OK		#pragma omp for lastprivate(n) firstprivate(n) // OK
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}		return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}		}

test/OpenMP/for_simd_lastprivate_messages.cpp

Show All 9 Lines
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}		struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;		extern S1 a;
class S2 {		class S2 {
mutable int a;		mutable int a;

public:		public:
S2() : a(0) {}		S2() : a(0) {}
S2(S2 &s2) : a(s2.a) {}		S2(S2 &s2) : a(s2.a) {}
		S2 &operator =(const S2&);
		const S2 &operator =(const S2&) const;
static float S2s; // expected-note {{static data member is predetermined as shared}}		static float S2s; // expected-note {{static data member is predetermined as shared}}
static const float S2sc;		static const float S2sc;
};		};
const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}		const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}
const S2 b;		const S2 b;
const S2 ba[5];		const S2 ba[5];
class S3 { // expected-note 2 {{'S3' declared here}}		class S3 {
int a;		int a;
S3 &operator=(const S3 &s3);		S3 &operator=(const S3 &s3); // expected-note 2 {{implicitly declared private here}}

public:		public:
S3() : a(0) {}		S3() : a(0) {}
S3(S3 &s3) : a(s3.a) {}		S3(S3 &s3) : a(s3.a) {}
};		};
const S3 c; // expected-note {{global variable is predetermined as shared}}		const S3 c; // expected-note {{global variable is predetermined as shared}}
const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}		const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}
extern const int f; // expected-note {{global variable is predetermined as shared}}		extern const int f; // expected-note {{global variable is predetermined as shared}}
class S4 { // expected-note 3 {{'S4' declared here}}		class S4 {
int a;		int a;
S4();		S4(); // expected-note 3 {{implicitly declared private here}}
S4(const S4 &s4);		S4(const S4 &s4);

public:		public:
S4(int v) : a(v) {}		S4(int v) : a(v) {}
};		};
class S5 { // expected-note {{'S5' declared here}}		class S5 {
int a;		int a;
S5() : a(0) {}		S5() : a(0) {} // expected-note {{implicitly declared private here}}

public:		public:
S5(const S5 &s5) : a(s5.a) {}		S5(const S5 &s5) : a(s5.a) {}
S5(int v) : a(v) {}		S5(int v) : a(v) {}
};		};
class S6 {		class S6 {
int a;		int a;
S6() : a(0) {}		S6() : a(0) {}

public:		public:
S6(const S6 &s6) : a(s6.a) {}		S6(const S6 &s6) : a(s6.a) {}
S6(int v) : a(v) {}		S6(int v) : a(v) {}
};		};

S3 h;		S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}		#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class I, class C>		template <class I, class C>
int foomain(int argc, char **argv) {		int foomain(int argc, char **argv) {
I e(4); // expected-note {{'e' defined here}}		I e(4);
I g(5); // expected-note {{'g' defined here}}		I g(5);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
Show All 27 Lines
#pragma omp for simd lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}		#pragma omp for simd lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(argv[1]) // expected-error {{expected variable name}}		#pragma omp for simd lastprivate(argv[1]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp for simd lastprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd		#pragma omp for simd
Show All 19 Lines	#pragma omp for simd lastprivate(i)
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
return 0;		return 0;
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
const int d = 5; // expected-note {{constant variable is predetermined as shared}}		const int d = 5; // expected-note {{constant variable is predetermined as shared}}
const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}		const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
S4 e(4); // expected-note {{'e' defined here}}		S4 e(4);
S5 g(5); // expected-note {{'g' defined here}}		S5 g(5);
S3 m; // expected-note 2 {{'m' defined here}}		S3 m;
S6 n(2);		S6 n(2);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
#pragma omp for simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}		#pragma omp for simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd		#pragma omp for simd
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp for simd lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp for simd lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}		#pragma omp for simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
Show All 11 Lines
#pragma omp for simd lastprivate(xa) // expected-error {{lastprivate variable must be shared}}		#pragma omp for simd lastprivate(xa) // expected-error {{lastprivate variable must be shared}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}		#pragma omp for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp for simd firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel		#pragma omp parallel
#pragma omp for simd lastprivate(n) firstprivate(n) // OK		#pragma omp for simd lastprivate(n) firstprivate(n) // OK
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}		return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}		}

test/OpenMP/parallel_for_lastprivate_messages.cpp

Show All 9 Lines
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}		struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;		extern S1 a;
class S2 {		class S2 {
mutable int a;		mutable int a;

public:		public:
S2() : a(0) {}		S2() : a(0) {}
S2(S2 &s2) : a(s2.a) {}		S2(S2 &s2) : a(s2.a) {}
		S2 &operator=(const S2 &);
		const S2 &operator=(const S2 &) const;
static float S2s;		static float S2s;
static const float S2sc;		static const float S2sc;
};		};
const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}		const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}
const S2 b;		const S2 b;
const S2 ba[5];		const S2 ba[5];
class S3 { // expected-note 2 {{'S3' declared here}}		class S3 {
int a;		int a;
S3 &operator=(const S3 &s3);		S3 &operator=(const S3 &s3); // expected-note 2 {{implicitly declared private here}}

public:		public:
S3() : a(0) {}		S3() : a(0) {}
S3(S3 &s3) : a(s3.a) {}		S3(S3 &s3) : a(s3.a) {}
};		};
const S3 c; // expected-note {{global variable is predetermined as shared}}		const S3 c; // expected-note {{global variable is predetermined as shared}}
const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}		const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}
extern const int f; // expected-note {{global variable is predetermined as shared}}		extern const int f; // expected-note {{global variable is predetermined as shared}}
class S4 { // expected-note 3 {{'S4' declared here}}		class S4 {
int a;		int a;
S4();		S4(); // expected-note 3 {{implicitly declared private here}}
S4(const S4 &s4);		S4(const S4 &s4);

public:		public:
S4(int v) : a(v) {}		S4(int v) : a(v) {}
};		};
class S5 { // expected-note {{'S5' declared here}}		class S5 {
int a;		int a;
S5() : a(0) {}		S5() : a(0) {} // expected-note {{implicitly declared private here}}

public:		public:
S5(const S5 &s5) : a(s5.a) {}		S5(const S5 &s5) : a(s5.a) {}
S5(int v) : a(v) {}		S5(int v) : a(v) {}
};		};
class S6 {		class S6 {
int a;		int a;
S6() : a(0) {}		S6() : a(0) {}

public:		public:
S6(const S6 &s6) : a(s6.a) {}		S6(const S6 &s6) : a(s6.a) {}
S6(int v) : a(v) {}		S6(int v) : a(v) {}
};		};

S3 h;		S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}		#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class I, class C>		template <class I, class C>
int foomain(int argc, char **argv) {		int foomain(int argc, char **argv) {
I e(4); // expected-note {{'e' defined here}}		I e(4);
I g(5); // expected-note {{'g' defined here}}		I g(5);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel for lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp parallel for lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp parallel for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
Show All 16 Lines	#pragma omp parallel for lastprivate(S1) // expected-error {{'S1' does not refer to a value}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}		#pragma omp parallel for lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for lastprivate(argv[1]) // expected-error {{expected variable name}}		#pragma omp parallel for lastprivate(argv[1]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp parallel for lastprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp parallel for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel for'}}		#pragma omp parallel for linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel for'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
Show All 16 Lines	#pragma omp parallel for lastprivate(i)
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
return 0;		return 0;
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
const int d = 5; // expected-note {{constant variable is predetermined as shared}}		const int d = 5; // expected-note {{constant variable is predetermined as shared}}
const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}		const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
S4 e(4); // expected-note {{'e' defined here}}		S4 e(4);
S5 g(5); // expected-note {{'g' defined here}}		S5 g(5);
S3 m; // expected-note 2 {{'m' defined here}}		S3 m;
S6 n(2);		S6 n(2);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel for lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp parallel for lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp parallel for lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines	#pragma omp parallel for lastprivate(S2::S2s)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}		#pragma omp parallel for lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel for'}}		#pragma omp parallel for safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel for'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp parallel for lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp parallel for lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp parallel for lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}		#pragma omp parallel for private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate(i)		#pragma omp parallel for lastprivate(i)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel private(xa)		#pragma omp parallel private(xa)
#pragma omp parallel for lastprivate(xa)		#pragma omp parallel for lastprivate(xa)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel reduction(+ : xa)		#pragma omp parallel reduction(+ : xa)
#pragma omp parallel for lastprivate(xa)		#pragma omp parallel for lastprivate(xa)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}		#pragma omp parallel for lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp parallel for firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for lastprivate(n) firstprivate(n) // OK		#pragma omp parallel for lastprivate(n) firstprivate(n) // OK
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}		return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}		}

test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

Show All 9 Lines
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}		struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;		extern S1 a;
class S2 {		class S2 {
mutable int a;		mutable int a;

public:		public:
S2() : a(0) {}		S2() : a(0) {}
S2(S2 &s2) : a(s2.a) {}		S2(S2 &s2) : a(s2.a) {}
		const S2 &operator=(const S2 &) const;
static float S2s;		static float S2s;
static const float S2sc;		static const float S2sc;
};		};
const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}		const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}
const S2 b;		const S2 b;
const S2 ba[5];		const S2 ba[5];
class S3 { // expected-note 2 {{'S3' declared here}}		class S3 {
int a;		int a;
S3 &operator=(const S3 &s3);		S3 &operator=(const S3 &s3); // expected-note 2 {{implicitly declared private here}}

public:		public:
S3() : a(0) {}		S3() : a(0) {}
S3(S3 &s3) : a(s3.a) {}		S3(S3 &s3) : a(s3.a) {}
};		};
const S3 c; // expected-note {{global variable is predetermined as shared}}		const S3 c; // expected-note {{global variable is predetermined as shared}}
const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}		const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}
extern const int f; // expected-note {{global variable is predetermined as shared}}		extern const int f; // expected-note {{global variable is predetermined as shared}}
class S4 { // expected-note 3 {{'S4' declared here}}		class S4 {
int a;		int a;
S4();		S4(); // expected-note 3 {{implicitly declared private here}}
S4(const S4 &s4);		S4(const S4 &s4);

public:		public:
S4(int v) : a(v) {}		S4(int v) : a(v) {}
};		};
class S5 { // expected-note {{'S5' declared here}}		class S5 {
int a;		int a;
S5() : a(0) {}		S5() : a(0) {} // expected-note {{implicitly declared private here}}

public:		public:
S5(const S5 &s5) : a(s5.a) {}		S5(const S5 &s5) : a(s5.a) {}
S5(int v) : a(v) {}		S5(int v) : a(v) {}
};		};
class S6 {		class S6 {
int a;		int a;
S6() : a(0) {}		S6() : a(0) {}

public:		public:
S6(const S6 &s6) : a(s6.a) {}		S6(const S6 &s6) : a(s6.a) {}
S6(int v) : a(v) {}		S6(int v) : a(v) {}
};		};

S3 h;		S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}		#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class I, class C>		template <class I, class C>
int foomain(int argc, char **argv) {		int foomain(int argc, char **argv) {
I e(4); // expected-note {{'e' defined here}}		I e(4);
I g(5); // expected-note {{'g' defined here}}		I g(5);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp parallel for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp parallel for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
Show All 16 Lines	#pragma omp parallel for simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for simd lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}		#pragma omp parallel for simd lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for simd lastprivate(argv[1]) // expected-error {{expected variable name}}		#pragma omp parallel for simd lastprivate(argv[1]) // expected-error {{expected variable name}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp parallel for simd lastprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp parallel for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
#pragma omp parallel for simd linear(i)		#pragma omp parallel for simd linear(i)
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
Show All 16 Lines	#pragma omp parallel for simd lastprivate(i)
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
return 0;		return 0;
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
const int d = 5; // expected-note {{constant variable is predetermined as shared}}		const int d = 5; // expected-note {{constant variable is predetermined as shared}}
const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}		const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
S4 e(4); // expected-note {{'e' defined here}}		S4 e(4);
S5 g(5); // expected-note {{'g' defined here}}		S5 g(5);
S3 m; // expected-note 2 {{'m' defined here}}		S3 m;
S6 n(2);		S6 n(2);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp parallel for simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp parallel for simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines	#pragma omp parallel for simd lastprivate(S2::S2s)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}		#pragma omp parallel for simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd safelen(5)		#pragma omp parallel for simd safelen(5)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp parallel for simd lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp parallel for simd lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp parallel for simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}		#pragma omp parallel for simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate(i) // expected-note {{defined as lastprivate}}		#pragma omp parallel for simd lastprivate(i) // expected-note {{defined as lastprivate}}
for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be lastprivate, predetermined as linear}}		for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp parallel for simd' directive may not be lastprivate, predetermined as linear}}
foo();		foo();
#pragma omp parallel private(xa)		#pragma omp parallel private(xa)
#pragma omp parallel for simd lastprivate(xa)		#pragma omp parallel for simd lastprivate(xa)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel reduction(+ : xa)		#pragma omp parallel reduction(+ : xa)
#pragma omp parallel for simd lastprivate(xa)		#pragma omp parallel for simd lastprivate(xa)
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}		#pragma omp parallel for simd lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp parallel for simd firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp parallel for simd lastprivate(n) firstprivate(n) // OK		#pragma omp parallel for simd lastprivate(n) firstprivate(n) // OK
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}		return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}		}

test/OpenMP/parallel_sections_lastprivate_messages.cpp

Show All 9 Lines
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}		struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;		extern S1 a;
class S2 {		class S2 {
mutable int a;		mutable int a;

public:		public:
S2() : a(0) {}		S2() : a(0) {}
S2(S2 &s2) : a(s2.a) {}		S2(S2 &s2) : a(s2.a) {}
		const S2 &operator=(const S2 &) const;
static float S2s;		static float S2s;
static const float S2sc;		static const float S2sc;
};		};
const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}		const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}
const S2 b;		const S2 b;
const S2 ba[5];		const S2 ba[5];
class S3 { // expected-note 2 {{'S3' declared here}}		class S3 {
int a;		int a;
S3 &operator=(const S3 &s3);		S3 &operator=(const S3 &s3); // expected-note 2 {{implicitly declared private here}}

public:		public:
S3() : a(0) {}		S3() : a(0) {}
S3(S3 &s3) : a(s3.a) {}		S3(S3 &s3) : a(s3.a) {}
};		};
const S3 c; // expected-note {{global variable is predetermined as shared}}		const S3 c; // expected-note {{global variable is predetermined as shared}}
const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}		const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}
extern const int f; // expected-note {{global variable is predetermined as shared}}		extern const int f; // expected-note {{global variable is predetermined as shared}}
class S4 { // expected-note 3 {{'S4' declared here}}		class S4 {
int a;		int a;
S4();		S4(); // expected-note 3 {{implicitly declared private here}}
S4(const S4 &s4);		S4(const S4 &s4);

public:		public:
S4(int v) : a(v) {}		S4(int v) : a(v) {}
};		};
class S5 { // expected-note {{'S5' declared here}}		class S5 {
int a;		int a;
S5() : a(0) {}		S5() : a(0) {} // expected-note {{implicitly declared private here}}

public:		public:
S5(const S5 &s5) : a(s5.a) {}		S5(const S5 &s5) : a(s5.a) {}
S5(int v) : a(v) {}		S5(int v) : a(v) {}
};		};
class S6 {		class S6 {
int a;		int a;
S6() : a(0) {}		S6() : a(0) {}

public:		public:
S6(const S6 &s6) : a(s6.a) {}		S6(const S6 &s6) : a(s6.a) {}
S6(int v) : a(v) {}		S6(int v) : a(v) {}
};		};

S3 h;		S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}		#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class I, class C>		template <class I, class C>
int foomain(int argc, char **argv) {		int foomain(int argc, char **argv) {
I e(4); // expected-note {{'e' defined here}}		I e(4);
I g(5); // expected-note {{'g' defined here}}		I g(5);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp parallel sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp parallel sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
{		{
Show All 26 Lines
#pragma omp parallel sections lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}		#pragma omp parallel sections lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(argv[1]) // expected-error {{expected variable name}}		#pragma omp parallel sections lastprivate(argv[1]) // expected-error {{expected variable name}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp parallel sections lastprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp parallel sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel sections'}}		#pragma omp parallel sections linear(i) // expected-error {{unexpected OpenMP clause 'linear' in directive '#pragma omp parallel sections'}}
Show All 21 Lines	#pragma omp parallel sections lastprivate(i)
foo();		foo();
}		}
return 0;		return 0;
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
const int d = 5; // expected-note {{constant variable is predetermined as shared}}		const int d = 5; // expected-note {{constant variable is predetermined as shared}}
const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}		const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
S4 e(4); // expected-note {{'e' defined here}}		S4 e(4);
S5 g(5); // expected-note {{'g' defined here}}		S5 g(5);
S3 m; // expected-note 2 {{'m' defined here}}		S3 m;
S6 n(2);		S6 n(2);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp parallel sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp parallel sections lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
#pragma omp parallel sections lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}		#pragma omp parallel sections lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel sections'}}		#pragma omp parallel sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp parallel sections'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp parallel sections lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp parallel sections lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp parallel sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}		#pragma omp parallel sections private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
Show All 13 Lines
#pragma omp parallel sections lastprivate(xa)		#pragma omp parallel sections lastprivate(xa)
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}		#pragma omp parallel sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp parallel sections firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
{		{
foo();		foo();
}		}
#pragma omp parallel sections lastprivate(n) firstprivate(n) // OK		#pragma omp parallel sections lastprivate(n) firstprivate(n) // OK
{		{
foo();		foo();
}		}
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}		return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}		}

test/OpenMP/sections_lastprivate_messages.cpp

Show All 9 Lines
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}		struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;		extern S1 a;
class S2 {		class S2 {
mutable int a;		mutable int a;

public:		public:
S2() : a(0) {}		S2() : a(0) {}
S2(S2 &s2) : a(s2.a) {}		S2(S2 &s2) : a(s2.a) {}
		const S2 &operator=(const S2 &) const;
static float S2s; // expected-note {{static data member is predetermined as shared}}		static float S2s; // expected-note {{static data member is predetermined as shared}}
static const float S2sc;		static const float S2sc;
};		};
const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}		const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}
const S2 b;		const S2 b;
const S2 ba[5];		const S2 ba[5];
class S3 { // expected-note 2 {{'S3' declared here}}		class S3 {
int a;		int a;
S3 &operator=(const S3 &s3);		S3 &operator=(const S3 &s3); // expected-note 2 {{implicitly declared private here}}

public:		public:
S3() : a(0) {}		S3() : a(0) {}
S3(S3 &s3) : a(s3.a) {}		S3(S3 &s3) : a(s3.a) {}
};		};
const S3 c; // expected-note {{global variable is predetermined as shared}}		const S3 c; // expected-note {{global variable is predetermined as shared}}
const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}		const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}
extern const int f; // expected-note {{global variable is predetermined as shared}}		extern const int f; // expected-note {{global variable is predetermined as shared}}
class S4 { // expected-note 3 {{'S4' declared here}}		class S4 {
int a;		int a;
S4();		S4(); // expected-note 3 {{implicitly declared private here}}
S4(const S4 &s4);		S4(const S4 &s4);

public:		public:
S4(int v) : a(v) {}		S4(int v) : a(v) {}
};		};
class S5 { // expected-note {{'S5' declared here}}		class S5 {
int a;		int a;
S5() : a(0) {}		S5() : a(0) {} // expected-note {{implicitly declared private here}}

public:		public:
S5(const S5 &s5) : a(s5.a) {}		S5(const S5 &s5) : a(s5.a) {}
S5(int v) : a(v) {}		S5(int v) : a(v) {}
};		};
class S6 {		class S6 {
int a;		int a;
S6() : a(0) {}		S6() : a(0) {}

public:		public:
S6(const S6 &s6) : a(s6.a) {}		S6(const S6 &s6) : a(s6.a) {}
S6(int v) : a(v) {}		S6(int v) : a(v) {}
};		};

S3 h;		S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}		#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}

template <class I, class C>		template <class I, class C>
int foomain(int argc, char **argv) {		int foomain(int argc, char **argv) {
I e(4); // expected-note {{'e' defined here}}		I e(4);
I g(5); // expected-note {{'g' defined here}}		I g(5);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
Show All 37 Lines	#pragma omp sections lastprivate(a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(argv[1]) // expected-error {{expected variable name}}		#pragma omp sections lastprivate(argv[1]) // expected-error {{expected variable name}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp sections lastprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
{		{
foo();		foo();
}		}
Show All 24 Lines	#pragma omp sections lastprivate(i)
foo();		foo();
}		}
return 0;		return 0;
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
const int d = 5; // expected-note {{constant variable is predetermined as shared}}		const int d = 5; // expected-note {{constant variable is predetermined as shared}}
const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}		const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
S4 e(4); // expected-note {{'e' defined here}}		S4 e(4);
S5 g(5); // expected-note {{'g' defined here}}		S5 g(5);
S3 m; // expected-note 2 {{'m' defined here}}		S3 m;
S6 n(2);		S6 n(2);
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp sections lastprivate // expected-error {{expected '(' after 'lastprivate'}}
{		{
foo();		foo();
}		}
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines	#pragma omp sections lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp sections'}}		#pragma omp sections safelen(5) // expected-error {{unexpected OpenMP clause 'safelen' in directive '#pragma omp sections'}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp sections lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp sections lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp sections lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
{		{
foo();		foo();
}		}
Show All 18 Lines	#pragma omp sections lastprivate(xa) // expected-error {{lastprivate variable must be shared}}
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}		#pragma omp sections lastprivate(j) // expected-error {{arguments of OpenMP clause 'lastprivate' cannot be of reference type}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections firstprivate(m) lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp sections firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
{		{
foo();		foo();
}		}
#pragma omp parallel		#pragma omp parallel
#pragma omp sections lastprivate(n) firstprivate(n) // OK		#pragma omp sections lastprivate(n) firstprivate(n) // OK
{		{
foo();		foo();
}		}
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}		return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
}		}

test/OpenMP/simd_lastprivate_messages.cpp

Show All 9 Lines
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}		struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
extern S1 a;		extern S1 a;
class S2 {		class S2 {
mutable int a;		mutable int a;

public:		public:
S2() : a(0) {}		S2() : a(0) {}
S2(S2 &s2) : a(s2.a) {}		S2(S2 &s2) : a(s2.a) {}
		const S2 &operator=(const S2 &) const;
static float S2s; // expected-note {{static data member is predetermined as shared}}		static float S2s; // expected-note {{static data member is predetermined as shared}}
static const float S2sc;		static const float S2sc;
};		};
const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}		const float S2::S2sc = 0; // expected-note {{static data member is predetermined as shared}}
const S2 b;		const S2 b;
const S2 ba[5];		const S2 ba[5];
class S3 { // expected-note {{'S3' declared here}}		class S3 {
int a;		int a;
S3 &operator=(const S3 &s3);		S3 &operator=(const S3 &s3); // expected-note {{implicitly declared private here}}

public:		public:
S3() : a(0) {}		S3() : a(0) {}
S3(S3 &s3) : a(s3.a) {}		S3(S3 &s3) : a(s3.a) {}
};		};
const S3 c; // expected-note {{global variable is predetermined as shared}}		const S3 c; // expected-note {{global variable is predetermined as shared}}
const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}		const S3 ca[5]; // expected-note {{global variable is predetermined as shared}}
extern const int f; // expected-note {{global variable is predetermined as shared}}		extern const int f; // expected-note {{global variable is predetermined as shared}}
class S4 { // expected-note {{'S4' declared here}}		class S4 {
int a;		int a;
S4();		S4(); // expected-note {{implicitly declared private here}}
S4(const S4 &s4);		S4(const S4 &s4);

public:		public:
S4(int v) : a(v) {}		S4(int v) : a(v) {}
};		};
class S5 { // expected-note {{'S5' declared here}}		class S5 {
int a;		int a;
S5() : a(0) {}		S5() : a(0) {} // expected-note {{implicitly declared private here}}

public:		public:
S5(const S5 &s5) : a(s5.a) {}		S5(const S5 &s5) : a(s5.a) {}
S5(int v) : a(v) {}		S5(int v) : a(v) {}
};		};

S3 h;		S3 h;
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}		#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines	#pragma omp simd lastprivate(i)
for (int k = 0; k < argc; ++k)		for (int k = 0; k < argc; ++k)
++k;		++k;
return 0;		return 0;
}		}

int main(int argc, char **argv) {		int main(int argc, char **argv) {
const int d = 5; // expected-note {{constant variable is predetermined as shared}}		const int d = 5; // expected-note {{constant variable is predetermined as shared}}
const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}		const int da[5] = {0}; // expected-note {{constant variable is predetermined as shared}}
S4 e(4); // expected-note {{'e' defined here}}		S4 e(4);
S5 g(5); // expected-note {{'g' defined here}}		S5 g(5);
S3 m; // expected-note {{'m' defined here}}		S3 m;
int i;		int i;
int &j = i; // expected-note {{'j' defined here}}		int &j = i; // expected-note {{'j' defined here}}
#pragma omp simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}		#pragma omp simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}		#pragma omp simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	#pragma omp simd lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}		#pragma omp simd lastprivate(S2::S2sc) // expected-error {{shared variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp simd firstprivate(g) // expected-error {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}}		#pragma omp simd firstprivate(g) // expected-error {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp simd lastprivate(e, g) // expected-error 2 {{lastprivate variable must have an accessible, unambiguous default constructor}}		#pragma omp simd lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp simd lastprivate(m) // expected-error {{lastprivate variable must have an accessible, unambiguous copy assignment operator}}		#pragma omp simd lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}		#pragma omp simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
#pragma omp simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}		#pragma omp simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
for (i = 0; i < argc; ++i)		for (i = 0; i < argc; ++i)
foo();		foo();
Show All 13 Lines

tools/libclang/CIndex.cpp

	Show First 20 Lines • Show All 2,016 Lines • ▼ Show 20 Lines
	}			}
	void OMPClauseEnqueue::VisitOMPFirstprivateClause(			void OMPClauseEnqueue::VisitOMPFirstprivateClause(
	const OMPFirstprivateClause *C) {			const OMPFirstprivateClause *C) {
	VisitOMPClauseList(C);			VisitOMPClauseList(C);
	}			}
	void OMPClauseEnqueue::VisitOMPLastprivateClause(			void OMPClauseEnqueue::VisitOMPLastprivateClause(
	const OMPLastprivateClause *C) {			const OMPLastprivateClause *C) {
	VisitOMPClauseList(C);			VisitOMPClauseList(C);
				for (auto *E : C->private_copies()) {
				Visitor->AddStmt(E);
				}
				for (auto *E : C->source_exprs()) {
				Visitor->AddStmt(E);
				}
				for (auto *E : C->destination_exprs()) {
				Visitor->AddStmt(E);
				}
				for (auto *E : C->assignment_ops()) {
				Visitor->AddStmt(E);
				}
	}			}
	void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) {			void OMPClauseEnqueue::VisitOMPSharedClause(const OMPSharedClause *C) {
	VisitOMPClauseList(C);			VisitOMPClauseList(C);
	}			}
	void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {			void OMPClauseEnqueue::VisitOMPReductionClause(const OMPReductionClause *C) {
	VisitOMPClauseList(C);			VisitOMPClauseList(C);
	for (auto *E : C->lhs_exprs()) {			for (auto *E : C->lhs_exprs()) {
	Visitor->AddStmt(E);			Visitor->AddStmt(E);
	▲ Show 20 Lines • Show All 5,286 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[OPENMP] Codegen for 'lastprivate' clause in 'for' directive.
ClosedPublic

Details

Diff Detail

Event Timeline

Alexey Bataev

Revision Contents

Diff 23760

include/clang/AST/DataRecursiveASTVisitor.h

include/clang/AST/OpenMPClause.h

include/clang/AST/RecursiveASTVisitor.h

lib/AST/Stmt.cpp

lib/AST/StmtProfile.cpp

lib/CodeGen/CGStmtOpenMP.cpp

lib/CodeGen/CodeGenFunction.h

lib/Sema/SemaOpenMP.cpp

lib/Serialization/ASTReaderStmt.cpp

lib/Serialization/ASTWriterStmt.cpp

test/OpenMP/for_lastprivate_codegen.cpp

test/OpenMP/for_lastprivate_messages.cpp

test/OpenMP/for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_for_lastprivate_messages.cpp

test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_sections_lastprivate_messages.cpp

test/OpenMP/sections_lastprivate_messages.cpp

test/OpenMP/simd_lastprivate_messages.cpp

tools/libclang/CIndex.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[OPENMP] Codegen for 'lastprivate' clause in 'for' directive.ClosedPublic

Details

Diff Detail

Event Timeline

Alexey Bataev

Revision Contents

Diff 23760

include/clang/AST/DataRecursiveASTVisitor.h

include/clang/AST/OpenMPClause.h

include/clang/AST/RecursiveASTVisitor.h

lib/AST/Stmt.cpp

lib/AST/StmtProfile.cpp

lib/CodeGen/CGStmtOpenMP.cpp

lib/CodeGen/CodeGenFunction.h

lib/Sema/SemaOpenMP.cpp

lib/Serialization/ASTReaderStmt.cpp

lib/Serialization/ASTWriterStmt.cpp

test/OpenMP/for_lastprivate_codegen.cpp

test/OpenMP/for_lastprivate_messages.cpp

test/OpenMP/for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_for_lastprivate_messages.cpp

test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_sections_lastprivate_messages.cpp

test/OpenMP/sections_lastprivate_messages.cpp

test/OpenMP/simd_lastprivate_messages.cpp

tools/libclang/CIndex.cpp

[OPENMP] Codegen for 'lastprivate' clause in 'for' directive.
ClosedPublic