Ensure that debugger calls to signature-less functions default to

passing arguments in the fixed style.

We have an abstraction for deciding this, but it's (1) deep in
IR-generation, (2) necessarily tied to exact argument lists, and
(3) triggered by unprototyped function types, which we can't
legitimately make in C++ mode.  So this solution, wherein Sema
rewrites the function type to an exact prototype but leaves the
variadic bit enabled so as to request x86-64-like platforms to
pass the extra variadic info, is very much a hack, but it's one
that works in practice on the platforms that LLDB will support
in the medium term --- the only place we know of where it's a
problem is instance methods in Windows, where variadic functions
are implicitly cdecl.  We may have a more abstracted base on which
to build a solution by then.

rdar://13731520

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@185112 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 40 insertions, 22 deletions

diff --git a/test/CodeGenCXX/unknown-anytype.cpp b/test/CodeGenCXX/unknown-anytype.cpp
index 902cc8de5c..aacb8493ef 100644
--- a/test/CodeGenCXX/unknown-anytype.cpp
+++ b/test/CodeGenCXX/unknown-anytype.cpp
@@ -1,33 +1,45 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -funknown-anytype -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -funknown-anytype -emit-llvm -o %t %s
+// RUN: FileCheck -check-prefix COMMON %s < %t
+// RUN: FileCheck -check-prefix X86_64 %s < %t
+// RUN: %clang_cc1 -triple i386-apple-darwin10 -funknown-anytype -emit-llvm -o %t %s
+// RUN: FileCheck -check-prefix COMMON %s < %t
+// RUN: FileCheck -check-prefix I386 %s < %t
+
+// x86-64 is the special case here because of its variadic convention.
+// We want to ensure that it always uses a variadic convention even if
+// other platforms do not.
+// rdar://13731520
 
 int test0() {
   extern __unknown_anytype test0_any;
-  // CHECK: load i32* @test0_any
+  // COMMON: load i32* @test0_any
   return (int) test0_any;
 }
 
 int test1() {
   extern __unknown_anytype test1_any();
-  // CHECK: call i32 @_Z9test1_anyv()
+  // COMMON: call i32 @_Z9test1_anyv()
   return (int) test1_any();
 }
 
 extern "C" __unknown_anytype test2_any(...);
 float test2() {
-  // CHECK: call float (...)* @test2_any(double {{[^,]+}})
+  // X86_64: call float (double, ...)* @test2_any(double {{[^,]+}})
+  // I386: call float (double, ...)* @test2_any(double {{[^,]+}})
   return (float) test2_any(0.5f);
 }
 
 extern "C" __unknown_anytype test2a_any(...);
 float test2a() {
-  // CHECK: call float (...)* @test2a_any(float {{[^,]+}})
+  // X86_64: call float (float, ...)* @test2a_any(float {{[^,]+}})
+  // I386: call float (float, ...)* @test2a_any(float {{[^,]+}})
   return (float) test2a_any((float) 0.5f);
 }
 
 float test3() {
   extern __unknown_anytype test3_any;
-  // CHECK: [[FN:%.*]] = load float (i32)** @test3_any,
-  // CHECK: call float [[FN]](i32 5)
+  // COMMON: [[FN:%.*]] = load float (i32)** @test3_any,
+  // COMMON: call float [[FN]](i32 5)
   return ((float(*)(int)) test3_any)(5);
 }
 
@@ -36,22 +48,22 @@ namespace test4 {
   extern __unknown_anytype test4_any2;
 
   int test() {
-    // CHECK: load i32* @_ZN5test410test4_any1E
-    // CHECK: load i8* @_ZN5test410test4_any2E
+    // COMMON: load i32* @_ZN5test410test4_any1E
+    // COMMON: load i8* @_ZN5test410test4_any2E
     return (int) test4_any1 + (char) test4_any2;
   }
 }
 
 extern "C" __unknown_anytype test5_any();
 void test5() {
-  // CHECK: call void @test5_any()
+  // COMMON: call void @test5_any()
   return (void) test5_any();
 }
 
 extern "C" __unknown_anytype test6_any(float *);
 long test6() {
-  // CHECK: call i64 @test6_any(float* null)
-  return (long) test6_any(0);
+  // COMMON: call i64 @test6_any(float* null)
+  return (long long) test6_any(0);
 }
 
 struct Test7 {
@@ -59,7 +71,7 @@ struct Test7 {
 };
 extern "C" __unknown_anytype test7_any(int);
 Test7 test7() {
-  // CHECK: call void @test7_any({{%.*}}* sret {{%.*}}, i32 5)
+  // COMMON: call void @test7_any({{%.*}}* sret {{%.*}}, i32 5)
   return (Test7) test7_any(5);
 }
 
@@ -71,29 +83,35 @@ struct Test8 {
 };
 void Test8::test() {
   float f;
-  // CHECK: call i32 @_ZN5Test83fooEv(
+  // COMMON: call i32 @_ZN5Test83fooEv(
   f = (int) foo();
-  // CHECK: call i32 @_ZN5Test83fooEi(
+  // COMMON: call i32 @_ZN5Test83fooEi(
   f = (int) foo(5);
-  // CHECK: call i32 @_ZN5Test83fooEv(
+  // COMMON: call i32 @_ZN5Test83fooEv(
   f = (float) this->foo();
-  // CHECK: call i32 @_ZN5Test83fooEi(
+  // COMMON: call i32 @_ZN5Test83fooEi(
   f = (float) this->foo(5);
 }
 void test8(Test8 *p) {
   double d;
-  // CHECK: call i32 @_ZN5Test83fooEv(
+  // COMMON: call i32 @_ZN5Test83fooEv(
   d = (double) p->foo();
-  // CHECK: call i32 @_ZN5Test83fooEi(
+  // COMMON: call i32 @_ZN5Test83fooEi(
   d = (double) p->foo(5);
-  // CHECK: call i32 @_ZN5Test83fooEv(
+  // COMMON: call i32 @_ZN5Test83fooEv(
   d = (bool) (*p).foo();
-  // CHECK: call i32 @_ZN5Test83fooEi(
+  // COMMON: call i32 @_ZN5Test83fooEi(
   d = (bool) (*p).foo(5);
 }
 
 extern "C" __unknown_anytype test9_foo;
 void *test9() {
-  // CHECK: ret i8* bitcast (i32* @test9_foo to i8*)
+  // COMMON: ret i8* bitcast (i32* @test9_foo to i8*)
   return (int*) &test9_foo;
 }
+
+// Don't explode on this.
+extern "C" __unknown_anytype test10_any(...);
+void test10() {
+  (void) test10_any(), (void) test10_any();
+}