[Clang][Attribute] Improve the AST/diagnoses fidelity of alignas and _Alignas

[yronglin]

Summary

• Fix diagnoses when the argument to alignas or _Alignas is an incomplete type.

Before:

./alignas.cpp:1:15: error: invalid application of 'alignof' to an incomplete type 'void'
class alignas(void) Foo {};
             ~^~~~~
1 error generated.

Now:

./alignas.cpp:1:15: error: invalid application of 'alignas' to an incomplete type 'void'
class alignas(void) Foo {};
             ~^~~~~
1 error generated.

• Improve the AST fidelity of alignas and _Alignas attribute.

Before:

AlignedAttr 0x13f07f278 <col:7> alignas
    `-ConstantExpr 0x13f07f258 <col:15, col:21> 'unsigned long'
      |-value: Int 8
      `-UnaryExprOrTypeTraitExpr 0x13f07f118 <col:15, col:21> 'unsigned long' alignof 'void *'

Now:

AlignedAttr 0x14288c608 <col:7> alignas 'void *'

[yronglin]

Update ReleaseNotes

[yronglin]

Format

[aaron.ballman]

Thank you for working on this! Just a few minor things.

clang/docs/ReleaseNotes.rst

306–317

clang/lib/Parse/ParseDecl.cpp

3039

clang/lib/Sema/SemaExpr.cpp

4715

It looks like a zero-width joiner was added here around the ! that should be removed.

4721

[yronglin]

Address comments.

[yronglin]

Thanks a lot for your review @aaron.ballman ! BTW, does the most good approach is that we just add a new ParsedAttribute with TypeSourceInfo but not an UnaryExprOrTypeTraitExpr, and only do a sema check same as alignof(type-id)?

clang/docs/ReleaseNotes.rst

306–317

+1, and add _Alignas

clang/lib/Sema/SemaExpr.cpp

4715

Thanks, removed.

[aaron.ballman]

In D150528#4342535, @yronglin wrote:

Thanks a lot for your review @aaron.ballman ! BTW, does the most good approach is that we just add a new ParsedAttribute with TypeSourceInfo but not an UnaryExprOrTypeTraitExpr, and only do a sema check same as alignof(type-id)?

Because you've already got a ParsedAttr, I think you'd use this constructor: https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Sema/ParsedAttr.h#L274 and move the call to GetTypeFromParser() until later, but it should still be modelled as a UnaryExprOrTypeTraitExpr.

[yronglin]

In D150528#4342600, @aaron.ballman wrote:

In D150528#4342535, @yronglin wrote:

Thanks a lot for your review @aaron.ballman ! BTW, does the most good approach is that we just add a new ParsedAttribute with TypeSourceInfo but not an UnaryExprOrTypeTraitExpr, and only do a sema check same as alignof(type-id)?

Because you've already got a ParsedAttr, I think you'd use this constructor: https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Sema/ParsedAttr.h#L274 and move the call to GetTypeFromParser() until later, but it should still be modelled as a UnaryExprOrTypeTraitExpr.

