mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-30 02:46:06 +00:00
8c7b64b5ae
For backwards compatiblity, we emit only a warning instead of an error if the
attribute is one of the existing type attributes that we have historically
allowed to "slide" to the `DeclSpec` just as if it had been specified in GNU
syntax. (We will call these "legacy type attributes" below.)
The high-level changes that achieve this are:
- We introduce a new field `Declarator::DeclarationAttrs` (with appropriate
accessors) to store C++11 attributes occurring in the attribute-specifier-seq
at the beginning of a simple-declaration (and other similar declarations).
Previously, these attributes were placed on the `DeclSpec`, which made it
impossible to reconstruct later on whether the attributes had in fact been
placed on the decl-specifier-seq or ahead of the declaration.
- In the parser, we propgate declaration attributes and decl-specifier-seq
attributes separately until we can place them in
`Declarator::DeclarationAttrs` or `DeclSpec::Attrs`, respectively.
- In `ProcessDeclAttributes()`, in addition to processing declarator attributes,
we now also process the attributes from `Declarator::DeclarationAttrs` (except
if they are legacy type attributes).
- In `ConvertDeclSpecToType()`, in addition to processing `DeclSpec` attributes,
we also process any legacy type attributes that occur in
`Declarator::DeclarationAttrs` (and emit a warning).
- We make `ProcessDeclAttribute` emit an error if it sees any non-declaration
attributes in C++11 syntax, except in the following cases:
- If it is being called for attributes on a `DeclSpec` or `DeclaratorChunk`
- If the attribute is a legacy type attribute (in which case we only emit
a warning)
The standard justifies treating attributes at the beginning of a
simple-declaration and attributes after a declarator-id the same. Here are some
relevant parts of the standard:
- The attribute-specifier-seq at the beginning of a simple-declaration
"appertains to each of the entities declared by the declarators of the
init-declarator-list" (https://eel.is/c++draft/dcl.dcl#dcl.pre-3)
- "In the declaration for an entity, attributes appertaining to that entity can
appear at the start of the declaration and after the declarator-id for that
declaration." (https://eel.is/c++draft/dcl.dcl#dcl.pre-note-2)
- "The optional attribute-specifier-seq following a declarator-id appertains to
the entity that is declared."
(https://eel.is/c++draft/dcl.dcl#dcl.meaning.general-1)
The standard contains similar wording to that for a simple-declaration in other
similar types of declarations, for example:
- "The optional attribute-specifier-seq in a parameter-declaration appertains to
the parameter." (https://eel.is/c++draft/dcl.fct#3)
- "The optional attribute-specifier-seq in an exception-declaration appertains
to the parameter of the catch clause" (https://eel.is/c++draft/except.pre#1)
The new behavior is tested both on the newly added type attribute
`annotate_type`, for which we emit errors, and for the legacy type attribute
`address_space` (chosen somewhat randomly from the various legacy type
attributes), for which we emit warnings.
Depends On D111548
Reviewed By: aaron.ballman, rsmith
Differential Revision: https://reviews.llvm.org/D126061
77 lines
2.6 KiB
C++
77 lines
2.6 KiB
C++
// Test without serialization:
|
|
// RUN: %clang_cc1 %s -ast-dump | FileCheck %s
|
|
//
|
|
// Test with serialization:
|
|
// RUN: %clang_cc1 -emit-pch -o %t %s
|
|
// RUN: %clang_cc1 -x c++ -include-pch %t -ast-dump-all /dev/null \
|
|
// RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
|
|
// RUN: | FileCheck %s
|
|
|
|
// Verify that the language address space attribute is
|
|
// understood correctly by clang.
|
|
|
|
void langas() {
|
|
// CHECK: VarDecl {{.*}} x_global '__global int *'
|
|
__attribute__((opencl_global)) int *x_global;
|
|
|
|
// CHECK: VarDecl {{.*}} y_global '__global int *'
|
|
int [[clang::opencl_global]] *y_global;
|
|
|
|
// CHECK: VarDecl {{.*}} z_global '__global int *'
|
|
[[clang::opencl_global]] int *z_global;
|
|
|
|
// CHECK: VarDecl {{.*}} x_global_device '__global_device int *'
|
|
__attribute__((opencl_global_device)) int *x_global_device;
|
|
|
|
// CHECK: VarDecl {{.*}} y_global_device '__global_device int *'
|
|
int [[clang::opencl_global_device]] *y_global_device;
|
|
|
|
// CHECK: VarDecl {{.*}} z_global_device '__global_device int *'
|
|
[[clang::opencl_global_device]] int *z_global_device;
|
|
|
|
// CHECK: VarDecl {{.*}} x_global_host '__global_host int *'
|
|
__attribute__((opencl_global_host)) int *x_global_host;
|
|
|
|
// CHECK: VarDecl {{.*}} y_global_host '__global_host int *'
|
|
int [[clang::opencl_global_host]] *y_global_host;
|
|
|
|
// CHECK: VarDecl {{.*}} z_global_host '__global_host int *'
|
|
[[clang::opencl_global_host]] int *z_global_host;
|
|
|
|
// CHECK: VarDecl {{.*}} x_local '__local int *'
|
|
__attribute__((opencl_local)) int *x_local;
|
|
|
|
// CHECK: VarDecl {{.*}} y_local '__local int *'
|
|
int [[clang::opencl_local]] *y_local;
|
|
|
|
// CHECK: VarDecl {{.*}} z_local '__local int *'
|
|
[[clang::opencl_local]] int *z_local;
|
|
|
|
// CHECK: VarDecl {{.*}} x_constant '__constant int *'
|
|
__attribute__((opencl_constant)) int *x_constant;
|
|
|
|
// CHECK: VarDecl {{.*}} y_constant '__constant int *'
|
|
int [[clang::opencl_constant]] *y_constant;
|
|
|
|
// CHECK: VarDecl {{.*}} z_constant '__constant int *'
|
|
[[clang::opencl_constant]] int *z_constant;
|
|
|
|
// CHECK: VarDecl {{.*}} x_private '__private int *'
|
|
__attribute__((opencl_private)) int *x_private;
|
|
|
|
// CHECK: VarDecl {{.*}} y_private '__private int *'
|
|
int [[clang::opencl_private]] *y_private;
|
|
|
|
// CHECK: VarDecl {{.*}} z_private '__private int *'
|
|
[[clang::opencl_private]] int *z_private;
|
|
|
|
// CHECK: VarDecl {{.*}} x_generic '__generic int *'
|
|
__attribute__((opencl_generic)) int *x_generic;
|
|
|
|
// CHECK: VarDecl {{.*}} y_generic '__generic int *'
|
|
int [[clang::opencl_generic]] *y_generic;
|
|
|
|
// CHECK: VarDecl {{.*}} z_generic '__generic int *'
|
|
[[clang::opencl_generic]] int *z_generic;
|
|
}
|