Diff 23588

include/clang/AST/DataRecursiveASTVisitor.h

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

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

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

include/clang/AST/OpenMPClause.h

	Show First 20 Lines • Show All 1,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'.
	///			///
				rjmccallUnsubmitted Not Done Reply Inline Actions This isn't external documentation, it's implementation documentation, so it should be written with instead of / and it should go inside the class definition. But otherwise, thank you for writing it. :) rjmccall: This isn't external documentation, it's implementation documentation, so it should be written…
				ABataevAuthorUnsubmitted Not Done Reply Inline Actions Ok, Done. ABataev: Ok, Done.
	class OMPLastprivateClause : public OMPVarListClause<OMPLastprivateClause> {			class OMPLastprivateClause : public OMPVarListClause<OMPLastprivateClause> {
				friend class OMPClauseReader;
	/// \brief Build clause with number of variables \a N.			/// \brief Build clause with number of variables \a N.
	///			///
	/// \param StartLoc Starting location of the clause.			/// \param StartLoc Starting location of the clause.
	/// \param LParenLoc Location of '('.			/// \param LParenLoc Location of '('.
	/// \param EndLoc Ending location of the clause.			/// \param EndLoc Ending location of the clause.
	/// \param N Number of the variables in the clause.			/// \param N Number of the variables in the clause.
	///			///
	OMPLastprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,			OMPLastprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
	SourceLocation EndLoc, unsigned N)			SourceLocation EndLoc, unsigned N)
	: OMPVarListClause<OMPLastprivateClause>(OMPC_lastprivate, StartLoc,			: OMPVarListClause<OMPLastprivateClause>(OMPC_lastprivate, StartLoc,
	LParenLoc, EndLoc, N) {}			LParenLoc, EndLoc, N) {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

include/clang/AST/RecursiveASTVisitor.h

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

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

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

lib/AST/Stmt.cpp

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

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

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

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

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

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

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

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

lib/AST/StmtProfile.cpp

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

lib/CodeGen/CGStmtOpenMP.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines	CodeGen(/ThenBlock/ false);
// There is no need to emit line number for unconditional branch.		// There is no need to emit line number for unconditional branch.
auto NL = ApplyDebugLocation::CreateEmpty(CGF);		auto NL = ApplyDebugLocation::CreateEmpty(CGF);
CGF.EmitBranch(ContBlock);		CGF.EmitBranch(ContBlock);
}		}
// Emit the continuation block for code after the if.		// Emit the continuation block for code after the if.
CGF.EmitBlock(ContBlock, /IsFinished/ true);		CGF.EmitBlock(ContBlock, /IsFinished/ true);
}		}