Many thanks for the tips, I think the next step is to build UnaryExprOrTypeTraitExpr in this place (https://github.com/llvm/llvm-project/blob/9715af434579022b5ef31781be40b722d7e63bee/clang/lib/Sema/SemaDeclAttr.cpp#L4335-L4358) and then calculate the alignment? If this approach is correct, I'm glad to investigate it.

[aaron.ballman]

In D150528#4342646, @yronglin wrote:

In D150528#4342600, @aaron.ballman wrote:

In D150528#4342535, @yronglin wrote:

Thanks a lot for your review @aaron.ballman ! BTW, does the most good approach is that we just add a new ParsedAttribute with TypeSourceInfo but not an UnaryExprOrTypeTraitExpr, and only do a sema check same as alignof(type-id)?

Because you've already got a ParsedAttr, I think you'd use this constructor: https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Sema/ParsedAttr.h#L274 and move the call to GetTypeFromParser() until later, but it should still be modelled as a UnaryExprOrTypeTraitExpr.

Many thanks for the tips, I think the next step is to build UnaryExprOrTypeTraitExpr in this place (https://github.com/llvm/llvm-project/blob/9715af434579022b5ef31781be40b722d7e63bee/clang/lib/Sema/SemaDeclAttr.cpp#L4335-L4358) and then calculate the alignment? If this approach is correct, I'm glad to investigate it.

Hmm, not quite. Roping in @erichkeane in case he's got other ideas, but I think this will be more involved. What I think needs to happen is:

• We need to add another argument to Aligned in Attr.td so that the attribute takes either an expression argument or a type argument.
• We need to update SemaDeclAttr.cpp and other places accordingly
• We need to add an overload of Sema::AddAlignedAttr() that takes a ParsedType and call this overload when given alignas(type)
• We need to add code to TreeTransform.h to instantiate a dependent type so we can support template <typename Ty> alignas(Ty) int foo = 12;

Your approach of creating a UnaryExprOrTypeTraitExpr would still end up having us model as alignas(alignof(type)) because the argument to the alignas attribute would be the type trait.

[yronglin]

In D150528#4343102, @aaron.ballman wrote:

In D150528#4342646, @yronglin wrote:

In D150528#4342600, @aaron.ballman wrote:

In D150528#4342535, @yronglin wrote:

Thanks a lot for your review @aaron.ballman ! BTW, does the most good approach is that we just add a new ParsedAttribute with TypeSourceInfo but not an UnaryExprOrTypeTraitExpr, and only do a sema check same as alignof(type-id)?

Because you've already got a ParsedAttr, I think you'd use this constructor: https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Sema/ParsedAttr.h#L274 and move the call to GetTypeFromParser() until later, but it should still be modelled as a UnaryExprOrTypeTraitExpr.

Many thanks for the tips, I think the next step is to build UnaryExprOrTypeTraitExpr in this place (https://github.com/llvm/llvm-project/blob/9715af434579022b5ef31781be40b722d7e63bee/clang/lib/Sema/SemaDeclAttr.cpp#L4335-L4358) and then calculate the alignment? If this approach is correct, I'm glad to investigate it.

Hmm, not quite. Roping in @erichkeane in case he's got other ideas, but I think this will be more involved. What I think needs to happen is:

• We need to add another argument to Aligned in Attr.td so that the attribute takes either an expression argument or a type argument.
• We need to update SemaDeclAttr.cpp and other places accordingly
• We need to add an overload of Sema::AddAlignedAttr() that takes a ParsedType and call this overload when given alignas(type)
• We need to add code to TreeTransform.h to instantiate a dependent type so we can support template <typename Ty> alignas(Ty) int foo = 12;

Your approach of creating a UnaryExprOrTypeTraitExpr would still end up having us model as alignas(alignof(type)) because the argument to the alignas attribute would be the type trait.

Sorry for the late reply and thanks for your tips! @aaron.ballman I followed your advice to update this patch, and below AST generated by clang:

class alignas(void *) Foo {};
_Alignas(void*) char align32array[128];

template <typename T> class alignas(T) Bar {};
template <unsigned N> class alignas(N) FooBar {};

int main() {
  Bar<int> bar;
  FooBar<4> fooBar;
  return 0;
}

➜  test ../rel/bin/clang++ -cc1 -triple x86_64-pc-linux -ast-dump ./alignas.cpp -std=c++11
 alignas _Alignas alignas alignasTranslationUnitDecl 0x14b043208 <<invalid sloc>> <invalid sloc>
|-TypedefDecl 0x14b043a70 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128'
| `-BuiltinType 0x14b0437d0 '__int128'
|-TypedefDecl 0x14b043ae0 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128'
| `-BuiltinType 0x14b0437f0 'unsigned __int128'
|-TypedefDecl 0x14b043e58 <<invalid sloc>> <invalid sloc> implicit __NSConstantString '__NSConstantString_tag'
| `-RecordType 0x14b043bd0 '__NSConstantString_tag'
|   `-CXXRecord 0x14b043b38 '__NSConstantString_tag'
|-TypedefDecl 0x14b043ef0 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *'
| `-PointerType 0x14b043eb0 'char *'
|   `-BuiltinType 0x14b0432b0 'char'
|-TypedefDecl 0x14b087858 <<invalid sloc>> <invalid sloc> implicit __builtin_va_list '__va_list_tag[1]'
| `-ConstantArrayType 0x14b087800 '__va_list_tag[1]' 1 
|   `-RecordType 0x14b043fe0 '__va_list_tag'
|     `-CXXRecord 0x14b043f48 '__va_list_tag'
|-CXXRecordDecl 0x14b0878e8 <./alignas.cpp:1:1, col:28> col:23 class Foo definition
| |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveConstructor exists simple trivial needs_implicit
| | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveAssignment exists simple trivial needs_implicit
| | `-Destructor simple irrelevant trivial needs_implicit
| |-AlignedAttr 0x14b087a08 <col:7> alignas 'void *'
| `-CXXRecordDecl 0x14b087a68 <col:1, col:23> col:23 implicit class Foo
|-VarDecl 0x14b087be8 <line:2:1, col:38> col:22 align32array 'char[128]'
| `-AlignedAttr 0x14b087c50 <col:1> _Alignas 'void *'
|-ClassTemplateDecl 0x14b087e80 <line:4:1, col:45> col:40 Bar
| |-TemplateTypeParmDecl 0x14b087cf8 <col:11, col:20> col:20 referenced typename depth 0 index 0 T
| |-CXXRecordDecl 0x14b087df0 <col:23, col:45> col:40 class Bar definition
| | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveConstructor exists simple trivial needs_implicit
| | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveAssignment exists simple trivial needs_implicit
| | | `-Destructor simple irrelevant trivial needs_implicit
| | |-AlignedAttr 0x14b0880d0 <col:29> alignas 'T'
| | `-CXXRecordDecl 0x14b088130 <col:23, col:40> col:40 implicit class Bar
| `-ClassTemplateSpecializationDecl 0x14b09e200 <col:1, col:45> col:40 class Bar definition
|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
|   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
|   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
|   | |-MoveConstructor exists simple trivial
|   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveAssignment exists simple trivial needs_implicit
|   | `-Destructor simple irrelevant trivial needs_implicit
|   |-TemplateArgument type 'int'
|   | `-BuiltinType 0x14b043310 'int'
|   |-AlignedAttr 0x14b09e458 <col:29> alignas 'int':'int'
|   |-CXXRecordDecl 0x14b09e520 <col:23, col:40> col:40 implicit class Bar
|   |-CXXConstructorDecl 0x14b09e5e0 <col:40> col:40 implicit used constexpr Bar 'void () noexcept' inline default trivial
|   | `-CompoundStmt 0x14b09eb48 <col:40>
|   |-CXXConstructorDecl 0x14b09e778 <col:40> col:40 implicit constexpr Bar 'void (const Bar<int> &)' inline default trivial noexcept-unevaluated 0x14b09e778
|   | `-ParmVarDecl 0x14b09e898 <col:40> col:40 'const Bar<int> &'
|   `-CXXConstructorDecl 0x14b09e978 <col:40> col:40 implicit constexpr Bar 'void (Bar<int> &&)' inline default trivial noexcept-unevaluated 0x14b09e978
|     `-ParmVarDecl 0x14b09ea98 <col:40> col:40 'Bar<int> &&'
|-ClassTemplateDecl 0x14b088310 <line:5:1, col:48> col:40 FooBar
| |-NonTypeTemplateParmDecl 0x14b0881f0 <col:11, col:20> col:20 referenced 'unsigned int' depth 0 index 0 N
| |-CXXRecordDecl 0x14b088280 <col:23, col:48> col:40 class FooBar definition
| | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveConstructor exists simple trivial needs_implicit
| | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveAssignment exists simple trivial needs_implicit
| | | `-Destructor simple irrelevant trivial needs_implicit
| | |-AlignedAttr 0x14b088580 <col:29> alignas
| | | `-DeclRefExpr 0x14b088260 <col:37> 'unsigned int' NonTypeTemplateParm 0x14b0881f0 'N' 'unsigned int'
| | `-CXXRecordDecl 0x14b0885e0 <col:23, col:40> col:40 implicit class FooBar
| `-ClassTemplateSpecializationDecl 0x14b09ed10 <col:1, col:48> col:40 class FooBar definition
|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
|   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
|   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
|   | |-MoveConstructor exists simple trivial
|   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveAssignment exists simple trivial needs_implicit
|   | `-Destructor simple irrelevant trivial needs_implicit
|   |-TemplateArgument integral 4
|   |-AlignedAttr 0x14b09ef90 <col:29> alignas
|   | `-ConstantExpr 0x14b09ef70 <col:37> 'unsigned int'
|   |   |-value: Int 4
|   |   `-SubstNonTypeTemplateParmExpr 0x14b09ef48 <col:37> 'unsigned int'
|   |     |-NonTypeTemplateParmDecl 0x14b0881f0 <col:11, col:20> col:20 referenced 'unsigned int' depth 0 index 0 N
|   |     `-IntegerLiteral 0x14b09ef28 <col:37> 'unsigned int' 4
|   |-CXXRecordDecl 0x14b09f058 <col:23, col:40> col:40 implicit class FooBar
|   |-CXXConstructorDecl 0x14980fc00 <col:40> col:40 implicit used constexpr FooBar 'void () noexcept' inline default trivial
|   | `-CompoundStmt 0x149810108 <col:40>
|   |-CXXConstructorDecl 0x14980fd68 <col:40> col:40 implicit constexpr FooBar 'void (const FooBar<4> &)' inline default trivial noexcept-unevaluated 0x14980fd68
|   | `-ParmVarDecl 0x14980fe88 <col:40> col:40 'const FooBar<4> &'
|   `-CXXConstructorDecl 0x14980ff68 <col:40> col:40 implicit constexpr FooBar 'void (FooBar<4> &&)' inline default trivial noexcept-unevaluated 0x14980ff68
|     `-ParmVarDecl 0x149810088 <col:40> col:40 'FooBar<4> &&'
`-FunctionDecl 0x14b0886e0 <line:7:1, line:11:1> line:7:5 main 'int ()'
  `-CompoundStmt 0x1498101e8 <col:12, line:11:1>
    |-DeclStmt 0x14b09eca0 <line:8:3, col:15>
    | `-VarDecl 0x14b09e3b0 <col:3, col:12> col:12 bar 'Bar<int>':'Bar<int>' callinit
    |   `-CXXConstructExpr 0x14b09ec78 <col:12> 'Bar<int>':'Bar<int>' 'void () noexcept'
    |-DeclStmt 0x1498101a0 <line:9:3, col:19>
    | `-VarDecl 0x14b09eec0 <col:3, col:13> col:13 fooBar 'FooBar<4>':'FooBar<4>' callinit
    |   `-CXXConstructExpr 0x149810178 <col:13> 'FooBar<4>':'FooBar<4>' 'void () noexcept'
    `-ReturnStmt 0x1498101d8 <line:10:3, col:10>
      `-IntegerLiteral 0x1498101b8 <col:10> 'int' 0

This AST dose not have a UnaryExprOrTypeTraitExpr in alignas, What do you think?

[aaron.ballman]

In D150528#4349711, @yronglin wrote:

Sorry for the late reply and thanks for your tips! @aaron.ballman I followed your advice to update this patch, and below AST generated by clang:

class alignas(void *) Foo {};
_Alignas(void*) char align32array[128];

template <typename T> class alignas(T) Bar {};
template <unsigned N> class alignas(N) FooBar {};

int main() {
  Bar<int> bar;
  FooBar<4> fooBar;
  return 0;
}

➜  test ../rel/bin/clang++ -cc1 -triple x86_64-pc-linux -ast-dump ./alignas.cpp -std=c++11
 alignas _Alignas alignas alignasTranslationUnitDecl 0x14b043208 <<invalid sloc>> <invalid sloc>
|-TypedefDecl 0x14b043a70 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128'
| `-BuiltinType 0x14b0437d0 '__int128'
|-TypedefDecl 0x14b043ae0 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128'
| `-BuiltinType 0x14b0437f0 'unsigned __int128'
|-TypedefDecl 0x14b043e58 <<invalid sloc>> <invalid sloc> implicit __NSConstantString '__NSConstantString_tag'
| `-RecordType 0x14b043bd0 '__NSConstantString_tag'
|   `-CXXRecord 0x14b043b38 '__NSConstantString_tag'
|-TypedefDecl 0x14b043ef0 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *'
| `-PointerType 0x14b043eb0 'char *'
|   `-BuiltinType 0x14b0432b0 'char'
|-TypedefDecl 0x14b087858 <<invalid sloc>> <invalid sloc> implicit __builtin_va_list '__va_list_tag[1]'
| `-ConstantArrayType 0x14b087800 '__va_list_tag[1]' 1 
|   `-RecordType 0x14b043fe0 '__va_list_tag'
|     `-CXXRecord 0x14b043f48 '__va_list_tag'
|-CXXRecordDecl 0x14b0878e8 <./alignas.cpp:1:1, col:28> col:23 class Foo definition
| |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveConstructor exists simple trivial needs_implicit
| | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveAssignment exists simple trivial needs_implicit
| | `-Destructor simple irrelevant trivial needs_implicit
| |-AlignedAttr 0x14b087a08 <col:7> alignas 'void *'
| `-CXXRecordDecl 0x14b087a68 <col:1, col:23> col:23 implicit class Foo
|-VarDecl 0x14b087be8 <line:2:1, col:38> col:22 align32array 'char[128]'
| `-AlignedAttr 0x14b087c50 <col:1> _Alignas 'void *'
|-ClassTemplateDecl 0x14b087e80 <line:4:1, col:45> col:40 Bar
| |-TemplateTypeParmDecl 0x14b087cf8 <col:11, col:20> col:20 referenced typename depth 0 index 0 T
| |-CXXRecordDecl 0x14b087df0 <col:23, col:45> col:40 class Bar definition
| | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveConstructor exists simple trivial needs_implicit
| | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveAssignment exists simple trivial needs_implicit
| | | `-Destructor simple irrelevant trivial needs_implicit
| | |-AlignedAttr 0x14b0880d0 <col:29> alignas 'T'
| | `-CXXRecordDecl 0x14b088130 <col:23, col:40> col:40 implicit class Bar
| `-ClassTemplateSpecializationDecl 0x14b09e200 <col:1, col:45> col:40 class Bar definition
|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
|   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
|   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
|   | |-MoveConstructor exists simple trivial
|   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveAssignment exists simple trivial needs_implicit
|   | `-Destructor simple irrelevant trivial needs_implicit
|   |-TemplateArgument type 'int'
|   | `-BuiltinType 0x14b043310 'int'
|   |-AlignedAttr 0x14b09e458 <col:29> alignas 'int':'int'
|   |-CXXRecordDecl 0x14b09e520 <col:23, col:40> col:40 implicit class Bar
|   |-CXXConstructorDecl 0x14b09e5e0 <col:40> col:40 implicit used constexpr Bar 'void () noexcept' inline default trivial
|   | `-CompoundStmt 0x14b09eb48 <col:40>
|   |-CXXConstructorDecl 0x14b09e778 <col:40> col:40 implicit constexpr Bar 'void (const Bar<int> &)' inline default trivial noexcept-unevaluated 0x14b09e778
|   | `-ParmVarDecl 0x14b09e898 <col:40> col:40 'const Bar<int> &'
|   `-CXXConstructorDecl 0x14b09e978 <col:40> col:40 implicit constexpr Bar 'void (Bar<int> &&)' inline default trivial noexcept-unevaluated 0x14b09e978
|     `-ParmVarDecl 0x14b09ea98 <col:40> col:40 'Bar<int> &&'
|-ClassTemplateDecl 0x14b088310 <line:5:1, col:48> col:40 FooBar
| |-NonTypeTemplateParmDecl 0x14b0881f0 <col:11, col:20> col:20 referenced 'unsigned int' depth 0 index 0 N
| |-CXXRecordDecl 0x14b088280 <col:23, col:48> col:40 class FooBar definition
| | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveConstructor exists simple trivial needs_implicit
| | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveAssignment exists simple trivial needs_implicit
| | | `-Destructor simple irrelevant trivial needs_implicit
| | |-AlignedAttr 0x14b088580 <col:29> alignas
| | | `-DeclRefExpr 0x14b088260 <col:37> 'unsigned int' NonTypeTemplateParm 0x14b0881f0 'N' 'unsigned int'
| | `-CXXRecordDecl 0x14b0885e0 <col:23, col:40> col:40 implicit class FooBar
| `-ClassTemplateSpecializationDecl 0x14b09ed10 <col:1, col:48> col:40 class FooBar definition
|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
|   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
|   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
|   | |-MoveConstructor exists simple trivial
|   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveAssignment exists simple trivial needs_implicit
|   | `-Destructor simple irrelevant trivial needs_implicit
|   |-TemplateArgument integral 4
|   |-AlignedAttr 0x14b09ef90 <col:29> alignas
|   | `-ConstantExpr 0x14b09ef70 <col:37> 'unsigned int'
|   |   |-value: Int 4
|   |   `-SubstNonTypeTemplateParmExpr 0x14b09ef48 <col:37> 'unsigned int'
|   |     |-NonTypeTemplateParmDecl 0x14b0881f0 <col:11, col:20> col:20 referenced 'unsigned int' depth 0 index 0 N
|   |     `-IntegerLiteral 0x14b09ef28 <col:37> 'unsigned int' 4
|   |-CXXRecordDecl 0x14b09f058 <col:23, col:40> col:40 implicit class FooBar
|   |-CXXConstructorDecl 0x14980fc00 <col:40> col:40 implicit used constexpr FooBar 'void () noexcept' inline default trivial
|   | `-CompoundStmt 0x149810108 <col:40>
|   |-CXXConstructorDecl 0x14980fd68 <col:40> col:40 implicit constexpr FooBar 'void (const FooBar<4> &)' inline default trivial noexcept-unevaluated 0x14980fd68
|   | `-ParmVarDecl 0x14980fe88 <col:40> col:40 'const FooBar<4> &'
|   `-CXXConstructorDecl 0x14980ff68 <col:40> col:40 implicit constexpr FooBar 'void (FooBar<4> &&)' inline default trivial noexcept-unevaluated 0x14980ff68
|     `-ParmVarDecl 0x149810088 <col:40> col:40 'FooBar<4> &&'
`-FunctionDecl 0x14b0886e0 <line:7:1, line:11:1> line:7:5 main 'int ()'
  `-CompoundStmt 0x1498101e8 <col:12, line:11:1>
    |-DeclStmt 0x14b09eca0 <line:8:3, col:15>
    | `-VarDecl 0x14b09e3b0 <col:3, col:12> col:12 bar 'Bar<int>':'Bar<int>' callinit
    |   `-CXXConstructExpr 0x14b09ec78 <col:12> 'Bar<int>':'Bar<int>' 'void () noexcept'
    |-DeclStmt 0x1498101a0 <line:9:3, col:19>
    | `-VarDecl 0x14b09eec0 <col:3, col:13> col:13 fooBar 'FooBar<4>':'FooBar<4>' callinit
    |   `-CXXConstructExpr 0x149810178 <col:13> 'FooBar<4>':'FooBar<4>' 'void () noexcept'
    `-ReturnStmt 0x1498101d8 <line:10:3, col:10>
      `-IntegerLiteral 0x1498101b8 <col:10> 'int' 0

This AST dose not have a UnaryExprOrTypeTraitExpr in alignas, What do you think?

That is exactly what I would hope the AST would look like -- it's great! The next step would be to add CodeGen tests to validate that the correct alignment is emitted to LLVM IR with the type-base form.

[yronglin]

In D150528#4349729, @aaron.ballman wrote:

In D150528#4349711, @yronglin wrote:

Sorry for the late reply and thanks for your tips! @aaron.ballman I followed your advice to update this patch, and below AST generated by clang:

class alignas(void *) Foo {};
_Alignas(void*) char align32array[128];

template <typename T> class alignas(T) Bar {};
template <unsigned N> class alignas(N) FooBar {};

int main() {
  Bar<int> bar;
  FooBar<4> fooBar;
  return 0;
}

➜  test ../rel/bin/clang++ -cc1 -triple x86_64-pc-linux -ast-dump ./alignas.cpp -std=c++11
 alignas _Alignas alignas alignasTranslationUnitDecl 0x14b043208 <<invalid sloc>> <invalid sloc>
|-TypedefDecl 0x14b043a70 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128'
| `-BuiltinType 0x14b0437d0 '__int128'
|-TypedefDecl 0x14b043ae0 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128'
| `-BuiltinType 0x14b0437f0 'unsigned __int128'
|-TypedefDecl 0x14b043e58 <<invalid sloc>> <invalid sloc> implicit __NSConstantString '__NSConstantString_tag'
| `-RecordType 0x14b043bd0 '__NSConstantString_tag'
|   `-CXXRecord 0x14b043b38 '__NSConstantString_tag'
|-TypedefDecl 0x14b043ef0 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *'
| `-PointerType 0x14b043eb0 'char *'
|   `-BuiltinType 0x14b0432b0 'char'
|-TypedefDecl 0x14b087858 <<invalid sloc>> <invalid sloc> implicit __builtin_va_list '__va_list_tag[1]'
| `-ConstantArrayType 0x14b087800 '__va_list_tag[1]' 1 
|   `-RecordType 0x14b043fe0 '__va_list_tag'
|     `-CXXRecord 0x14b043f48 '__va_list_tag'
|-CXXRecordDecl 0x14b0878e8 <./alignas.cpp:1:1, col:28> col:23 class Foo definition
| |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveConstructor exists simple trivial needs_implicit
| | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | |-MoveAssignment exists simple trivial needs_implicit
| | `-Destructor simple irrelevant trivial needs_implicit
| |-AlignedAttr 0x14b087a08 <col:7> alignas 'void *'
| `-CXXRecordDecl 0x14b087a68 <col:1, col:23> col:23 implicit class Foo
|-VarDecl 0x14b087be8 <line:2:1, col:38> col:22 align32array 'char[128]'
| `-AlignedAttr 0x14b087c50 <col:1> _Alignas 'void *'
|-ClassTemplateDecl 0x14b087e80 <line:4:1, col:45> col:40 Bar
| |-TemplateTypeParmDecl 0x14b087cf8 <col:11, col:20> col:20 referenced typename depth 0 index 0 T
| |-CXXRecordDecl 0x14b087df0 <col:23, col:45> col:40 class Bar definition
| | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveConstructor exists simple trivial needs_implicit
| | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveAssignment exists simple trivial needs_implicit
| | | `-Destructor simple irrelevant trivial needs_implicit
| | |-AlignedAttr 0x14b0880d0 <col:29> alignas 'T'
| | `-CXXRecordDecl 0x14b088130 <col:23, col:40> col:40 implicit class Bar
| `-ClassTemplateSpecializationDecl 0x14b09e200 <col:1, col:45> col:40 class Bar definition
|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
|   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
|   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
|   | |-MoveConstructor exists simple trivial
|   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveAssignment exists simple trivial needs_implicit
|   | `-Destructor simple irrelevant trivial needs_implicit
|   |-TemplateArgument type 'int'
|   | `-BuiltinType 0x14b043310 'int'
|   |-AlignedAttr 0x14b09e458 <col:29> alignas 'int':'int'
|   |-CXXRecordDecl 0x14b09e520 <col:23, col:40> col:40 implicit class Bar
|   |-CXXConstructorDecl 0x14b09e5e0 <col:40> col:40 implicit used constexpr Bar 'void () noexcept' inline default trivial
|   | `-CompoundStmt 0x14b09eb48 <col:40>
|   |-CXXConstructorDecl 0x14b09e778 <col:40> col:40 implicit constexpr Bar 'void (const Bar<int> &)' inline default trivial noexcept-unevaluated 0x14b09e778
|   | `-ParmVarDecl 0x14b09e898 <col:40> col:40 'const Bar<int> &'
|   `-CXXConstructorDecl 0x14b09e978 <col:40> col:40 implicit constexpr Bar 'void (Bar<int> &&)' inline default trivial noexcept-unevaluated 0x14b09e978
|     `-ParmVarDecl 0x14b09ea98 <col:40> col:40 'Bar<int> &&'
|-ClassTemplateDecl 0x14b088310 <line:5:1, col:48> col:40 FooBar
| |-NonTypeTemplateParmDecl 0x14b0881f0 <col:11, col:20> col:20 referenced 'unsigned int' depth 0 index 0 N
| |-CXXRecordDecl 0x14b088280 <col:23, col:48> col:40 class FooBar definition
| | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
| | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr
| | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveConstructor exists simple trivial needs_implicit
| | | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
| | | |-MoveAssignment exists simple trivial needs_implicit
| | | `-Destructor simple irrelevant trivial needs_implicit
| | |-AlignedAttr 0x14b088580 <col:29> alignas
| | | `-DeclRefExpr 0x14b088260 <col:37> 'unsigned int' NonTypeTemplateParm 0x14b0881f0 'N' 'unsigned int'
| | `-CXXRecordDecl 0x14b0885e0 <col:23, col:40> col:40 implicit class FooBar
| `-ClassTemplateSpecializationDecl 0x14b09ed10 <col:1, col:48> col:40 class FooBar definition
|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init
|   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
|   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param
|   | |-MoveConstructor exists simple trivial
|   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param
|   | |-MoveAssignment exists simple trivial needs_implicit
|   | `-Destructor simple irrelevant trivial needs_implicit
|   |-TemplateArgument integral 4
|   |-AlignedAttr 0x14b09ef90 <col:29> alignas
|   | `-ConstantExpr 0x14b09ef70 <col:37> 'unsigned int'
|   |   |-value: Int 4
|   |   `-SubstNonTypeTemplateParmExpr 0x14b09ef48 <col:37> 'unsigned int'
|   |     |-NonTypeTemplateParmDecl 0x14b0881f0 <col:11, col:20> col:20 referenced 'unsigned int' depth 0 index 0 N
|   |     `-IntegerLiteral 0x14b09ef28 <col:37> 'unsigned int' 4
|   |-CXXRecordDecl 0x14b09f058 <col:23, col:40> col:40 implicit class FooBar
|   |-CXXConstructorDecl 0x14980fc00 <col:40> col:40 implicit used constexpr FooBar 'void () noexcept' inline default trivial
|   | `-CompoundStmt 0x149810108 <col:40>
|   |-CXXConstructorDecl 0x14980fd68 <col:40> col:40 implicit constexpr FooBar 'void (const FooBar<4> &)' inline default trivial noexcept-unevaluated 0x14980fd68
|   | `-ParmVarDecl 0x14980fe88 <col:40> col:40 'const FooBar<4> &'
|   `-CXXConstructorDecl 0x14980ff68 <col:40> col:40 implicit constexpr FooBar 'void (FooBar<4> &&)' inline default trivial noexcept-unevaluated 0x14980ff68
|     `-ParmVarDecl 0x149810088 <col:40> col:40 'FooBar<4> &&'
`-FunctionDecl 0x14b0886e0 <line:7:1, line:11:1> line:7:5 main 'int ()'
  `-CompoundStmt 0x1498101e8 <col:12, line:11:1>
    |-DeclStmt 0x14b09eca0 <line:8:3, col:15>
    | `-VarDecl 0x14b09e3b0 <col:3, col:12> col:12 bar 'Bar<int>':'Bar<int>' callinit
    |   `-CXXConstructExpr 0x14b09ec78 <col:12> 'Bar<int>':'Bar<int>' 'void () noexcept'
    |-DeclStmt 0x1498101a0 <line:9:3, col:19>
    | `-VarDecl 0x14b09eec0 <col:3, col:13> col:13 fooBar 'FooBar<4>':'FooBar<4>' callinit
    |   `-CXXConstructExpr 0x149810178 <col:13> 'FooBar<4>':'FooBar<4>' 'void () noexcept'
    `-ReturnStmt 0x1498101d8 <line:10:3, col:10>
      `-IntegerLiteral 0x1498101b8 <col:10> 'int' 0

This AST dose not have a UnaryExprOrTypeTraitExpr in alignas, What do you think?

That is exactly what I would hope the AST would look like -- it's great! The next step would be to add CodeGen tests to validate that the correct alignment is emitted to LLVM IR with the type-base form.

Thanks, I'll do that!

[yronglin]

Improve the AST fidelity of `alignas and _Alignas` attribute.

[yronglin]

Remove extra include.

[yronglin]

Test asm dump.

[yronglin]

Fix crash.

[yronglin]

Update

[yronglin]

Format.

[aaron.ballman]

In general, I think this is looking pretty good, thank you! I'll leave it to @erichkeane to do the final sign-off as attributes code owner since this is making a fair number of changes in that area.

clang/lib/Sema/SemaDeclAttr.cpp

4415–4419

4422–4424

[yronglin]

In D150528#4365688, @aaron.ballman wrote:

In general, I think this is looking pretty good, thank you! I'll leave it to @erichkeane to do the final sign-off as attributes code owner since this is making a fair number of changes in that area.

Thanks for your review @aaron.ballman ! BTW, I have two questions:

1. Should we print the cached alignment value when dump AST?
2. The AlignedAttr::getAlignment has a bit redundant with GetAlignOfType(in ExprConstant.cpp ), should we merge these?

[aaron.ballman]

In D150528#4368023, @yronglin wrote:

In D150528#4365688, @aaron.ballman wrote:

In general, I think this is looking pretty good, thank you! I'll leave it to @erichkeane to do the final sign-off as attributes code owner since this is making a fair number of changes in that area.

Thanks for your review @aaron.ballman ! BTW, I have two questions:

1. Should we print the cached alignment value when dump AST?

I think it would be nice to dump that as well, but not critical.

2. The AlignedAttr::getAlignment has a bit redundant with GetAlignOfType(in ExprConstant.cpp ), should we merge these?

It would be good to unify them, but that can be done in a follow-up as it's a bit orthogonal.

[yronglin]

Address comments.

[yronglin]

Thanks, maybe I can do these trivially change in separate patch.

[yronglin]

ping～ @erichkeane

[erichkeane]

Just 1 change I'd like, but otherwise this LGTM.

clang/lib/AST/AttrImpl.cpp

244

I don't think it makes sense to make this a lambda here rather than just implementing it inline if the value isn't cached.

[yronglin]

Address comment.

[yronglin]

Thanks for your comments, @erichkeane !

[erichkeane]

1 nit I don't care either way about, 1 suggestion.

clang/lib/AST/AttrImpl.cpp

247

Typically we don't do curleys on a single-statement... but I am on the fence due to how complicated it is below.

259

You can replace this 'if' with: T = T->getNonReferenceType();

[yronglin]

Address comments

[yronglin]

clang/lib/AST/AttrImpl.cpp

247

I've updated this function, What do you think?

259

+1, both update GetAlignOfType in ExprConstant.cpp

[erichkeane]

Still LGTM, thanks!

clang/lib/AST/AttrImpl.cpp

247

Much nicer, thanks!

[yronglin]

The libcxx CI failure seems not caused bye this patch, there have a patch to fix this issue. https://reviews.llvm.org/D151508

clang/docs/ReleaseNotes.rst

- ``__declspec`` attributes can now be used together with the using keyword. Before
   point where the alias is used.
 - Introduced a new ``USR`` (unified symbol resolution) clause inside of the
   existing ``__attribute__((external_source_symbol))`` attribute. Clang's indexer
   uses the optional USR value when indexing Clang's AST. This value is expected
   to be generated by an external compiler when generating C++ bindings during
   the compilation of the foreign language sources (e.g. Swift).
 - The ``__has_attribute``, ``__has_c_attribute`` and ``__has_cpp_attribute``
   preprocessor operators now return 1 also for attributes defined by plugins.
+- Improve the AST fidelity of ``alignas`` and ``_Alignas`` attribute. Before, we 
+  model ``alignas(type-id)`` as though the user wrote ``alignas(alignof(type-id))``,
+  now we directly use ``alignas(type-id)``.
 
 Improvements to Clang's diagnostics
 -----------------------------------
 - We now generate a diagnostic for signed integer overflow due to unary minus
   in a non-constant expression context.
   (`#31643 <https://github.com/llvm/llvm-project/issues/31643>`_)
 - Clang now warns by default for C++20 and later about deprecated capture of
   ``this`` with a capture default of ``=``. This warning can be disabled with
- ``-Wformat`` now recognizes ``%lb`` for the ``printf``/``scanf`` family of
   functions.
   (`#62247: <https://github.com/llvm/llvm-project/issues/62247>`_).
 - Clang now diagnoses shadowing of lambda's template parameter by a capture.
   (`#61105: <https://github.com/llvm/llvm-project/issues/61105>`_).
 - Address a false positive in ``-Wpacked`` when applied to a non-pod type using
   Clang ABI >= 15.
   (`#62353: <https://github.com/llvm/llvm-project/issues/62353>`_,
   fallout from the non-POD packing ABI fix in LLVM 15).
 - Clang constexpr evaluator now prints subobject's name instead of its type in notes
   when a constexpr variable has uninitialized subobjects after its constructor call.
   (`#58601 <https://github.com/llvm/llvm-project/issues/58601>`_)
 - Clang's `-Wshadow` warning now warns about shadowings by static local variables
   (`#62850: <https://github.com/llvm/llvm-project/issues/62850>`_).
 - Clang now warns when any predefined macro is undefined or redefined, instead
   of only some of them.
+- Clang now correctly diagnoses when the argument to ``alignas`` or ``_Alignas`` 
+  is an incomplete type.
+  (`#55175: <https://github.com/llvm/llvm-project/issues/55175>`_, and fixes an
+  incorrect mention of ``alignof`` in a diagnostic about ``alignas``).
 
 Bug Fixes in This Version
 -------------------------
 
 - Fix segfault while running clang-rename on a non existing file.
   (`#36471 <https://github.com/llvm/llvm-project/issues/36471>`_)
 - Fix crash when diagnosing incorrect usage of ``_Nullable`` involving alias
   templates.
   (`#60344 <https://github.com/llvm/llvm-project/issues/60344>`_)

clang/include/clang/Parse/Parser.h

private:
 
   void ParseTypeofSpecifier(DeclSpec &DS);
   SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);
   void AnnotateExistingDecltypeSpecifier(const DeclSpec &DS,
                                          SourceLocation StartLoc,
                                          SourceLocation EndLoc);
   void ParseAtomicSpecifier(DeclSpec &DS);
 
-  ExprResult ParseAlignArgument(SourceLocation Start,
-                                SourceLocation &EllipsisLoc);
+  ExprResult ParseAlignArgument(StringRef KWName, SourceLocation Start,
+                                SourceLocation &EllipsisLoc, bool &IsType,
+                                ParsedType &Ty);
   void ParseAlignmentSpecifier(ParsedAttributes &Attrs,
                                SourceLocation *endLoc = nullptr);
   ExprResult ParseExtIntegerArgument();
 
   VirtSpecifiers::Specifier isCXX11VirtSpecifier(const Token &Tok) const;
   VirtSpecifiers::Specifier isCXX11VirtSpecifier() const {
     return isCXX11VirtSpecifier(Tok);
   }

clang/include/clang/Sema/ParsedAttr.h

ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
     new (&ExtraData.MatchingCType) ParsedType(matchingCType);
     ExtraData.LayoutCompatible = layoutCompatible;
     ExtraData.MustBeNull = mustBeNull;
   }
 
   /// Constructor for attributes with a single type argument.
   ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
-             ParsedType typeArg, Form formUsed)
+             ParsedType typeArg, Form formUsed, SourceLocation ellipsisLoc)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc, formUsed),
-        NumArgs(0), Invalid(false), UsedAsTypeAttr(false),
-        IsAvailability(false), IsTypeTagForDatatype(false), IsProperty(false),
-        HasParsedType(true), HasProcessingCache(false),
-        IsPragmaClangAttribute(false), Info(ParsedAttrInfo::get(*this)) {
+        EllipsisLoc(ellipsisLoc), NumArgs(0), Invalid(false),
+        UsedAsTypeAttr(false), IsAvailability(false),
+        IsTypeTagForDatatype(false), IsProperty(false), HasParsedType(true),
+        HasProcessingCache(false), IsPragmaClangAttribute(false),
+        Info(ParsedAttrInfo::get(*this)) {
     new (&getTypeBuffer()) ParsedType(typeArg);
   }
 
   /// Constructor for microsoft __declspec(property) attribute.
   ParsedAttr(IdentifierInfo *attrName, SourceRange attrRange,
              IdentifierInfo *scopeName, SourceLocation scopeLoc,
              IdentifierInfo *getterId, IdentifierInfo *setterId, Form formUsed)
       : AttributeCommonInfo(attrName, scopeName, attrRange, scopeLoc, formUsed),
return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
                                        argumentKind, matchingCType,
                                        layoutCompatible, mustBeNull, form));
   }
 
   ParsedAttr *createTypeAttribute(IdentifierInfo *attrName,
                                   SourceRange attrRange,
                                   IdentifierInfo *scopeName,
                                   SourceLocation scopeLoc, ParsedType typeArg,
-                                  ParsedAttr::Form formUsed) {
+                                  ParsedAttr::Form formUsed,
+                                  SourceLocation ellipsisLoc) {
     void *memory = allocate(
         ParsedAttr::totalSizeToAlloc<ArgsUnion, detail::AvailabilityData,
                                      detail::TypeTagForDatatypeData, ParsedType,
                                      detail::PropertyData>(0, 0, 0, 1, 0));
     return add(new (memory) ParsedAttr(attrName, attrRange, scopeName, scopeLoc,
-                                       typeArg, formUsed));
+                                       typeArg, formUsed, ellipsisLoc));
   }
 
   ParsedAttr *
   createPropertyAttribute(IdentifierInfo *attrName, SourceRange attrRange,
                           IdentifierInfo *scopeName, SourceLocation scopeLoc,
                           IdentifierInfo *getterId, IdentifierInfo *setterId,
                           ParsedAttr::Form formUsed) {
     void *memory = allocate(AttributeFactory::PropertyAllocSize);
ParsedAttr *attr = pool.createTypeTagForDatatype(
         layoutCompatible, mustBeNull, form);
     addAtEnd(attr);
     return attr;
   }
 
   /// Add an attribute with a single type argument.
   ParsedAttr *addNewTypeAttr(IdentifierInfo *attrName, SourceRange attrRange,
                              IdentifierInfo *scopeName, SourceLocation scopeLoc,
-                             ParsedType typeArg, ParsedAttr::Form formUsed) {
-    ParsedAttr *attr = pool.createTypeAttribute(attrName, attrRange, scopeName,
-                                                scopeLoc, typeArg, formUsed);
+                             ParsedType typeArg, ParsedAttr::Form formUsed,
+                             SourceLocation ellipsisLoc = SourceLocation()) {
+    ParsedAttr *attr =
+        pool.createTypeAttribute(attrName, attrRange, scopeName, scopeLoc,
+                                 typeArg, formUsed, ellipsisLoc);
     addAtEnd(attr);
     return attr;
   }
 
   /// Add microsoft __delspec(property) attribute.
   ParsedAttr *
   addNewPropertyAttr(IdentifierInfo *attrName, SourceRange attrRange,
                      IdentifierInfo *scopeName, SourceLocation scopeLoc,

clang/include/clang/Sema/Sema.h

public:
   ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op,
                           Expr *Input, bool IsAfterAmp = false);
 
   bool isQualifiedMemberAccess(Expr *E);
   QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
 
   bool CheckTypeTraitArity(unsigned Arity, SourceLocation Loc, size_t N);
 
