Fix for bug 25786 - Assertion "Chunk.Kind == DeclaratorChunk::Function" failed with regparm attribute.

[• a.makarov]

Summary

This patch is to avoid attaching the calling convention attribute to the result type if this attribute was ignored and calling convention was substituted by default.

[rnk]

include/clang/Sema/Sema.h

2938 ↗

(On Diff #42284)

Rather than adding this extra entry point, I think it would be simpler to extend CheckCallingConvAttr to return whatever extra info we need.

Besides, this new entry point also emits diagnostics, and it has a name that suggests it will not emit diagnostics.

lib/Sema/SemaType.cpp

5920

Right, we've already done the work that you are doing down below. We should just get what we needed to know out of here and pass it on.

5979–5980

At a high level, why would you want to not create an AttributedType here? That seems desirable, the user wrote the type attribute in the source, and that should be reflected in the AST sugar.

If adding this sugar causes assertions later, then the bug must be somewhere else.

test/CodeGen/adding_defaulted_attr_to_type.c

5 ↗

(On Diff #42284)

You can add more tests. I noticed this crashes for me:

void (__attribute__((regparm(2), stdcall)) foo)(int);

That seems like a good one to add.

You can also rerun the test with i686-unknown-linux-gnu and #ifdefs to see that we accept the convention as desired on 32-bit.

[• a.makarov]

I've updated the patch. Please, re-review it again.
About creating attributed type - I think we shouldn't create it if we ignored specified CC attribute. Ignoring specified CC attribute (and emitting the warning, of course) leads to substituting it by default; calling convention, substituted by default, is the same situation like there is no CC attribute specified for chosen function. Thus, from this point of view, we should not create AttributedType.

[• a.makarov]

Actual updated patch. Sorry for noise.

[• a.makarov]

Ping

[aaron.ballman]

In D15373#315457, @a.makarov wrote:

I've updated the patch. Please, re-review it again.
About creating attributed type - I think we shouldn't create it if we ignored specified CC attribute. Ignoring specified CC attribute (and emitting the warning, of course) leads to substituting it by default; calling convention, substituted by default, is the same situation like there is no CC attribute specified for chosen function. Thus, from this point of view, we should not create AttributedType.

I tend to agree with @rnk on this -- it is a shame to lose that syntactic information in the AST representation (for instance, tools may wish to detect the presence of that attribute in the source to perform different analyses on the type). Even if it is semantically ignored, it is still something the user wrote. For instance, this means we cannot round-trip the user's source code through pretty printing, despite the code not being ill-formed.

test/CodeGen/adding_defaulted_cc_attr_to_type.c

1 ↗

(On Diff #43442)

Can you drop the svn props on the file? Our convention is to not rely on props, but instead save the file with UNIX line endings.

[• a.makarov]

Thanks for review! I've understood your idea, I'm working on updating the patch.

[• a.makarov]

I've updated the patch. Now, I've updated the function unwrapping mechanism to work properly with AttributedType.
Please, re-review the patch.

[• a.makarov]

Oops, forgot to drop svn properties. Done. Sorry for noise.

[aaron.ballman]

This looks correct to me, but my knowledge of type attributes isn't strong enough to officially sign off, so please wait for @rnk or @rsmith to take a look as well.

[• a.makarov]

Ping

[• a.makarov]

Richard, Reid, please take a look.

[rnk]

Thanks, lgtm!

lib/Sema/SemaType.cpp

namespace {
   ///   if (unwrapped.isFunctionType()) {
   ///     const FunctionType *fn = unwrapped.get();
   ///     // change fn somehow
   ///     T = unwrapped.wrap(fn);
   ///   }
   struct FunctionTypeUnwrapper {
     enum WrapKind {
       Desugar,
+      Attributed,
       Parens,
       Pointer,
       BlockPointer,
       Reference,
       MemberPointer
     };
 
     QualType Original;
FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) {
           T = cast<BlockPointerType>(Ty)->getPointeeType();
           Stack.push_back(BlockPointer);
         } else if (isa<MemberPointerType>(Ty)) {
           T = cast<MemberPointerType>(Ty)->getPointeeType();
           Stack.push_back(MemberPointer);
         } else if (isa<ReferenceType>(Ty)) {
           T = cast<ReferenceType>(Ty)->getPointeeType();
           Stack.push_back(Reference);
+        } else if (isa<AttributedType>(Ty)) {
+          T = cast<AttributedType>(Ty)->getEquivalentType();
+          Stack.push_back(Attributed);
         } else {
           const Type *DTy = Ty->getUnqualifiedDesugaredType();
           if (Ty == DTy) {
             Fn = nullptr;
             return;
           }
 
           T = QualType(DTy, 0);
QualType wrap(ASTContext &C, const Type *Old, unsigned I) {
       if (I == Stack.size()) return QualType(Fn, 0);
 
       switch (static_cast<WrapKind>(Stack[I++])) {
       case Desugar:
         // This is the point at which we potentially lose source
         // information.
         return wrap(C, Old->getUnqualifiedDesugaredType(), I);
 
+      case Attributed:
+        return wrap(C, cast<AttributedType>(Old)->getEquivalentType(), I);
+
       case Parens: {
         QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
         return C.getParenType(New);
       }
 
       case Pointer: {
         QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I);
         return C.getPointerType(New);
if (attr.getKind() == AttributeList::AT_Regparm) {
     return true;
   }
 
   // Delay if the type didn't work out to a function.
   if (!unwrapped.isFunctionType()) return false;
 
   // Otherwise, a calling convention.
   CallingConv CC;
   if (S.CheckCallingConvAttr(attr, CC))
     return true;
 
   const FunctionType *fn = unwrapped.get();
   CallingConv CCOld = fn->getCallConv();
   AttributedType::Kind CCAttrKind = getCCTypeAttrKind(attr);
 
   if (CCOld != CC) {
     // Error out on when there's already an attribute on the type
static bool handleFunctionTypeAttr(TypeProcessingState &state,
   return true;
 }
 
 bool Sema::hasExplicitCallingConv(QualType &T) {
   QualType R = T.IgnoreParens();
   while (const AttributedType *AT = dyn_cast<AttributedType>(R)) {
     if (AT->isCallingConv())
       return true;
     R = AT->getModifiedType().IgnoreParens();
   }
   return false;
 }
 
 void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
                                   SourceLocation Loc) {
   FunctionTypeUnwrapper Unwrapped(*this, T);
   const FunctionType *FT = Unwrapped.get();
   bool IsVariadic = (isa<FunctionProtoType>(FT) &&

test/CodeGen/pr25786.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple i686-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK-OK
+
+void (__attribute__((regparm(3), stdcall)) *pf) ();
+void (__attribute__((regparm(2), stdcall)) foo)(int a) {
+}
+// CHECK: @pf = common global void (...)* null
+// CHECK: define void @foo(i32 %a)
+
+// CHECK-OK: @pf = common global void (...)* null
+// CHECK-OK: define x86_stdcallcc void @foo(i32 inreg %a)

test/Sema/pr25786.c

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -DTEST -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple i686-unknown-linux-gnu -fsyntax-only -verify %s
+
+#if TEST
+void (__attribute__((regparm(3), stdcall)) *pf) (); //expected-warning {{calling convention 'stdcall' ignored for this target}}
+void (__attribute__((regparm(2), stdcall)) foo)(int a) { //expected-warning {{calling convention 'stdcall' ignored for this target}}
+}
+#else
+//expected-no-diagnostics
+void (__attribute__((regparm(3), stdcall)) *pf) ();
+void (__attribute__((regparm(2), stdcall)) foo)(int a) {}
+#endif