[OPENMP 4.0] Initial support for '#pragma omp declare simd' directive.

[ABataev]

Summary

Initial 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 applied 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 applied to.
A delayed parsing is used for parsing a pragma itself, because this directive has several clauses that can reference arguments of the associated function.

[hfinkel]

test/OpenMP/declare_simd_ast_print.c

11

I understand that the point is that you can have multiple 'declare simd' directives for the same function. However, if you have actual duplicates, should we issue a warning?

[ABataev]

Hal, I don't think that this is necessary (at least now). It does not
change anything, the function still must be marked as simd. There will
be additional analysis for clauses, because most of clauses arguments
must be referenced only once.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

23.06.2015 4:25, [e-mail] пишет:

Comment at: test/OpenMP/declare_simd_ast_print.c:10
@@ +9,3 @@
+#pragma omp declare simd
+#pragma omp declare simd

+void add_1(float *d, float *s1, float *s2);

I understand that the point is that you can have multiple 'declare simd' directives for the same function. However, if you have actual duplicates, should we issue a warning?

http://reviews.llvm.org/D10599

EMAIL PREFERENCES

http://reviews.llvm.org/settings/panel/emailpreferences/

[ABataev]

Ping!

[ABataev]

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:

#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.

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).

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.

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.

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.

Attribute is not implicit.

Fixed.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

06.07.2015 16:13, Aaron Ballman пишет:

[ABataev]

Update after review

[ABataev]

Update after review

[aaron.ballman]

LGTM with one question below. I would wait for review from Richard or
Hal before committing.

Index: lib/Parse/ParseOpenMP.cpp

• lib/Parse/ParseOpenMP.cpp

+++ lib/Parse/ParseOpenMP.cpp
@@ -30,6 +30,7 @@

