[PATCH] [OPENMP] Initial support for '#pragma omp declare simd' directive.
Hal Finkel
hfinkel at anl.gov
Tue Jul 7 05:56:24 PDT 2015
----- Original Message -----
> From: "Alexey Bataev" <a.bataev at hotmail.com>
> To: "Hal Finkel" <hfinkel at anl.gov>, "Aaron Ballman" <aaron.ballman at gmail.com>
> Cc: reviews+D10599+public+2871690e17faf647 at reviews.llvm.org, "Richard Smith" <richard at metafoo.co.uk>,
> ejstotzer at gmail.com, fraggamuffin at gmail.com, "llvm cfe" <cfe-commits at cs.uiuc.edu>
> Sent: Tuesday, July 7, 2015 7:52:02 AM
> Subject: Re: [PATCH] [OPENMP] Initial support for '#pragma omp declare simd' directive.
>
> Hal, it is not a problem to emit the diagnostic for naked pragmas,
> but I
> expect a lot of troubles with warnings for pragmas with a lot of
> clauses, mixed different way. But if you really-really think, that we
> need this stuff, I'll add it. :)
Let's wait and think about it :)
My underlying thought is that a warning will catch cases where the user intended to declare the function for, say, 2 different simd lengths, but actually just repeated one simd length twice. Regardless, let's revisit this once we have support for some clauses here.
Thanks again,
Hal
>
> Best regards,
> Alexey Bataev
> =============
> Software Engineer
> Intel Compiler Team
>
> 07.07.2015 15:35, Hal Finkel пишет:
> > ----- Original Message -----
> >> From: "Aaron Ballman" <aaron.ballman at gmail.com>
> >> To: "Alexey Bataev" <a.bataev at hotmail.com>
> >> Cc: reviews+D10599+public+2871690e17faf647 at reviews.llvm.org,
> >> "Richard Smith" <richard at metafoo.co.uk>, "Hal Finkel"
> >> <hfinkel at anl.gov>, ejstotzer at gmail.com, fraggamuffin at gmail.com,
> >> "llvm cfe" <cfe-commits at cs.uiuc.edu>
> >> Sent: Tuesday, July 7, 2015 7:18:04 AM
> >> Subject: Re: [PATCH] [OPENMP] Initial support for '#pragma omp
> >> declare simd' directive.
> >>
> >> On Tue, Jul 7, 2015 at 7:40 AM, Bataev, Alexey
> >> <a.bataev at hotmail.com>
> >> wrote:
> >>>> I tend to agree with hal that this should be a warning. It's low
> >>>> priority, definitely, but silently allowing the programmer to
> >>>> get
> >>>> away
> >>>> with incorrect code doesn't seem beneficial to anyone. It would
> >>>> also
> >>>> point out the two other places in your tests that have this
> >>>> exact
> >>>> same
> >>>> code pattern with no additional testing benefit. ;-)
> >>>
> >>> This code is correct, OpenMP standard allows to mark the same
> >>> function many
> >>> times with the same pragma. Here is an excerpt:
> >> Eww, but fair enough. :-)
> > Okay, but this was not my point. I did not say it should be an
> > error. Warnings are not for incorrect code, they are for correct
> > code were we feel the user *probably* intended something else. If
> > a function is marked with several identical 'omp declare simd'
> > pragmas, is that likely to be intentional or a mistake of some
> > kind?
> >
> > Even if we decide on a warning here, I'm fine with adding it in
> > follow-up. I think it would need to account for the other clauses
> > as well anyway.
> >
> > Thanks again,
> > Hal
> >
> >>> #pragma omp declare simd [clause[[,] clause] ...] new-line
> >>> [#pragma omp declare simd [clause[[,] clause] ...] new-line]
> >>> [...]
> >>> function definition or declaration
> >>>
> >>> There may be multiple declare simd directives for a function (C,
> >>> C++,
> >>> Fortran) or subroutine (Fortran).
> >>>
> >>>> I would also like to see a test for #pragma omp declare simd
> >>>> that
> >>>> is
> >>>> at the end of the TU with no futher statements (to ensure it
> >>>> gets
> >>>> diagnosed).
> >>>
> >>> Ok, will be added.
> >>>
> >>>> Copy paste error?
> >>> Nope, I have to verify that the compiler allows to mark the same
> >>> function
> >>> several times with '#pragma omp declare simd' according to
> >>> standard.
> >> Fair, but we don't need that tested multiple times.
> >>
> >>>> This attribute has a pragma spelling where the namespace is
> >>>> openmp
> >>>> and
> >>>> the name is declare. It's the same pattern used by the loop hint
> >>>> and
> >>>> init_seg pragmas.
> >>>
> >>> Can't add spellings, it breaks -ast-print mode (pragmas are
> >>> printed
> >>> just
> >>> like attributes, directly after function declaration).
> >> That means -ast-print is broken and should be fixed.
> >>
> >>>> Please document this attribute as it does have a pragma
> >>>> spelling.
> >>>
> >>> Will add
> >>>
> >>>> This attribute appears to be missing its Subjects clause as
> >>>> well.
> >>>> That's not information we currently care about for pragmas, but
> >>>> I
> >>>> would like the declarative part of the attribute to match the
> >>>> semantic
> >>>> expectations.
> >>>
> >>> Will add too.
> >>>
> >>>> I've not seen any tests for ObjC, so does this really apply to
> >>>> methods?
> >>> I'll fix this message.
> >>>
> >>>> Capitalize the first word in the documentation part of the
> >>>> sentence.
> >>> Thanks, fixed.
> >>>
> >>>> Drop the virtual, add override.
> >>> Fixed.
> >>>
> >>>> Drop the "if"
> >>> Fixed
> >>>
> >>>> Can you use a range-based for loop please?
> >>> Done
> >>>
> >>>> This is not an implicit attribute because it's the direct result
> >>>> of
> >>>> the user typing something in source code.
> >>> Fixed.
> >>>
> >>>> This really weirds me out. That means this function doesn't
> >>>> parse
> >>>> just
> >>>> the pragma, it also parses any external declaration.
> >>> Yes, we have to parse function right after pragma to be able
> >>> correctly
> >>> handle clauses associated with this pragma. These clauses may
> >>> have
> >>> refernces
> >>> to function arguments and because of that we have to parse the
> >>> function
> >>> first and only then the pragma itself.
> >> Can we update the name of the function to suggest this?
> >>
> >>>> The comments don't look correct here.
> >>> Missed this one, thanks.
> >>>
> >>>> Is this safe to assert in a parsing method, or should this be
> >>>> diagnosed?
> >>> There always must be at least one token if the compiler works
> >>> correctly -
> >>> tok::annot_pragma_openmp. No need to diagnose.
> >> Good deal, thank you!
> >>
> >>>> Has this situation already been diagnosed? If so, then why are
> >>>> we
> >>>> generating the tokens in a way that require this work? And if
> >>>> not,
> >>>> are
> >>>> we missing a diagnostic here?
> >>> Yes, this was diagnosed already. We need to remove cached tokens,
> >>> so just
> >>> skip them.
> >> Thank you!
> >>
> >> ~Aaron
> >>
> >>>> Attribute is not implicit.
> >>> Fixed.
> >>>
> >>> Best regards,
> >>> Alexey Bataev
> >>> =============
> >>> Software Engineer
> >>> Intel Compiler Team
> >>>
> >>> 06.07.2015 16:13, Aaron Ballman пишет:
> >>>
> >>>> On Mon, Jun 22, 2015 at 7:35 AM, Alexey Bataev
> >>>> <a.bataev at hotmail.com>
> >>>> wrote:
> >>>>> Hi rsmith, aaron.ballman, hfinkel, ejstotzer, fraggamuffin,
> >>>>>
> >>>>> Inital parsing/sema/serialization/deserialization support for
> >>>>> '#pragma
> >>>>> omp declare simd' directive.
> >>>>> The declare simd construct can be applied to a function to
> >>>>> enable
> >>>>> the
> >>>>> creation of one or more versions that can process multiple
> >>>>> arguments using
> >>>>> SIMD instructions from a single invocation from a SIMD loop.
> >>>>> If the function has any declarations, then the declare simd
> >>>>> construct for
> >>>>> any declaration that has one must be equivalent to the one
> >>>>> specified for the
> >>>>> definition. Otherwise, the result is unspecified.
> >>>>> This pragma can be aplied many times to the same declaration.
> >>>>> Internally this pragma is represented as an attribute. But we
> >>>>> need
> >>>>> special processing for this pragma because it must be used
> >>>>> before
> >>>>> function
> >>>>> declaration, this directive is appplied to.
> >>>>> If pragma is applied to method declared/defined in the class
> >>>>> lexical
> >>>>> context, then the delayed parsing procedure is used.
> >>>>> Also delayed parsing is used for poarsing a pragma itself,
> >>>>> because this
> >>>>> directive has several clauses that can reference arguments of
> >>>>> the
> >>>>> associated
> >>>>> function/method.
> >>>>>
> >>>>> http://reviews.llvm.org/D10599
> >>>>>
> >>>>> Files:
> >>>>> include/clang/AST/ASTMutationListener.h
> >>>>> include/clang/Basic/Attr.td
> >>>>> include/clang/Basic/DiagnosticParseKinds.td
> >>>>> include/clang/Basic/DiagnosticSemaKinds.td
> >>>>> include/clang/Basic/OpenMPKinds.def
> >>>>> include/clang/Parse/Parser.h
> >>>>> include/clang/Sema/Sema.h
> >>>>> include/clang/Serialization/ASTWriter.h
> >>>>> lib/AST/DeclPrinter.cpp
> >>>>> lib/Basic/OpenMPKinds.cpp
> >>>>> lib/Frontend/MultiplexConsumer.cpp
> >>>>> lib/Parse/ParseDeclCXX.cpp
> >>>>> lib/Parse/ParseOpenMP.cpp
> >>>>> lib/Parse/Parser.cpp
> >>>>> lib/Sema/SemaOpenMP.cpp
> >>>>> lib/Serialization/ASTCommon.h
> >>>>> lib/Serialization/ASTReaderDecl.cpp
> >>>>> lib/Serialization/ASTWriter.cpp
> >>>>> test/OpenMP/declare_simd_ast_print.c
> >>>>> test/OpenMP/declare_simd_ast_print.cpp
> >>>>> test/OpenMP/declare_simd_messages.cpp
> >>>>>
> >>>>> EMAIL PREFERENCES
> >>>>> http://reviews.llvm.org/settings/panel/emailpreferences/
> >>>> Index: test/OpenMP/declare_simd_messages.cpp
> >>>> ===================================================================
> >>>> --- test/OpenMP/declare_simd_messages.cpp
> >>>> +++ test/OpenMP/declare_simd_messages.cpp
> >>>> @@ -0,0 +1,45 @@
> >>>> +// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify
> >>>> -fopenmp
> >>>> -x c++ -std=c++11 %s
> >>>> +
> >>>> +// expected-error at +1 {{expected an OpenMP directive}}
> >>>> +#pragma omp declare
> >>>> +
> >>>> +// expected-error at +2 {{'#pragma omp declare simd' can be
> >>>> applied
> >>>> to
> >>>> functions or methods only}}
> >>>> +#pragma omp declare simd
> >>>> +int a;
> >>>> +// expected-error at +2 {{'#pragma omp declare simd' can be
> >>>> applied
> >>>> to
> >>>> functions or methods only}}
> >>>> +#pragma omp declare simd
> >>>> +#pragma omp threadprivate(a)
> >>>> +int var;
> >>>> +#pragma omp threadprivate(var)
> >>>> +
> >>>> +// expected-error at +2 {{expected an OpenMP directive}}
> >>>> +#pragma omp declare simd
> >>>> +#pragma omp declare
> >>>> +
> >>>> +#pragma omp declare simd
> >>>> +#pragma omp declare simd
> >>>>
> >>>> I tend to agree with hal that this should be a warning. It's low
> >>>> priority, definitely, but silently allowing the programmer to
> >>>> get
> >>>> away
> >>>> with incorrect code doesn't seem beneficial to anyone. It would
> >>>> also
> >>>> point out the two other places in your tests that have this
> >>>> exact
> >>>> same
> >>>> code pattern with no additional testing benefit. ;-)
> >>>>
> >>>> +int main();
> >>>> +
> >>>> +#pragma omp declare simd
> >>>> +template <class C>
> >>>> +void h(C *hp, C *hp2, C *hq, C *lin) {
> >>>> +}
> >>>> +
> >>>> +#pragma omp declare simd
> >>>> +template <>
> >>>> +void h(int *hp, int *hp2, int *hq, int *lin) {
> >>>> + h((float *)hp, (float *)hp2, (float *)hq, (float *)lin);
> >>>> +}
> >>>> +
> >>>> +template <class T>
> >>>> +struct St {
> >>>> +#pragma omp declare simd
> >>>> + void h(T *hp) {
> >>>> +// expected-error at +1 {{unexpected OpenMP directive '#pragma omp
> >>>> declare
> >>>> simd'}}
> >>>> +#pragma omp declare simd
> >>>> + *hp = *t;
> >>>> + }
> >>>> +
> >>>> +private:
> >>>> + T t;
> >>>> +};
> >>>>
> >>>> I would also like to see a test for #pragma omp declare simd
> >>>> that
> >>>> is
> >>>> at the end of the TU with no futher statements (to ensure it
> >>>> gets
> >>>> diagnosed).
> >>>>
> >>>> Index: test/OpenMP/declare_simd_ast_print.cpp
> >>>> ===================================================================
> >>>> --- test/OpenMP/declare_simd_ast_print.cpp
> >>>> +++ test/OpenMP/declare_simd_ast_print.cpp
> >>>> @@ -0,0 +1,103 @@
> >>>> +// RUN: %clang_cc1 -verify -fopenmp -x c++ -std=c++11
> >>>> -ast-print
> >>>> %s |
> >>>> FileCheck %s
> >>>> +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t
> >>>> %s
> >>>> +// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -include-pch %t
> >>>> -fsyntax-only -verify %s -ast-print | FileCheck %s
> >>>> +// expected-no-diagnostics
> >>>> +
> >>>> +#ifndef HEADER
> >>>> +#define HEADER
> >>>> +
> >>>> +#pragma omp declare simd
> >>>> +void add_1(float *d);
> >>>> +
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: void add_1(float *d);
> >>>> +//
> >>>> +
> >>>> +#pragma omp declare simd
> >>>> +template <class C> void h(C *hp, C *hp2, C *hq, C *lin) {
> >>>> +}
> >>>> +
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: template <class C = int> void h(int *hp, int
> >>>> *hp2,
> >>>> int
> >>>> *hq, int *lin) {
> >>>> +// CHECK-NEXT: h((float *)hp, (float *)hp2, (float *)hq, (float
> >>>> *)lin);
> >>>> +// CHECK-NEXT: }
> >>>> +
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: template <class C = float> void h(float *hp,
> >>>> float
> >>>> *hp2, float *hq, float *lin) {
> >>>> +// CHECK-NEXT: }
> >>>> +
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK: template <class C> void h(C *hp, C *hp2, C *hq, C
> >>>> *lin)
> >>>> {
> >>>> +// CHECK-NEXT: }
> >>>> +//
> >>>> +
> >>>> +// Instatiate with <C=int> explicitly.
> >>>> +// Pragmas need to be same, otherwise standard says that's
> >>>> undefined
> >>>> behavior.
> >>>> +#pragma omp declare simd
> >>>> +template <>
> >>>> +void h(int *hp, int *hp2, int *hq, int *lin)
> >>>> +{
> >>>> + // Instatiate with <C=float> implicitly.
> >>>> + // This is special case where the directive is stored by Sema
> >>>> and is
> >>>> + // generated together with the (pending) function
> >>>> instatiation.
> >>>> + h((float*) hp, (float*) hp2, (float*) hq, (float*) lin);
> >>>> +}
> >>>> +
> >>>> +class VV {
> >>>> + // CHECK: #pragma omp declare simd
> >>>> + // CHECK-NEXT: int add(int a, int b) {
> >>>> + // CHECK-NEXT: return a + b;
> >>>> + // CHECK-NEXT: }
> >>>> + #pragma omp declare simd
> >>>> + int add(int a, int b) { return a + b; }
> >>>> +
> >>>> + // CHECK: #pragma omp declare simd
> >>>> + // CHECK-NEXT: #pragma omp declare simd
> >>>> + // CHECK-NEXT: float addpf(float *a, float *b) {
> >>>> + // CHECK-NEXT: return *a + *b;
> >>>> + // CHECK-NEXT: }
> >>>> + #pragma omp declare simd
> >>>> + #pragma omp declare simd
> >>>>
> >>>> Copy paste error?
> >>>>
> >>>> + float addpf(float *a, float *b) { return *a + *b; }
> >>>> +};
> >>>> +
> >>>> +// CHECK: template <int X = 16> class TVV {
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: int tadd(int a, int b);
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: float taddpf(float *a, float *b) {
> >>>> +// CHECK-NEXT: return *a + *b;
> >>>> +// CHECK-NEXT: }
> >>>> +// CHECK: }
> >>>> +template <int X>
> >>>> +class TVV {
> >>>> +public:
> >>>> +// CHECK: template <int X> class TVV {
> >>>> + #pragma omp declare simd
> >>>> + int tadd(int a, int b) { return a + b; }
> >>>> +
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: int tadd(int a, int b) {
> >>>> +// CHECK-NEXT: return a + b;
> >>>> +// CHECK-NEXT: }
> >>>> +
> >>>> +
> >>>> + #pragma omp declare simd
> >>>> + float taddpf(float *a, float *b) { return *a + *b; }
> >>>> +
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: float taddpf(float *a, float *b) {
> >>>> +// CHECK-NEXT: return *a + *b;
> >>>> +// CHECK-NEXT: }
> >>>> +};
> >>>> +// CHECK: };
> >>>> +
> >>>> +// CHECK: TVV<16> t16;
> >>>> +TVV<16> t16;
> >>>> +
> >>>> +void f() {
> >>>> + float a = 1.0f, b = 2.0f;
> >>>> + float r = t16.taddpf(&a, &b);
> >>>> +}
> >>>> +
> >>>> +#endif
> >>>> Index: test/OpenMP/declare_simd_ast_print.c
> >>>> ===================================================================
> >>>> --- test/OpenMP/declare_simd_ast_print.c
> >>>> +++ test/OpenMP/declare_simd_ast_print.c
> >>>> @@ -0,0 +1,17 @@
> >>>> +// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck
> >>>> %s
> >>>> +// RUN: %clang_cc1 -fopenmp -emit-pch -o %t %s
> >>>> +// RUN: %clang_cc1 -fopenmp -include-pch %t -fsyntax-only
> >>>> -verify
> >>>> %s
> >>>> -ast-print | FileCheck %s
> >>>> +// expected-no-diagnostics
> >>>> +
> >>>> +#ifndef HEADER
> >>>> +#define HEADER
> >>>> +
> >>>> +#pragma omp declare simd
> >>>> +#pragma omp declare simd
> >>>>
> >>>> Copy paste error?
> >>>>
> >>>> +void add_1(float *d, float *s1, float *s2);
> >>>> +
> >>>> +// CHECK: #pragma omp declare simd
> >>>> +// CHECK-NEXT: #pragma omp declare simd
> >>>> +// CHECK-NEXT: void add_1(float *d, float *s1, float *s2)
> >>>> +
> >>>> +#endif
> >>>> Index: include/clang/Basic/OpenMPKinds.def
> >>>> ===================================================================
> >>>> --- include/clang/Basic/OpenMPKinds.def
> >>>> +++ include/clang/Basic/OpenMPKinds.def
> >>>> @@ -94,6 +94,7 @@
> >>>> OPENMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd")
> >>>> OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections")
> >>>> OPENMP_DIRECTIVE_EXT(for_simd, "for simd")
> >>>> +OPENMP_DIRECTIVE_EXT(declare_simd, "declare simd")
> >>>>
> >>>> // OpenMP clauses.
> >>>> OPENMP_CLAUSE(if, OMPIfClause)
> >>>> Index: include/clang/Basic/Attr.td
> >>>> ===================================================================
> >>>> --- include/clang/Basic/Attr.td
> >>>> +++ include/clang/Basic/Attr.td
> >>>> @@ -2044,3 +2044,19 @@
> >>>> let SemaHandler = 0;
> >>>> let Documentation = [Undocumented];
> >>>> }
> >>>> +
> >>>> +def OMPDeclareSimdDecl : InheritableAttr {
> >>>> + // This attribute has no spellings as it is only ever created
> >>>> implicitly.
> >>>> + let Spellings = [];
> >>>>
> >>>> This attribute has a pragma spelling where the namespace is
> >>>> openmp
> >>>> and
> >>>> the name is declare. It's the same pattern used by the loop hint
> >>>> and
> >>>> init_seg pragmas.
> >>>>
> >>>> + let SemaHandler = 0;
> >>>> + let Documentation = [Undocumented];
> >>>>
> >>>> Please document this attribute as it does have a pragma
> >>>> spelling.
> >>>>
> >>>> + let Args = [UnsignedArgument<"NumberOfDirectives">,
> >>>> BoolArgument<"Complete">];
> >>>> + let AdditionalMembers = [{
> >>>> + void printPrettyPragma(raw_ostream &OS, const PrintingPolicy
> >>>> &Policy)
> >>>> const {
> >>>> + OS << "#pragma omp declare simd\n";
> >>>> + }
> >>>> + void setNumberOfDirectives(unsigned N) { numberOfDirectives =
> >>>> N; }
> >>>> + void setComplete() { complete = true; }
> >>>>
> >>>> This attribute appears to be missing its Subjects clause as
> >>>> well.
> >>>> That's not information we currently care about for pragmas, but
> >>>> I
> >>>> would like the declarative part of the attribute to match the
> >>>> semantic
> >>>> expectations.
> >>>>
> >>>> + }];
> >>>> +}
> >>>> +
> >>>> Index: include/clang/Basic/DiagnosticParseKinds.td
> >>>> ===================================================================
> >>>> --- include/clang/Basic/DiagnosticParseKinds.td
> >>>> +++ include/clang/Basic/DiagnosticParseKinds.td
> >>>> @@ -989,6 +989,8 @@
> >>>> "'#pragma omp %0' cannot be an immediate substatement">;
> >>>> def err_omp_expected_identifier_for_critical : Error<
> >>>> "expected identifier specifying the name of the 'omp
> >>>> critical'
> >>>> directive">;
> >>>> +def err_omp_single_decl_in_declare_simd : Error<
> >>>> + "single declaration is expected with 'declare simd'
> >>>> directive">;
> >>>>
> >>>> // Pragma loop support.
> >>>> def err_pragma_loop_missing_argument : Error<
> >>>> Index: include/clang/Basic/DiagnosticSemaKinds.td
> >>>> ===================================================================
> >>>> --- include/clang/Basic/DiagnosticSemaKinds.td
> >>>> +++ include/clang/Basic/DiagnosticSemaKinds.td
> >>>> @@ -7601,6 +7601,8 @@
> >>>> "the 'copyprivate' clause must not be used with the
> >>>> 'nowait'
> >>>> clause">;
> >>>> def note_omp_nowait_clause_here : Note<
> >>>> "'nowait' clause is here">;
> >>>> +def err_omp_function_expected : Error<
> >>>> + "'#pragma omp declare simd' can be applied to functions or
> >>>> methods
> >>>> only">;
> >>>>
> >>>> I've not seen any tests for ObjC, so does this really apply to
> >>>> methods?
> >>>>
> >>>> } // end of OpenMP category
> >>>>
> >>>> let CategoryName = "Related Result Type Issue" in {
> >>>> Index: include/clang/Sema/Sema.h
> >>>> ===================================================================
> >>>> --- include/clang/Sema/Sema.h
> >>>> +++ include/clang/Sema/Sema.h
> >>>> @@ -144,6 +144,7 @@
> >>>> class ObjCPropertyDecl;
> >>>> class ObjCProtocolDecl;
> >>>> class OMPThreadPrivateDecl;
> >>>> + class OMPDeclareSimdDecl;
> >>>> class OMPClause;
> >>>> class OverloadCandidateSet;
> >>>> class OverloadExpr;
> >>>> @@ -7758,6 +7759,13 @@
> >>>> Stmt *AStmt,
> >>>> SourceLocation
> >>>> StartLoc,
> >>>> SourceLocation
> >>>> EndLoc);
> >>>>
> >>>> + /// \brief Called on well-formed '\#pragma omp declare simd'
> >>>> after
> >>>> parsing of
> >>>> + /// the associated method/function.
> >>>> + DeclGroupPtrTy
> >>>> ActOnOpenMPDeclareSimdDirective(ArrayRef<OMPClause *>
> >>>> Clauses,
> >>>> + Decl *ADecl,
> >>>> + SourceLocation
> >>>> StartLoc,
> >>>> + bool
> >>>> LastDirective);
> >>>> +
> >>>> OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind
> >>>> Kind,
> >>>> Expr *Expr,
> >>>> SourceLocation
> >>>> StartLoc,
> >>>> Index: include/clang/AST/ASTMutationListener.h
> >>>> ===================================================================
> >>>> --- include/clang/AST/ASTMutationListener.h
> >>>> +++ include/clang/AST/ASTMutationListener.h
> >>>> @@ -113,6 +113,12 @@
> >>>> /// \param D the declaration marked OpenMP threadprivate.
> >>>> virtual void DeclarationMarkedOpenMPThreadPrivate(const
> >>>> Decl
> >>>> *D) {}
> >>>>
> >>>> + /// \brief A declaration is marked as OpenMP declare simd
> >>>> which
> >>>> was not
> >>>> + /// previously marked as declare simd.
> >>>> + ///
> >>>> + /// \param D the declaration marked OpenMP declare simd.
> >>>>
> >>>> Capitalize the first word in the documentation part of the
> >>>> sentence.
> >>>>
> >>>> + virtual void DeclarationMarkedOpenMPDeclareSimd(const Decl
> >>>> *D)
> >>>> {}
> >>>> +
> >>>> /// \brief A definition has been made visible by being
> >>>> redefined
> >>>> locally.
> >>>> ///
> >>>> /// \param D The definition that was previously not
> >>>> visible.
> >>>> Index: include/clang/Parse/Parser.h
> >>>> ===================================================================
> >>>> --- include/clang/Parse/Parser.h
> >>>> +++ include/clang/Parse/Parser.h
> >>>> @@ -1019,6 +1019,19 @@
> >>>> CachedTokens *ExceptionSpecTokens;
> >>>> };
> >>>>
> >>>> + /// \brief An OpenMP declaration inside a class.
> >>>> + struct LateParsedOpenMPDeclaration : public
> >>>> LateParsedDeclaration {
> >>>> + explicit LateParsedOpenMPDeclaration(Parser *P) : Self(P)
> >>>> {}
> >>>> +
> >>>> + virtual void ParseLexedMethodDeclarations();
> >>>>
> >>>> Drop the virtual, add override.
> >>>>
> >>>> +
> >>>> + Parser *Self;
> >>>> +
> >>>> + /// \brief The set of tokens that make up an
> >>>> exception-specification
> >>>> that
> >>>> + /// has not yet been parsed.
> >>>> + CachedTokens Tokens;
> >>>> + };
> >>>> +
> >>>> /// LateParsedMemberInitializer - An initializer for a
> >>>> non-static
> >>>> class data
> >>>> /// member whose parsing must to be delayed until the class
> >>>> is
> >>>> completely
> >>>> /// defined (C++11 [class.mem]p2).
> >>>> @@ -2364,7 +2377,13 @@
> >>>>
> >>>> //===--------------------------------------------------------------------===//
> >>>> // OpenMP: Directives and clauses.
> >>>> /// \brief Parses declarative OpenMP directives.
> >>>> - DeclGroupPtrTy ParseOpenMPDeclarativeDirective();
> >>>> + /// \param Level Current level of declarative directive, in
> >>>> case if it
> >>>> is
> >>>>
> >>>> Drop the "if"
> >>>>
> >>>> + /// allowed to apply multiple declarative directives to the
> >>>> same
> >>>> declaration.
> >>>> + DeclGroupPtrTy ParseOpenMPDeclarativeDirective(bool
> >>>> IsInTagDecl,
> >>>> + unsigned Level
> >>>> =
> >>>> 0);
> >>>> + /// \brief Late parse directive.
> >>>> + void LateParseOpenMPDeclarativeDirective(OpenMPDirectiveKind
> >>>> DKind,
> >>>> + SourceLocation Loc);
> >>>> /// \brief Parses simple list of variables.
> >>>> ///
> >>>> /// \param Kind Kind of the directive.
> >>>> Index: include/clang/Serialization/ASTWriter.h
> >>>> ===================================================================
> >>>> --- include/clang/Serialization/ASTWriter.h
> >>>> +++ include/clang/Serialization/ASTWriter.h
> >>>> @@ -859,6 +859,7 @@
> >>>> const ObjCCategoryDecl
> >>>> *ClassExt)
> >>>> override;
> >>>> void DeclarationMarkedUsed(const Decl *D) override;
> >>>> void DeclarationMarkedOpenMPThreadPrivate(const Decl *D)
> >>>> override;
> >>>> + void DeclarationMarkedOpenMPDeclareSimd(const Decl *D)
> >>>> override;
> >>>> void RedefinedHiddenDefinition(const NamedDecl *D, Module
> >>>> *M)
> >>>> override;
> >>>> };
> >>>>
> >>>> Index: lib/Frontend/MultiplexConsumer.cpp
> >>>> ===================================================================
> >>>> --- lib/Frontend/MultiplexConsumer.cpp
> >>>> +++ lib/Frontend/MultiplexConsumer.cpp
> >>>> @@ -127,6 +127,7 @@
> >>>> const ObjCCategoryDecl
> >>>> *ClassExt)
> >>>> override;
> >>>> void DeclarationMarkedUsed(const Decl *D) override;
> >>>> void DeclarationMarkedOpenMPThreadPrivate(const Decl *D)
> >>>> override;
> >>>> + void DeclarationMarkedOpenMPDeclareSimd(const Decl *D)
> >>>> override;
> >>>> void RedefinedHiddenDefinition(const NamedDecl *D, Module
> >>>> *M)
> >>>> override;
> >>>>
> >>>> private:
> >>>> @@ -221,6 +222,11 @@
> >>>> for (size_t i = 0, e = Listeners.size(); i != e; ++i)
> >>>> Listeners[i]->DeclarationMarkedOpenMPThreadPrivate(D);
> >>>> }
> >>>> +void
> >>>> MultiplexASTMutationListener::DeclarationMarkedOpenMPDeclareSimd(
> >>>> + const Decl *D) {
> >>>> + for (size_t i = 0, e = Listeners.size(); i != e; ++i)
> >>>> + Listeners[i]->DeclarationMarkedOpenMPDeclareSimd(D);
> >>>> +}
> >>>>
> >>>> Can you use a range-based for loop please?
> >>>>
> >>>> void
> >>>> MultiplexASTMutationListener::RedefinedHiddenDefinition(const
> >>>> NamedDecl *D,
> >>>> Module
> >>>> *M)
> >>>> {
> >>>> for (auto *L : Listeners)
> >>>> Index: lib/Basic/OpenMPKinds.cpp
> >>>> ===================================================================
> >>>> --- lib/Basic/OpenMPKinds.cpp
> >>>> +++ lib/Basic/OpenMPKinds.cpp
> >>>> @@ -324,6 +324,8 @@
> >>>> break;
> >>>> }
> >>>> break;
> >>>> + case OMPD_declare_simd:
> >>>> + break;
> >>>> case OMPD_unknown:
> >>>> case OMPD_threadprivate:
> >>>> case OMPD_section:
> >>>> Index: lib/Sema/SemaOpenMP.cpp
> >>>> ===================================================================
> >>>> --- lib/Sema/SemaOpenMP.cpp
> >>>> +++ lib/Sema/SemaOpenMP.cpp
> >>>> @@ -1283,6 +1283,7 @@
> >>>> case OMPD_barrier:
> >>>> case OMPD_taskwait:
> >>>> case OMPD_flush:
> >>>> + case OMPD_declare_simd:
> >>>> llvm_unreachable("OpenMP Directive is not allowed");
> >>>> case OMPD_unknown:
> >>>> llvm_unreachable("Unknown OpenMP directive");
> >>>> @@ -1989,6 +1990,7 @@
> >>>> EndLoc);
> >>>> break;
> >>>> case OMPD_threadprivate:
> >>>> + case OMPD_declare_simd:
> >>>> llvm_unreachable("OpenMP Directive is not allowed");
> >>>> case OMPD_unknown:
> >>>> llvm_unreachable("Unknown OpenMP directive");
> >>>> @@ -2006,6 +2008,34 @@
> >>>> return Res;
> >>>> }
> >>>>
> >>>> +Sema::DeclGroupPtrTy
> >>>> +Sema::ActOnOpenMPDeclareSimdDirective(ArrayRef<OMPClause *>
> >>>> Clauses,
> >>>> + Decl *ADecl,
> >>>> SourceLocation
> >>>> StartLoc,
> >>>> + bool LastDirective) {
> >>>> + if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl)) {
> >>>> + ADecl = FTD->getTemplatedDecl();
> >>>> + }
> >>>>
> >>>> Elide braces.
> >>>>
> >>>> + if (!isa<FunctionDecl>(ADecl)) {
> >>>> + Diag(ADecl->getLocation(), diag::err_omp_function_expected)
> >>>> + << ADecl->getDeclContext()->isFileContext();
> >>>> + return DeclGroupPtrTy();
> >>>> + }
> >>>> + if (auto *Attr = ADecl->getAttr<OMPDeclareSimdDeclAttr>()) {
> >>>> + if (!Attr->getComplete()) {
> >>>> + Attr->setNumberOfDirectives(Attr->getNumberOfDirectives()
> >>>> +
> >>>> 1);
> >>>> + if (LastDirective)
> >>>> + Attr->setComplete();
> >>>> + }
> >>>> + } else {
> >>>> + auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit(
> >>>> + Context, 1, LastDirective, SourceRange(StartLoc,
> >>>> StartLoc));
> >>>>
> >>>> This is not an implicit attribute because it's the direct result
> >>>> of
> >>>> the user typing something in source code.
> >>>>
> >>>> + ADecl->addAttr(NewAttr);
> >>>> + if (auto *ML = Context.getASTMutationListener())
> >>>> + ML->DeclarationMarkedOpenMPDeclareSimd(ADecl);
> >>>> + }
> >>>> + return ConvertDeclToDeclGroup(ADecl);
> >>>> +}
> >>>> +
> >>>> StmtResult
> >>>> Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause
> >>>> *>
> >>>> Clauses,
> >>>> Stmt *AStmt,
> >>>> SourceLocation
> >>>> StartLoc,
> >>>> Index: lib/AST/DeclPrinter.cpp
> >>>> ===================================================================
> >>>> --- lib/AST/DeclPrinter.cpp
> >>>> +++ lib/AST/DeclPrinter.cpp
> >>>> @@ -36,6 +36,7 @@
> >>>> void ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls);
> >>>>
> >>>> void Print(AccessSpecifier AS);
> >>>> + void print(OMPDeclareSimdDeclAttr *A);
> >>>>
> >>>> /// Print an Objective-C method type in parentheses.
> >>>> ///
> >>>> @@ -405,7 +406,22 @@
> >>>> }
> >>>> }
> >>>>
> >>>> +void DeclPrinter::print(OMPDeclareSimdDeclAttr *A) {
> >>>> + for (unsigned i = 0; i < A->getNumberOfDirectives(); ++i) {
> >>>> + A->printPrettyPragma(Out, Policy);
> >>>> + Indent();
> >>>> + }
> >>>> +}
> >>>> +
> >>>> void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
> >>>> + if (auto *Attr = D->getAttr<OMPDeclareSimdDeclAttr>()) {
> >>>> + if (D->getTemplatedKind() !=
> >>>> + FunctionDecl::TK_FunctionTemplateSpecialization &&
> >>>> + D->getTemplatedKind() !=
> >>>> FunctionDecl::TK_FunctionTemplate &&
> >>>> + D->getTemplatedKind() !=
> >>>> +
> >>>> FunctionDecl::TK_DependentFunctionTemplateSpecialization)
> >>>> + print(Attr);
> >>>> + }
> >>>> CXXConstructorDecl *CDecl =
> >>>> dyn_cast<CXXConstructorDecl>(D);
> >>>> CXXConversionDecl *ConversionDecl =
> >>>> dyn_cast<CXXConversionDecl>(D);
> >>>> if (!Policy.SuppressSpecifiers) {
> >>>> @@ -912,11 +928,17 @@
> >>>> if (PrintInstantiation) {
> >>>> TemplateParameterList *Params =
> >>>> D->getTemplateParameters();
> >>>> for (auto *I : D->specializations()) {
> >>>> + if (auto *Attr = I->getAttr<OMPDeclareSimdDeclAttr>()) {
> >>>> + print(Attr);
> >>>> + }
> >>>>
> >>>> Elide braces.
> >>>>
> >>>> PrintTemplateParameters(Params,
> >>>> I->getTemplateSpecializationArgs());
> >>>> Visit(I);
> >>>> }
> >>>> }
> >>>>
> >>>> + if (auto *Attr =
> >>>> D->getTemplatedDecl()->getAttr<OMPDeclareSimdDeclAttr>()) {
> >>>> + print(Attr);
> >>>> + }
> >>>>
> >>>> Elide braces.
> >>>>
> >>>> return VisitRedeclarableTemplateDecl(D);
> >>>> }
> >>>>
> >>>> Index: lib/Parse/ParseDeclCXX.cpp
> >>>> ===================================================================
> >>>> --- lib/Parse/ParseDeclCXX.cpp
> >>>> +++ lib/Parse/ParseDeclCXX.cpp
> >>>> @@ -2942,7 +2942,7 @@
> >>>> }
> >>>>
> >>>> if (Tok.is(tok::annot_pragma_openmp)) {
> >>>> - ParseOpenMPDeclarativeDirective();
> >>>> + ParseOpenMPDeclarativeDirective(/*IsInTagDecl=*/true);
> >>>> continue;
> >>>> }
> >>>>
> >>>> Index: lib/Parse/ParseOpenMP.cpp
> >>>> ===================================================================
> >>>> --- lib/Parse/ParseOpenMP.cpp
> >>>> +++ lib/Parse/ParseOpenMP.cpp
> >>>> @@ -30,18 +30,26 @@
> >>>> // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
> >>>> // TODO: add other combined directives in topological
> >>>> order.
> >>>> const OpenMPDirectiveKind F[][3] = {
> >>>> - { OMPD_for, OMPD_simd, OMPD_for_simd },
> >>>> - { OMPD_parallel, OMPD_for, OMPD_parallel_for },
> >>>> - { OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd },
> >>>> - { OMPD_parallel, OMPD_sections, OMPD_parallel_sections }
> >>>> + {OMPD_unknown /*declare*/, OMPD_simd, OMPD_declare_simd},
> >>>> + {OMPD_for, OMPD_simd, OMPD_for_simd},
> >>>> + {OMPD_parallel, OMPD_for, OMPD_parallel_for},
> >>>> + {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd},
> >>>> + {OMPD_parallel, OMPD_sections, OMPD_parallel_sections}
> >>>> };
> >>>> auto Tok = P.getCurToken();
> >>>> auto DKind =
> >>>> Tok.isAnnotation()
> >>>> ? OMPD_unknown
> >>>> :
> >>>> getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
> >>>> + bool TokenMatched = false;
> >>>> for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) {
> >>>> - if (DKind == F[i][0]) {
> >>>> + if (!Tok.isAnnotation() && DKind == OMPD_unknown) {
> >>>> + TokenMatched =
> >>>> + (i == 0) &&
> >>>> !P.getPreprocessor().getSpelling(Tok).compare("declare");
> >>>> + } else {
> >>>> + TokenMatched = DKind == F[i][0];
> >>>> + }
> >>>>
> >>>> Elide braces.
> >>>>
> >>>> + if (TokenMatched) {
> >>>> Tok = P.getPreprocessor().LookAhead(0);
> >>>> auto SDKind =
> >>>> Tok.isAnnotation()
> >>>> @@ -61,13 +69,17 @@
> >>>> /// threadprivate-directive:
> >>>> /// annot_pragma_openmp 'threadprivate'
> >>>> simple-variable-list
> >>>> ///
> >>>> -Parser::DeclGroupPtrTy
> >>>> Parser::ParseOpenMPDeclarativeDirective()
> >>>> {
> >>>> +Parser::DeclGroupPtrTy
> >>>> +Parser::ParseOpenMPDeclarativeDirective(bool IsInTagDecl,
> >>>> unsigned Level)
> >>>> {
> >>>> assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP
> >>>> directive!");
> >>>> ParenBraceBracketBalancer BalancerRAIIObj(*this);
> >>>>
> >>>> + auto AnnotationVal =
> >>>> reinterpret_cast<uintptr_t>(Tok.getAnnotationValue());
> >>>> SourceLocation Loc = ConsumeToken();
> >>>> SmallVector<Expr *, 5> Identifiers;
> >>>> - auto DKind = ParseOpenMPDirectiveKind(*this);
> >>>> + OpenMPDirectiveKind DKind =
> >>>> + (AnnotationVal == 0) ? ParseOpenMPDirectiveKind(*this)
> >>>> + :
> >>>> static_cast<OpenMPDirectiveKind>(AnnotationVal);
> >>>>
> >>>> switch (DKind) {
> >>>> case OMPD_threadprivate:
> >>>> @@ -85,6 +97,86 @@
> >>>> return Actions.ActOnOpenMPThreadprivateDirective(Loc,
> >>>> Identifiers);
> >>>> }
> >>>> break;
> >>>> + case OMPD_declare_simd: {
> >>>> + // The syntax is:
> >>>> + // { #pragma omp declare simd }
> >>>> + // <function-declaration-or-definition>
> >>>> + //
> >>>> + if (AnnotationVal == 0) {
> >>>> + // Skip 'simd' if it was restored from cached tokens.
> >>>> + ConsumeToken();
> >>>> + }
> >>>>
> >>>> Elide braces.
> >>>>
> >>>> + if (IsInTagDecl) {
> >>>> +
> >>>> LateParseOpenMPDeclarativeDirective(/*DKind=*/OMPD_declare_simd,
> >>>> Loc);
> >>>> + return DeclGroupPtrTy();
> >>>> + }
> >>>> +
> >>>> + SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
> >>>> OMPC_unknown
> >>>> + 1>
> >>>> + FirstClauses(OMPC_unknown + 1);
> >>>> + SmallVector<OMPClause *, 4> Clauses;
> >>>> + SmallVector<Token, 8> CachedPragmas;
> >>>> +
> >>>> + while (Tok.isNot(tok::annot_pragma_openmp_end) &&
> >>>> Tok.isNot(tok::eof)) {
> >>>> + CachedPragmas.push_back(Tok);
> >>>> + ConsumeAnyToken();
> >>>> + }
> >>>> + CachedPragmas.push_back(Tok);
> >>>> + if (Tok.isNot(tok::eof))
> >>>> + ConsumeAnyToken();
> >>>> +
> >>>> + DeclGroupPtrTy Ptr;
> >>>> + if (Tok.is(tok::annot_pragma_openmp)) {
> >>>> + Ptr = ParseOpenMPDeclarativeDirective(IsInTagDecl, Level
> >>>> +
> >>>> 1);
> >>>> + } else {
> >>>> + // Here we expect to see some function declaration.
> >>>> + ParsedAttributesWithRange attrs(AttrFactory);
> >>>> + MaybeParseCXX11Attributes(attrs);
> >>>> + MaybeParseMicrosoftAttributes(attrs);
> >>>> + ParsingDeclSpec PDS(*this);
> >>>> + Ptr = ParseExternalDeclaration(attrs, &PDS);
> >>>>
> >>>> This really weirds me out. That means this function doesn't
> >>>> parse
> >>>> just
> >>>> the pragma, it also parses any external declaration.
> >>>>
> >>>> + }
> >>>> + if (!Ptr || Ptr.get().isNull())
> >>>> + return DeclGroupPtrTy();
> >>>> + if (Ptr.get().isDeclGroup()) {
> >>>> + Diag(Tok, diag::err_omp_single_decl_in_declare_simd);
> >>>> + return DeclGroupPtrTy();
> >>>> + }
> >>>> +
> >>>> + // Append the current token at the end of the new token
> >>>> stream so
> >>>> that it
> >>>> + // doesn't get lost.
> >>>> + CachedPragmas.push_back(Tok);
> >>>> + // Push back tokens for pragma.
> >>>> + PP.EnterTokenStream(CachedPragmas.data(),
> >>>> CachedPragmas.size(),
> >>>> + /*DisableMacroExpansion=*/true,
> >>>> + /*OwnsTokens=*/false);
> >>>> + // Parse pragma itself.
> >>>> + // Consume the previously pushed token.
> >>>> + ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
> >>>> +
> >>>> + Actions.StartOpenMPClauses();
> >>>> + while (Tok.isNot(tok::annot_pragma_openmp_end)) {
> >>>> + OpenMPClauseKind CKind = Tok.isAnnotation()
> >>>> + ? OMPC_unknown
> >>>> + :
> >>>> getOpenMPClauseKind(PP.getSpelling(Tok));
> >>>> + OMPClause *Clause =
> >>>> + ParseOpenMPClause(DKind, CKind,
> >>>> !FirstClauses[CKind].getInt());
> >>>> + FirstClauses[CKind].setInt(true);
> >>>> + if (Clause) {
> >>>> + FirstClauses[CKind].setPointer(Clause);
> >>>> + Clauses.push_back(Clause);
> >>>> + }
> >>>> +
> >>>> + // Skip ',' if any.
> >>>> + if (Tok.is(tok::comma))
> >>>> + ConsumeToken();
> >>>> + }
> >>>> + Actions.EndOpenMPClauses();
> >>>> + // Consume final annot_pragma_openmp_end.
> >>>> + ConsumeToken();
> >>>> +
> >>>> + return Actions.ActOnOpenMPDeclareSimdDirective(
> >>>> + Clauses, Ptr.get().getSingleDecl(), Loc, Level == 0);
> >>>> + }
> >>>> case OMPD_unknown:
> >>>> Diag(Tok, diag::err_omp_unknown_directive);
> >>>> break;
> >>>> @@ -118,6 +210,69 @@
> >>>> return DeclGroupPtrTy();
> >>>> }
> >>>>
> >>>> +/// \brief Late parsing of declarative OpenMP directives.
> >>>> +///
> >>>> +/// threadprivate-directive:
> >>>> +/// annot_pragma_openmp 'threadprivate'
> >>>> simple-variable-list
> >>>>
> >>>> The comments don't look correct here.
> >>>>
> >>>> +/// annot_pragma_openmp_end
> >>>> +///
> >>>> +void
> >>>> Parser::LateParseOpenMPDeclarativeDirective(OpenMPDirectiveKind
> >>>> DKind,
> >>>> + SourceLocation
> >>>> Loc) {
> >>>> + if (DKind == OMPD_declare_simd) {
> >>>> + LateParsedOpenMPDeclaration *Decl = new
> >>>> LateParsedOpenMPDeclaration(this);
> >>>> + getCurrentClass().LateParsedDeclarations.push_back(Decl);
> >>>> +
> >>>> + Token LocalTok;
> >>>> + LocalTok.startToken();
> >>>> + LocalTok.setKind(tok::annot_pragma_openmp);
> >>>> + LocalTok.setLocation(Loc);
> >>>> + LocalTok.setAnnotationValue(
> >>>> + reinterpret_cast<void
> >>>> *>(static_cast<uintptr_t>(OMPD_declare_simd)));
> >>>> + Decl->Tokens.push_back(LocalTok);
> >>>> +
> >>>> + do {
> >>>> + while (Tok.isNot(tok::annot_pragma_openmp_end) &&
> >>>> Tok.isNot(tok::eof)) {
> >>>> + Decl->Tokens.push_back(Tok);
> >>>> + ConsumeAnyToken();
> >>>> + }
> >>>> + Decl->Tokens.push_back(Tok);
> >>>> + if (Tok.isNot(tok::eof))
> >>>> + ConsumeAnyToken();
> >>>> + } while (Tok.is(tok::annot_pragma_openmp));
> >>>> +
> >>>> + LexTemplateFunctionForLateParsing(Decl->Tokens);
> >>>> + }
> >>>> +}
> >>>> +
> >>>> +/// \brief Actual parsing of late OpenMP declaration.
> >>>> +void
> >>>> Parser::LateParsedOpenMPDeclaration::ParseLexedMethodDeclarations()
> >>>> {
> >>>> + // Save the current token position.
> >>>> + SourceLocation OrigLoc = Self->Tok.getLocation();
> >>>> +
> >>>> + assert(!Tokens.empty() && "Empty body!");
> >>>>
> >>>> Is this safe to assert in a parsing method, or should this be
> >>>> diagnosed?
> >>>>
> >>>> + // Append the current token at the end of the new token
> >>>> stream
> >>>> so that
> >>>> it
> >>>> + // doesn't get lost.
> >>>> + Tokens.push_back(Self->Tok);
> >>>> + Self->PP.EnterTokenStream(Tokens.data(), Tokens.size(), true,
> >>>> false);
> >>>> +
> >>>> + // Consume the previously pushed token.
> >>>> + Self->ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
> >>>> +
> >>>> + Self->ParseOpenMPDeclarativeDirective(/*IsInTagDecl=*/false);
> >>>> +
> >>>> + if (Self->Tok.getLocation() != OrigLoc) {
> >>>> + // Due to parsing error, we either went over the cached
> >>>> tokens or
> >>>> + // there are still cached tokens left. If it's the latter
> >>>> case skip
> >>>> the
> >>>> + // leftover tokens.
> >>>> + // Since this is an uncommon situation that should be
> >>>> avoided, use
> >>>> the
> >>>> + // expensive isBeforeInTranslationUnit call.
> >>>> + if (Self->PP.getSourceManager().isBeforeInTranslationUnit(
> >>>> + Self->Tok.getLocation(), OrigLoc))
> >>>> + while (Self->Tok.getLocation() != OrigLoc &&
> >>>> Self->Tok.isNot(tok::eof))
> >>>> + Self->ConsumeAnyToken();
> >>>>
> >>>> Has this situation already been diagnosed? If so, then why are
> >>>> we
> >>>> generating the tokens in a way that require this work? And if
> >>>> not,
> >>>> are
> >>>> we missing a diagnostic here?
> >>>>
> >>>> + }
> >>>> +}
> >>>> +
> >>>> /// \brief Parsing of declarative or executable OpenMP
> >>>> directives.
> >>>> ///
> >>>> /// threadprivate-directive:
> >>>> @@ -274,6 +429,11 @@
> >>>> OMPDirectiveScope.Exit();
> >>>> break;
> >>>> }
> >>>> + case OMPD_declare_simd:
> >>>> + Diag(Tok, diag::err_omp_unexpected_directive)
> >>>> + << getOpenMPDirectiveName(DKind);
> >>>> + SkipUntil(tok::annot_pragma_openmp_end);
> >>>> + break;
> >>>> case OMPD_unknown:
> >>>> Diag(Tok, diag::err_omp_unknown_directive);
> >>>> SkipUntil(tok::annot_pragma_openmp_end);
> >>>> Index: lib/Parse/Parser.cpp
> >>>> ===================================================================
> >>>> --- lib/Parse/Parser.cpp
> >>>> +++ lib/Parse/Parser.cpp
> >>>> @@ -653,7 +653,7 @@
> >>>> HandlePragmaOpenCLExtension();
> >>>> return DeclGroupPtrTy();
> >>>> case tok::annot_pragma_openmp:
> >>>> - return ParseOpenMPDeclarativeDirective();
> >>>> + return
> >>>> ParseOpenMPDeclarativeDirective(/*IsInTagDecl=*/false);
> >>>> case tok::annot_pragma_ms_pointers_to_members:
> >>>> HandlePragmaMSPointersToMembers();
> >>>> return DeclGroupPtrTy();
> >>>> Index: lib/Serialization/ASTReaderDecl.cpp
> >>>> ===================================================================
> >>>> --- lib/Serialization/ASTReaderDecl.cpp
> >>>> +++ lib/Serialization/ASTReaderDecl.cpp
> >>>> @@ -3888,6 +3888,14 @@
> >>>> Reader.Context, ReadSourceRange(Record, Idx)));
> >>>> break;
> >>>>
> >>>> + case UPD_DECL_MARKED_OPENMP_DECLARE_SIMD: {
> >>>> + auto *Attr = OMPDeclareSimdDeclAttr::CreateImplicit(
> >>>> + Reader.Context, Record[Idx++], Record[Idx++] != 0,
> >>>> + ReadSourceRange(Record, Idx));
> >>>>
> >>>> Attribute is not implicit.
> >>>>
> >>>> + D->addAttr(Attr);
> >>>> + break;
> >>>> + }
> >>>> +
> >>>> case UPD_DECL_EXPORTED:
> >>>> unsigned SubmoduleID = readSubmoduleID(Record, Idx);
> >>>> auto *Exported = cast<NamedDecl>(D);
> >>>> Index: lib/Serialization/ASTCommon.h
> >>>> ===================================================================
> >>>> --- lib/Serialization/ASTCommon.h
> >>>> +++ lib/Serialization/ASTCommon.h
> >>>> @@ -36,6 +36,7 @@
> >>>> UPD_MANGLING_NUMBER,
> >>>> UPD_STATIC_LOCAL_NUMBER,
> >>>> UPD_DECL_MARKED_OPENMP_THREADPRIVATE,
> >>>> + UPD_DECL_MARKED_OPENMP_DECLARE_SIMD,
> >>>> UPD_DECL_EXPORTED
> >>>> };
> >>>>
> >>>> Index: lib/Serialization/ASTWriter.cpp
> >>>> ===================================================================
> >>>> --- lib/Serialization/ASTWriter.cpp
> >>>> +++ lib/Serialization/ASTWriter.cpp
> >>>> @@ -4615,6 +4615,14 @@
> >>>> Record);
> >>>> break;
> >>>>
> >>>> + case UPD_DECL_MARKED_OPENMP_DECLARE_SIMD: {
> >>>> + auto *Attr = D->getAttr<OMPDeclareSimdDeclAttr>();
> >>>> + AddSourceRange(Attr->getRange(), Record);
> >>>> + Record.push_back(Attr->getNumberOfDirectives());
> >>>> + Record.push_back(Attr->getComplete() ? 1 : 0);
> >>>> + break;
> >>>> + }
> >>>> +
> >>>> case UPD_DECL_EXPORTED:
> >>>> Record.push_back(getSubmoduleID(Update.getModule()));
> >>>> break;
> >>>> @@ -5761,6 +5769,14 @@
> >>>>
> >>>> DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_THREADPRIVATE));
> >>>> }
> >>>>
> >>>> +void ASTWriter::DeclarationMarkedOpenMPDeclareSimd(const Decl
> >>>> *D)
> >>>> {
> >>>> + assert(!WritingAST && "Already writing the AST!");
> >>>> + if (!D->isFromASTFile())
> >>>> + return;
> >>>> +
> >>>> +
> >>>> DeclUpdates[D].push_back(DeclUpdate(UPD_DECL_MARKED_OPENMP_DECLARE_SIMD));
> >>>> +}
> >>>> +
> >>>> void ASTWriter::RedefinedHiddenDefinition(const NamedDecl *D,
> >>>> Module *M)
> >>>> {
> >>>> assert(!WritingAST && "Already writing the AST!");
> >>>> assert(D->isHidden() && "expected a hidden declaration");
> >>>
>
>
--
Hal Finkel
Assistant Computational Scientist
Leadership Computing Facility
Argonne National Laboratory
More information about the cfe-commits
mailing list