+  bool ActOnAlignasTypeArgument(StringRef KWName, ParsedType Ty,
+                                SourceLocation OpLoc, SourceRange R);
+  bool CheckAlignasTypeArgument(StringRef KWName, TypeSourceInfo *TInfo,
+                                SourceLocation OpLoc, SourceRange R);
+
   ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
                                             SourceLocation OpLoc,
                                             UnaryExprOrTypeTrait ExprKind,
                                             SourceRange R);
   ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
                                             UnaryExprOrTypeTrait ExprKind);
   ExprResult
     ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
                                   UnaryExprOrTypeTrait ExprKind,
                                   bool IsType, void *TyOrEx,
                                   SourceRange ArgRange);
 
   ExprResult CheckPlaceholderExpr(Expr *E);
   bool CheckVecStepExpr(Expr *E);
 
   bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
   bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
                                         SourceRange ExprRange,
-                                        UnaryExprOrTypeTrait ExprKind);
+                                        UnaryExprOrTypeTrait ExprKind,
+                                        StringRef KWName);
   ExprResult ActOnSizeofParameterPackExpr(Scope *S,
                                           SourceLocation OpLoc,
                                           IdentifierInfo &Name,
                                           SourceLocation NameLoc,
                                           SourceLocation RParenLoc);
   ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
                                  tok::TokenKind Kind, Expr *Input);
 

