Allow _Atomic to be specified on incomplete types

[aaron.ballman]

Summary

The C standard does not prohibit the _Atomic specifier on incomplete types, which turns out to be sometimes useful.

This addresses PR37237.

Note that C++ still requires checking if the type is complete in order to support member pointers under the Microsoft ABI (because that check completes some information on the type), which is a use case we have in test\SemaCXX\atomic-type.cpp.

[efriedma]

This generally makes sense.

Need some tests to make sure we emit an appropriate error if you try to actually use atomic operators (load/store) or intrinsics (__atomic_is_lock_free etc.) with an incomplete type. And a test that code generation emits something appropriate.

lib/Sema/SemaType.cpp

8022

If you're going to allow incomplete types in C++, you'll need some code to handle the case where the type is initially incomplete, but completed later.

[rsmith]

lib/Sema/SemaType.cpp

8022

Perhaps the trivially-copyable requirement could be deferred in all cases until we reach an actual load or store. Constraints that are only enforced when a type happens to be complete are generally a bad idea (we have a mess like this for constraints on types being non-abstract, and we're still working on unsticking ourselves from that mess in the C++ standard).

In passing, I'd also note that we need the trivially-copyable requirement even outside C++, for structs containing __weak / __strong fields.

[aaron.ballman]

Hopefully address the review comments.

[aaron.ballman]

lib/Sema/SemaType.cpp

8022

I'm not quite certain I've properly captured the request here, but I took a stab at it. One thing to note is that our behavior for type checking __atomic_load() appears to diverge from GCC with regards to trivial copyability, even before my patch.

https://godbolt.org/g/g2fqLK

[efriedma]

I think the request was that we check that a type is trivially copyable when we perform an atomic operation? I don't see the code for that anywhere.

Also needs some test coverage for atomic operations which aren't calls, like "typedef struct S S; void f(_Atomic S *s, _Atomic S *s2) { *s = *s2; };".

[aaron.ballman]

Addresses review comments.

[aaron.ballman]

Modifications based on review feedback.

[aaron.ballman]

In D46112#1091981, @efriedma wrote:

I think the request was that we check that a type is trivially copyable when we perform an atomic operation? I don't see the code for that anywhere.

Sorry about that -- I didn't notice that GNU was handled while C11 was not. That's been updated now.

Also needs some test coverage for atomic operations which aren't calls, like "typedef struct S S; void f(_Atomic S *s, _Atomic S *s2) { *s = *s2; };".

Thank you for pointing this out -- that uncovered an issue where we were not properly diagnosing the types as being incomplete. I've added a new test case and rolled the contents of Sema\atomic-type.cpp (which I added in an earlier patch) into SemaCXX\atomic-type.cpp (which already existed and I missed it).

I believe the change I made to Type::isIncompleteType() is correct, but was surprised by the new behavior in SemaCXX/atomic-type.cpp that resulted. It appears that the RecordDecl for "struct inner" has IsCompleteDefinition set to false while instantiating struct atomic, but I'm not familiar enough with the template instantiation process to know whether this is reasonable or not.

[rsmith]

test/SemaCXX/atomic-type.cpp

5

This is a bug. You need to teach RequireCompleteType to look through atomic types when looking for a class type to instantiate.

[aaron.ballman]

Look through atomic types when checking type completeness during template instantiation.

[aaron.ballman]

test/SemaCXX/atomic-type.cpp

5

Thank you for the explanation -- I think I've addressed this in the latest patch.

[rsmith]

lib/Sema/SemaType.cpp

7604–7608

This function is duplicating the work of finding the type to complete, which was already done by isIncompleteType. Rather than unwrapping T here...

7636–7637

... these uses of T should be dyn_casting Def, which is the declaration that isIncompleteType said needed completing.

7648–7649

This would nicely address this FIXME, since isIncompleteType has already walked through arrays.

7679–7683

Likewise here, this should probably just be if (const auto *RD = dyn_cast<RecordDecl>(Def)).

[aaron.ballman]

Updated based on review comments.

[aaron.ballman]

lib/Sema/SemaType.cpp

7604–7608

Thank you for the explanation!

[rsmith]

In D46112#1096893, @aaron.ballman wrote:

In D46112#1091981, @efriedma wrote:

Also needs some test coverage for atomic operations which aren't calls, like "typedef struct S S; void f(_Atomic S *s, _Atomic S *s2) { *s = *s2; };".

Thank you for pointing this out -- that uncovered an issue where we were not properly diagnosing the types as being incomplete. I've added a new test case and rolled the contents of Sema\atomic-type.cpp (which I added in an earlier patch) into SemaCXX\atomic-type.cpp (which already existed and I missed it).

I don't think this has sufficiently addressed the comment. Specifically, for a case like:

struct NotTriviallyCopyable { NotTriviallyCopyable(const NotTriviallyCopyable&); };
void f(_Atomic NotTriviallyCopyable *p) { *p = *p; }

... we should reject the assignment, because it would perform an atomic operation on a non-trivially-copyable type. It would probably suffice to check the places where we form an AtomicToNonAtomic or NonAtomicToAtomic conversion.

In passing, I noticed that this crashes Clang (because we fail to create an lvalue-to-rvalue conversion for x):

struct X {};                              
void f(_Atomic X *p, X x) { *p = x; }

This will likely get in the way of your test cases unless you fix it :)