void CodeGenFunction::EmitOMPAggregateAssign(LValue OriginalAddr,		void CodeGenFunction::EmitOMPAggregateAssign(
llvm::Value *PrivateAddr,		llvm::Value DestAddr, llvm::Value SrcAddr, QualType OriginalType,
const Expr *AssignExpr,		const llvm::function_ref<void(llvm::Value , llvm::Value )> &CopyGen) {
QualType OriginalType,
const VarDecl *VDInit) {
EmitBlock(createBasicBlock(".omp.assign.begin."));
if (!isa<CXXConstructExpr>(AssignExpr) \|\| isTrivialInitializer(AssignExpr)) {
// Perform simple memcpy.
EmitAggregateAssign(PrivateAddr, OriginalAddr.getAddress(),
AssignExpr->getType());
} else {
// Perform element-by-element initialization.		// Perform element-by-element initialization.
QualType ElementTy;		QualType ElementTy;
auto SrcBegin = OriginalAddr.getAddress();		auto SrcBegin = SrcAddr;
auto DestBegin = PrivateAddr;		auto DestBegin = DestAddr;
auto ArrayTy = OriginalType->getAsArrayTypeUnsafe();		auto ArrayTy = OriginalType->getAsArrayTypeUnsafe();
auto SrcNumElements = emitArrayLength(ArrayTy, ElementTy, SrcBegin);		auto SrcNumElements = emitArrayLength(ArrayTy, ElementTy, SrcBegin);
auto DestNumElements = emitArrayLength(ArrayTy, ElementTy, DestBegin);		auto DestNumElements = emitArrayLength(ArrayTy, ElementTy, DestBegin);
auto SrcEnd = Builder.CreateGEP(SrcBegin, SrcNumElements);		auto *NumElements = Builder.CreateSelect(
auto DestEnd = Builder.CreateGEP(DestBegin, DestNumElements);		Builder.CreateICmpULT(SrcNumElements, DestNumElements), SrcNumElements,
		DestNumElements);
		auto DestEnd = Builder.CreateGEP(DestBegin, NumElements);
// The basic structure here is a do-while loop, because we don't		// The basic structure here is a do-while loop, because we don't
// need to check for the zero-element case.		// need to check for the zero-element case.
auto BodyBB = createBasicBlock("omp.arraycpy.body");		auto BodyBB = createBasicBlock("omp.arraycpy.body");
auto DoneBB = createBasicBlock("omp.arraycpy.done");		auto DoneBB = createBasicBlock("omp.arraycpy.done");
auto IsEmpty =		auto IsEmpty =
Builder.CreateICmpEQ(DestBegin, DestEnd, "omp.arraycpy.isempty");		Builder.CreateICmpEQ(DestBegin, DestEnd, "omp.arraycpy.isempty");
Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);		Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);

// Enter the loop body, making that address the current address.		// Enter the loop body, making that address the current address.
auto EntryBB = Builder.GetInsertBlock();		auto EntryBB = Builder.GetInsertBlock();
EmitBlock(BodyBB);		EmitBlock(BodyBB);
auto SrcElementPast = Builder.CreatePHI(SrcBegin->getType(), 2,		auto SrcElementCurrent =
"omp.arraycpy.srcElementPast");		Builder.CreatePHI(SrcBegin->getType(), 2, "omp.arraycpy.srcElementPast");
SrcElementPast->addIncoming(SrcEnd, EntryBB);		SrcElementCurrent->addIncoming(SrcBegin, EntryBB);
auto DestElementPast = Builder.CreatePHI(DestBegin->getType(), 2,		auto DestElementCurrent = Builder.CreatePHI(DestBegin->getType(), 2,
"omp.arraycpy.destElementPast");		"omp.arraycpy.destElementPast");
DestElementPast->addIncoming(DestEnd, EntryBB);		DestElementCurrent->addIncoming(DestBegin, EntryBB);

// Shift the address back by one element.		// Shift the address back by one element.
auto NegativeOne = llvm::ConstantInt::get(SizeTy, -1, true);		auto DestElement = Builder.CreateConstGEP1_32(DestElementCurrent, /Idx0=/1,
auto DestElement = Builder.CreateGEP(DestElementPast, NegativeOne,
"omp.arraycpy.dest.element");		"omp.arraycpy.dest.element");
auto SrcElement = Builder.CreateGEP(SrcElementPast, NegativeOne,		auto SrcElement = Builder.CreateConstGEP1_32(SrcElementCurrent, /Idx0=/1,
"omp.arraycpy.src.element");		"omp.arraycpy.src.element");
{		// Emit copy.
// Create RunCleanScope to cleanup possible temps.		CopyGen(DestElement, SrcElement);
CodeGenFunction::RunCleanupsScope Init(*this);
// Emit initialization for single element.
LocalDeclMap[VDInit] = SrcElement;
EmitAnyExprToMem(AssignExpr, DestElement,
AssignExpr->getType().getQualifiers(),
/IsInitializer/ false);
LocalDeclMap.erase(VDInit);
}

// Check whether we've reached the end.		// Check whether we've reached the end.
auto Done =		auto Done = Builder.CreateICmpEQ(DestElement, DestEnd, "omp.arraycpy.done");
Builder.CreateICmpEQ(DestElement, DestBegin, "omp.arraycpy.done");
Builder.CreateCondBr(Done, DoneBB, BodyBB);		Builder.CreateCondBr(Done, DoneBB, BodyBB);
DestElementPast->addIncoming(DestElement, Builder.GetInsertBlock());		DestElementCurrent->addIncoming(DestElement, Builder.GetInsertBlock());
SrcElementPast->addIncoming(SrcElement, Builder.GetInsertBlock());		SrcElementCurrent->addIncoming(SrcElement, Builder.GetInsertBlock());

// Done.		// Done.
EmitBlock(DoneBB, true);		EmitBlock(DoneBB, true);
}		}
EmitBlock(createBasicBlock(".omp.assign.end."));
		void CodeGenFunction::EmitOMPCopy(CodeGenFunction &CGF,
		QualType OriginalType, llvm::Value *DestAddr,
		llvm::Value SrcAddr, const VarDecl DestVD,
		const VarDecl SrcVD, const Expr Copy) {
		if (OriginalType->isArrayType()) {
		auto *BO = dyn_cast<BinaryOperator>(Copy);
		if (BO && BO->getOpcode() == BO_Assign) {
		// Perform simple memcpy for simple copying.
		CGF.EmitAggregateAssign(DestAddr, SrcAddr, OriginalType);
		} else {
		// For arrays with complex element types perform element by element
		// copying.
		CGF.EmitOMPAggregateAssign(
		DestAddr, SrcAddr, OriginalType,
		[&CGF, Copy, SrcVD, DestVD](llvm::Value *DestElement,
		llvm::Value *SrcElement) {
		// Working with the single array element, so have to remap
		// destination and source variables to corresponding array
		// elements.
		CodeGenFunction::OMPPrivateScope Remap(CGF);
		Remap.addPrivate(DestVD, [DestElement]() -> llvm::Value *{
		return DestElement;
		});
		Remap.addPrivate(
		SrcVD, [SrcElement]() -> llvm::Value *{ return SrcElement; });
		(void)Remap.Privatize();
		CGF.EmitIgnoredExpr(Copy);
		});
		}
		} else {
		// Remap pseudo source variable to private copy.
		CodeGenFunction::OMPPrivateScope Remap(CGF);
		Remap.addPrivate(SrcVD, [SrcAddr]() -> llvm::Value *{ return SrcAddr; });
		Remap.addPrivate(DestVD, [DestAddr]() -> llvm::Value *{ return DestAddr; });
		(void)Remap.Privatize();
		// Emit copying of the whole variable.
		CGF.EmitIgnoredExpr(Copy);
		}
}		}