clang/lib/AST/AttrImpl.cpp

void OMPDeclareVariantAttr::printPrettyPragma(
   };
   if (appendArgs_size()) {
     OS << " append_args(";
     PrintInteropInfo(appendArgs_begin(), appendArgs_end());
     OS << ")";
   }
 }
 
+unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
+  assert(!isAlignmentDependent());
+  if (getCachedAlignmentValue())
+    return *getCachedAlignmentValue();
+
+  // Handle alignmentType case.
+  if (!isAlignmentExpr()) {
+    QualType T = getAlignmentType()->getType();
+
+    // C++ [expr.alignof]p3:
+    //     When alignof is applied to a reference type, the result is the
+    //     alignment of the referenced type.
+    T = T.getNonReferenceType();
+
+    if (T.getQualifiers().hasUnaligned())
+      return Ctx.getCharWidth();
+
+    return Ctx.getTypeAlignInChars(T.getTypePtr()).getQuantity() *
+           Ctx.getCharWidth();
+  }
+
+  // Handle alignmentExpr case.
+  if (alignmentExpr)
+    return alignmentExpr->EvaluateKnownConstInt(Ctx).getZExtValue() *
+           Ctx.getCharWidth();
+
+  return Ctx.getTargetDefaultAlignForAttributeAligned();
+}
+
 #include "clang/AST/AttrImpl.inc"

