AST: Implement mangling support for function types without a prototype.

[pcc]

Summary

Function types without prototypes can arise when mangling a function type
within an overloadable function in C. We mangle these as the absence of
any parameter types (not even an empty parameter list).

[rsmith]

lib/AST/ItaniumMangle.cpp

2060–2062 ↗

(On Diff #31543)

This seems like a suboptimal mangling; a no-prototype function type is not compatible with a varargs function type, and in particular may have a different calling convention across a C/C++ ABI boundary. How about instead mangling this as the absence of any parameter types? (That is, drop the z, and mangle your testcase below as just _Z1fPFvzE.) libc++abi already demangles that as desired (but libstdc++ considers it an invalid mangled name).

[pcc]

lib/AST/ItaniumMangle.cpp

2060–2062 ↗

(On Diff #31543)

Do you mean _Z1fPFvE? Sounds reasonable to me. I guess on the MS side we can use @ instead of Z to create the distinction there.

[rsmith]

lib/AST/ItaniumMangle.cpp

2060–2062 ↗

(On Diff #31543)

Er, yes, thanks :)

[pcc]

• Use a mangling distinct from (...) as suggested by Richard

[rsmith]

LGTM

cfe/trunk/lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleType(const FunctionProtoType *T) {
   // encoding for extern "C" function types.
   mangleBareFunctionType(T, /*MangleReturnType=*/true);
 
   // Mangle the ref-qualifier, if present.
   mangleRefQualifier(T->getRefQualifier());
 
   Out << 'E';
 }
+
 void CXXNameMangler::mangleType(const FunctionNoProtoType *T) {
-  llvm_unreachable("Can't mangle K&R function prototypes");
+  // Function types without prototypes can arise when mangling a function type
+  // within an overloadable function in C. We mangle these as the absence of any
+  // parameter types (not even an empty parameter list).
+  Out << 'F';
+
+  FunctionTypeDepthState saved = FunctionTypeDepth.push();
+
+  FunctionTypeDepth.enterResultType();
+  mangleType(T->getReturnType());
+  FunctionTypeDepth.leaveResultType();
+
+  FunctionTypeDepth.pop(saved);
+  Out << 'E';
 }
+
 void CXXNameMangler::mangleBareFunctionType(const FunctionType *T,
                                             bool MangleReturnType) {
   // We should never be mangling something without a prototype.
   const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
 
   // Record that we're in a function type.  See mangleFunctionParam
   // for details on what we're trying to achieve here.
   FunctionTypeDepthState saved = FunctionTypeDepth.push();

cfe/trunk/lib/AST/MicrosoftMangle.cpp

if (T->getTypeQuals() || T->getRefQualifier() != RQ_None) {
     mangleFunctionType(T, /*D=*/nullptr, /*ForceThisQuals=*/true);
   } else {
     Out << "$$A6";
     mangleFunctionType(T);
   }
 }
 void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T,
                                          Qualifiers, SourceRange) {
-  llvm_unreachable("Can't mangle K&R function prototypes");
+  Out << "$$A6";
+  mangleFunctionType(T);
 }
 
 void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T,
                                                  const FunctionDecl *D,
                                                  bool ForceThisQuals) {
   // <function-type> ::= <this-cvr-qualifiers> <calling-convention>
   //                     <return-type> <argument-list> <throw-spec>
-  const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
+  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(T);
 
   SourceRange Range;
   if (D) Range = D->getSourceRange();
 
   bool IsStructor = false, HasThisQuals = ForceThisQuals, IsCtorClosure = false;
   CallingConv CC = T->getCallConv();
   if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
     if (MD->isInstance())
if (IsCtorClosure) {
       } else {
         llvm_unreachable("unexpected constructor closure!");
       }
       Out << 'Z';
       return;
     }
     Out << '@';
   } else {
-    QualType ResultType = Proto->getReturnType();
+    QualType ResultType = T->getReturnType();
     if (const auto *AT =
             dyn_cast_or_null<AutoType>(ResultType->getContainedAutoType())) {
       Out << '?';
       mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
       Out << '?';
       mangleSourceName(AT->isDecltypeAuto() ? "<decltype-auto>" : "<auto>");
       Out << '@';
     } else {
       if (ResultType->isVoidType())
         ResultType = ResultType.getUnqualifiedType();
       mangleType(ResultType, Range, QMM_Result);
     }
   }
 
   // <argument-list> ::= X # void
   //                 ::= <type>+ @
   //                 ::= <type>* Z # varargs
-  if (Proto->getNumParams() == 0 && !Proto->isVariadic()) {
+  if (!Proto) {
+    // Function types without prototypes can arise when mangling a function type
+    // within an overloadable function in C. We mangle these as the absence of
+    // any parameter types (not even an empty parameter list).
+    Out << '@';
+  } else if (Proto->getNumParams() == 0 && !Proto->isVariadic()) {
     Out << 'X';
   } else {
     // Happens for function pointer type arguments for example.
     for (const QualType &Arg : Proto->param_types())
       mangleArgumentType(Arg, Range);
     // <builtin-type>      ::= Z  # ellipsis
     if (Proto->isVariadic())
       Out << 'Z';

cfe/trunk/test/CodeGen/mangle-ms.c

+// RUN: %clang_cc1 -emit-llvm %s -o - -triple=x86_64-pc-win32 | FileCheck %s
+
+// CHECK: define void @"\01?f@@$$J0YAXP6AX@Z@Z"
+__attribute__((overloadable)) void f(void (*x)()) {}

cfe/trunk/test/CodeGen/overloadable.c

 // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-llvm %s -o - | FileCheck %s
 // CHECK: _Z1fPA10_1X
+// CHECK: _Z1fPFvE
 
 int __attribute__((overloadable)) f(int x) { return x; }
 float __attribute__((overloadable)) f(float x) { return x; }
 double __attribute__((overloadable)) f(double x) { return x; }
 double _Complex __attribute__((overloadable)) f(double _Complex x) { return x; }
 typedef short v4hi __attribute__ ((__vector_size__ (8)));
 v4hi __attribute__((overloadable)) f(v4hi x) { return x; }
 
 struct X { };
 void  __attribute__((overloadable)) f(struct X (*ptr)[10]) { }
 
 void __attribute__((overloadable)) f(int x, int y, ...) { }
 
+void __attribute__((overloadable)) f(void (*x)()) {}
+
 int main() {
   int iv = 17;
   float fv = 3.0f;
   double dv = 4.0;
   double _Complex cdv;
   v4hi vv;
 
   iv = f(iv);
   fv = f(fv);
   dv = f(dv);
   cdv = f(cdv);
   vv = f(vv);
 }