void CodeGenFunction::EmitOMPFirstprivateClause(		void CodeGenFunction::EmitOMPFirstprivateClause(
const OMPExecutableDirective &D,		const OMPExecutableDirective &D,
CodeGenFunction::OMPPrivateScope &PrivateScope) {		CodeGenFunction::OMPPrivateScope &PrivateScope) {
auto PrivateFilter = [](const OMPClause *C) -> bool {		auto PrivateFilter = [](const OMPClause *C) -> bool {
return C->getClauseKind() == OMPC_firstprivate;		return C->getClauseKind() == OMPC_firstprivate;
};		};
for (OMPExecutableDirective::filtered_clause_iterator<decltype(PrivateFilter)>		for (OMPExecutableDirective::filtered_clause_iterator<decltype(PrivateFilter)>
I(D.clauses(), PrivateFilter); I; ++I) {		I(D.clauses(), PrivateFilter); I; ++I) {
auto C = cast<OMPFirstprivateClause>(I);		auto C = cast<OMPFirstprivateClause>(I);
auto IRef = C->varlist_begin();		auto IRef = C->varlist_begin();
auto InitsRef = C->inits().begin();		auto InitsRef = C->inits().begin();
for (auto IInit : C->private_copies()) {		for (auto IInit : C->private_copies()) {
auto OrigVD = cast<VarDecl>(cast<DeclRefExpr>(IRef)->getDecl());		auto OrigVD = cast<VarDecl>(cast<DeclRefExpr>(IRef)->getDecl());
auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IInit)->getDecl());		auto *VD = cast<VarDecl>(cast<DeclRefExpr>(IInit)->getDecl());
bool IsRegistered;		bool IsRegistered;
if (*InitsRef != nullptr) {		if (*InitsRef != nullptr) {
// Emit VarDecl with copy init for arrays.		// Emit VarDecl with copy init for arrays.
auto *FD = CapturedStmtInfo->lookup(OrigVD);		auto *FD = CapturedStmtInfo->lookup(OrigVD);
LValue Base = MakeNaturalAlignAddrLValue(		LValue Base = MakeNaturalAlignAddrLValue(
CapturedStmtInfo->getContextValue(),		CapturedStmtInfo->getContextValue(),
getContext().getTagDeclType(FD->getParent()));		getContext().getTagDeclType(FD->getParent()));
auto OriginalAddr = EmitLValueForField(Base, FD);		auto *OriginalAddr = EmitLValueForField(Base, FD).getAddress();
auto VDInit = cast<VarDecl>(cast<DeclRefExpr>(*InitsRef)->getDecl());		auto VDInit = cast<VarDecl>(cast<DeclRefExpr>(*InitsRef)->getDecl());
IsRegistered = PrivateScope.addPrivate(OrigVD, [&]() -> llvm::Value * {		IsRegistered = PrivateScope.addPrivate(OrigVD, [&]() -> llvm::Value *{
auto Emission = EmitAutoVarAlloca(*VD);		auto Emission = EmitAutoVarAlloca(*VD);
// Emit initialization of aggregate firstprivate vars.		// Emit initialization of aggregate firstprivate vars.
EmitOMPAggregateAssign(OriginalAddr, Emission.getAllocatedAddress(),		auto *Init = VD->getInit();
VD->getInit(), (*IRef)->getType(), VDInit);		if (!isa<CXXConstructExpr>(Init) \|\| isTrivialInitializer(Init)) {
		// Perform simple memcpy.
		EmitAggregateAssign(Emission.getAllocatedAddress(), OriginalAddr,
		(*IRef)->getType());
		} else {
		EmitOMPAggregateAssign(
		Emission.getAllocatedAddress(), OriginalAddr,
		(*IRef)->getType(),
		[this, VDInit, Init](llvm::Value *DestElement,
		llvm::Value *SrcElement) {
		// Clean up any temporaries needed by the initialization.
		RunCleanupsScope InitScope(*this);
		// Emit initialization for single element.
		LocalDeclMap[VDInit] = SrcElement;
		EmitAnyExprToMem(Init, DestElement,
		Init->getType().getQualifiers(),
		/IsInitializer/ false);
		LocalDeclMap.erase(VDInit);
		});
		}
EmitAutoVarCleanups(Emission);		EmitAutoVarCleanups(Emission);
return Emission.getAllocatedAddress();		return Emission.getAllocatedAddress();
});		});
} else		} else
IsRegistered = PrivateScope.addPrivate(OrigVD, [&]() -> llvm::Value * {		IsRegistered = PrivateScope.addPrivate(OrigVD, [&]() -> llvm::Value *{
// Emit private VarDecl with copy init.		// Emit private VarDecl with copy init.
EmitDecl(*VD);		EmitDecl(*VD);
return GetAddrOfLocalVar(VD);		return GetAddrOfLocalVar(VD);
});		});
assert(IsRegistered && "firstprivate var already registered as private");		assert(IsRegistered && "firstprivate var already registered as private");
// Silence the warning about unused variable.		// Silence the warning about unused variable.
(void)IsRegistered;		(void)IsRegistered;
++IRef, ++InitsRef;		++IRef, ++InitsRef;
Show All 23 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;
		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());
		auto DestVD = cast<VarDecl>(cast<DeclRefExpr>(IDestRef)->getDecl());
		PrivateScope.addPrivate(DestVD, [this, OrigVD, IRef]() -> llvm::Value *{
		DeclRefExpr DRE(const_cast<VarDecl *>(OrigVD),
		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
		rjmccallUnsubmitted Not Done Reply Inline Actions Is this DRE actually different from IDestRef? rjmccall:* Is this DRE actually different from *IDestRef?
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions Yes, it is different. IDestRef points to some pseudo-variable, but we need it to point to the address of the original variable. ABataev: Yes, it is different. IDestRef points to some pseudo-variable, but we need it to point to the…
		// 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 =
		rjmccallUnsubmitted Not Done Reply Inline Actions Word wrap. rjmccall: Word wrap.
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions Arghhh, automatic reformatting, thanks. ABataev: Arghhh, automatic reformatting, thanks.
		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;
		};
		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());
		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);
		rjmccallUnsubmitted Not Done Reply Inline Actions This is: if (AlreadyEmittedVars.insert(PrivateVD).second) { Also, in general, you should only ever use canonical declarations as hash keys. The only time that's unnecessary is when you know you're dealing with something that can't be redeclared (e.g. a non-extern local variable or a non-static data member). In principle, it would also be unnecessary whenever it's structurally impossible for different places to see different declarations. For example, in C you don't need to canonicalize here because (1) the lastprivate clauses have to be adjacent without any intervening declarations and (2) they must be written in exactly the same way, and so (3) they perform the exact same lookup and must find the exact same redeclaration. But in C++, differently-qualified names can find different redeclarations because of using declarations, so you really do need to always canonicalize. For example, this would do it: namespace A { int x; } namespace B { using A::x; } namespace A { int x = 4; } ... #pragma omp for lastprivate(A::x, B::x) Plus, who knows, somebody might add some crazy language extension which basically recreates this problem in C (I could easily imagine it coming up with modules, for example). So it's safest to just always use canonical declarations as keys. This is something you need to worry about in Sema, too; it looks like getTopDSA has the same problem, where you could theoretically apply inconsistent rules to the same entity using different redeclarations. rjmccall: This is: if (AlreadyEmittedVars.insert(PrivateVD).second) { Also, in general, you should…
		ABataevAuthorUnsubmitted Not Done Reply Inline Actions John, thanks for pointing out to this important problem! I will fix it ASAP. ABataev: John, thanks for pointing out to this important problem! I will fix it ASAP.
		++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 540 Lines • ▼ Show 20 Lines
/// \brief Emit a helper variable and return corresponding lvalue.		/// \brief Emit a helper variable and return corresponding lvalue.
static LValue EmitOMPHelperVar(CodeGenFunction &CGF,		static LValue EmitOMPHelperVar(CodeGenFunction &CGF,
const DeclRefExpr *Helper) {		const DeclRefExpr *Helper) {
auto VDecl = cast<VarDecl>(Helper->getDecl());		auto VDecl = cast<VarDecl>(Helper->getDecl());
CGF.EmitVarDecl(*VDecl);		CGF.EmitVarDecl(*VDecl);
return CGF.EmitLValue(Helper);		return CGF.EmitLValue(Helper);
}		}

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

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

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

		bool HasLastprivateClause;
// Check pre-condition.		// Check pre-condition.
{		{
// Skip the entire loop if we don't meet the precondition.		// Skip the entire loop if we don't meet the precondition.
RegionCounter Cnt = getPGORegionCounter(&S);		RegionCounter Cnt = getPGORegionCounter(&S);
auto ThenBlock = createBasicBlock("omp.precond.then");		auto ThenBlock = createBasicBlock("omp.precond.then");
auto ContBlock = createBasicBlock("omp.precond.end");		auto ContBlock = createBasicBlock("omp.precond.end");
EmitBranchOnBoolExpr(S.getPreCond(), ThenBlock, ContBlock, Cnt.getCount());		EmitBranchOnBoolExpr(S.getPreCond(), ThenBlock, ContBlock, Cnt.getCount());
EmitBlock(ThenBlock);		EmitBlock(ThenBlock);
Cnt.beginRegion(Builder);		Cnt.beginRegion(Builder);
// Emit 'then' code.		// Emit 'then' code.
{		{
// Emit helper vars inits.		// Emit helper vars inits.
LValue LB =		LValue LB =
EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getLowerBoundVariable()));		EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getLowerBoundVariable()));
LValue UB =		LValue UB =
EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getUpperBoundVariable()));		EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getUpperBoundVariable()));
LValue ST =		LValue ST =
EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getStrideVariable()));		EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getStrideVariable()));
LValue IL =		LValue IL =
EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getIsLastIterVariable()));		EmitOMPHelperVar(*this, cast<DeclRefExpr>(S.getIsLastIterVariable()));