lib/Sema/SemaChecking.cpp

3202

The (pre-existing) isScalarType() check here looks wrong to me. If we had a non-trivially-copyable scalar type (which I think do not currently exist in our type system), I think we should reject it here.

lib/Sema/SemaType.cpp

7662

May as well cast directly to CXXRecordDecl here; none of the code controlled by this if does anything in C.

[aaron.ballman]

Corrected some of the review comments.

[aaron.ballman]

In D46112#1098243, @rsmith wrote:

In D46112#1096893, @aaron.ballman wrote:

In D46112#1091981, @efriedma wrote:

Also needs some test coverage for atomic operations which aren't calls, like "typedef struct S S; void f(_Atomic S *s, _Atomic S *s2) { *s = *s2; };".

Thank you for pointing this out -- that uncovered an issue where we were not properly diagnosing the types as being incomplete. I've added a new test case and rolled the contents of Sema\atomic-type.cpp (which I added in an earlier patch) into SemaCXX\atomic-type.cpp (which already existed and I missed it).

I don't think this has sufficiently addressed the comment. Specifically, for a case like:

struct NotTriviallyCopyable { NotTriviallyCopyable(const NotTriviallyCopyable&); };
void f(_Atomic NotTriviallyCopyable *p) { *p = *p; }

... we should reject the assignment, because it would perform an atomic operation on a non-trivially-copyable type. It would probably suffice to check the places where we form an AtomicToNonAtomic or NonAtomicToAtomic conversion.

In passing, I noticed that this crashes Clang (because we fail to create an lvalue-to-rvalue conversion for x):

struct X {};                              
void f(_Atomic X *p, X x) { *p = x; }

This will likely get in the way of your test cases unless you fix it :)

It only gets in the way for C++ whereas my primary concern for this patch is C. I tried spending a few hours on this today and got nowhere -- we have a lot of FIXME comments surrounding atomic type qualifiers in C++. I've run out of time to be able to work on this patch and may have to abandon it. I'd hate to lose the forward progress already made, so I'm wondering if the C bits are sufficiently baked that even more FIXMEs around atomics in C++ would suffice?

[efriedma]

If you don't want to spend too much time on C++, fine; could you add a short Objective-C test instead to make sure the trivially-copyable checks are working?

What are the changes to Sema::RequireCompleteTypeImpl supposed to do?

test/Sema/atomic-type.c

30

This error message is terrible; yes, technically 'void' isn't trivially copyable, but that isn't really helpful.

[jfb]

In D46112#1113557, @aaron.ballman wrote:

In D46112#1098243, @rsmith wrote:

In D46112#1096893, @aaron.ballman wrote:

In D46112#1091981, @efriedma wrote:

Also needs some test coverage for atomic operations which aren't calls, like "typedef struct S S; void f(_Atomic S *s, _Atomic S *s2) { *s = *s2; };".

Thank you for pointing this out -- that uncovered an issue where we were not properly diagnosing the types as being incomplete. I've added a new test case and rolled the contents of Sema\atomic-type.cpp (which I added in an earlier patch) into SemaCXX\atomic-type.cpp (which already existed and I missed it).

I don't think this has sufficiently addressed the comment. Specifically, for a case like:

struct NotTriviallyCopyable { NotTriviallyCopyable(const NotTriviallyCopyable&); };
void f(_Atomic NotTriviallyCopyable *p) { *p = *p; }