clang/lib/AST/ExprConstant.cpp

bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
   return ExprEvaluatorBaseTy::VisitCastExpr(E);
 }
 
 static CharUnits GetAlignOfType(EvalInfo &Info, QualType T,
                                 UnaryExprOrTypeTrait ExprKind) {
   // C++ [expr.alignof]p3:
   //     When alignof is applied to a reference type, the result is the
   //     alignment of the referenced type.
-  if (const ReferenceType *Ref = T->getAs<ReferenceType>())
-    T = Ref->getPointeeType();
+  T = T.getNonReferenceType();
 
   if (T.getQualifiers().hasUnaligned())
     return CharUnits::One();
 
   const bool AlignOfReturnsPreferred =
       Info.Ctx.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7;
 
   // __alignof is defined to return the preferred alignment.

clang/lib/Parse/ParseDecl.cpp

case DeclaratorContext::RequiresExpr:
     return DeclSpecContext::DSC_normal;
   }
 
   llvm_unreachable("Missing DeclaratorContext case");
 }
 
 /// ParseAlignArgument - Parse the argument to an alignment-specifier.
 ///
-/// FIXME: Simply returns an alignof() expression if the argument is a
-/// type. Ideally, the type should be propagated directly into Sema.
-///
 /// [C11]   type-id
 /// [C11]   constant-expression
 /// [C++0x] type-id ...[opt]
 /// [C++0x] assignment-expression ...[opt]
-ExprResult Parser::ParseAlignArgument(SourceLocation Start,
-                                      SourceLocation &EllipsisLoc) {
+ExprResult Parser::ParseAlignArgument(StringRef KWName, SourceLocation Start,
+                                      SourceLocation &EllipsisLoc, bool &IsType,
+                                      ParsedType &TypeResult) {
   ExprResult ER;
   if (isTypeIdInParens()) {
     SourceLocation TypeLoc = Tok.getLocation();
     ParsedType Ty = ParseTypeName().get();
     SourceRange TypeRange(Start, Tok.getLocation());
-    ER = Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true,
-                                               Ty.getAsOpaquePtr(), TypeRange);
-  } else
+    if (Actions.ActOnAlignasTypeArgument(KWName, Ty, TypeLoc, TypeRange))
+      return ExprError();
+    TypeResult = Ty;
+    IsType = true;
+  } else {
     ER = ParseConstantExpression();
+    IsType = false;
+  }
 
   if (getLangOpts().CPlusPlus11)
     TryConsumeToken(tok::ellipsis, EllipsisLoc);
 
   return ER;
 }
 
 /// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the
 /// attribute to Attrs.
 ///
 /// alignment-specifier:
 /// [C11]   '_Alignas' '(' type-id ')'
 /// [C11]   '_Alignas' '(' constant-expression ')'
 /// [C++11] 'alignas' '(' type-id ...[opt] ')'
 /// [C++11] 'alignas' '(' assignment-expression ...[opt] ')'
 void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs,
                                      SourceLocation *EndLoc) {
   assert(Tok.isOneOf(tok::kw_alignas, tok::kw__Alignas) &&
          "Not an alignment-specifier!");
-
-  IdentifierInfo *KWName = Tok.getIdentifierInfo();
-  auto Kind = Tok.getKind();
+  Token KWTok = Tok;
+  IdentifierInfo *KWName = KWTok.getIdentifierInfo();
+  auto Kind = KWTok.getKind();
   SourceLocation KWLoc = ConsumeToken();
 
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.expectAndConsume())
     return;
 
+  bool IsType;
+  ParsedType TypeResult;
   SourceLocation EllipsisLoc;
-  ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc);
+  ExprResult ArgExpr =
+      ParseAlignArgument(PP.getSpelling(KWTok), T.getOpenLocation(),
+                         EllipsisLoc, IsType, TypeResult);
   if (ArgExpr.isInvalid()) {
     T.skipToEnd();
     return;
   }
 
   T.consumeClose();
   if (EndLoc)
     *EndLoc = T.getCloseLocation();
 
+  if (IsType) {
+    Attrs.addNewTypeAttr(KWName, KWLoc, nullptr, KWLoc, TypeResult, Kind,
+                         EllipsisLoc);
+  } else {
     ArgsVector ArgExprs;
     ArgExprs.push_back(ArgExpr.get());
     Attrs.addNew(KWName, KWLoc, nullptr, KWLoc, ArgExprs.data(), 1, Kind,
                  EllipsisLoc);
   }
+}
 
 ExprResult Parser::ParseExtIntegerArgument() {
   assert(Tok.isOneOf(tok::kw__ExtInt, tok::kw__BitInt) &&
          "Not an extended int type");
   ConsumeToken();
 
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.expectAndConsume())

clang/lib/Sema/SemaDeclAttr.cpp

if (!E->isValueDependent()) {
     return;
   }
 
   // Save dependent expressions in the AST to be instantiated.
   D->addAttr(::new (Context) AlignValueAttr(Context, CI, E));
 }
 
 static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  if (AL.hasParsedType()) {
+    const ParsedType &TypeArg = AL.getTypeArg();
+    TypeSourceInfo *TInfo;
+    (void)S.GetTypeFromParser(
+        ParsedType::getFromOpaquePtr(TypeArg.getAsOpaquePtr()), &TInfo);
+    if (AL.isPackExpansion() &&
+        !TInfo->getType()->containsUnexpandedParameterPack()) {
+      S.Diag(AL.getEllipsisLoc(),
+             diag::err_pack_expansion_without_parameter_packs);
+      return;
+    }
+
+    if (!AL.isPackExpansion() &&
+        S.DiagnoseUnexpandedParameterPack(TInfo->getTypeLoc().getBeginLoc(),
+                                          TInfo, Sema::UPPC_Expression))
+      return;
+
+    S.AddAlignedAttr(D, AL, TInfo, AL.isPackExpansion());
+    return;
+  }
+
   // check the attribute arguments.
   if (AL.getNumArgs() > 1) {
     S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
     return;
   }
 
   if (AL.getNumArgs() == 0) {
     D->addAttr(::new (S.Context) AlignedAttr(S.Context, AL, true, nullptr));
     return;
   }
 
   Expr *E = AL.getArgAsExpr(0);
   if (AL.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
     S.Diag(AL.getEllipsisLoc(),
            diag::err_pack_expansion_without_parameter_packs);
     return;
   }
 
   if (!AL.isPackExpansion() && S.DiagnoseUnexpandedParameterPack(E))
     return;
 
   S.AddAlignedAttr(D, AL, E, AL.isPackExpansion());
 }
 