OMPPrivateScope LoopScope(*this);		OMPPrivateScope LoopScope(*this);
		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 573 Lines • Show Last 20 Lines

lib/CodeGen/CodeGenFunction.h

Show First 20 Lines • Show All 2,023 Lines • ▼ Show 20 Lines	void EmitCXXForRangeStmt(const CXXForRangeStmt &S,
ArrayRef<const Attr *> Attrs = None);		ArrayRef<const Attr *> Attrs = None);

LValue InitCapturedStruct(const CapturedStmt &S);		LValue InitCapturedStruct(const CapturedStmt &S);
llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);		llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);
void GenerateCapturedStmtFunctionProlog(const CapturedStmt &S);		void GenerateCapturedStmtFunctionProlog(const CapturedStmt &S);
llvm::Function *GenerateCapturedStmtFunctionEpilog(const CapturedStmt &S);		llvm::Function *GenerateCapturedStmtFunctionEpilog(const CapturedStmt &S);
llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S);		llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S);
llvm::Value *GenerateCapturedStmtArgument(const CapturedStmt &S);		llvm::Value *GenerateCapturedStmtArgument(const CapturedStmt &S);
void EmitOMPAggregateAssign(LValue OriginalAddr, llvm::Value *PrivateAddr,		/// \brief Perform element by element copying of arrays with type \a
const Expr *AssignExpr, QualType Type,		/// OriginalType from \a SrcAddr to \a DestAddr using copying procedure
const VarDecl *VDInit);		/// generated by \a CopyGen.
		///
		/// \param DestAddr Address of the destination array.
		/// \param SrcAddr Address of the source array.
		/// \param OriginalType Type of destination and source arrays.
		/// \param CopyGen Copying procedure that copies value of single array element
		/// to another single array element.
		void EmitOMPAggregateAssign(
		llvm::Value DestAddr, llvm::Value SrcAddr, QualType OriginalType,
		const llvm::function_ref<void(llvm::Value , llvm::Value )> &CopyGen);
		/// \brief Emit proper copying of data from one variable to another.
		///
		/// \param OriginalType Original type of the copied variables.
		/// \param DestAddr Destination address.
		/// \param SrcAddr Source address.
		/// \param DestVD Destination variable used in \a CopyExpr (for arrays, has
		/// type of the base array element).
		/// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of
		/// the base array element).
		/// \param Copy Actual copygin expression for copying data from \a SrcVD to \a
		/// DestVD.
		void EmitOMPCopy(CodeGenFunction &CGF, QualType OriginalType,
		llvm::Value DestAddr, llvm::Value SrcAddr,
		const VarDecl DestVD, const VarDecl SrcVD,
		const Expr *Copy);