... we should reject the assignment, because it would perform an atomic operation on a non-trivially-copyable type. It would probably suffice to check the places where we form an AtomicToNonAtomic or NonAtomicToAtomic conversion.

In passing, I noticed that this crashes Clang (because we fail to create an lvalue-to-rvalue conversion for x):

struct X {};                              
void f(_Atomic X *p, X x) { *p = x; }

This will likely get in the way of your test cases unless you fix it :)

It only gets in the way for C++ whereas my primary concern for this patch is C. I tried spending a few hours on this today and got nowhere -- we have a lot of FIXME comments surrounding atomic type qualifiers in C++. I've run out of time to be able to work on this patch and may have to abandon it. I'd hate to lose the forward progress already made, so I'm wondering if the C bits are sufficiently baked that even more FIXMEs around atomics in C++ would suffice?

FYI I ran into this here: https://reviews.llvm.org/D49458

include/clang/Basic/DiagnosticSemaKinds.td

   "block pointer to non-function type is invalid">;
 def err_return_block_has_expr : Error<"void block should not return a value">;
 def err_block_return_missing_expr : Error<
   "non-void block should return a value">;
 def err_func_def_incomplete_result : Error<
   "incomplete result type %0 in function definition">;
 def err_atomic_specifier_bad_type : Error<
   "_Atomic cannot be applied to "
-  "%select{incomplete |array |function |reference |atomic |qualified |}0type "
-  "%1 %select{||||||which is not trivially copyable}0">;
+  "%select{array|function|reference|atomic|qualified}0 type %1">;
 
 // Expressions.
 def ext_sizeof_alignof_function_type : Extension<
   "invalid application of '%select{sizeof|alignof|vec_step}0' to a "
   "function type">, InGroup<PointerArith>;
 def ext_sizeof_alignof_void_type : Extension<
   "invalid application of '%select{sizeof|alignof|vec_step}0' to a void "
   "type">, InGroup<PointerArith>;