-void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
-                          bool IsPackExpansion) {
-  AlignedAttr TmpAttr(Context, CI, true, E);
-  SourceLocation AttrLoc = CI.getLoc();
-
-  // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
-  if (TmpAttr.isAlignas()) {
-    // C++11 [dcl.align]p1:
-    //   An alignment-specifier may be applied to a variable or to a class
-    //   data member, but it shall not be applied to a bit-field, a function
-    //   parameter, the formal parameter of a catch clause, or a variable
-    //   declared with the register storage class specifier. An
-    //   alignment-specifier may also be applied to the declaration of a class
-    //   or enumeration type.
-    // CWG 2354:
-    //   CWG agreed to remove permission for alignas to be applied to
-    //   enumerations.
-    // C11 6.7.5/2:
-    //   An alignment attribute shall not be specified in a declaration of
-    //   a typedef, or a bit-field, or a function, or a parameter, or an
-    //   object declared with the register storage-class specifier.
-    int DiagKind = -1;
-    if (isa<ParmVarDecl>(D)) {
-      DiagKind = 0;
-    } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
-      if (VD->getStorageClass() == SC_Register)
-        DiagKind = 1;
-      if (VD->isExceptionVariable())
-        DiagKind = 2;
-    } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
-      if (FD->isBitField())
-        DiagKind = 3;
-    } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
-      if (ED->getLangOpts().CPlusPlus)
-        DiagKind = 4;
-    } else if (!isa<TagDecl>(D)) {
-      Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
-        << (TmpAttr.isC11() ? ExpectedVariableOrField
+/// Perform checking of type validity
+///
+/// C++11 [dcl.align]p1:
+///   An alignment-specifier may be applied to a variable or to a class
+///   data member, but it shall not be applied to a bit-field, a function
+///   parameter, the formal parameter of a catch clause, or a variable
+///   declared with the register storage class specifier. An
+///   alignment-specifier may also be applied to the declaration of a class
+///   or enumeration type.
+/// CWG 2354:
+///   CWG agreed to remove permission for alignas to be applied to
+///   enumerations.
+/// C11 6.7.5/2:
+///   An alignment attribute shall not be specified in a declaration of
+///   a typedef, or a bit-field, or a function, or a parameter, or an
+///   object declared with the register storage-class specifier.
+static bool validateAlignasAppliedType(Sema &S, Decl *D,
+                                       const AlignedAttr &Attr,
+                                       SourceLocation AttrLoc) {
+    return S.Diag(AttrLoc, diag::err_attribute_wrong_decl_type)
+           << &Attr
+           << (Attr.isC11() ? ExpectedVariableOrField
                             : ExpectedVariableFieldOrTag);
-      return;
-    }
-    if (DiagKind != -1) {
-      Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
-        << &TmpAttr << DiagKind;
-      return;
-    }
-  }
+    return S.Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
+           << &Attr << DiagKind;
+  return false;
 
+void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
+                          bool IsPackExpansion) {
+  AlignedAttr TmpAttr(Context, CI, true, E);
+  SourceLocation AttrLoc = CI.getLoc();
+
+  // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
+  if (TmpAttr.isAlignas() &&
+      validateAlignasAppliedType(*this, D, TmpAttr, AttrLoc))
+    return;
+
   if (E->isValueDependent()) {
     // We can't support a dependent alignment on a non-dependent type,
     // because we have no way to model that a type is "alignment-dependent"
     // but not dependent in any other way.
     if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
       if (!TND->getUnderlyingType()->isDependentType()) {
         Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
             << E->getSourceRange();
if (Ty->isVectorType() && AlignVal < 16) {
       Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned)
           << VD->getType() << 16;
       return;
     }
   }
 
   AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, true, ICE.get());
   AA->setPackExpansion(IsPackExpansion);
+  AA->setCachedAlignmentValue(
+      static_cast<unsigned>(AlignVal * Context.getCharWidth()));
   D->addAttr(AA);
 }
 
 void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI,
                           TypeSourceInfo *TS, bool IsPackExpansion) {
-  // FIXME: Cache the number on the AL object if non-dependent?
-  // FIXME: Perform checking of type validity
+  AlignedAttr TmpAttr(Context, CI, false, TS);
+  SourceLocation AttrLoc = CI.getLoc();
+
+  // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
+  if (TmpAttr.isAlignas() &&
+      validateAlignasAppliedType(*this, D, TmpAttr, AttrLoc))
+    return;
+
+  if (TS->getType()->isDependentType()) {
+    // We can't support a dependent alignment on a non-dependent type,
+    // because we have no way to model that a type is "type-dependent"
+    // but not dependent in any other way.
+    if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
+      if (!TND->getUnderlyingType()->isDependentType()) {
+        Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
+            << TS->getTypeLoc().getSourceRange();
+        return;
+      }
+    }
+
+    AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, false, TS);
+    AA->setPackExpansion(IsPackExpansion);
+    D->addAttr(AA);
+    return;
+  }
+
+  const auto *VD = dyn_cast<VarDecl>(D);
+  unsigned AlignVal = TmpAttr.getAlignment(Context);
+  // On AIX, an aligned attribute can not decrease the alignment when applied
+  // to a variable declaration with vector type.
+  if (VD && Context.getTargetInfo().getTriple().isOSAIX()) {
+    const Type *Ty = VD->getType().getTypePtr();
+    if (Ty->isVectorType() &&
+        Context.toCharUnitsFromBits(AlignVal).getQuantity() < 16) {
+      Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned)
+          << VD->getType() << 16;
+      return;
+    }
+  }
+
   AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, false, TS);
   AA->setPackExpansion(IsPackExpansion);
+  AA->setCachedAlignmentValue(AlignVal);
   D->addAttr(AA);
 }
 
 void Sema::CheckAlignasUnderalignment(Decl *D) {
   assert(D->hasAttrs() && "no attributes on decl");
 
   QualType UnderlyingTy, DiagTy;
   if (const auto *VD = dyn_cast<ValueDecl>(D)) {

clang/lib/Sema/SemaExpr.cpp

if (const auto *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) {
       warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
                                BO->getRHS());
     }
   }
 
   return false;
 }
 
-/// Check the constraints on operands to unary expression and type
-/// traits.
-///
-/// This will complete any types necessary, and validate the various constraints
-/// on those operands.
-///
-/// The UsualUnaryConversions() function is *not* called by this routine.
-/// C99 6.3.2.1p[2-4] all state:
-///   Except when it is the operand of the sizeof operator ...
-///
-/// C++ [expr.sizeof]p4
-///   The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
-///   standard conversions are not applied to the operand of sizeof.
-///
-/// This policy is followed for all of the unary trait expressions.
-bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
-                                            SourceLocation OpLoc,
-                                            SourceRange ExprRange,
-                                            UnaryExprOrTypeTrait ExprKind) {
-  if (ExprType->isDependentType())
-    return false;
-
-  // C++ [expr.sizeof]p2:
-  //     When applied to a reference or a reference type, the result
-  //     is the size of the referenced type.
-  // C++11 [expr.alignof]p3:
-  //     When alignof is applied to a reference type, the result
-  //     shall be the alignment of the referenced type.
-  if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>())
-    ExprType = Ref->getPointeeType();
-
-  // C11 6.5.3.4/3, C++11 [expr.alignof]p3:
-  //   When alignof or _Alignof is applied to an array type, the result
-  //   is the alignment of the element type.
-  if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
-      ExprKind == UETT_OpenMPRequiredSimdAlign)
-    ExprType = Context.getBaseElementType(ExprType);
-
-  if (ExprKind == UETT_VecStep)
-    return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);
-
-  // Explicitly list some types as extensions.
-  if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
-                                      ExprKind))
-    return false;
-
-  if (RequireCompleteSizedType(
-          OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
-          getTraitSpelling(ExprKind), ExprRange))
-    return true;
-
-  if (ExprType->isFunctionType()) {
-    Diag(OpLoc, diag::err_sizeof_alignof_function_type)
-        << getTraitSpelling(ExprKind) << ExprRange;
-    return true;
-  }
-
-  if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange,
-                                       ExprKind))
-    return true;
-
-  return false;
-}
-
 static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
   // Cannot know anything else if the expression is dependent.
   if (E->isTypeDependent())
     return false;
 
   if (E->getObjectKind() == OK_BitField) {
     S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
        << 1 << E->getSourceRange();
case Type::TypeOfExpr:
       break;
     case Type::Atomic:
       T = cast<AtomicType>(Ty)->getValueType();
       break;
     }
   } while (!T.isNull() && T->isVariablyModifiedType());
 }
 
-/// Build a sizeof or alignof expression given a type operand.
-ExprResult
-Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
+/// Check the constraints on operands to unary expression and type
+/// traits.
+///
+/// This will complete any types necessary, and validate the various constraints
+/// on those operands.
+///
+/// The UsualUnaryConversions() function is *not* called by this routine.
+/// C99 6.3.2.1p[2-4] all state:
+///   Except when it is the operand of the sizeof operator ...
+///
+/// C++ [expr.sizeof]p4
+///   The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
+///   standard conversions are not applied to the operand of sizeof.
+///
+/// This policy is followed for all of the unary trait expressions.
+bool Sema::CheckUnaryExprOrTypeTraitOperand(QualType ExprType,
                                             SourceLocation OpLoc,
+                                            SourceRange ExprRange,
                                             UnaryExprOrTypeTrait ExprKind,
-                                     SourceRange R) {
-  if (!TInfo)
-    return ExprError();
+                                            StringRef KWName) {
+  if (ExprType->isDependentType())
+    return false;
 
-  QualType T = TInfo->getType();
+  // C++ [expr.sizeof]p2:
+  //     When applied to a reference or a reference type, the result
+  //     is the size of the referenced type.
+  // C++11 [expr.alignof]p3:
+  //     When alignof is applied to a reference type, the result
+  //     shall be the alignment of the referenced type.
+  if (const ReferenceType *Ref = ExprType->getAs<ReferenceType>())
+    ExprType = Ref->getPointeeType();
 
-  if (!T->isDependentType() &&
-      CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind))
-    return ExprError();
+  // C11 6.5.3.4/3, C++11 [expr.alignof]p3:
+  //   When alignof or _Alignof is applied to an array type, the result
+  //   is the alignment of the element type.
+  if (ExprKind == UETT_AlignOf || ExprKind == UETT_PreferredAlignOf ||
+      ExprKind == UETT_OpenMPRequiredSimdAlign)
+    ExprType = Context.getBaseElementType(ExprType);
 