/// \brief Emit atomic update code for constructs: \a X = \a X \a BO \a E or		/// \brief Emit atomic update code for constructs: \a X = \a X \a BO \a E or
/// \a X = \a E \a BO \a E.		/// \a X = \a E \a BO \a E.
///		///
/// \param X Value to be updated.		/// \param X Value to be updated.
/// \param E Update value.		/// \param E Update value.
/// \param BO Binary operation for update operation.		/// \param BO Binary operation for update operation.
/// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update		/// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update
/// expression, false otherwise.		/// expression, false otherwise.
/// \param AO Atomic ordering of the generated atomic instructions.		/// \param AO Atomic ordering of the generated atomic instructions.
/// \param CommonGen Code generator for complex expressions that cannot be		/// \param CommonGen Code generator for complex expressions that cannot be
/// expressed through atomicrmw instruction.		/// expressed through atomicrmw instruction.
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);
void EmitOMPFirstprivateClause(const OMPExecutableDirective &D,		void 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 31 Lines	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		void
EmitOMPInnerLoop(const Stmt &S, bool RequiresCleanup, const Expr *LoopCond,		EmitOMPInnerLoop(const Stmt &S, bool RequiresCleanup, const Expr *LoopCond,
const Expr *IncExpr,		const Expr *IncExpr,
const llvm::function_ref<void(CodeGenFunction &)> &BodyGen);		const llvm::function_ref<void(CodeGenFunction &)> &BodyGen);
void EmitOMPSimdFinal(const OMPLoopDirective &S);		void EmitOMPSimdFinal(const OMPLoopDirective &S);
void EmitOMPWorksharingLoop(const OMPLoopDirective &S);		/// \brief Emit code for the worksharing loop-based directive.
		/// \return true, if this construct has any lastprivate clause, false -
		/// otherwise.
		bool EmitOMPWorksharingLoop(const OMPLoopDirective &S);
void EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind,		void EmitOMPForOuterLoop(OpenMPScheduleClauseKind ScheduleKind,
const OMPLoopDirective &S,		const OMPLoopDirective &S,
OMPPrivateScope &LoopScope, llvm::Value *LB,		OMPPrivateScope &LoopScope, llvm::Value *LB,
llvm::Value UB, llvm::Value ST, llvm::Value *IL,		llvm::Value UB, llvm::Value ST, llvm::Value *IL,
llvm::Value *Chunk);		llvm::Value *Chunk);