// E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
// TODO: add other combined directives in topological order.
const OpenMPDirectiveKind F[][3] = {

+ {OMPD_unknown /*declare*/, OMPD_simd, OMPD_declare_simd},

{OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/,
 OMPD_cancellation_point},
{OMPD_for, OMPD_simd, OMPD_for_simd},

@@ -43,25 +44,25 @@

        : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
bool TokenMatched = false;
for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) {

• if (!Tok.isAnnotation() && DKind == OMPD_unknown) {

+ if (!Tok.isAnnotation() && DKind == OMPD_unknown)

TokenMatched =

• (i == 0) &&
• !P.getPreprocessor().getSpelling(Tok).compare("cancellation");
• } else {

+ ((i == 0) &&
+ !P.getPreprocessor().getSpelling(Tok).compare("declare")) ||
+ ((i == 1) &&
+ !P.getPreprocessor().getSpelling(Tok).compare("cancellation"));
+ else

TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown;

• } if (TokenMatched) { Tok = P.getPreprocessor().LookAhead(0); auto SDKind = Tok.isAnnotation() ? OMPD_unknown : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
• if (!Tok.isAnnotation() && DKind == OMPD_unknown) {

+ if (!Tok.isAnnotation() && SDKind == OMPD_unknown)

TokenMatched =

• (i == 0) && !P.getPreprocessor().getSpelling(Tok).compare("point");
• } else {

+ (i == 1) && !P.getPreprocessor().getSpelling(Tok).compare("point");
+ else

TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown;

• } if (TokenMatched) { P.ConsumeToken(); DKind = F[i][2];

@@ -75,14 +76,25 @@
/
/ threadprivate-directive:
/ annot_pragma_openmp 'threadprivate' simple-variable-list
+/ annot_pragma_omp_end
/
-Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
+/ declare-simd-directive:
+/ annot_pragma_openmp 'declare simd' {<clause> [,]}
+/ annot_pragma_omp_end
+/ <function declaration/definition>
+/
+Parser::DeclGroupPtrTy
+Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(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:

@@ -100,6 +112,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();
+ if (IsInTagDecl) {
+ LateParseOpenMPDeclarativeDirectiveWithTemplateFunction(
+ /*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 = ParseOpenMPDeclarativeDirectiveWithExtDecl(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);
+ }
+ if (!Ptr || Ptr.get().isNull())
+ return DeclGroupPtrTy();
+ if (Ptr.get().isDeclGroup()) {
+ Diag(Tok, diag::err_omp_single_decl_in_declare_simd);
+ return DeclGroupPtrTy();

Would it make sense to return Ptr here instead so that further
diagnostics can be reported?

~Aaron

[hfinkel]

In D10599#201312, @aaron.ballman wrote:

LGTM with one question below. I would wait for review from Richard or
Hal before committing.

I'm not really the right person to okay this patch. Richard, can you please look at this?

Index: lib/Parse/ParseOpenMP.cpp

• lib/Parse/ParseOpenMP.cpp

+++ lib/Parse/ParseOpenMP.cpp
@@ -30,6 +30,7 @@

// E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
// TODO: add other combined directives in topological order.
const OpenMPDirectiveKind F[][3] = {

+ {OMPD_unknown /*declare*/, OMPD_simd, OMPD_declare_simd},

{OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/,
 OMPD_cancellation_point},
{OMPD_for, OMPD_simd, OMPD_for_simd},

@@ -43,25 +44,25 @@

        : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
bool TokenMatched = false;
for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) {

• if (!Tok.isAnnotation() && DKind == OMPD_unknown) {

+ if (!Tok.isAnnotation() && DKind == OMPD_unknown)

TokenMatched =

• (i == 0) &&
• !P.getPreprocessor().getSpelling(Tok).compare("cancellation");
• } else {

+ ((i == 0) &&
+ !P.getPreprocessor().getSpelling(Tok).compare("declare")) ||
+ ((i == 1) &&
+ !P.getPreprocessor().getSpelling(Tok).compare("cancellation"));
+ else

TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown;

• } if (TokenMatched) { Tok = P.getPreprocessor().LookAhead(0); auto SDKind = Tok.isAnnotation() ? OMPD_unknown : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
• if (!Tok.isAnnotation() && DKind == OMPD_unknown) {

+ if (!Tok.isAnnotation() && SDKind == OMPD_unknown)

TokenMatched =

• (i == 0) && !P.getPreprocessor().getSpelling(Tok).compare("point");
• } else {

+ (i == 1) && !P.getPreprocessor().getSpelling(Tok).compare("point");
+ else

TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown;

• } if (TokenMatched) { P.ConsumeToken(); DKind = F[i][2];

@@ -75,14 +76,25 @@
/
/ threadprivate-directive:
/ annot_pragma_openmp 'threadprivate' simple-variable-list
+/ annot_pragma_omp_end
/
-Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
+/ declare-simd-directive:
+/ annot_pragma_openmp 'declare simd' {<clause> [,]}
+/ annot_pragma_omp_end
+/ <function declaration/definition>
+/
+Parser::DeclGroupPtrTy
+Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(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:

@@ -100,6 +112,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();
+ if (IsInTagDecl) {
+ LateParseOpenMPDeclarativeDirectiveWithTemplateFunction(
+ /*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 = ParseOpenMPDeclarativeDirectiveWithExtDecl(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);
+ }
+ if (!Ptr || Ptr.get().isNull())
+ return DeclGroupPtrTy();
+ if (Ptr.get().isDeclGroup()) {
+ Diag(Tok, diag::err_omp_single_decl_in_declare_simd);
+ return DeclGroupPtrTy();

Would it make sense to return Ptr here instead so that further
diagnostics can be reported?

~Aaron

lib/Parse/ParseOpenMP.cpp

155

This is not your fault, and should not be fixed by this patch, but this series of three:

ParsedAttributesWithRange Attrs(AttrFactory);
MaybeParseCXX11Attributes(Attrs);
MaybeParseMicrosoftAttributes(Attrs);

occurs a lot. It would be nice to factor this into one function to reduce the amount of repeated logic.

[ABataev]

Would it make sense to return Ptr here instead so that further
diagnostics can be reported?

I think you're right. Will be fixed.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

08.07.2015 23:55, Aaron Ballman пишет:

LGTM with one question below. I would wait for review from Richard or
Hal before committing.

Index: lib/Parse/ParseOpenMP.cpp

• lib/Parse/ParseOpenMP.cpp

+++ lib/Parse/ParseOpenMP.cpp
@@ -30,6 +30,7 @@

// E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
// TODO: add other combined directives in topological order.
const OpenMPDirectiveKind F[][3] = {

+ {OMPD_unknown /*declare*/, OMPD_simd, OMPD_declare_simd},

{OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/,
 OMPD_cancellation_point},
{OMPD_for, OMPD_simd, OMPD_for_simd},

@@ -43,25 +44,25 @@

        : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
bool TokenMatched = false;
for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) {

• if (!Tok.isAnnotation() && DKind == OMPD_unknown) {

+ if (!Tok.isAnnotation() && DKind == OMPD_unknown)

TokenMatched =

• (i == 0) &&
• !P.getPreprocessor().getSpelling(Tok).compare("cancellation");
• } else {

+ ((i == 0) &&
+ !P.getPreprocessor().getSpelling(Tok).compare("declare")) ||
+ ((i == 1) &&
+ !P.getPreprocessor().getSpelling(Tok).compare("cancellation"));
+ else

TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown;

• } if (TokenMatched) { Tok = P.getPreprocessor().LookAhead(0); auto SDKind = Tok.isAnnotation() ? OMPD_unknown : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
• if (!Tok.isAnnotation() && DKind == OMPD_unknown) {

+ if (!Tok.isAnnotation() && SDKind == OMPD_unknown)

TokenMatched =

• (i == 0) && !P.getPreprocessor().getSpelling(Tok).compare("point");
• } else {

+ (i == 1) && !P.getPreprocessor().getSpelling(Tok).compare("point");
+ else

TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown;

• } if (TokenMatched) { P.ConsumeToken(); DKind = F[i][2];

@@ -75,14 +76,25 @@

///
///       threadprivate-directive:
///         annot_pragma_openmp 'threadprivate' simple-variable-list

+/// annot_pragma_omp_end

///

-Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
+/ declare-simd-directive:
+/ annot_pragma_openmp 'declare simd' {<clause> [,]}
+/ annot_pragma_omp_end
+/ <function declaration/definition>
+///
+Parser::DeclGroupPtrTy
+Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(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:

@@ -100,6 +112,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();
+ if (IsInTagDecl) {
+ LateParseOpenMPDeclarativeDirectiveWithTemplateFunction(
+ /*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 = ParseOpenMPDeclarativeDirectiveWithExtDecl(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);
+ }
+ if (!Ptr || Ptr.get().isNull())
+ return DeclGroupPtrTy();
+ if (Ptr.get().isDeclGroup()) {
+ Diag(Tok, diag::err_omp_single_decl_in_declare_simd);
+ return DeclGroupPtrTy();

Would it make sense to return Ptr here instead so that further
diagnostics can be reported?

~Aaron

[ABataev]

Update after review

[ABataev]

Ping

[ABataev]

Ping!

[rsmith]

You have a lot of logic here to handle delayed parsing, but none of your testcases need any delayed parsing.

Are you supporting delayed parsing just to deal with the argument-list in the various clauses? (Your current delayed parsing support doesn't work for that, because the pragma is not parsed within the scope of the function prototype.) If so, have you considered producing a list of identifiers from the parser, and looking them up when the attribute is applied to the declaration in Sema? That would seem to remove the need for all of the delayed parsing.

lib/Parse/ParseOpenMP.cpp

149–150

So, you can combine "#pragma omp declare simd" with other pragmas, but only if the simd pragmas come first?

test/OpenMP/declare_simd_ast_print.cpp

35

This is an explicit specialization, not an instantiation.

[rsmith]

include/clang/AST/ASTMutationListener.h

118–122 ↗

(On Diff #29297)

Why do you need this? Isn't the attribute always applied to a "fresh" declaration (one that was recently created, rather than one that was imported from an external source)?

include/clang/Basic/Attr.td

2093

Comment is out of date.

2104–2105

Why do you need setters?

include/clang/Parse/Parser.h

1035

exception-specification?

lib/AST/DeclPrinter.cpp

422–437

This level of special-casing is not OK, please find a more general way of dealing with this.

lib/Parse/ParseOpenMP.cpp

96

IsInTagDecl is the wrong name for this; enums are tag decls, but they shouldn't get this treatment.

208

What does this have to do with "TemplateFunction"s?

232

This doesn't make sense; that function is for MS-compatibility delayed template parsing, which seems entirely unrelated to this OpenMP pragma.

[ABataev]

Update after review

[rsmith]

Please find a better way to handle this attribute in DeclPrinter. Perhaps you could generalize your existing support to cover all attributes with pragma spelling?

lib/Parse/ParseDeclCXX.cpp

2816

Please can you split this refactoring out into a separate commit? That'll make the functional change here (handling annot_pragma_openmp) much easier for future code archaeologists to see.

lib/Parse/ParseOpenMP.cpp

50–74

Bracing here is now inconsistent.

147

Add braces around this multi-line else (and the corresponding if for consistency).

151

Do you really need both these checks?

168–174

Why are you doing this delayed parsing? You still seem to have no tests that require it.

lib/Sema/SemaOpenMP.cpp

2167

You don't use Clauses for anything in here; is that intentional?

[ABataev]

Richard, thanks for the review. I'll try to fix printing of pragmas.

lib/Parse/ParseDeclCXX.cpp

2816

Ok, done

lib/Parse/ParseOpenMP.cpp

50–74

Fixed, thanks

147

Done, thanks

151

Removed the second one and turned it to assert()

168–174

We need it for future parsing of clauses associated with the 'declare simd' construct. Some of the clauses may have references to function arguments. That's why I'm using delayed parsing: at first we need to parse a function along with arguments and only then we'll parse all the pragmas along with their clauses and references to args.
Of course currently it is not used, because this patch does not introduce parsing of clauses. It will be added later.

lib/Sema/SemaOpenMP.cpp

2167

It will be used later when we'll add parsing of clauses for this pragma

[rsmith]

lib/Parse/ParseOpenMP.cpp

168–174

This code won't work for that; you've left the scope of the function parameters, so lookup for them will fail here. Generally-speaking, we don't like speculative / untested code to be committed, and would prefer to hold back on those changes until we can actually test them in some way.

Here's what I suggest: remove the delayed parsing code from here for this commit (parse the pragma first, then parse the nested declaration, then act on the result), and bring that code back once you introduce parsing for a clause that needs it, if indeed that's the right approach for those clauses. (As I mentioned before, if all they do is to provide a list of identifiers naming parameters, you don't need delay parsing and can instead store them as identifiers and look them up in Sema after the fact. On the other hand, if this pragma allows an arbitrary expression referencing a parameter to appear before the declaration of that parameter, then we'll need something like delayed parsing.)

[rsmith]

See also this unanswered question on the OpenMP forums:
http://openmp.org/forum/viewtopic.php?f=12&t=1532

[ABataev]

Ok,
I'll remove it for now and rework it later when it will be required.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

01.08.2015 0:07, Richard Smith пишет:

rsmith added inline comments.

Comment at: lib/Parse/ParseOpenMP.cpp:171-177
@@ +170,9 @@
+
+ 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.

ABataev wrote:

rsmith wrote:

Why are you doing this delayed parsing? You still seem to have no tests that require it.

We need it for future parsing of clauses associated with the 'declare simd' construct. Some of the clauses may have references to function arguments. That's why I'm using delayed parsing: at first we need to parse a function along with arguments and only then we'll parse all the pragmas along with their clauses and references to args.
Of course currently it is not used, because this patch does not introduce parsing of clauses. It will be added later.

This code won't work for that; you've left the scope of the function parameters, so lookup for them will fail here. Generally-speaking, we don't like speculative / untested code to be committed, and would prefer to hold back on those changes until we can actually test them in some way.

Here's what I suggest: remove the delayed parsing code from here for this commit (parse the pragma first, then parse the nested declaration, then act on the result), and bring that code back once you introduce parsing for a clause that needs it, if indeed that's the right approach for those clauses. (As I mentioned before, if all they do is to provide a list of identifiers naming parameters, you don't need delay parsing and can instead store them as identifiers and look them up in Sema after the fact. On the other hand, if this pragma allows an arbitrary expression referencing a parameter to appear before the declaration of that parameter, then we'll need something like delayed parsing.)

http://reviews.llvm.org/D10599

[ABataev]

Update after review

[ABataev]

Richard?

[rsmith]

include/clang/Basic/Attr.td

2098–2102

What's this for?

include/clang/Basic/DiagnosticParseKinds.td

996–999

with -> after, in both diagnstics.

include/clang/Basic/DiagnosticSemaKinds.td

7664

can be applied to functions only -> can only be applied to functions

lib/AST/DeclPrinter.cpp

214

It looks like we would no longer print attributes with pragma spelling for non-function declarations after this change (but I don't think we have any such pragmas at the moment). I don't want to ask you to write a bunch more code here that you can't test, but can you add a FIXME somewhere in here to add calls to print pragmas in more places?

lib/Parse/ParseOpenMP.cpp

133

You should bail out if you don't actually find your desired token. If you carry on without checking, your ConsumeToken call might consume the tok::eof token or some similar bad thing.

144–145

I find this loop slightly surprising: the cases where Parse*Declaration return a null DeclGroupPtrTy are when they parsed some declaration-like entity (such as a declaration-like pragma) but didn't create some declaration to represent it.

Do you really want to allow such things between your pragma and its associated function? As an extreme case, you'd accept things like this:

#pragma omp declare simd
#pragma pack (...)
;
public:
__if_exists(foo) {
  int n;
}
int the_simd_function();

145

Do you really need to check both !Ptr and Ptr.get().isNull() here? Generally, the parser shouldn't really be calling get() on an OpaquePtr -- these pointers are supposed to be opaque to the parser.

160

The only way you could get here without being at EOF or EOM would be if you hit an unexpected right-brace. Shouldn't you diagnose that? For instance, it looks like you won't diagnose this case:

namespace N {
  #pragma omp declare simd
}

162–168

I would suggest that you instead call ActOnOpenMPDeclareSimdDirective unconditionally, pass in Ptr rather than its contained declaration, and check for a single declaration in Sema -- this seems much more of a semantic check than a syntactic one.

[ABataev]

Richard, thanks for the review!

include/clang/Basic/Attr.td

2098–2102

This is required for proper AST printing of pragma. Without this additional member (this one is required for pragma attributes by attribute generation system) all pragmas will be printed in one line.

include/clang/Basic/DiagnosticParseKinds.td

996–999

Done, thanks.

include/clang/Basic/DiagnosticSemaKinds.td

7664

Done

lib/AST/DeclPrinter.cpp

214

Ok, will do.

lib/Parse/ParseOpenMP.cpp

133

Done, thanks.

144–145

We need to be able to combine 'declare simd' pragma with other pragmas, for example:

#pragma omp declare simd
#pragma GCC visibility push(default)
#pragma options align=packed
#pragma omp declare simd
#pragma GCC visibility pop
int tadd(int b) { return x[b] + b; }

We should be able to accept such code. But I will reduce the number of allowed constructs.

145

Ok, removed Ptr.get().isNull()

162–168

Ok, done

[ABataev]

Update after review

[ABataev]

Ping

[ABataev]

Richard, any comments about latest version?

[ABataev]

Ping

[rsmith]

include/clang/Basic/Attr.td

2098–2102

Can we instead handle this in the generated code? Presumably we'd get this wrong in the same way for all attributes with pragma spelling?

lib/Parse/ParseOpenMP.cpp

133

Hmm, on reflection it would be better to use:

while (Tok.isNot(tok::annot_pragma_openmp_end))
  ConsumeAnyToken();

We know that there is an annot_pragma_openmp_end token coming, but SkipUntil might stop early if there's (say) a stray right-paren in the token stream.

144–145

I don't think your example is reasonable to accept. Right now (prior to your patch), we have two fundamentally different kinds of pragmas:

1. Lexer-level pragmas. These can appear anywhere in the token stream, and take effect immediately. These are handled entirely by the lexer.

2. Declaration-like pragmas. These can only appear where a declaration is permitted, and act as if they declare ... something. We transform these into tokens and handle them in the parser.

You're adding a third kind of pragma, an attribute-like pragma, that can only appear before declarations. As such, if your pragma appears before a pragma of kind 2 (such as #pragma GCC visibility), it should act as an attribute applying to *that* declaration-like entity.

So I think the only thing you should allow between your pragma and the declaration to which it applies is more attribute-like pragmas.

[ABataev]

include/clang/Basic/Attr.td

2098–2102

Done.

lib/Parse/ParseOpenMP.cpp

133

Done, thanks.

144–145

Reworked.

[ABataev]

Update after review

[aaron.ballman]

include/clang/Basic/AttrDocs.td

1620

Line length is an issue here. ;-)

Also, "from a single invocation from a SIMD loop"; should that be "from a single invocation of a SIMD loop" instead?

Any time you use "declare simd" as a syntactic phrase, it should be properly formatted for RST as `declare simd`.

lib/Parse/ParseOpenMP.cpp

97

Can we not name the last parameter with an identifier that is also a type name? That always weirds me out. ;-)

152

Can you add a test case for a member declaration that has attributes to ensure the attributes are properly handled here? In fact, it would be good to add one for the top-level function as well.

lib/Sema/SemaOpenMP.cpp

2186

Please use OMPDeclareSimdDeclAttr::CreateImplicit instead.

[ABataev]

include/clang/Basic/AttrDocs.td

1620

Fixed, thanks

lib/Parse/ParseOpenMP.cpp

97

Fixed, thanks.

152

Ok, will add

lib/Sema/SemaOpenMP.cpp

2186

Fixed, thanks

[ABataev]

Update after review

[aaron.ballman]

I don't think we generally want files commit with explicit svn properties like your new test files have. However, beyond that, LGTM. You should still wait for approval from Richard before committing, however.

[ABataev]

Richard, any comments?

[ABataev]

Ping

[rjmccall]

Richard should really be the one to sign off on this, since he's been managing the review so far.

I am curious why we decided to handle this separately instead of treating it as a different attribute spelling kind.

[ABataev]

In D10599#312135, @rjmccall wrote:

Richard should really be the one to sign off on this, since he's been managing the review so far.

I am curious why we decided to handle this separately instead of treating it as a different attribute spelling kind.

It is a separate pragma with many clauses (that will be implemented as soon as the pragma itself is committed), so we just can't treat it as a different spelling kind.

[ABataev]

Updated to latest version

[ABataev]

Richard?

[ABataev]

Ping

include/clang/Basic/Attr.td

 }
 
 def OMPThreadPrivateDecl : InheritableAttr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
+
+def OMPDeclareSimdDecl : Attr {
+  let Spellings = [Pragma<"omp", "declare simd">];
+  let Subjects = SubjectList<[Function]>;
+  let SemaHandler = 0;
+  let HasCustomParsing = 1;
+  let Documentation = [OMPDeclareSimdDocs];
+  let AdditionalMembers = [{
+  void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
+    OS << "\n";
+  }
+  }];
+}
+

include/clang/Basic/AttrDocs.td

 def NoAliasDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``noalias`` attribute indicates that the only memory accesses inside
 function are loads and stores from objects pointed to by its pointer-typed
 arguments, with arbitrary offsets.
   }];
 }
+
+def OMPDeclareSimdDocs : Documentation {
+  let Category = DocCatStmt;
+  let Heading = "#pragma omp declare simd";
+  let Content = [{
+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. The declare simd directive is a declarative directive. There may be multiple declare simd directives for a function. The use of a declare simd construct on a function enables the creation of SIMD
+versions of the associated function that can be used to process multiple arguments from a single invocation from a SIMD loop concurrently.
+The syntax of the declare simd construct is as follows:
+
+  .. code-block:: c
+
+  #pragma omp declare simd [clause[[,] clause] ...] new-line
+  [#pragma omp declare simd [clause[[,] clause] ...] new-line]
+  [...]
+  function definition or declaration
+
+where clause is one of the following:
+
+  .. code-block:: c
+
+  simdlen(length)
+  linear(argument-list[:constant-linear-step])
+  aligned(argument-list[:alignment])
+  uniform(argument-list)
+  inbranch
+  notinbranch
+
+  }];
+}
+

include/clang/Basic/DiagnosticParseKinds.td

 def err_omp_unexpected_clause : Error<
   "unexpected OpenMP clause '%0' in directive '#pragma omp %1'">;
 def err_omp_more_one_clause : Error<
   "directive '#pragma omp %0' cannot contain more than one '%1' clause">;
 def err_omp_immediate_directive : Error<
   "'#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_decl_in_declare_simd : Error<
+  "function declaration is expected after 'declare simd' directive">;
 
 // Pragma loop support.
 def err_pragma_loop_missing_argument : Error<
   "missing argument; expected %select{an integer value|"
   "'enable', %select{'assume_safety'|'full'}1 or 'disable'}0">;
 def err_pragma_loop_invalid_option : Error<
   "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, "
   "vectorize_width, interleave, interleave_count, unroll, or unroll_count">;
 def err_pragma_invalid_keyword : Error<
   "invalid argument; expected 'enable', %select{'assume_safety'|'full'}0 or 'disable'">;

include/clang/Basic/DiagnosticSemaKinds.td

 def note_omp_nested_teams_construct_here : Note<
   "nested teams construct here">;
 def note_omp_nested_statement_here : Note<
   "%select{statement|directive}0 outside teams construct here">;
 def err_omp_single_copyprivate_with_nowait : Error<
   "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_single_decl_in_declare_simd : Error<
+  "single declaration is expected after 'declare simd' directive">;
+def err_omp_function_expected : Error<
+  "'#pragma omp declare simd' can only be applied to functions">;
 def err_omp_wrong_cancel_region : Error<
   "one of 'for', 'parallel', 'sections' or 'taskgroup' is expected">;
 def err_omp_parent_cancel_region_nowait : Error<
   "parent region for 'omp %select{cancellation point/cancel}0' construct cannot be nowait">;
 def err_omp_parent_cancel_region_ordered : Error<
   "parent region for 'omp %select{cancellation point/cancel}0' construct cannot be ordered">;
 def err_omp_array_section_use : Error<"OpenMP array section is not allowed here">;
 def err_omp_typecheck_section_value : Error<

include/clang/Basic/OpenMPKinds.def

 OPENMP_DIRECTIVE(teams)
 OPENMP_DIRECTIVE(cancel)
 OPENMP_DIRECTIVE_EXT(target_data, "target data")
 OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for")
 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(cancellation_point, "cancellation point")
+OPENMP_DIRECTIVE_EXT(declare_simd, "declare simd")
 
 // OpenMP clauses.
 OPENMP_CLAUSE(if, OMPIfClause)
 OPENMP_CLAUSE(final, OMPFinalClause)
 OPENMP_CLAUSE(num_threads, OMPNumThreadsClause)
 OPENMP_CLAUSE(safelen, OMPSafelenClause)
 OPENMP_CLAUSE(simdlen, OMPSimdlenClause)
 OPENMP_CLAUSE(collapse, OMPCollapseClause)

include/clang/Parse/Parser.h

private:
   /// 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).
   struct LateParsedMemberInitializer : public LateParsedDeclaration {
     LateParsedMemberInitializer(Parser *P, Decl *FD)
       : Self(P), Field(FD) { }
 
     void ParseLexedMemberInitializers() override;
 
     Parser *Self;
 
     /// Field - The field declaration.
     Decl *Field;
 
     /// CachedTokens - The sequence of tokens that comprises the initializer,
     /// including any leading '='.
     CachedTokens Toks;
private:
   void MaybeParseAndDiagnoseDeclSpecAfterCXX11VirtSpecifierSeq(Declarator &D,
                                                                VirtSpecifiers &VS);
   DeclGroupPtrTy ParseCXXClassMemberDeclaration(
       AccessSpecifier AS, AttributeList *Attr,
       const ParsedTemplateInfo &TemplateInfo = ParsedTemplateInfo(),
       ParsingDeclRAIIObject *DiagsFromTParams = nullptr);
   DeclGroupPtrTy ParseCXXClassMemberDeclarationWithPragmas(
       AccessSpecifier &AS, ParsedAttributesWithRange &AccessAttrs,
-      DeclSpec::TST TagType, Decl *TagDecl);
+      DeclSpec::TST TagType, Decl *TagDecl,
+      bool OnlyFunctionAndPragmas = false);
   void ParseConstructorInitializer(Decl *ConstructorDecl);
   MemInitResult ParseMemInitializer(Decl *ConstructorDecl);
   void HandleMemberFunctionDeclDelays(Declarator& DeclaratorInfo,
                                       Decl *ThisDecl);
 
   //===--------------------------------------------------------------------===//
   // C++ 10: Derived classes [class.derived]
   TypeResult ParseBaseTypeSpecifier(SourceLocation &BaseLoc,
bool ParseUnqualifiedIdTemplateId(CXXScopeSpec &SS,
                                     bool AssumeTemplateId);
   bool ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
                                   ParsedType ObjectType,
                                   UnqualifiedId &Result);
 
   //===--------------------------------------------------------------------===//
   // OpenMP: Directives and clauses.
   /// \brief Parses declarative OpenMP directives.
-  DeclGroupPtrTy ParseOpenMPDeclarativeDirective();
+  DeclGroupPtrTy ParseOpenMPDeclarativeDirectiveWithExtDecl(
+      AccessSpecifier &AS, ParsedAttributesWithRange &Attrs,
+      DeclSpec::TST TagType = DeclSpec::TST_unspecified,
+      Decl *TagDecl = nullptr);
   /// \brief Parses simple list of variables.
   ///
   /// \param Kind Kind of the directive.
   /// \param [out] VarList List of referenced variables.
   /// \param AllowScopeSpecifier true, if the variables can have fully
   /// qualified names.
   ///
   bool ParseOpenMPSimpleVarList(OpenMPDirectiveKind Kind,

include/clang/Sema/Sema.h

namespace clang {
   class ObjCInterfaceDecl;
   class ObjCIvarDecl;
   template <class T> class ObjCList;
   class ObjCMessageExpr;
   class ObjCMethodDecl;
   class ObjCPropertyDecl;
   class ObjCProtocolDecl;
   class OMPThreadPrivateDecl;
+  class OMPDeclareSimdDecl;
   class OMPClause;
   class OverloadCandidateSet;
   class OverloadExpr;
   class ParenListExpr;
   class ParmVarDecl;
   class Preprocessor;
   class PseudoDestructorTypeStorage;
   class PseudoObjectExpr;
public:
   ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
                                         SourceLocation EndLoc,
                                         OpenMPDirectiveKind CancelRegion);
   /// \brief Called on well-formed '\#pragma omp cancel'.
   StmtResult ActOnOpenMPCancelDirective(SourceLocation StartLoc,
                                         SourceLocation EndLoc,
                                         OpenMPDirectiveKind CancelRegion);
 
+  /// \brief Called on well-formed '\#pragma omp declare simd' after parsing of
+  /// the associated method/function.
+  DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG,
+                                                 SourceLocation StartLoc);
+
   OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
                                          Expr *Expr,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc);
   /// \brief Called on well-formed 'if' clause.
   OMPClause *ActOnOpenMPIfClause(Expr *Condition, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,

lib/AST/DeclPrinter.cpp

public:
     void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
     void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
     void VisitUsingDecl(UsingDecl *D);
     void VisitUsingShadowDecl(UsingShadowDecl *D);
     void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
 
     void PrintTemplateParameters(const TemplateParameterList *Params,
                                  const TemplateArgumentList *Args = nullptr);
-    void prettyPrintAttributes(Decl *D);
+    void prettyPrintAttributes(Decl *D, bool PrintPragmas = false);
     void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
   };
 }
 
 void Decl::print(raw_ostream &Out, unsigned Indentation,
                  bool PrintInstantiation) const {
   print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation);
 }

 }
 
 raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
   for (unsigned i = 0; i != Indentation; ++i)
     Out << "  ";
   return Out;
 }
 
-void DeclPrinter::prettyPrintAttributes(Decl *D) {
+void DeclPrinter::prettyPrintAttributes(Decl *D, bool PrintPragmas) {
   if (Policy.PolishForDeclaration)
     return;
-  
   if (D->hasAttrs()) {
     AttrVec &Attrs = D->getAttrs();
-    for (AttrVec::const_iterator i=Attrs.begin(), e=Attrs.end(); i!=e; ++i) {
-      Attr *A = *i;
+    for (auto *A : Attrs) {
+      switch (A->getKind()) {
+#define ATTR(X)
+#define PRAGMA_SPELLING_ATTR(X) case attr::X:
+#include "clang/Basic/AttrList.inc"
+        if (PrintPragmas) {
           A->printPretty(Out, Policy);
+          Indent();
+        }
+        break;
+      default:
+        if (!PrintPragmas)
+          A->printPretty(Out, Policy);
+        break;
+      }
     }
   }
 }
 
 void DeclPrinter::printDeclType(QualType T, StringRef DeclName, bool Pack) {
   // Normally, a PackExpansionType is written as T[3]... (for instance, as a
   // template argument), but if it is the type of a declaration, the ellipsis
   // is placed before the name being declared.

 void DeclPrinter::VisitEnumConstantDecl(EnumConstantDecl *D) {
   Out << *D;
   if (Expr *Init = D->getInitExpr()) {
     Out << " = ";
     Init->printPretty(Out, nullptr, Policy, Indentation);
   }
 }
 
 void DeclPrinter::VisitFunctionDecl(FunctionDecl *D) {
+  if (!D->getDescribedFunctionTemplate() &&
+      !D->isFunctionTemplateSpecialization())
+    prettyPrintAttributes(D, /*PrintPragmas=*/true);
+
   CXXConstructorDecl *CDecl = dyn_cast<CXXConstructorDecl>(D);
   CXXConversionDecl *ConversionDecl = dyn_cast<CXXConversionDecl>(D);
   if (!Policy.SuppressSpecifiers) {
     switch (D->getStorageClass()) {
     case SC_None: break;
     case SC_Extern: Out << "extern "; break;
     case SC_Static: Out << "static "; break;
     case SC_PrivateExtern: Out << "__private_extern__ "; break;
     case SC_Auto: case SC_Register: case SC_OpenCLWorkGroupLocal:
       llvm_unreachable("invalid for functions");
     }
 
     if (D->isInlineSpecified())  Out << "inline ";
     if (D->isVirtualAsWritten()) Out << "virtual ";
     if (D->isModulePrivate())    Out << "__module_private__ ";
     if (D->isConstexpr() && !D->isExplicitlyDefaulted()) Out << "constexpr ";
     if ((CDecl && CDecl->isExplicitSpecified()) ||
         (ConversionDecl && ConversionDecl->isExplicit()))
       Out << "explicit ";
void DeclPrinter::VisitFriendDecl(FriendDecl *D) {
   else if (ClassTemplateDecl *CTD =
            dyn_cast<ClassTemplateDecl>(D->getFriendDecl())) {
     Out << "friend ";
     VisitRedeclarableTemplateDecl(CTD);
   }
 }
 
 void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
+  // FIXME: add printing of pragma attributes if required.
   if (!Policy.SuppressSpecifiers && D->isMutable())
     Out << "mutable ";
   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
     Out << "__module_private__ ";
 
   Out << D->getASTContext().getUnqualifiedObjCPointerType(D->getType()).
             stream(Policy, D->getName());
 
void DeclPrinter::VisitFieldDecl(FieldDecl *D) {
   prettyPrintAttributes(D);
 }
 
 void DeclPrinter::VisitLabelDecl(LabelDecl *D) {
   Out << *D << ":";
 }
 
 void DeclPrinter::VisitVarDecl(VarDecl *D) {
+  // FIXME: add printing of pragma attributes if required.
   if (!Policy.SuppressSpecifiers) {
     StorageClass SC = D->getStorageClass();
     if (SC != SC_None)
       Out << VarDecl::getStorageClassSpecifierString(SC) << " ";
 
     switch (D->getTSCSpec()) {
     case TSCS_unspecified:
       break;
void DeclPrinter::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
   Out << *D->getAliasedNamespace();
 }
 
 void DeclPrinter::VisitEmptyDecl(EmptyDecl *D) {
   prettyPrintAttributes(D);
 }
 
 void DeclPrinter::VisitCXXRecordDecl(CXXRecordDecl *D) {
+  // FIXME: add printing of pragma attributes if required.
   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
     Out << "__module_private__ ";
   Out << D->getKindName();
 
   prettyPrintAttributes(D);
 
   if (D->getIdentifier())
     Out << ' ' << *D;
if (const TemplateTemplateParmDecl *TTP =
     Visit(D->getTemplatedDecl());
   }
 }
 
 void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   if (PrintInstantiation) {
     TemplateParameterList *Params = D->getTemplateParameters();
     for (auto *I : D->specializations()) {
+      prettyPrintAttributes(I, /*PrintPragmas=*/true);
       PrintTemplateParameters(Params, I->getTemplateSpecializationArgs());
       Visit(I);
     }
   }
 
+  prettyPrintAttributes(D->getTemplatedDecl(), /*PrintPragmas=*/true);
   return VisitRedeclarableTemplateDecl(D);
 }
 
 void DeclPrinter::VisitClassTemplateDecl(ClassTemplateDecl *D) {
   if (PrintInstantiation) {
     TemplateParameterList *Params = D->getTemplateParameters();
     for (auto *I : D->specializations()) {
       PrintTemplateParameters(Params, &I->getTemplateArgs());

lib/Basic/OpenMPKinds.cpp

 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
   case OMPC_##Name:                                                            \
     return true;
 #include "clang/Basic/OpenMPKinds.def"
     default:
       break;
     }
     break;
+  case OMPD_declare_simd:
+    break;
   case OMPD_unknown:
   case OMPD_threadprivate:
   case OMPD_section:
   case OMPD_master:
   case OMPD_critical:
   case OMPD_taskyield:
   case OMPD_barrier:
   case OMPD_taskwait:

lib/Parse/ParseDecl.cpp

while (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
 
     if (Tok.is(tok::annot_pragma_align)) {
       HandlePragmaAlign();
       continue;
     }
 
     if (Tok.is(tok::annot_pragma_openmp)) {
       // Result can be ignored, because it must be always empty.
-      auto Res = ParseOpenMPDeclarativeDirective();
+      AccessSpecifier AS = AS_none;
+      ParsedAttributesWithRange Attrs(AttrFactory);
+      auto Res = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs);
       assert(!Res);
       // Silence possible warnings.
       (void)Res;
       continue;
     }
     if (!Tok.is(tok::at)) {
       auto CFieldCallback = [&](ParsingFieldDeclarator &FD) {
         // Install the declarator into the current TagDecl.

lib/Parse/ParseDeclCXX.cpp

void Parser::SkipCXXMemberSpecification(SourceLocation RecordLoc,
   T.skipToEnd();
 
   // Parse and discard any trailing attributes.
   ParsedAttributes Attrs(AttrFactory);
   if (Tok.is(tok::kw___attribute))
     MaybeParseGNUAttributes(Attrs);
 }
 
 Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas(
     AccessSpecifier &AS, ParsedAttributesWithRange &AccessAttrs,
-    DeclSpec::TST TagType, Decl *TagDecl) {
-  if (getLangOpts().MicrosoftExt &&
+    DeclSpec::TST TagType, Decl *TagDecl, bool OnlyFunctionAndPragmas) {
+  if (!OnlyFunctionAndPragmas && getLangOpts().MicrosoftExt &&
       Tok.isOneOf(tok::kw___if_exists, tok::kw___if_not_exists)) {
     ParseMicrosoftIfExistsClassDeclaration(TagType, AS);
     return DeclGroupPtrTy();
   }
 
   // Check for extraneous top-level semicolon.
-  if (Tok.is(tok::semi)) {
+  if (!OnlyFunctionAndPragmas && Tok.is(tok::semi)) {
     ConsumeExtraSemi(InsideStruct, TagType);
     return DeclGroupPtrTy();
   }
 
   if (Tok.is(tok::annot_pragma_vis)) {
     HandlePragmaVisibility();
     return DeclGroupPtrTy();
   }
Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas(
   }
 
   // If we see a namespace here, a close brace was missing somewhere.
   if (Tok.is(tok::kw_namespace)) {
     DiagnoseUnexpectedNamespace(cast<NamedDecl>(TagDecl));
     return DeclGroupPtrTy();
   }
 
+  if (!OnlyFunctionAndPragmas) {
     AccessSpecifier NewAS = getAccessSpecifierIfPresent();
     if (NewAS != AS_none) {
       // Current token is a C++ access specifier.
       AS = NewAS;
       SourceLocation ASLoc = Tok.getLocation();
       unsigned TokLength = Tok.getLength();
       ConsumeToken();
       AccessAttrs.clear();
       MaybeParseGNUAttributes(AccessAttrs);
 
       SourceLocation EndLoc;
       if (TryConsumeToken(tok::colon, EndLoc)) {
       } else if (TryConsumeToken(tok::semi, EndLoc)) {
         Diag(EndLoc, diag::err_expected)
             << tok::colon << FixItHint::CreateReplacement(EndLoc, ":");
       } else {
         EndLoc = ASLoc.getLocWithOffset(TokLength);
         Diag(EndLoc, diag::err_expected)
             << tok::colon << FixItHint::CreateInsertion(EndLoc, ":");
       }
 
       // The Microsoft extension __interface does not permit non-public
       // access specifiers.
       if (TagType == DeclSpec::TST_interface && AS != AS_public) {
-      Diag(ASLoc, diag::err_access_specifier_interface) << (AS == AS_protected);
+        Diag(ASLoc, diag::err_access_specifier_interface)
+            << (AS == AS_protected);
       }
 
       if (Actions.ActOnAccessSpecifier(NewAS, ASLoc, EndLoc,
                                        AccessAttrs.getList())) {
         // found another attribute than only annotations
         AccessAttrs.clear();
       }
 
       return DeclGroupPtrTy();
     }
+  }
 
   if (Tok.is(tok::annot_pragma_openmp))
-    return ParseOpenMPDeclarativeDirective();
+    return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, AccessAttrs, TagType,
+                                                      TagDecl);
 
   // Parse all the comma separated declarators.
   return ParseCXXClassMemberDeclaration(AS, AccessAttrs.getList());
 }
 
 /// ParseCXXMemberSpecification - Parse the class definition.
 ///
 ///       member-specification:

lib/Parse/ParseOpenMP.cpp

 // OpenMP declarative directives.
 //===----------------------------------------------------------------------===//
 
 static OpenMPDirectiveKind ParseOpenMPDirectiveKind(Parser &P) {
   // Array of foldings: F[i][0] F[i][1] ===> F[i][2].
   // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
   // TODO: add other combined directives in topological order.
   const OpenMPDirectiveKind F[][3] = {
+      {OMPD_unknown /*declare*/, OMPD_simd, OMPD_declare_simd},
       {OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/,
        OMPD_cancellation_point},
       {OMPD_target, OMPD_unknown /*data*/, OMPD_target_data},
       {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 (!Tok.isAnnotation() && DKind == OMPD_unknown) {
       TokenMatched =
-          (i == 0) &&
-          !P.getPreprocessor().getSpelling(Tok).compare("cancellation");
-    } else {
+          ((i == 0) &&
+           !P.getPreprocessor().getSpelling(Tok).compare("declare")) ||
+          ((i == 1) &&
+           !P.getPreprocessor().getSpelling(Tok).compare("cancellation"));
+    } else
       TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown;
-    }
 
     if (TokenMatched) {
       Tok = P.getPreprocessor().LookAhead(0);
       auto TokenIsAnnotation = Tok.isAnnotation();
       auto SDKind =
           TokenIsAnnotation
               ? OMPD_unknown
               : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
 
       if (!TokenIsAnnotation && SDKind == OMPD_unknown) {
         TokenMatched =
-            ((i == 0) &&
+            ((i == 1) &&
              !P.getPreprocessor().getSpelling(Tok).compare("point")) ||
-            ((i == 1) && !P.getPreprocessor().getSpelling(Tok).compare("data"));
-      } else {
+            ((i == 2) && !P.getPreprocessor().getSpelling(Tok).compare("data"));
+      } else
         TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown;
-      }
 
       if (TokenMatched) {
         P.ConsumeToken();
         DKind = F[i][2];
       }
     }
   }
   return DKind;
 }
 
 /// \brief Parsing of declarative OpenMP directives.
 ///
 ///       threadprivate-directive:
 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
+///         annot_pragma_omp_end
 ///
-Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
+///       declare-simd-directive:
+///         annot_pragma_openmp 'declare simd' {<clause> [,]}
+///         annot_pragma_omp_end
+///         <function declaration/definition>
+///
+Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
+    AccessSpecifier &AS, ParsedAttributesWithRange &Attrs,
+    DeclSpec::TST TagType, Decl *TagDecl) {
   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
 
   SourceLocation Loc = ConsumeToken();
   SmallVector<Expr *, 5> Identifiers;
   auto DKind = ParseOpenMPDirectiveKind(*this);
 
   switch (DKind) {
   case OMPD_threadprivate:
     ConsumeToken();
     if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, true)) {
       // The last seen token is annot_pragma_openmp_end - need to check for
       // extra tokens.
       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
         Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
             << getOpenMPDirectiveName(OMPD_threadprivate);
         SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
       }
       // Skip the last annot_pragma_openmp_end.
       ConsumeToken();
       return Actions.ActOnOpenMPThreadprivateDirective(Loc, Identifiers);
     }
     break;
+  case OMPD_declare_simd: {
+    // The syntax is:
+    // { #pragma omp declare simd }
+    // <function-declaration-or-definition>
+    //
+
+    ConsumeToken();
+    // The last seen token is annot_pragma_openmp_end - need to check for
+    // extra tokens.
+    if (Tok.isNot(tok::annot_pragma_openmp_end)) {
+      Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
+          << getOpenMPDirectiveName(OMPD_declare_simd);
+      if (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
+        return DeclGroupPtrTy();
+    }
+    // Skip the last annot_pragma_openmp_end.
+    ConsumeToken();
+
+    DeclGroupPtrTy Ptr;
+    if (Tok.is(tok::annot_pragma_openmp)) {
+      Ptr = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs, TagType,
+                                                       TagDecl);
+    } else {
+      // Here we expect to see some function declaration.
+      while (Tok.isNot(tok::r_brace) && !isEofOrEom() && !Ptr) {
+        if (AS == AS_none) {
+          assert(TagType == DeclSpec::TST_unspecified);
+          MaybeParseCXX11Attributes(Attrs);
+          MaybeParseMicrosoftAttributes(Attrs);
+          ParsingDeclSpec PDS(*this);
+          Ptr = ParseExternalDeclaration(Attrs, &PDS);
+        } else {
+          Ptr = ParseCXXClassMemberDeclarationWithPragmas(
+              AS, Attrs, TagType, TagDecl, /*OnlyFunctionAndPragmas=*/true);
+        }
+      }
+    }
+    if (!Ptr && (isEofOrEom() || Tok.is(tok::r_brace))) {
+      Diag(Loc, diag::err_omp_decl_in_declare_simd);
+      return DeclGroupPtrTy();
+    }
+
+    return Actions.ActOnOpenMPDeclareSimdDirective(Ptr, Loc);
+  }
   case OMPD_unknown:
     Diag(Tok, diag::err_omp_unknown_directive);
     break;
   case OMPD_parallel:
   case OMPD_simd:
   case OMPD_task:
   case OMPD_taskyield:
   case OMPD_barrier:
   case OMPD_taskwait:
   case OMPD_taskgroup:
   case OMPD_flush:
   case OMPD_for:
   case OMPD_for_simd:
   case OMPD_sections:
   case OMPD_section:
   case OMPD_single:
   case OMPD_master:
   case OMPD_ordered:

 
 /// \brief Parsing of declarative or executable OpenMP directives.
 ///
 ///       threadprivate-directive:
 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
 ///         annot_pragma_openmp_end
 ///
 ///       executable-directive:
 ///         annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |
 ///         'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] |
 ///         'parallel for' | 'parallel sections' | 'task' | 'taskyield' |
 ///         'barrier' | 'taskwait' | 'flush' | 'ordered' | 'atomic' |
 ///         'for simd' | 'parallel for simd' | 'target' | 'target data' |
 ///         'taskgroup' | 'teams' {clause}
 ///         annot_pragma_openmp_end
 ///
 StmtResult
 Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) {
   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
   SmallVector<Expr *, 5> Identifiers;
   SmallVector<OMPClause *, 5> Clauses;
   SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
   FirstClauses(OMPC_unknown + 1);
   unsigned ScopeFlags =
       Scope::FnScope | Scope::DeclScope | Scope::OpenMPDirectiveScope;
   SourceLocation Loc = ConsumeToken(), EndLoc;
   auto DKind = ParseOpenMPDirectiveKind(*this);
   OpenMPDirectiveKind CancelRegion = OMPD_unknown;
   // Name of critical directive.
   DeclarationNameInfo DirName;
   StmtResult Directive = StmtError();
   bool HasAssociatedStatement = true;
   bool FlushHasClause = false;
 
   switch (DKind) {
   case OMPD_threadprivate:
     ConsumeToken();
     if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, false)) {
       // The last seen token is annot_pragma_openmp_end - need to check for
       // extra tokens.
if (CreateDirective)
           DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc,
           EndLoc);
 
     // Exit scope.
     Actions.EndOpenMPDSABlock(Directive.get());
     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);
     break;
   }
   return Directive;
 }
 

lib/Parse/Parser.cpp

case tok::annot_pragma_redefine_extname:
     HandlePragmaRedefineExtname();
     return DeclGroupPtrTy();
   case tok::annot_pragma_fp_contract:
     HandlePragmaFPContract();
     return DeclGroupPtrTy();
   case tok::annot_pragma_opencl_extension:
     HandlePragmaOpenCLExtension();
     return DeclGroupPtrTy();
-  case tok::annot_pragma_openmp:
-    return ParseOpenMPDeclarativeDirective();
+  case tok::annot_pragma_openmp: {
+    AccessSpecifier AS = AS_none;
+    return ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, attrs);
+  }
   case tok::annot_pragma_ms_pointers_to_members:
     HandlePragmaMSPointersToMembers();
     return DeclGroupPtrTy();
   case tok::annot_pragma_ms_vtordisp:
     HandlePragmaMSVtorDisp();
     return DeclGroupPtrTy();
   case tok::annot_pragma_ms_pragma:
     HandlePragmaMSPragma();

lib/Sema/SemaOpenMP.cpp

void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   }
   case OMPD_threadprivate:
   case OMPD_taskyield:
   case OMPD_barrier:
   case OMPD_taskwait:
   case OMPD_cancellation_point:
   case OMPD_cancel:
   case OMPD_flush:
+  case OMPD_declare_simd:
     llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
     llvm_unreachable("Unknown OpenMP directive");
   }
 }
 
 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
                                       ArrayRef<OMPClause *> Clauses) {
assert(AStmt == nullptr &&
            "No associated statement allowed for 'omp cancel' directive");
     Res = ActOnOpenMPCancelDirective(StartLoc, EndLoc, CancelRegion);
     break;
   case OMPD_target_data:
     Res = ActOnOpenMPTargetDataDirective(ClausesWithImplicit, AStmt, StartLoc,
                                          EndLoc);
     break;
   case OMPD_threadprivate:
+  case OMPD_declare_simd:
     llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
     llvm_unreachable("Unknown OpenMP directive");
   }
 
   for (auto P : VarsWithInheritedDSA) {
     Diag(P.second->getExprLoc(), diag::err_omp_no_dsa_for_variable)
         << P.first << P.second->getSourceRange();
   }
   if (!VarsWithInheritedDSA.empty())
     return StmtError();
 
   if (ErrorFound)
     return StmtError();
   return Res;
 }
 
+Sema::DeclGroupPtrTy
+Sema::ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG,
+                                      SourceLocation StartLoc) {
+  if (!DG || DG.get().isNull())
+    return DeclGroupPtrTy();
+
+  if (!DG.get().isSingleDecl()) {
+    Diag(StartLoc, diag::err_omp_single_decl_in_declare_simd);
+    return DG;
+  }
+  auto *ADecl = DG.get().getSingleDecl();
+  if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
+    ADecl = FTD->getTemplatedDecl();
+
+  if (!isa<FunctionDecl>(ADecl)) {
+    Diag(ADecl->getLocation(), diag::err_omp_function_expected)
+        << ADecl->getDeclContext()->isFileContext();
+    return DeclGroupPtrTy();
+  }
+
+  auto *NewAttr = new (Context) OMPDeclareSimdDeclAttr(
+      SourceRange(StartLoc, StartLoc), Context, /*SI=*/0);
+  ADecl->addAttr(NewAttr);
+  return ConvertDeclToDeclGroup(ADecl);
+}
+
 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
                                               SourceLocation EndLoc) {
   assert(AStmt && isa<CapturedStmt>(AStmt) && "Captured statement expected");
   CapturedStmt *CS = cast<CapturedStmt>(AStmt);
   // 1.2.2 OpenMP Language Terminology
   // Structured block - An executable statement with a single entry at the

test/OpenMP/declare_simd_ast_print.c

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

test/OpenMP/declare_simd_ast_print.cpp

+// 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: }
+//
+
+// Explicit specialization with <C=int>.
+// 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)
+{
+  // Implicit specialization with <C=float>.
+  // 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: float taddpf(float *a, float *b)     {
+  // CHECK-NEXT: return *a + *b;
+  // CHECK-NEXT: }
+  #pragma options align=packed
+  #pragma GCC visibility push(default)
+  #pragma omp declare simd
+  float taddpf(float *a, float *b) { return *a + *b; }
+  #pragma GCC visibility pop
+
+// CHECK: #pragma omp declare simd
+// CHECK-NEXT: #pragma omp declare simd
+// CHECK-NEXT: int tadd(int b) {
+// CHECK-NEXT: return this->x[b] + b;
+// CHECK-NEXT: }
+  #pragma omp declare simd
+  #pragma GCC visibility push(default)
+  #pragma options align=packed
+  #pragma omp declare simd
+  #pragma GCC visibility pop
+  int tadd(int b) { return x[b] + b; }
+
+private:
+  int x[10];
+};
+
+// 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: #pragma omp declare simd
+// CHECK-NEXT: #pragma omp declare simd
+// CHECK-NEXT: int tadd(int b) {
+// CHECK-NEXT: return this->x[b] + 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 options align=packed
+  #pragma GCC visibility push(default)
+  #pragma omp declare simd
+  float taddpf(float *a, float *b) { return *a + *b; }
+  #pragma GCC visibility pop
+
+// CHECK: #pragma omp declare simd
+// CHECK-NEXT: float taddpf(float *a, float *b) {
+// CHECK-NEXT: return *a + *b;
+// CHECK-NEXT: }
+
+  #pragma omp declare simd
+  #pragma GCC visibility push(default)
+  #pragma options align=packed
+  #pragma omp declare simd
+  #pragma GCC visibility pop
+  int tadd(int b) { return x[b] + b; }
+
+// CHECK: #pragma omp declare simd
+// CHECK-NEXT: #pragma omp declare simd
+// CHECK-NEXT: int tadd(int b) {
+// CHECK-NEXT: return this->x[b] + b;
+// CHECK-NEXT: }
+
+private:
+  int x[X];
+};
+// CHECK: };
+
+// CHECK: TVV<16> t16;
+TVV<16> t16;
+
+void f() {
+  float a = 1.0f, b = 2.0f;
+  float r = t16.taddpf(&a, &b);
+  int res = t16.tadd(b);
+}
+
+#endif

test/OpenMP/declare_simd_messages.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-macos10.7.0 -verify -fopenmp -x c++ -std=c++11 %s
+
+// expected-error@+1 {{expected an OpenMP directive}}
+#pragma omp declare
+
+// expected-error@+2 {{'#pragma omp declare simd' can only be applied to functions}}
+#pragma omp declare simd
+int a;
+// expected-error@+2 {{'#pragma omp declare simd' can only be applied to functions}}
+#pragma omp declare simd
+#pragma omp threadprivate(a)
+int var;
+#pragma omp threadprivate(var)
+
+// expected-error@+2 {{expected an OpenMP directive}}
+#pragma omp declare simd
+#pragma omp declare
+
+#pragma omp declare simd
+#pragma omp declare simd
+int main();
+
+// expected-error@+1 {{single declaration is expected after 'declare simd' directive}}
+#pragma omp declare simd
+int b, c;
+
+#pragma omp declare simd
+template <class C>
+void h(C *hp, C *hp2, C *hq, C *lin) {
+  b = 0;
+}
+
+#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@+1 {{unexpected OpenMP directive '#pragma omp declare simd'}}
+#pragma omp declare simd
+    *hp = *t;
+  }
+
+private:
+  T t;
+};
+namespace N {
+  // expected-error@+1 {{function declaration is expected after 'declare simd' directive}}
+  #pragma omp declare simd
+}
+// expected-error@+1 {{function declaration is expected after 'declare simd' directive}}
+#pragma omp declare simd
+// expected-error@+1 {{function declaration is expected after 'declare simd' directive}}
+#pragma omp declare simd