Avoid assert when a non-static member function is qualified with __unaligned

[rogfer01]

Summary

Under -fms-extensions __unaligned is a type-qualifier that can be applied to a non-static member function declaration.

This causes an assertion when mangling the name under Itanium, where that qualifier is not mangled.

This patch justs makes the minimal change to avoid the crash and avoid mangling __unaligned.

The test just makes sure the clash is actually detected.

[aaron.ballman]

This seems reasonable to me, but you should wait for confirmation before committing (I'm not as familiar with the mangler as others are).

test/CodeGenCXX/unaligned-duplicated-mangle-name.cpp

16 ↗

(On Diff #94962)

Might as well put this note with the declaration rather than using an offset for the message.

[ahatanak]

test/CodeGenCXX/unaligned-duplicated-mangle-name.cpp

15 ↗

(On Diff #94962)

Do you know why clang doesn't error out until it reaches IRGen when compiling this test? I found it interesting that Sema detects the redeclaration and errors out when the function is marked "restrict", but doesn't do so when it's marked "unaligned".

[rogfer01]

clang::Sema::IsOverload explicitly forbids the __restrict case for the qualifier of non-static member functions. I assume __unaligned is not forbidden because the MSVC ABI does encode this qualifier while the Itanium ABI currently does not.

This patch just makes the attached test case fail like the one below:

// Compile with        "-target x86_64-unknown-linux-gnu -x c++ -fms-extensions" 
// and compare it with "-target x86_64-pc-windows-msvc -x c++ -fms-extensions" 
void foo(__unaligned int* a) { }
void foo(int *a) { }

Regards.

[ahatanak]

I see, thank you for the explanation.

cfe/trunk/lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleNestedName(const NamedDecl *ND,
   // <nested-name> 
   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> 
   //       <template-args> E
 
   Out << 'N';
   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
     Qualifiers MethodQuals =
-        Qualifiers::fromCVRMask(Method->getTypeQualifiers());
+        Qualifiers::fromCVRUMask(Method->getTypeQualifiers());
     // We do not consider restrict a distinguishing attribute for overloading
     // purposes so we must not mangle it.
     MethodQuals.removeRestrict();
+    // __unaligned is not currently mangled in any way, so remove it.
+    MethodQuals.removeUnaligned();
     mangleQualifiers(MethodQuals);
     mangleRefQualifier(Method->getRefQualifier());
   }
   
   // Check if we have a template.
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
     mangleTemplatePrefix(TD, NoFunction);

cfe/trunk/test/CodeGenCXX/unaligned-duplicated-mangle-name.cpp

+// RUN: %clang_cc1 -triple %itanium_abi_triple -fms-extensions -emit-llvm-only %s -verify
+
+struct A
+{
+    int x;
+    void foo() __unaligned;
+    void foo();
+};
+
+void A::foo() __unaligned
+{
+    this->x++;
+}
+
+void A::foo() // expected-error {{definition with same mangled name as another definition}}
+              // expected-note@-6 {{previous definition is here}}
+{
+    this->x++;
+}
+