public:		public:

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

lib/Sema/SemaOpenMP.cpp

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

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

DSAStack->pop();		DSAStack->pop();
DiscardCleanupsInEvaluationContext();		DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();		PopExpressionEvaluationContext();
▲ Show 20 Lines • Show All 4,339 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 998 Lines • Show Last 20 Lines

lib/Serialization/ASTReaderStmt.cpp

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

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

lib/Serialization/ASTWriterStmt.cpp

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

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

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

test/OpenMP/for_lastprivate_codegen.cpp

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

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

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

				volatile int g = 1212;

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

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

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

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

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

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

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

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

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

				// original s_arr[]=private_s_arr[];
				// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// 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_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
				// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]]
				// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
				// CHECK: [[S_ARR_BODY]]
				// CHECK: call {{.}} [[S_FLOAT_TY_COPY_ASSIGN:@.+]]([[S_FLOAT_TY]] {{.+}}, [[S_FLOAT_TY]]* {{.+}})
				// CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]]
				// CHECK: [[S_ARR_BODY_DONE]]

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

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

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

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

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

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

				// original s_arr[]=private_s_arr[];
				// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
				// 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_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
				// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_BEGIN]], [[S_ARR_END]]
				// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
				// CHECK: [[S_ARR_BODY]]
				// CHECK: call {{.}} [[S_INT_TY_COPY_ASSIGN:@.+]]([[S_INT_TY]] {{.+}}, [[S_INT_TY]]* {{.+}})
				// CHECK: br i1 {{.+}}, label %[[S_ARR_BODY_DONE]], label %[[S_ARR_BODY]]
				// CHECK: [[S_ARR_BODY_DONE]]

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

test/OpenMP/for_lastprivate_messages.cpp

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

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

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

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

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

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

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

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

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

test/OpenMP/for_simd_lastprivate_messages.cpp

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

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

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

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

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

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

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

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

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