lib/AST/Type.cpp

     *Def = nullptr;
 
   switch (CanonicalType->getTypeClass()) {
   default: return false;
   case Builtin:
     // Void is the only incomplete builtin type.  Per C99 6.2.5p19, it can never
     // be completed.
     return isVoidType();
+  case Atomic:
+    // Atomic types do not have to have the same size and alignment
+    // requirements as their underlying type, however, for determining
+    // completeness, if the underlying type is incomplete, the atomic-qualified
+    // type cannot be complete.
+    return cast<AtomicType>(CanonicalType)
+        ->getValueType()
+        ->isIncompleteType(Def);
   case Enum: {
     EnumDecl *EnumD = cast<EnumType>(CanonicalType)->getDecl();
     if (Def)
       *Def = EnumD;
     return !EnumD->isComplete();
   }
   case Record: {
     // A tagged type (struct/union/enum/class) is incomplete if the decl is a

lib/Sema/SemaChecking.cpp

   DeclRefExpr *DRE =cast<DeclRefExpr>(TheCall->getCallee()->IgnoreParenCasts());
 
   // All the non-OpenCL operations take one of the following forms.
   // The OpenCL operations take the __c11 forms with one extra argument for
   // synchronization scope.
   enum {
     // C    __c11_atomic_init(A *, C)
     Init,
 
     // C    __c11_atomic_load(A *, int)
     Load,
 
     // void __atomic_load(A *, CP, int)
     LoadCopy,
 
     // void __atomic_store(A *, CP, int)
     Copy,

   Ptr = ConvertedPtr.get();
   const PointerType *pointerType = Ptr->getType()->getAs<PointerType>();
   if (!pointerType) {
     Diag(DRE->getLocStart(), diag::err_atomic_builtin_must_be_pointer)
       << Ptr->getType() << Ptr->getSourceRange();
     return ExprError();
   }
 
-  // For a __c11 builtin, this should be a pointer to an _Atomic type.
+  // For a __c11 builtin, this should be a pointer to a complete _Atomic type.
   QualType AtomTy = pointerType->getPointeeType(); // 'A'
   QualType ValType = AtomTy; // 'C'
   if (IsC11) {
     if (!AtomTy->isAtomicType()) {
       Diag(DRE->getLocStart(), diag::err_atomic_op_needs_atomic)
         << Ptr->getType() << Ptr->getSourceRange();
       return ExprError();
     }
     if (AtomTy.isConstQualified() ||
         AtomTy.getAddressSpace() == LangAS::opencl_constant) {
       Diag(DRE->getLocStart(), diag::err_atomic_op_needs_non_const_atomic)
           << (AtomTy.isConstQualified() ? 0 : 1) << Ptr->getType()
           << Ptr->getSourceRange();
       return ExprError();
     }
     ValType = AtomTy->getAs<AtomicType>()->getValueType();
+
+    if (RequireCompleteType(DRE->getLocStart(), ValType,
+                            diag::err_invalid_incomplete_type_use, ValType))
+      return ExprError();
   } else if (Form != Load && Form != LoadCopy) {
     if (ValType.isConstQualified()) {
       Diag(DRE->getLocStart(), diag::err_atomic_op_needs_non_const_pointer)
         << Ptr->getType() << Ptr->getSourceRange();
       return ExprError();
     }
   }
 

   } else if (IsN && !ValType->isIntegerType() && !ValType->isPointerType()) {
     // For __atomic_*_n operations, the value type must be a scalar integral or
     // pointer type which is 1, 2, 4, 8 or 16 bytes in length.
     Diag(DRE->getLocStart(), diag::err_atomic_op_needs_atomic_int_or_ptr)
       << IsC11 << Ptr->getType() << Ptr->getSourceRange();
     return ExprError();
   }
 
-  if (!IsC11 && !AtomTy.isTriviallyCopyableType(Context) &&
-      !AtomTy->isScalarType()) {
-    // For GNU atomics, require a trivially-copyable type. This is not part of
-    // the GNU atomics specification, but we enforce it for sanity.
+  if (!ValType.isTriviallyCopyableType(Context)) {
+    // Always require a trivially-copyable type. This is not part of the GNU
+    // atomics specification, but we enforce it for sanity.
     Diag(DRE->getLocStart(), diag::err_atomic_op_needs_trivial_copy)
         << Ptr->getType() << Ptr->getSourceRange();
     return ExprError();
   }
 
   switch (ValType.getObjCLifetime()) {
   case Qualifiers::OCL_None:
   case Qualifiers::OCL_ExplicitNone:
     // okay
     break;

lib/Sema/SemaType.cpp

     }
   }
 
   NamedDecl *Def = nullptr;
   bool Incomplete = T->isIncompleteType(&Def);
 
   // Check that any necessary explicit specializations are visible. For an
   // enum, we just need the declaration, so don't check this.
   if (Def && !isa<EnumDecl>(Def))
     checkSpecializationVisibility(Loc, Def);
 
   // If we have a complete type, we're done.
   if (!Incomplete) {
     // If we know about the definition but it is not visible, complain.
     NamedDecl *SuggestedDef = nullptr;
     if (Def &&
         !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) {
       // If the user is going to see an error here, recover by making the
       // definition visible.
       bool TreatAsComplete = Diagnoser && !isSFINAEContext();
       if (Diagnoser && SuggestedDef)
         diagnoseMissingImport(Loc, SuggestedDef, MissingImportKind::Definition,
                               /*Recover*/TreatAsComplete);
       return !TreatAsComplete;
     } else if (Def && !TemplateInstCallbacks.empty()) {
       CodeSynthesisContext TempInst;
       TempInst.Kind = CodeSynthesisContext::Memoization;
       TempInst.Template = Def;
       TempInst.Entity = Def;
       TempInst.PointOfInstantiation = Loc;
       atTemplateBegin(TemplateInstCallbacks, *this, TempInst);
       atTemplateEnd(TemplateInstCallbacks, *this, TempInst);
     }
 
     return false;
   }
 
-  const TagType *Tag = T->getAs<TagType>();
-  const ObjCInterfaceType *IFace = T->getAs<ObjCInterfaceType>();
-
   // If there's an unimported definition of this type in a module (for
   // instance, because we forward declared it, then imported the definition),
   // import that definition now.
   //
   // FIXME: What about other cases where an import extends a redeclaration
   // chain for a declaration that can be accessed through a mechanism other
   // than name lookup (eg, referenced in a template, or a variable whose type
   // could be completed by the module)?
-  //
-  // FIXME: Should we map through to the base array element type before
-  // checking for a tag type?
-  if (Tag || IFace) {
-    NamedDecl *D =
-        Tag ? static_cast<NamedDecl *>(Tag->getDecl()) : IFace->getDecl();
-
+  if (Def) {
     // Avoid diagnosing invalid decls as incomplete.
-    if (D->isInvalidDecl())
+    if (Def->isInvalidDecl())
       return true;
 
     // Give the external AST source a chance to complete the type.
     if (auto *Source = Context.getExternalSource()) {
-      if (Tag) {
-        TagDecl *TagD = Tag->getDecl();
+      if (auto *TagD = dyn_cast<TagDecl>(Def)) {
         if (TagD->hasExternalLexicalStorage())
           Source->CompleteType(TagD);
-      } else {
-        ObjCInterfaceDecl *IFaceD = IFace->getDecl();
+      } else if (auto *IFaceD = dyn_cast<ObjCInterfaceDecl>(Def)) {
         if (IFaceD->hasExternalLexicalStorage())
-          Source->CompleteType(IFace->getDecl());
+          Source->CompleteType(IFaceD);
       }
       // If the external source completed the type, go through the motions
       // again to ensure we're allowed to use the completed type.
       if (!T->isIncompleteType())
         return RequireCompleteTypeImpl(Loc, T, Diagnoser);
     }
   }
 
   // If we have a class template specialization or a class member of a
   // class template specialization, or an array with known size of such,
   // try to instantiate it.
-  QualType MaybeTemplate = T;
-  while (const ConstantArrayType *Array
-           = Context.getAsConstantArrayType(MaybeTemplate))
-    MaybeTemplate = Array->getElementType();
-  if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) {
+  if (auto *Rec = dyn_cast_or_null<CXXRecordDecl>(Def)) {
     bool Instantiated = false;
     bool Diagnosed = false;
-    if (ClassTemplateSpecializationDecl *ClassTemplateSpec
-          = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
+    if (auto *ClassTemplateSpec =
+            dyn_cast<ClassTemplateSpecializationDecl>(Rec)) {
       if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) {
         Diagnosed = InstantiateClassTemplateSpecialization(
             Loc, ClassTemplateSpec, TSK_ImplicitInstantiation,
             /*Complain=*/Diagnoser);
         Instantiated = true;
       }
-    } else if (CXXRecordDecl *Rec
-                 = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
+    } else {
       CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass();
       if (!Rec->isBeingDefined() && Pattern) {
         MemberSpecializationInfo *MSI = Rec->getMemberSpecializationInfo();
         assert(MSI && "Missing member specialization information?");
         // This record was instantiated from a class within a template.
         if (MSI->getTemplateSpecializationKind() !=
             TSK_ExplicitSpecialization) {
           Diagnosed = InstantiateClass(Loc, Rec, Pattern,
                                        getTemplateInstantiationArgs(Rec),
                                        TSK_ImplicitInstantiation,
                                        /*Complain=*/Diagnoser);
           Instantiated = true;
         }
       }
     }

   // FIXME: If we didn't instantiate a definition because of an explicit
   // specialization declaration, check that it's visible.
 
   if (!Diagnoser)
     return true;
 
   Diagnoser->diagnose(*this, Loc, T);
 
-  // If the type was a forward declaration of a class/struct/union
-  // type, produce a note.
-  if (Tag && !Tag->getDecl()->isInvalidDecl())
-    Diag(Tag->getDecl()->getLocation(),
-         Tag->isBeingDefined() ? diag::note_type_being_defined
-                               : diag::note_forward_declaration)
-      << QualType(Tag, 0);
-
-  // If the Objective-C class was a forward declaration, produce a note.
-  if (IFace && !IFace->getDecl()->isInvalidDecl())
-    Diag(IFace->getDecl()->getLocation(), diag::note_forward_class);
+  if (Def && !Def->isInvalidDecl()) {
+    // If the type was a forward declaration of a class/struct/union
+    // type, produce a note.
+    if (const auto *TD = dyn_cast<TagDecl>(Def))
+      Diag(TD->getLocation(), TD->isBeingDefined()
+                                  ? diag::note_type_being_defined
+                                  : diag::note_forward_declaration)
+          << QualType(TD->getTypeForDecl(), 0);
+
+    // If the Objective-C class was a forward declaration, produce a note.
+    if (isa<ObjCInterfaceDecl>(Def))
+      Diag(Def->getLocation(), diag::note_forward_class);
+  }
 
   // If we have external information that we can use to suggest a fix,
   // produce a note.
   if (ExternalSource)
     ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T);
 
   return true;
 }

                                         UnaryTransformType::EnumUnderlyingType);
     }
   }
   llvm_unreachable("unknown unary transform type");
 }
 
 QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) {
   if (!T->isDependentType()) {
-    // FIXME: It isn't entirely clear whether incomplete atomic types
-    // are allowed or not; for simplicity, ban them for the moment.
-    if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
-      return QualType();
-
     int DisallowedKind = -1;
     if (T->isArrayType())
-      DisallowedKind = 1;
+      DisallowedKind = 0;
     else if (T->isFunctionType())
-      DisallowedKind = 2;
+      DisallowedKind = 1;
     else if (T->isReferenceType())
-      DisallowedKind = 3;
+      DisallowedKind = 2;
     else if (T->isAtomicType())
-      DisallowedKind = 4;
+      DisallowedKind = 3;
     else if (T.hasQualifiers())
-      DisallowedKind = 5;
-    else if (!T.isTriviallyCopyableType(Context))
-      // Some other non-trivially-copyable type (probably a C++ class)
-      DisallowedKind = 6;
+      DisallowedKind = 4;
 
     if (DisallowedKind != -1) {
       Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind << T;
       return QualType();
     }
 
     // FIXME: Do we need any handling for ARC here?
   }
 
   // Build the pointer type.
   return Context.getAtomicType(T);
 }