-  if (T->isVariablyModifiedType() && FunctionScopes.size() > 1) {
-    if (auto *TT = T->getAs<TypedefType>()) {
+  if (ExprKind == UETT_VecStep)
+    return CheckVecStepTraitOperandType(*this, ExprType, OpLoc, ExprRange);
+
+  // Explicitly list some types as extensions.
+  if (!CheckExtensionTraitOperandType(*this, ExprType, OpLoc, ExprRange,
+                                      ExprKind))
+    return false;
+
+  if (RequireCompleteSizedType(
+          OpLoc, ExprType, diag::err_sizeof_alignof_incomplete_or_sizeless_type,
+          KWName, ExprRange))
+    return true;
+
+  if (ExprType->isFunctionType()) {
+    Diag(OpLoc, diag::err_sizeof_alignof_function_type) << KWName << ExprRange;
+    return true;
+  }
+
+  if (CheckObjCTraitOperandConstraints(*this, ExprType, OpLoc, ExprRange,
+                                       ExprKind))
+    return true;
+
+  if (ExprType->isVariablyModifiedType() && FunctionScopes.size() > 1) {
+    if (auto *TT = ExprType->getAs<TypedefType>()) {
       for (auto I = FunctionScopes.rbegin(),
                 E = std::prev(FunctionScopes.rend());
            I != E; ++I) {
         auto *CSI = dyn_cast<CapturingScopeInfo>(*I);
         if (CSI == nullptr)
           break;
         DeclContext *DC = nullptr;
         if (auto *LSI = dyn_cast<LambdaScopeInfo>(CSI))
           DC = LSI->CallOperator;
         else if (auto *CRSI = dyn_cast<CapturedRegionScopeInfo>(CSI))
           DC = CRSI->TheCapturedDecl;
         else if (auto *BSI = dyn_cast<BlockScopeInfo>(CSI))
           DC = BSI->TheDecl;
         if (DC) {
           if (DC->containsDecl(TT->getDecl()))
             break;
-          captureVariablyModifiedType(Context, T, CSI);
+          captureVariablyModifiedType(Context, ExprType, CSI);
         }
       }
     }
   }
 
-  // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
+  return false;
+}
+
+/// Build a sizeof or alignof expression given a type operand.
+ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
+                                                SourceLocation OpLoc,
+                                                UnaryExprOrTypeTrait ExprKind,
+                                                SourceRange R) {
+  if (!TInfo)
+    return ExprError();
+
+  QualType T = TInfo->getType();
+
+  if (!T->isDependentType() &&
+      CheckUnaryExprOrTypeTraitOperand(T, OpLoc, R, ExprKind,
+                                       getTraitSpelling(ExprKind)))
+    return ExprError();
+
+  // Adds overload of TransformToPotentiallyEvaluated for TypeSourceInfo to
+  // properly deal with VLAs in nested calls of sizeof and typeof.
   if (isUnevaluatedContext() && ExprKind == UETT_SizeOf &&
       TInfo->getType()->isVariablyModifiedType())
     TInfo = TransformToPotentiallyEvaluated(TInfo);
 
+  // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t.
   return new (Context) UnaryExprOrTypeTraitExpr(
       ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd());
 }
 
 /// Build a sizeof or alignof expression given an expression
 /// operand.
 ExprResult
 Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
if (IsType) {
     return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange);
   }
 
   Expr *ArgEx = (Expr *)TyOrEx;
   ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind);
   return Result;
 }
 