test/OpenMP/parallel_firstprivate_codegen.cpp

	Show First 20 Lines • Show All 159 Lines • ▼ Show 20 Lines
	// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]],			// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_FLOAT_TY]],
	// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],			// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
	// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1			// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1
	// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PTR_REF]],			// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PTR_REF]],
	// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_REF]],			// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_REF]],
	// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_PRIV]],			// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_PRIV]],
	// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0			// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0
	// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}], [2 x i{{[0-9]+}}]* [[VEC_PTR_REF:%.+]],			// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}], [2 x i{{[0-9]+}}]* [[VEC_PTR_REF:%.+]],
	// CHECK: br label %[[VEC_PRIV_INIT:.+]]
	// CHECK: [[VEC_PRIV_INIT]]
	// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*			// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*
	// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*			// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*
	// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],			// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],
	// CHECK: br label %[[VEC_PRIV_INIT_END:.+]]
	// CHECK: [[VEC_PRIV_INIT_END]]
	// 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_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_REF:%.+]] = load [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_REF_PTR]],
	// CHECK: br label %[[S_ARR_PRIV_INIT:.+]]
	// CHECK: [[S_ARR_PRIV_INIT]]
	// 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_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:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0			// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_FLOAT_TY]]], [2 x [[S_FLOAT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
	// CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
	// CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2			// CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2
	// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]]			// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_FLOAT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]]
	// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]			// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
	// CHECK: [[S_ARR_BODY]]			// CHECK: [[S_ARR_BODY]]
	// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR:@.+]]([[ST_TY]] [[ST_TY_TEMP:%.+]])			// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR:@.+]]([[ST_TY]] [[ST_TY_TEMP:%.+]])
	// CHECK: call {{.}} [[S_FLOAT_TY_COPY_CONSTR:@.+]]([[S_FLOAT_TY]] {{.+}}, [[S_FLOAT_TY]]* {{.+}}, [[ST_TY]]* [[ST_TY_TEMP]])			// CHECK: call {{.}} [[S_FLOAT_TY_COPY_CONSTR:@.+]]([[S_FLOAT_TY]] {{.+}}, [[S_FLOAT_TY]]* {{.+}}, [[ST_TY]]* [[ST_TY_TEMP]])
	// CHECK: call {{.}} [[ST_TY_DESTR:@.+]]([[ST_TY]] [[ST_TY_TEMP]])			// CHECK: call {{.}} [[ST_TY_DESTR:@.+]]([[ST_TY]] [[ST_TY_TEMP]])
	// CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]]			// CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]]
	// CHECK: br label %[[S_ARR_PRIV_INIT_END:.+]]
	// CHECK: [[S_ARR_PRIV_INIT_END]]
	// CHECK: [[VAR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_MAIN_TY]], [[CAP_MAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3			// 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: [[VAR_REF:%.+]] = load [[S_FLOAT_TY]], [[S_FLOAT_TY]]* [[VAR_REF_PTR]],
	// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]] [[ST_TY_TEMP:%.+]])			// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]] [[ST_TY_TEMP:%.+]])
	// CHECK: call {{.}} [[S_FLOAT_TY_COPY_CONSTR]]([[S_FLOAT_TY]] [[VAR_PRIV]], [[S_FLOAT_TY]]* {{.}} [[VAR_REF]], [[ST_TY]] [[ST_TY_TEMP]])			// CHECK: call {{.}} [[S_FLOAT_TY_COPY_CONSTR]]([[S_FLOAT_TY]] [[VAR_PRIV]], [[S_FLOAT_TY]]* {{.}} [[VAR_REF]], [[ST_TY]] [[ST_TY_TEMP]])
	// CHECK: call {{.}} [[ST_TY_DESTR]]([[ST_TY]] [[ST_TY_TEMP]])			// CHECK: call {{.}} [[ST_TY_DESTR]]([[ST_TY]] [[ST_TY_TEMP]])
	// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_ADDR_ADDR]]			// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_ADDR_ADDR]]
	// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_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: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
	Show All 15 Lines
	// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]],			// CHECK: [[VAR_PRIV:%.+]] = alloca [[S_INT_TY]],
	// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],			// CHECK: store i{{[0-9]+}}* [[GTID_ADDR]], i{{[0-9]+}}** [[GTID_ADDR_ADDR:%.+]],
	// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1			// CHECK: [[T_VAR_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 1
	// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PTR_REF]],			// CHECK: [[T_VAR_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_PTR_REF]],
	// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_REF]],			// CHECK: [[T_VAR_VAL:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[T_VAR_REF]],
	// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_PRIV]],			// CHECK: store i{{[0-9]+}} [[T_VAR_VAL]], i{{[0-9]+}}* [[T_VAR_PRIV]],
	// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0			// CHECK: [[VEC_PTR_REF:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 0
	// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}], [2 x i{{[0-9]+}}]* [[VEC_PTR_REF:%.+]],			// CHECK: [[VEC_REF:%.+]] = load [2 x i{{[0-9]+}}], [2 x i{{[0-9]+}}]* [[VEC_PTR_REF:%.+]],
	// CHECK: br label %[[VEC_PRIV_INIT:.+]]
	// CHECK: [[VEC_PRIV_INIT]]
	// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*			// CHECK: [[VEC_DEST:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_PRIV]] to i8*
	// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*			// CHECK: [[VEC_SRC:%.+]] = bitcast [2 x i{{[0-9]+}}]* [[VEC_REF]] to i8*
	// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],			// CHECK: call void @llvm.memcpy.{{.+}}(i8* [[VEC_DEST]], i8* [[VEC_SRC]],
	// CHECK: br label %[[VEC_PRIV_INIT_END:.+]]
	// CHECK: [[VEC_PRIV_INIT_END]]
	// 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_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_REF:%.+]] = load [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_REF_PTR]],
	// CHECK: br label %[[S_ARR_PRIV_INIT:.+]]
	// CHECK: [[S_ARR_PRIV_INIT]]
	// 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_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:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0			// CHECK: [[S_ARR_PRIV_BEGIN:%.+]] = getelementptr inbounds [2 x [[S_INT_TY]]], [2 x [[S_INT_TY]]]* [[S_ARR_PRIV]], i{{[0-9]+}} 0, i{{[0-9]+}} 0
	// CHECK: [[S_ARR_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_BEGIN]], i{{[0-9]+}} 2
	// CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2			// CHECK: [[S_ARR_PRIV_END:%.+]] = getelementptr [[S_INT_TY]], [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], i{{[0-9]+}} 2
	// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]]			// CHECK: [[IS_EMPTY:%.+]] = icmp eq [[S_INT_TY]]* [[S_ARR_PRIV_BEGIN]], [[S_ARR_PRIV_END]]
	// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]			// CHECK: br i1 [[IS_EMPTY]], label %[[S_ARR_BODY_DONE:.+]], label %[[S_ARR_BODY:.+]]
	// CHECK: [[S_ARR_BODY]]			// CHECK: [[S_ARR_BODY]]
	// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]] [[ST_TY_TEMP:%.+]])			// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]] [[ST_TY_TEMP:%.+]])
	// CHECK: call {{.}} [[S_INT_TY_COPY_CONSTR:@.+]]([[S_INT_TY]] {{.+}}, [[S_INT_TY]]* {{.+}}, [[ST_TY]]* [[ST_TY_TEMP]])			// CHECK: call {{.}} [[S_INT_TY_COPY_CONSTR:@.+]]([[S_INT_TY]] {{.+}}, [[S_INT_TY]]* {{.+}}, [[ST_TY]]* [[ST_TY_TEMP]])
	// CHECK: call {{.}} [[ST_TY_DESTR]]([[ST_TY]] [[ST_TY_TEMP]])			// CHECK: call {{.}} [[ST_TY_DESTR]]([[ST_TY]] [[ST_TY_TEMP]])
	// CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]]			// CHECK: br i1 {{.+}}, label %{{.+}}, label %[[S_ARR_BODY]]
	// CHECK: br label %[[S_ARR_PRIV_INIT_END:.+]]
	// CHECK: [[S_ARR_PRIV_INIT_END]]
	// CHECK: [[VAR_REF_PTR:%.+]] = getelementptr inbounds [[CAP_TMAIN_TY]], [[CAP_TMAIN_TY]]* %{{.+}}, i{{[0-9]+}} 0, i{{[0-9]+}} 3			// 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: [[VAR_REF:%.+]] = load [[S_INT_TY]], [[S_INT_TY]]* [[VAR_REF_PTR]],
	// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]] [[ST_TY_TEMP:%.+]])			// CHECK: call {{.}} [[ST_TY_DEFAULT_CONSTR]]([[ST_TY]] [[ST_TY_TEMP:%.+]])
	// CHECK: call {{.}} [[S_INT_TY_COPY_CONSTR]]([[S_INT_TY]] [[VAR_PRIV]], [[S_INT_TY]]* {{.}} [[VAR_REF]], [[ST_TY]] [[ST_TY_TEMP]])			// CHECK: call {{.}} [[S_INT_TY_COPY_CONSTR]]([[S_INT_TY]] [[VAR_PRIV]], [[S_INT_TY]]* {{.}} [[VAR_REF]], [[ST_TY]] [[ST_TY_TEMP]])
	// CHECK: call {{.}} [[ST_TY_DESTR]]([[ST_TY]] [[ST_TY_TEMP]])			// CHECK: call {{.}} [[ST_TY_DESTR]]([[ST_TY]] [[ST_TY_TEMP]])
	// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_ADDR_ADDR]]			// CHECK: [[GTID_REF:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_ADDR_ADDR]]
	// CHECK: [[GTID:%.+]] = load i{{[0-9]+}}, i{{[0-9]+}}* [[GTID_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: call i32 @__kmpc_cancel_barrier(%{{.+}}* [[IMPLICIT_BARRIER_LOC]], i{{[0-9]+}} [[GTID]])
	// CHECK-DAG: call {{.}} [[S_INT_TY_DESTR]]([[S_INT_TY]] [[VAR_PRIV]])			// CHECK-DAG: call {{.}} [[S_INT_TY_DESTR]]([[S_INT_TY]] [[VAR_PRIV]])
	// CHECK-DAG: call {{.}} [[S_INT_TY_DESTR]]([[S_INT_TY]]			// CHECK-DAG: call {{.}} [[S_INT_TY_DESTR]]([[S_INT_TY]]
	// CHECK: ret void			// CHECK: ret void
	#endif			#endif

