*/
CXCursor_OMPSectionsDirective = 235,
- CXCursor_LastStmt = CXCursor_OMPSectionsDirective,
+ /** \brief OpenMP section directive.
+ */
+ CXCursor_OMPSectionDirective = 236,
+
+ CXCursor_LastStmt = CXCursor_OMPSectionDirective,
/**
* \brief Cursor that represents the translation unit itself.
return false;
})
+DEF_TRAVERSE_STMT(OMPSectionDirective, {
+ if (!TraverseOMPExecutableDirective(S))
+ return false;
+})
+
// OpenMP clauses.
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
return false;
})
+DEF_TRAVERSE_STMT(OMPSectionDirective, {
+ if (!TraverseOMPExecutableDirective(S))
+ return false;
+})
+
// OpenMP clauses.
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
}
};
+/// \brief This represents '#pragma omp section' directive.
+///
+/// \code
+/// #pragma omp section
+/// \endcode
+///
+class OMPSectionDirective : public OMPExecutableDirective {
+ friend class ASTStmtReader;
+ /// \brief Build directive with the given start and end location.
+ ///
+ /// \param StartLoc Starting location of the directive kind.
+ /// \param EndLoc Ending location of the directive.
+ ///
+ OMPSectionDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+ : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section,
+ StartLoc, EndLoc, 0, 1) {}
+
+ /// \brief Build an empty directive.
+ ///
+ explicit OMPSectionDirective()
+ : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section,
+ SourceLocation(), SourceLocation(), 0, 1) {}
+
+public:
+ /// \brief Creates directive.
+ ///
+ /// \param C AST context.
+ /// \param StartLoc Starting location of the directive kind.
+ /// \param EndLoc Ending Location of the directive.
+ /// \param AssociatedStmt Statement, associated with the directive.
+ ///
+ static OMPSectionDirective *Create(const ASTContext &C,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc,
+ Stmt *AssociatedStmt);
+
+ /// \brief Creates an empty directive.
+ ///
+ /// \param C AST context.
+ ///
+ static OMPSectionDirective *CreateEmpty(const ASTContext &C, EmptyShell);
+
+ static bool classof(const Stmt *T) {
+ return T->getStmtClass() == OMPSectionDirectiveClass;
+ }
+};
+
} // end namespace clang
#endif
"OpenMP constructs may not be nested inside a simd region">;
def err_omp_sections_not_compound_stmt : Error<
"the statement for '#pragma omp sections' must be a compound statement">;
+def err_omp_orphaned_section_directive : Error<
+ "%select{orphaned 'omp section' directives are prohibited, it|'omp section' directive}0"
+ " must be closely nested to a sections region%select{|, not a %1 region}0">;
+def err_omp_sections_substmt_not_section : Error<
+ "statement in 'omp sections' directive must be enclosed into a section region">;
} // end of OpenMP category
let CategoryName = "Related Result Type Issue" in {
OPENMP_DIRECTIVE(simd)
OPENMP_DIRECTIVE(for)
OPENMP_DIRECTIVE(sections)
+OPENMP_DIRECTIVE(section)
// OpenMP clauses.
OPENMP_CLAUSE(if, OMPIfClause)
def OMPSimdDirective : DStmt<OMPExecutableDirective>;
def OMPForDirective : DStmt<OMPExecutableDirective>;
def OMPSectionsDirective : DStmt<OMPExecutableDirective>;
+def OMPSectionDirective : DStmt<OMPExecutableDirective>;
StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
Stmt *AStmt, SourceLocation StartLoc,
SourceLocation EndLoc);
+ /// \brief Called on well-formed '\#pragma omp section' after parsing of the
+ /// associated statement.
+ StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
+ SourceLocation EndLoc);
OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
Expr *Expr,
STMT_OMP_SIMD_DIRECTIVE,
STMT_OMP_FOR_DIRECTIVE,
STMT_OMP_SECTIONS_DIRECTIVE,
+ STMT_OMP_SECTION_DIRECTIVE,
// ARC
EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr
return new (Mem) OMPSectionsDirective(NumClauses);
}
+OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc,
+ Stmt *AssociatedStmt) {
+ unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
+ llvm::alignOf<Stmt *>());
+ void *Mem = C.Allocate(Size + sizeof(Stmt *));
+ OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc);
+ Dir->setAssociatedStmt(AssociatedStmt);
+ return Dir;
+}
+
+OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
+ EmptyShell) {
+ unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
+ llvm::alignOf<Stmt *>());
+ void *Mem = C.Allocate(Size + sizeof(Stmt *));
+ return new (Mem) OMPSectionDirective();
+}
+
PrintOMPExecutableDirective(Node);
}
+void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
+ Indent() << "#pragma omp section";
+ PrintOMPExecutableDirective(Node);
+}
+
//===----------------------------------------------------------------------===//
// Expr printing methods.
//===----------------------------------------------------------------------===//
VisitOMPExecutableDirective(S);
}
+void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) {
+ VisitOMPExecutableDirective(S);
+}
+
void StmtProfiler::VisitExpr(const Expr *S) {
VisitStmt(S);
}
case OMPD_unknown:
case OMPD_threadprivate:
case OMPD_task:
+ case OMPD_section:
break;
}
return false;
}
bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
- return DKind == OMPD_for ||
- DKind == OMPD_sections; // TODO add next directives.
+ return DKind == OMPD_for || DKind == OMPD_sections ||
+ DKind == OMPD_section; // TODO add next directives.
}
bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
case Stmt::OMPSectionsDirectiveClass:
EmitOMPSectionsDirective(cast<OMPSectionsDirective>(*S));
break;
+ case Stmt::OMPSectionDirectiveClass:
+ EmitOMPSectionDirective(cast<OMPSectionDirective>(*S));
+ break;
}
}
llvm_unreachable("CodeGen for 'omp sections' is not supported yet.");
}
+void CodeGenFunction::EmitOMPSectionDirective(const OMPSectionDirective &) {
+ llvm_unreachable("CodeGen for 'omp section' is not supported yet.");
+}
+
void EmitOMPSimdDirective(const OMPSimdDirective &S);
void EmitOMPForDirective(const OMPForDirective &S);
void EmitOMPSectionsDirective(const OMPSectionsDirective &S);
+ void EmitOMPSectionDirective(const OMPSectionDirective &S);
//===--------------------------------------------------------------------===//
// LValue Expression Emission
case OMPD_task:
case OMPD_for:
case OMPD_sections:
+ case OMPD_section:
Diag(Tok, diag::err_omp_unexpected_directive)
<< getOpenMPDirectiveName(DKind);
break;
/// annot_pragma_openmp_end
///
/// executable-directive:
-/// annot_pragma_openmp 'parallel'|'simd'|'for'|'sections' {clause}
-/// annot_pragma_openmp_end
+/// annot_pragma_openmp 'parallel'|'simd'|'for'|'sections'|'section'
+/// {clause} annot_pragma_openmp_end
///
StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective() {
assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
case OMPD_parallel:
case OMPD_simd:
case OMPD_for:
- case OMPD_sections: {
+ case OMPD_sections:
+ case OMPD_section: {
ConsumeToken();
if (isOpenMPLoopDirective(DKind))
ActOnCapturedRegionStart(Loc, CurScope, CR_OpenMP, Params);
break;
}
+ case OMPD_section: {
+ Sema::CapturedParamNameType Params[] = {
+ std::make_pair(StringRef(), QualType()) // __context with shared vars
+ };
+ ActOnCapturedRegionStart(Loc, CurScope, CR_OpenMP, Params);
+ break;
+ }
case OMPD_threadprivate:
case OMPD_task:
llvm_unreachable("OpenMP Directive is not allowed");
SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_simd);
return true;
}
+ if (CurrentRegion == OMPD_section) {
+ // OpenMP [2.7.2, sections Construct, Restrictions]
+ // Orphaned section directives are prohibited. That is, the section
+ // directives must appear within the sections construct and must not be
+ // encountered elsewhere in the sections region.
+ if (ParentRegion != OMPD_sections) {
+ SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive)
+ << (ParentRegion != OMPD_unknown)
+ << getOpenMPDirectiveName(ParentRegion);
+ return true;
+ }
+ return false;
+ }
if (isOpenMPWorksharingDirective(CurrentRegion) &&
!isOpenMPParallelDirective(CurrentRegion) &&
!isOpenMPSimdDirective(CurrentRegion)) {
Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc,
EndLoc);
break;
+ case OMPD_section:
+ assert(ClausesWithImplicit.empty() &&
+ "No clauses is allowed for 'omp section' directive");
+ Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc);
+ break;
case OMPD_threadprivate:
case OMPD_task:
llvm_unreachable("OpenMP Directive is not allowed");
return StmtError();
// All associated statements must be '#pragma omp section' except for
// the first one.
- // TODO
+ for (++S; S; ++S) {
+ auto SectionStmt = *S;
+ if (!SectionStmt || !isa<OMPSectionDirective>(SectionStmt)) {
+ if (SectionStmt)
+ Diag(SectionStmt->getLocStart(),
+ diag::err_omp_sections_substmt_not_section);
+ return StmtError();
+ }
+ }
} else {
Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt);
return StmtError();
AStmt);
}
+StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ assert(AStmt && isa<CapturedStmt>(AStmt) && "Captured statement expected");
+
+ getCurFunction()->setHasBranchProtectedScope();
+
+ return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt);
+}
+
OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
SourceLocation StartLoc,
SourceLocation LParenLoc,
return Res;
}
+template <typename Derived>
+StmtResult
+TreeTransform<Derived>::TransformOMPSectionDirective(OMPSectionDirective *D) {
+ DeclarationNameInfo DirName;
+ getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr);
+ StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
+ getDerived().getSema().EndOpenMPDSABlock(Res.get());
+ return Res;
+}
+
//===----------------------------------------------------------------------===//
// OpenMP clause transformation
//===----------------------------------------------------------------------===//
VisitOMPExecutableDirective(D);
}
+void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
+ VisitStmt(D);
+ VisitOMPExecutableDirective(D);
+}
+
//===----------------------------------------------------------------------===//
// ASTReader Implementation
//===----------------------------------------------------------------------===//
Context, Record[ASTStmtReader::NumStmtFields], Empty);
break;
+ case STMT_OMP_SECTION_DIRECTIVE:
+ S = OMPSectionDirective::CreateEmpty(Context, Empty);
+ break;
+
case EXPR_CXX_OPERATOR_CALL:
S = new (Context) CXXOperatorCallExpr(Context, Empty);
break;
Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE;
}
+void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
+ VisitStmt(D);
+ VisitOMPExecutableDirective(D);
+ Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
+}
+
//===----------------------------------------------------------------------===//
// ASTWriter Implementation
//===----------------------------------------------------------------------===//
case Stmt::OMPSimdDirectiveClass:
case Stmt::OMPForDirectiveClass:
case Stmt::OMPSectionsDirectiveClass:
+ case Stmt::OMPSectionDirectiveClass:
llvm_unreachable("Stmt should not be in analyzer evaluation loop");
case Stmt::ObjCSubscriptRefExprClass:
void foo() {
#pragma omp parallel
#pragma omp for
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
#pragma omp parallel
#pragma omp simd
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
#pragma omp parallel
#pragma omp sections
{
bar();
}
+#pragma omp parallel
+#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}}
+ {
+ bar();
+ }
#pragma omp simd
for (int i = 0; i < 10; ++i) {
#pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp simd
for (int i = 0; i < 10; ++i) {
#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp simd
for (int i = 0; i < 10; ++i) {
#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp simd
for (int i = 0; i < 10; ++i) {
bar();
}
}
+#pragma omp simd
+ for (int i = 0; i < 10; ++i) {
+#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+ {
+ bar();
+ }
+ }
#pragma omp for
for (int i = 0; i < 10; ++i) {
#pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp for
for (int i = 0; i < 10; ++i) {
#pragma omp simd
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp for
for (int i = 0; i < 10; ++i) {
#pragma omp parallel
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp for
for (int i = 0; i < 10; ++i) {
bar();
}
}
+#pragma omp for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}}
+ {
+ bar();
+ }
+ }
#pragma omp sections
{
#pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp sections
{
#pragma omp simd
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp sections
{
#pragma omp parallel
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp sections
{
bar();
}
}
+#pragma omp sections
+ {
+#pragma omp section
+ {
+ bar();
+ }
+ }
+#pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}}
+ {
+ bar();
+ }
}
void foo() {
#pragma omp parallel
#pragma omp for
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
#pragma omp parallel
#pragma omp simd
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
#pragma omp parallel
#pragma omp sections
{
bar();
}
+#pragma omp parallel
+#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}}
+ {
+ bar();
+ }
#pragma omp simd
for (int i = 0; i < 10; ++i) {
#pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp simd
for (int i = 0; i < 10; ++i) {
#pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp simd
for (int i = 0; i < 10; ++i) {
#pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp simd
for (int i = 0; i < 10; ++i) {
bar();
}
}
+#pragma omp simd
+ for (int i = 0; i < 10; ++i) {
+#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+ {
+ bar();
+ }
+ }
#pragma omp for
for (int i = 0; i < 10; ++i) {
#pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp for
for (int i = 0; i < 10; ++i) {
#pragma omp simd
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp for
for (int i = 0; i < 10; ++i) {
#pragma omp parallel
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp for
for (int i = 0; i < 10; ++i) {
bar();
}
}
+#pragma omp for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}}
+ {
+ bar();
+ }
+ }
#pragma omp sections
{
#pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp sections
{
#pragma omp simd
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp sections
{
#pragma omp parallel
- for (int i = 0; i < 10; ++i);
+ for (int i = 0; i < 10; ++i)
+ ;
}
#pragma omp sections
{
bar();
}
}
+#pragma omp sections
+ {
+#pragma omp section
+ {
+ bar();
+ }
+ }
+#pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}}
+ {
+ bar();
+ }
return foo<int>();
}
static T a;
// CHECK: static T a;
#pragma omp parallel
-#pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction (-: g) nowait
+#pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(- : g) nowait
{
- foo();
+ foo();
}
// CHECK-NEXT: #pragma omp parallel
// CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(c,d) lastprivate(d,f) reduction(-: g) nowait
static int a;
// CHECK: static int a;
#pragma omp parallel
-#pragma omp sections private(argc, b), firstprivate(argv, c), lastprivate(d, f) reduction(+:g) nowait
+#pragma omp sections private(argc, b), firstprivate(argv, c), lastprivate(d, f) reduction(+ : g) nowait
{
- foo();
+#pragma omp section
+ foo();
+#pragma omp section
+ foo();
}
// CHECK-NEXT: #pragma omp parallel
// CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(argv,c) lastprivate(d,f) reduction(+: g) nowait
// CHECK-NEXT: {
+ // CHECK-NEXT: #pragma omp section
+ // CHECK-NEXT: foo();
+ // CHECK-NEXT: #pragma omp section
// CHECK-NEXT: foo();
// CHECK-NEXT: }
return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0]));
// expected-error@+2 {{the statement for '#pragma omp sections' must be a compound statement}}
#pragma omp sections
++i;
+
+#pragma omp sections
+ {
+ foo();
+ foo(); // expected-error {{statement in 'omp sections' directive must be enclosed into a section region}}
+ }
+
}
void test_branch_protected_scope() {
L2:
x[i]++;
}
+#pragma omp section
+ if (i == 5)
+ goto L1; // expected-error {{use of undeclared label 'L1'}}
+ else if (i == 6)
+ return; // expected-error {{cannot return from OpenMP region}}
+ else if (i == 7)
+ goto L3;
+ else if (i == 8) {
+ L3:
+ x[i]++;
+ }
}
if (x[0] == 0)
goto L2; // expected-error {{use of undeclared label 'L2'}}
else if (x[1] == 1)
goto L1;
+ goto L3; // expected-error {{use of undeclared label 'L3'}}
}
void test_invalid_clause() {
#pragma omp sections foo bar
{
foo();
+// expected-error@+1 {{unexpected OpenMP clause 'nowait' in directive '#pragma omp section'}}
+#pragma omp section nowait
+ ;
}
}
void VisitOMPSimdDirective(const OMPSimdDirective *D);
void VisitOMPForDirective(const OMPForDirective *D);
void VisitOMPSectionsDirective(const OMPSectionsDirective *D);
+ void VisitOMPSectionDirective(const OMPSectionDirective *D);
private:
void AddDeclarationNameInfo(const Stmt *S);
VisitOMPExecutableDirective(D);
}
+void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) {
+ VisitOMPExecutableDirective(D);
+}
+
void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
}
return cxstring::createRef("OMPForDirective");
case CXCursor_OMPSectionsDirective:
return cxstring::createRef("OMPSectionsDirective");
+ case CXCursor_OMPSectionDirective:
+ return cxstring::createRef("OMPSectionDirective");
}
llvm_unreachable("Unhandled CXCursorKind");
case Stmt::OMPSectionsDirectiveClass:
K = CXCursor_OMPSectionsDirective;
break;
+ case Stmt::OMPSectionDirectiveClass:
+ K = CXCursor_OMPSectionDirective;
+ break;
}
CXCursor C = { K, 0, { Parent, S, TU } };
projects / platform / upstream / llvm.git / commitdiff