+bool Sema::CheckAlignasTypeArgument(StringRef KWName, TypeSourceInfo *TInfo,
+                                    SourceLocation OpLoc, SourceRange R) {
+  if (!TInfo)
+    return true;
+  return CheckUnaryExprOrTypeTraitOperand(TInfo->getType(), OpLoc, R,
+                                          UETT_AlignOf, KWName);
+}
+
+/// ActOnAlignasTypeArgument - Handle @c alignas(type-id) and @c
+/// _Alignas(type-name) .
+/// [dcl.align] An alignment-specifier of the form
+/// alignas(type-id) has the same effect as alignas(alignof(type-id)).
+///
+/// [N1570 6.7.5] _Alignas(type-name) is equivalent to
+/// _Alignas(_Alignof(type-name)).
+bool Sema::ActOnAlignasTypeArgument(StringRef KWName, ParsedType Ty,
+                                    SourceLocation OpLoc, SourceRange R) {
+  TypeSourceInfo *TInfo;
+  (void)GetTypeFromParser(ParsedType::getFromOpaquePtr(Ty.getAsOpaquePtr()),
+                          &TInfo);
+  return CheckAlignasTypeArgument(KWName, TInfo, OpLoc, R);
+}
+
 static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc,
                                      bool IsReal) {
   if (V.get()->isTypeDependent())
     return S.Context.DependentTy;
 
   // _Real and _Imag are only l-values for normal l-values.
   if (V.get()->getObjectKind() != OK_Ordinary) {
     V = S.DefaultLvalueConversion(V.get());

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

static void instantiateDependentAlignedAttr(
   if (Aligned->isAlignmentExpr()) {
     // The alignment expression is a constant expression.
     EnterExpressionEvaluationContext Unevaluated(
         S, Sema::ExpressionEvaluationContext::ConstantEvaluated);
     ExprResult Result = S.SubstExpr(Aligned->getAlignmentExpr(), TemplateArgs);
     if (!Result.isInvalid())
       S.AddAlignedAttr(New, *Aligned, Result.getAs<Expr>(), IsPackExpansion);
   } else {
-    TypeSourceInfo *Result = S.SubstType(Aligned->getAlignmentType(),
-                                         TemplateArgs, Aligned->getLocation(),
-                                         DeclarationName());
-    if (Result)
+    if (TypeSourceInfo *Result =
+            S.SubstType(Aligned->getAlignmentType(), TemplateArgs,
+                        Aligned->getLocation(), DeclarationName())) {
+      if (!S.CheckAlignasTypeArgument(Aligned->getSpelling(), Result,
+                                      Aligned->getLocation(),
+                                      Result->getTypeLoc().getSourceRange()))
         S.AddAlignedAttr(New, *Aligned, Result, IsPackExpansion);
     }
   }
+}
 
 static void instantiateDependentAlignedAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
     const AlignedAttr *Aligned, Decl *New) {
   if (!Aligned->isPackExpansion()) {
     instantiateDependentAlignedAttr(S, TemplateArgs, Aligned, New, false);
     return;
   }

clang/test/AST/ast-dump-attr.cpp

 
 alignas(8) extern int x;
 extern int x;
 // CHECK: VarDecl{{.*}} x 'int'
 // CHECK: VarDecl{{.*}} x 'int'
 // CHECK-NEXT: AlignedAttr{{.*}} Inherited
 }
 
+namespace TestAligns {
+
+template<typename...T> struct my_union {
+  alignas(T...) char buffer[1024];
+};
+
+template<typename...T> struct my_union2 {
+  _Alignas(T...) char buffer[1024];
+};
+
+struct alignas(8) A { char c; };
+struct alignas(4) B { short s; };
+struct C { char a[16]; };
+
+// CHECK: ClassTemplateSpecializationDecl {{.*}} struct my_union
+// CHECK: CXXRecordDecl {{.*}} implicit struct my_union
+// CHECK: FieldDecl {{.*}} buffer 'char[1024]'
+// CHECK-NEXT: AlignedAttr {{.*}} alignas 'TestAligns::A':'TestAligns::A'
+// CHECK-NEXT: AlignedAttr {{.*}} alignas 'TestAligns::B':'TestAligns::B'
+// CHECK-NEXT: AlignedAttr {{.*}} alignas 'TestAligns::C':'TestAligns::C'
+my_union<A, B, C> my_union_val;
+
+// CHECK: ClassTemplateSpecializationDecl {{.*}} struct my_union2
+// CHECK: CXXRecordDecl {{.*}} implicit struct my_union2
+// CHECK: FieldDecl {{.*}} buffer 'char[1024]'
+// CHECK-NEXT: AlignedAttr {{.*}} _Alignas 'TestAligns::A':'TestAligns::A'
+// CHECK-NEXT: AlignedAttr {{.*}} _Alignas 'TestAligns::B':'TestAligns::B'
+// CHECK-NEXT: AlignedAttr {{.*}} _Alignas 'TestAligns::C':'TestAligns::C'
+my_union2<A, B, C> my_union2_val;
+
+} // namespace TestAligns
+
 int __attribute__((cdecl)) TestOne(void), TestTwo(void);
 // CHECK: FunctionDecl{{.*}}TestOne{{.*}}__attribute__((cdecl))
 // CHECK: FunctionDecl{{.*}}TestTwo{{.*}}__attribute__((cdecl))
 
 void func() {
   auto Test = []() __attribute__((no_thread_safety_analysis)) {};
   // CHECK: CXXMethodDecl{{.*}}operator() 'void () const'
   // CHECK: NoThreadSafetyAnalysisAttr

clang/test/Sema/aix-attr-aligned-vector-warn.c

 // RUN: %clang_cc1 -triple powerpc64-unknown-aix -target-feature +altivec -target-cpu pwr7 -verify -fsyntax-only %s
 // RUN: %clang_cc1 -triple powerpc-unknown-aix -target-feature +altivec -target-cpu pwr7 -verify -fsyntax-only %s
 
 int escape(vector int*);
 
 typedef vector int __attribute__((aligned(8))) UnderAlignedVI;
 UnderAlignedVI TypedefedGlobal;
 
 vector int V __attribute__((aligned(8))); // expected-warning {{requested alignment is less than minimum alignment of 16 for type '__vector int' (vector of 4 'int' values)}}
+vector int V __attribute__((aligned(8))); // expected-warning {{requested alignment is less than minimum alignment of 16 for type '__vector int' (vector of 4 'int' values)}}
 
 int localTypedefed(void) {
   UnderAlignedVI TypedefedLocal;
   return escape(&TypedefedLocal); // expected-warning {{passing 8-byte aligned argument to 16-byte aligned parameter 1 of 'escape' may result in an unaligned pointer access}}
 }

clang/test/Sema/aix-attr-aligned-vector-warn.cpp

+// RUN: %clang_cc1 -triple powerpc64-unknown-aix -target-feature +altivec -target-cpu pwr7 -verify -fsyntax-only %s
+// RUN: %clang_cc1 -triple powerpc-unknown-aix -target-feature +altivec -target-cpu pwr7 -verify -fsyntax-only %s
+
+struct alignas(8) Align8 {
+  void *a, *b;
+};
+
+alignas(8) vector int V1; // expected-warning {{requested alignment is less than minimum alignment of 16 for type '__vector int' (vector of 4 'int' values)}}
+alignas(Align8) vector int V2; // expected-warning {{requested alignment is less than minimum alignment of 16 for type '__vector int' (vector of 4 'int' values)}}

clang/test/Sema/sizeless-1.c

void func(int sel) {
   svint8_t local_int8;
   int8_typedef typedef_int8;
   svint16_t local_int16;
 
   svint8_t __attribute__((aligned)) aligned_int8_1;    // expected-error {{'aligned' attribute cannot be applied to sizeless type 'svint8_t'}}
   svint8_t __attribute__((aligned(4))) aligned_int8_2; // expected-error {{'aligned' attribute cannot be applied to sizeless type 'svint8_t'}}
   svint8_t _Alignas(int) aligned_int8_3;               // expected-error {{'_Alignas' attribute cannot be applied to sizeless type 'svint8_t'}}
 
-  int _Alignas(svint8_t) aligned_int; // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}}
+  int _Alignas(svint8_t) aligned_int; // expected-error {{invalid application of '_Alignas' to sizeless type 'svint8_t'}}
 
   // Using pointers to sizeless data isn't wrong here, but because the
   // type is incomplete, it doesn't provide any alignment guarantees.
   _Static_assert(__atomic_is_lock_free(1, &local_int8) == __atomic_is_lock_free(1, incomplete_ptr), "");
   _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static assertion expression is not an integral constant expression}}
   _Static_assert(__atomic_always_lock_free(1, &local_int8) == __atomic_always_lock_free(1, incomplete_ptr), "");
 
   local_int8; // expected-warning {{expression result unused}}

clang/test/SemaCXX/attr-cxx0x.cpp

 static_assert(alignof(outer<int,char>::inner<double,short>) == alignof(int) * alignof(double), "template's alignment is wrong");
 
 static_assert(alignof(int(int)) >= 1, "alignof(function) not positive"); // expected-error{{invalid application of 'alignof' to a function type}}
 
 [[__carries_dependency__]]
 void func(void);
 
 alignas(4) auto PR19252 = 0;
+
+// Check the diagnostic message
+class alignas(void) AlignasVoid {}; // expected-error {{invalid application of 'alignas' to an incomplete type 'void'}}

clang/test/SemaCXX/builtin-align-cxx.cpp

 static_assert(!__builtin_is_aligned(static_cast<signed short>(7), static_cast<signed long>(4)), "");
 // Also check signed -- unsigned mismatch.
 static_assert(!__builtin_is_aligned(static_cast<signed long>(7), static_cast<signed long>(4)), "");
 static_assert(!__builtin_is_aligned(static_cast<unsigned long>(7), static_cast<unsigned long>(4)), "");
 static_assert(!__builtin_is_aligned(static_cast<signed long>(7), static_cast<unsigned long>(4)), "");
 static_assert(!__builtin_is_aligned(static_cast<unsigned long>(7), static_cast<signed long>(4)), "");
 static_assert(!__builtin_is_aligned(static_cast<signed long>(7), static_cast<unsigned short>(4)), "");
 static_assert(!__builtin_is_aligned(static_cast<unsigned short>(7), static_cast<signed long>(4)), "");
+
+// Check the diagnostic message
+_Alignas(void) char align_void_array[1]; // expected-error {{invalid application of '_Alignas' to an incomplete type 'void'}}

clang/test/SemaCXX/cxx11-attr-print.cpp

 int d [[deprecated("warning")]];
 
 // CHECK: __attribute__((deprecated("warning", "fixit")));
 int e __attribute__((deprecated("warning", "fixit")));
 
 // CHECK: int cxx11_alignas alignas(4);
 alignas(4) int cxx11_alignas;
 
-// CHECK: int c11_alignas _Alignas(alignof(int));
+// CHECK: int c11_alignas _Alignas(int);
 _Alignas(int) int c11_alignas;
 
 // CHECK: void foo() __attribute__((const));
 void foo() __attribute__((const));
 
 // CHECK: void bar() __attribute__((__const));
 void bar() __attribute__((__const));
 

 inline void f7 [[gnu::gnu_inline]] ();
 
 // arguments printing
 // CHECK: __attribute__((format(printf, 2, 3)));
 void f8 (void *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
 
 // CHECK: int m __attribute__((aligned(4
 // CHECK: int n alignas(4
+// CHECK: int p alignas(int
 // CHECK: static int f() __attribute__((pure))
 // CHECK: static int g() {{\[}}[gnu::pure]]
 template <typename T> struct S {
   __attribute__((aligned(4))) int m;
   alignas(4) int n;
+  alignas(int) int p;
   __attribute__((pure)) static int f() {
     return 0;
   }
   [[gnu::pure]] static int g() {
     return 1;
   }
 };
 
 // CHECK: int m __attribute__((aligned(4
 // CHECK: int n alignas(4
 // CHECK: static int f() __attribute__((pure))
 // CHECK: static int g() {{\[}}[gnu::pure]]
 template struct S<int>;
 
 // CHECK: using Small2 {{\[}}[gnu::mode(byte)]] = int;
 using Small2 [[gnu::mode(byte)]] = int;

clang/test/SemaCXX/sizeless-1.cpp

void func(int sel) {
 
   svint8_t local_int8;
   svint16_t local_int16;
 
   svint8_t __attribute__((aligned)) aligned_int8_1;    // expected-error {{'aligned' attribute cannot be applied to sizeless type 'svint8_t'}}
   svint8_t __attribute__((aligned(4))) aligned_int8_2; // expected-error {{'aligned' attribute cannot be applied to sizeless type 'svint8_t'}}
   svint8_t _Alignas(int) aligned_int8_3;               // expected-error {{'_Alignas' attribute cannot be applied to sizeless type 'svint8_t'}}
 
-  int _Alignas(svint8_t) aligned_int; // expected-error {{invalid application of 'alignof' to sizeless type 'svint8_t'}}
+  int _Alignas(svint8_t) aligned_int; // expected-error {{invalid application of '_Alignas' to sizeless type 'svint8_t'}}
 
   // Using pointers to sizeless data isn't wrong here, but because the
   // type is incomplete, it doesn't provide any alignment guarantees.
   _Static_assert(__atomic_is_lock_free(1, &local_int8) == __atomic_is_lock_free(1, incomplete_ptr), "");
   _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static assertion expression is not an integral constant expression}}
   _Static_assert(__atomic_always_lock_free(1, &local_int8) == __atomic_always_lock_free(1, incomplete_ptr), "");
 
   local_int8; // expected-warning {{expression result unused}}

clang/utils/TableGen/ClangAttrEmitter.cpp

void writeAccessors(raw_ostream &OS) const override {
       OS << "    assert(is" << getLowerName() << "Expr);\n";
       OS << "    return " << getLowerName() << "Expr;\n";
       OS << "  }\n";
 
       OS << "  TypeSourceInfo *get" << getUpperName() << "Type() const {\n";
       OS << "    assert(!is" << getLowerName() << "Expr);\n";
       OS << "    return " << getLowerName() << "Type;\n";
       OS << "  }";
+
+      OS << "  std::optional<unsigned> getCached" << getUpperName()
+         << "Value() const {\n";
+      OS << "    return " << getLowerName() << "Cache;\n";
+      OS << "  }";
+
+      OS << "  void setCached" << getUpperName()
+         << "Value(unsigned AlignVal) {\n";
+      OS << "    " << getLowerName() << "Cache = AlignVal;\n";
+      OS << "  }";
     }
 
     void writeAccessorDefinitions(raw_ostream &OS) const override {
       OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
          << "Dependent() const {\n";
       OS << "  if (is" << getLowerName() << "Expr)\n";
       OS << "    return " << getLowerName() << "Expr && (" << getLowerName()
          << "Expr->isValueDependent() || " << getLowerName()
          << "Expr->isTypeDependent());\n";
       OS << "  else\n";
       OS << "    return " << getLowerName()
          << "Type->getType()->isDependentType();\n";
       OS << "}\n";
 
       OS << "bool " << getAttrName() << "Attr::is" << getUpperName()
          << "ErrorDependent() const {\n";
       OS << "  if (is" << getLowerName() << "Expr)\n";
       OS << "    return " << getLowerName() << "Expr && " << getLowerName()
          << "Expr->containsErrors();\n";
       OS << "  return " << getLowerName()
          << "Type->getType()->containsErrors();\n";
       OS << "}\n";
-
-      // FIXME: Do not do the calculation here
-      // FIXME: Handle types correctly
-      // A null pointer means maximum alignment
-      OS << "unsigned " << getAttrName() << "Attr::get" << getUpperName()
-         << "(ASTContext &Ctx) const {\n";
-      OS << "  assert(!is" << getUpperName() << "Dependent());\n";
-      OS << "  if (is" << getLowerName() << "Expr)\n";
-      OS << "    return " << getLowerName() << "Expr ? " << getLowerName()
-         << "Expr->EvaluateKnownConstInt(Ctx).getZExtValue()"
-         << " * Ctx.getCharWidth() : "
-         << "Ctx.getTargetDefaultAlignForAttributeAligned();\n";
-      OS << "  else\n";
-      OS << "    return 0; // FIXME\n";
-      OS << "}\n";
     }
 
     void writeASTVisitorTraversal(raw_ostream &OS) const override {
       StringRef Name = getUpperName();
       OS << "  if (A->is" << Name << "Expr()) {\n"
          << "    if (!getDerived().TraverseStmt(A->get" << Name << "Expr()))\n"
          << "      return false;\n"
          << "  } else if (auto *TSI = A->get" << Name << "Type()) {\n"
void writeImplicitCtorArgs(raw_ostream &OS) const override {
       OS << "Is" << getUpperName() << "Expr, " << getUpperName();
     }
 
     void writeDeclarations(raw_ostream &OS) const override {
       OS << "bool is" << getLowerName() << "Expr;\n";
       OS << "union {\n";
       OS << "Expr *" << getLowerName() << "Expr;\n";
       OS << "TypeSourceInfo *" << getLowerName() << "Type;\n";
-      OS << "};";
+      OS << "};\n";
+      OS << "std::optional<unsigned> " << getLowerName() << "Cache;\n";
     }
 
     void writePCHReadArgs(raw_ostream &OS) const override {
       OS << "is" << getLowerName() << "Expr, " << getLowerName() << "Ptr";
     }
 
     void writePCHReadDecls(raw_ostream &OS) const override {
       OS << "    bool is" << getLowerName() << "Expr = Record.readInt();\n";
void writePCHWrite(raw_ostream &OS) const override {
       OS << "    if (SA->is" << getUpperName() << "Expr())\n";
       OS << "      Record.AddStmt(SA->get" << getUpperName() << "Expr());\n";
       OS << "    else\n";
       OS << "      Record.AddTypeSourceInfo(SA->get" << getUpperName()
          << "Type());\n";
     }
 
     std::string getIsOmitted() const override {
-      return "!is" + getLowerName().str() + "Expr || !" + getLowerName().str()
-             + "Expr";
+      return "!((is" + getLowerName().str() + "Expr && " +
+             getLowerName().str() + "Expr) || (!is" + getLowerName().str() +
+             "Expr && " + getLowerName().str() + "Type))";
     }
 
     void writeValue(raw_ostream &OS) const override {
       OS << "\";\n";
-      OS << "    " << getLowerName()
+      OS << "    if (is" << getLowerName() << "Expr && " << getLowerName()
+         << "Expr)";
+      OS << "      " << getLowerName()
          << "Expr->printPretty(OS, nullptr, Policy);\n";
+      OS << "    if (!is" << getLowerName() << "Expr && " << getLowerName()
+         << "Type)";
+      OS << "      " << getLowerName()
+         << "Type->getType().print(OS, Policy);\n";
       OS << "    OS << \"";
     }
 
     void writeDump(raw_ostream &OS) const override {
       OS << "    if (!SA->is" << getUpperName() << "Expr())\n";
       OS << "      dumpType(SA->get" << getUpperName()
          << "Type()->getType());\n";
     }