test/OpenMP/parallel_for_lastprivate_messages.cpp

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

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

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

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

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

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

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

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

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

test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

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

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

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

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

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

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

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

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

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

test/OpenMP/parallel_sections_lastprivate_messages.cpp

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

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

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

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

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

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

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

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

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

test/OpenMP/sections_lastprivate_messages.cpp

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

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

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

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

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

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

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

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

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

test/OpenMP/simd_lastprivate_messages.cpp

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

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

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

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

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

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

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

tools/libclang/CIndex.cpp

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

This is an archive of the discontinued LLVM Phabricator instance.

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

Details

Diff Detail

Event Timeline

Alexey Bataev

Revision Contents

Diff 23588

include/clang/AST/DataRecursiveASTVisitor.h

include/clang/AST/OpenMPClause.h

include/clang/AST/RecursiveASTVisitor.h

lib/AST/Stmt.cpp

lib/AST/StmtProfile.cpp

lib/CodeGen/CGStmtOpenMP.cpp

lib/CodeGen/CodeGenFunction.h

lib/Sema/SemaOpenMP.cpp

lib/Serialization/ASTReaderStmt.cpp

lib/Serialization/ASTWriterStmt.cpp

test/OpenMP/for_lastprivate_codegen.cpp

test/OpenMP/for_lastprivate_messages.cpp

test/OpenMP/for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_firstprivate_codegen.cpp

test/OpenMP/parallel_for_lastprivate_messages.cpp

test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_sections_lastprivate_messages.cpp

test/OpenMP/sections_lastprivate_messages.cpp

test/OpenMP/simd_lastprivate_messages.cpp

tools/libclang/CIndex.cpp

This is an archive of the discontinued LLVM Phabricator instance.

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

Details

Diff Detail

Event Timeline

Alexey Bataev

Revision Contents

Diff 23588

include/clang/AST/DataRecursiveASTVisitor.h

include/clang/AST/OpenMPClause.h

include/clang/AST/RecursiveASTVisitor.h

lib/AST/Stmt.cpp

lib/AST/StmtProfile.cpp

lib/CodeGen/CGStmtOpenMP.cpp

lib/CodeGen/CodeGenFunction.h

lib/Sema/SemaOpenMP.cpp

lib/Serialization/ASTReaderStmt.cpp

lib/Serialization/ASTWriterStmt.cpp

test/OpenMP/for_lastprivate_codegen.cpp

test/OpenMP/for_lastprivate_messages.cpp

test/OpenMP/for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_firstprivate_codegen.cpp

test/OpenMP/parallel_for_lastprivate_messages.cpp

test/OpenMP/parallel_for_simd_lastprivate_messages.cpp

test/OpenMP/parallel_sections_lastprivate_messages.cpp

test/OpenMP/sections_lastprivate_messages.cpp

test/OpenMP/simd_lastprivate_messages.cpp

tools/libclang/CIndex.cpp

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