test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp

void g() {
   for (char c : "test")
     ;
   for (auto a : f()) // expected-error {{cannot use type 'void' as a range}}
     ;
 
   extern int incomplete[];
   for (auto a : incomplete) // expected-error {{cannot use incomplete type 'int []' as a range}}
     ;
-  extern struct Incomplete also_incomplete[2]; // expected-note {{forward declaration}}
+  extern struct Incomplete also_incomplete[2]; // expected-note 2{{forward declaration}}
   for (auto &a : also_incomplete) // expected-error {{cannot use incomplete type 'struct Incomplete [2]' as a range}}
     ;
 
   struct VoidBegin {
     void begin(); // expected-note {{selected 'begin' function with iterator type 'void'}}
     void end();
   };
   for (auto a : VoidBegin()) // expected-error {{cannot use type 'void' as an iterator}}
#endif
   struct NoBegin {
     null_t end();
   };
   struct NoEnd {
     null_t begin();
   };
   for (auto u : NoBegin()) { // expected-error {{range type 'NoBegin' has 'end' member but no 'begin' member}}
   }
-  for (auto u : NoEnd()) { // expected-error {{range type 'NoEnd' has 'begin' member but no 'end' member}} 
+  for (auto u : NoEnd()) { // expected-error {{range type 'NoEnd' has 'begin' member but no 'end' member}}
   }
 
   struct NoIncr {
     void *begin(); // expected-note {{selected 'begin' function with iterator type 'void *'}}
     void *end();
   };
   for (auto u : NoIncr()) { // expected-error {{arithmetic on a pointer to void}}\
     expected-note {{in implicit call to 'operator++' for iterator of type 'NoIncr'}}

test/CodeGen/c11atomics.c

   // Prefix increment
   // Special case for bool: set to true and return true
   // CHECK: store atomic i8 1, i8* @b seq_cst, align 1
   ++b;
   // Currently, we have no variant of atomicrmw that returns the new value, so
   // we have to generate an atomic add, which returns the old value, and then a
   // non-atomic add.
   // CHECK: atomicrmw add i32* @i, i32 1 seq_cst
-  // CHECK: add i32 
+  // CHECK: add i32
   ++i;
   // CHECK: atomicrmw add i64* @l, i64 1 seq_cst
   // CHECK: add i64
   ++l;
   // CHECK: atomicrmw add i16* @s, i16 1 seq_cst
   // CHECK: add i16
   ++s;
 }

   // CHECK:   [[ADDR8:%.*]] = bitcast i64* [[ADDR64]] to i8*
   // CHECK:   [[ATOMIC_DESIRED8:%.*]] = bitcast i64* [[ATOMIC_DESIRED64]] to i8*
   // CHECK:   [[NEW64:%.*]] = load i64, i64* [[ATOMIC_NEW64]], align 2
   // CHECK:   [[RES:%.*]] = call arm_aapcscc zeroext i1 @__atomic_compare_exchange_8(i8* [[ADDR8]], i8* [[ATOMIC_DESIRED8]], i64 [[NEW64]], i32 5, i32 5)
   // CHECK:   ret i1 [[RES]]
   return __c11_atomic_compare_exchange_strong(addr, desired, *new, 5, 5);
 }
 
+int test_atomic_void_ptr(_Atomic void *addr) {
+  // CHECK-LABEL: @test_atomic_void_ptr(
+  // CHECK:   [[ADDR_ARG:%.*]] = alloca { i8, [1 x i8] }*, align 4
+  // CHECK:   [[ATOMIC_RES:%.*]] = alloca i32, align 4
+  // CHECK:   store { i8, [1 x i8] }* %addr, { i8, [1 x i8] }** [[ADDR_ARG]], align 4
+  // CHECK:   [[ADDR_LOCK_FREE_VP:%.*]] = load { i8, [1 x i8] }*, { i8, [1 x i8] }** [[ADDR_ARG]], align 4
+  // CHECK:   [[ADDR_LOCK_FREE:%.*]] = bitcast { i8, [1 x i8] }* [[ADDR_LOCK_FREE_VP]] to i8*
+  // CHECK:   call arm_aapcscc i32 @__atomic_is_lock_free(i32 1, i8* [[ADDR_LOCK_FREE]])
+  // CHECK:   [[ADDR:%.*]] = load { i8, [1 x i8] }*, { i8, [1 x i8] }** [[ADDR_ARG]], align 4
+  // CHECK:   [[CAST1:%.*]] = bitcast { i8, [1 x i8] }* [[ADDR]] to i32*
+  // CHECK:   [[CAST2:%.*]] = bitcast i32* [[CAST1]] to i8*
+  // CHECK:   [[CALL:%.*]] = call arm_aapcscc i32 @__atomic_load_4(i8* [[CAST2]], i32 5)
+  // CHECK:   store i32 [[CALL]], i32* [[ATOMIC_RES]], align 4
+  // CHECK:   [[RES:%.*]] = load i32, i32* [[ATOMIC_RES]], align 4
+  // CHECK:   ret i32 [[RES]]
+  (void)__atomic_is_lock_free(1, addr);
+  return (int)__c11_atomic_load((_Atomic int *)addr, 5);
+}
+
 struct Empty {};
 
 struct Empty test_empty_struct_load(_Atomic(struct Empty)* empty) {
   // CHECK-LABEL: @test_empty_struct_load(
   // CHECK: call arm_aapcscc zeroext i8 @__atomic_load_1(i8* %{{.*}}, i32 5)
   return __c11_atomic_load(empty, 5);
 }
 
 void test_empty_struct_store(_Atomic(struct Empty)* empty, struct Empty value) {
   // CHECK-LABEL: @test_empty_struct_store(
   // CHECK: call arm_aapcscc void @__atomic_store_1(i8* %{{.*}}, i8 zeroext %{{.*}}, i32 5)
   __c11_atomic_store(empty, value, 5);
 }
+
+typedef struct T T;
+void test_struct_copy(_Atomic(T) *t1, _Atomic(T) *t2);
+struct T { int a, b; };
+void test_struct_copy(_Atomic(T) *t1, _Atomic(T) *t2) {
+  // CHECK-LABEL: @test_struct_copy(
+  // CHECK:  [[T1:%.*]] = alloca %struct.T*, align 4
+  // CHECK:  [[T2:%.*]] = alloca %struct.T*, align 4
+  // CHECK:  [[TEMP:%.*]] = alloca %struct.T, align 8
+  // CHECK:  store %struct.T* %t1, %struct.T** [[T1]], align 4
+  // CHECK:  store %struct.T* %t2, %struct.T** [[T2]], align 4
+  // CHECK:  [[LOAD1:%.*]] = load %struct.T*, %struct.T** [[T1]], align 4
+  // CHECK:  [[LOAD2:%.*]] = load %struct.T*, %struct.T** [[T2]], align 4
+  // CHECK:  [[CAST1:%.*]] = bitcast %struct.T* [[LOAD2]] to i8*
+  // CHECK:  [[CAST2:%.*]] = bitcast %struct.T* [[TEMP]] to i8*
+  // CHECK:  call arm_aapcscc void @__atomic_load(i32 8, i8* [[CAST1]], i8* [[CAST2]], i32 5)
+  // CHECK:  [[CAST3:%.*]] = bitcast %struct.T* [[LOAD1]] to i8*
+  // CHECK:  [[CAST4:%.*]] = bitcast %struct.T* [[TEMP]] to i8*
+  // CHECK:  call arm_aapcscc void @__atomic_store(i32 8, i8* [[CAST3]], i8* [[CAST4]], i32 5)
+  // CHECK:  ret void
+  *t1 = *t2;
+}

test/Sema/atomic-type.c

void f(void) {
   _Atomic(_Atomic(int)*) *t4[2] = { &t3, 0 };
   testf(t4);
 }
 extern _Atomic(int (*)(int(*)[], int(*)[10])) mergetest;
 extern _Atomic(int (*)(int(*)[10], int(*)[])) mergetest;
 extern _Atomic(int (*)(int(*)[10], int(*)[10])) mergetest;
 
 _Atomic(int()) error1; // expected-error {{_Atomic cannot be applied to function type}}
-_Atomic(struct ErrorS) error2; // expected-error {{_Atomic cannot be applied to incomplete type}} expected-note {{forward declaration}}
+_Atomic(struct ErrorS) error2; // expected-error {{tentative definition has type '_Atomic(struct ErrorS)' that is never completed}} \
+                               // expected-note {{forward declaration of 'struct ErrorS'}}
 _Atomic(int[10]) error3; // expected-error {{_Atomic cannot be applied to array type}}
 _Atomic(const int) error4; // expected-error {{_Atomic cannot be applied to qualified type}}
 _Atomic(_Atomic(int)) error5; // expected-error {{_Atomic cannot be applied to atomic type}}
+
+void g(_Atomic void *ptr);
+void h(_Atomic struct Incomplete *ptr); // expected-warning {{declaration of 'struct Incomplete' will not be visible outside of this function}}
+
+void test_atomic_void_ptr(_Atomic void *addr) {
+  int i;
+  (void)__atomic_load(addr, &i, 5); // expected-error {{address argument to atomic operation must be a pointer to a trivially-copyable type ('_Atomic(void) *' invalid)}}
+  (void)__c11_atomic_load(addr, 5); // expected-error {{invalid use of incomplete type 'void'}}
+  _Static_assert(__atomic_is_lock_free(1, addr), "");
+}
+
+typedef struct S S; // expected-note {{forward declaration of 'struct S'}}
+void test_atomic_incomplete_struct_assignment(_Atomic S *s, _Atomic S *s2) {
+  *s = *s2; // expected-error {{incomplete type '_Atomic(S)' is not assignable}}
+}

test/SemaCXX/atomic-type.cpp

 // RUN: %clang_cc1 -verify -pedantic %s -std=c++98
 // RUN: %clang_cc1 -verify -pedantic %s -std=c++11
 
 template<typename T> struct atomic {
   _Atomic(T) value;
 
   void f() _Atomic; // expected-error {{expected ';' at end of declaration list}}
 };
 
 template<typename T> struct user {
   struct inner { char n[sizeof(T)]; };
   atomic<inner> i;
 };
#endif
   Y y4 = { { X(0) }, 4 };
   _Atomic(int) ai = { 4 }; // expected-error {{illegal initializer type}}
   _Atomic(X) ax = { X(0) };
 }
 
 bool PR21836(_Atomic(int) *x) {
     return *x;
 }
+
+struct T;
+
+void f(_Atomic T *t);
+
+struct T { int a, b; };
+
+void f(_Atomic T *t) {
+  T t2;
+  (void)__atomic_load(t, &t2, 5); // expected-error {{address argument to atomic operation must be a pointer to a trivially-copyable type ('_Atomic(T) *' invalid)}}
+  (void)__c11_atomic_load(t, 5);
+}

test/SemaObjC/arc.m

   [v test16_1: 0]; // expected-error {{multiple methods named 'test16_1:' found with mismatched result, parameter type or attributes}}
   [v test16_2: 0]; // expected-error {{multiple methods named}}
   [v test16_3: 0]; // expected-error {{multiple methods named}}
   [v test16_4: 0]; // expected-error {{multiple methods named}}
   [v test16_5: 0]; // expected-error {{multiple methods named}}
   [v test16_6: 0];
 }
 
-@class Test17; // expected-note 2{{forward declaration of class here}}
+@class Test17; // expected-note 3{{forward declaration of class here}}
 @protocol Test17p
 - (void) test17;
 + (void) test17;
 @end
 void test17(void) {
   Test17 *v0;
   [v0 test17]; // expected-error {{receiver type 'Test17' for instance message is a forward declaration}}