Diff 23823

cfe/trunk/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

cfe/trunk/include/clang/AST/OpenMPClause.h

	Show First 20 Lines • Show All 1,131 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> {
				// 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());
				}

				/// \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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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,
		(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.
		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());
		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) {
// 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

cfe/trunk/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

cfe/trunk/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);
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()) {
		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

cfe/trunk/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

cfe/trunk/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

cfe/trunk/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-apple-darwin10 -emit-llvm %s -o - \| FileCheck %s
				// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -triple x86_64-apple-darwin10 -emit-pch -o %t %s
				// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -triple x86_64-apple-darwin10 -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 x86_64-apple-darwin10 -emit-llvm %s -o - \| FileCheck -check-prefix=LAMBDA %s
				// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -x c++ -fblocks -DBLOCKS -triple x86_64-apple-darwin10 -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 { i32 }
				// CHECK: [[CAP_TMAIN_TY:%.+]] = type { i{{[0-9]+}}, [2 x i{{[0-9]+}}], [2 x [[S_INT_TY]]], [[S_INT_TY]] }
				// CHECK-DAG: [[IMPLICIT_BARRIER_LOC:@.+]] = private unnamed_addr constant %{{.+}} { i32 0, i32 66, i32 0, i32 0, i8*
				// CHECK-DAG: [[X:@.+]] = global double 0.0
				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();
				}

				namespace A {
				double x;
				}
				namespace B {
				using A::x;
				}

				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;
				}
				#pragma omp parallel
				#pragma omp for lastprivate(A::x, B::x)
				for (int i = 0; i < 2; ++i) {
				A::x++;
				}
				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 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]+}}, %{{.+}}) [[MAIN_MICROTASK1:@.+]] 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 internal void [[MAIN_MICROTASK1]](i{{[0-9]+}}* [[GTID_ADDR:%.+]], i{{[0-9]+}}* %{{.+}}, %{{.+}}* %{{.+}})
				// CHECK: [[X_PRIV:%.+]] = alloca double,
				// CHECK-NOT: alloca double

				// Check for default initialization.
				// CHECK-NOT: [[X_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 x=private_x;
				// CHECK: [[X_VAL:%.+]] = load double, double* [[X_PRIV]],
				// CHECK: store double [[X_VAL]], double* [[X]],
				// CHECK-NEXT: br label %[[LAST_DONE]]
				// CHECK: [[LAST_DONE]]

				// 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

cfe/trunk/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}}
}		}

cfe/trunk/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}}
}		}

cfe/trunk/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}}
}		}

cfe/trunk/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}}
}		}

cfe/trunk/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}}
}		}

cfe/trunk/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}}
}		}

cfe/trunk/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

cfe/trunk/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 23823

cfe/trunk/include/clang/AST/DataRecursiveASTVisitor.h

cfe/trunk/include/clang/AST/OpenMPClause.h

cfe/trunk/include/clang/AST/RecursiveASTVisitor.h

cfe/trunk/lib/AST/Stmt.cpp

cfe/trunk/lib/AST/StmtProfile.cpp

cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp

cfe/trunk/lib/CodeGen/CodeGenFunction.h

cfe/trunk/lib/Sema/SemaOpenMP.cpp

cfe/trunk/lib/Serialization/ASTReaderStmt.cpp

cfe/trunk/lib/Serialization/ASTWriterStmt.cpp

cfe/trunk/test/OpenMP/for_lastprivate_codegen.cpp

cfe/trunk/test/OpenMP/for_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/for_simd_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/parallel_for_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/parallel_sections_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/sections_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/simd_lastprivate_messages.cpp

cfe/trunk/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 23823

cfe/trunk/include/clang/AST/DataRecursiveASTVisitor.h

cfe/trunk/include/clang/AST/OpenMPClause.h

cfe/trunk/include/clang/AST/RecursiveASTVisitor.h

cfe/trunk/lib/AST/Stmt.cpp

cfe/trunk/lib/AST/StmtProfile.cpp

cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp

cfe/trunk/lib/CodeGen/CodeGenFunction.h

cfe/trunk/lib/Sema/SemaOpenMP.cpp

cfe/trunk/lib/Serialization/ASTReaderStmt.cpp

cfe/trunk/lib/Serialization/ASTWriterStmt.cpp

cfe/trunk/test/OpenMP/for_lastprivate_codegen.cpp

cfe/trunk/test/OpenMP/for_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/for_simd_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/parallel_for_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/parallel_sections_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/sections_lastprivate_messages.cpp

cfe/trunk/test/OpenMP/simd_lastprivate_messages.cpp

cfe/trunk/tools/libclang/CIndex.cpp

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