clang/test/CodeGenCXX/x86_64-arguments.cpp

   1 // RUN: %clang_cc1 -no-enable-noundef-analysis -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
   2
   3 // Basic base class test.
   4 struct f0_s0 { unsigned a; };
   5 struct f0_s1 : public f0_s0 { void *b; };
   6 // CHECK-LABEL: define{{.*}} void @_Z2f05f0_s1(i32 %a0.coerce0, ptr %a0.coerce1)
   7 void f0(f0_s1 a0) { }
   8
   9 // Check with two eight-bytes in base class.
  10 struct f1_s0 { unsigned a; unsigned b; float c; };
  11 struct f1_s1 : public f1_s0 { float d;};
  12 // CHECK-LABEL: define{{.*}} void @_Z2f15f1_s1(i64 %a0.coerce0, <2 x float> %a0.coerce1)
  13 void f1(f1_s1 a0) { }
  14
  15 // Check with two eight-bytes in base class and merge.
  16 struct f2_s0 { unsigned a; unsigned b; float c; };
  17 struct f2_s1 : public f2_s0 { char d;};
  18 // CHECK-LABEL: define{{.*}} void @_Z2f25f2_s1(i64 %a0.coerce0, i64 %a0.coerce1)
  19 void f2(f2_s1 a0) { }
  20
  21 // PR5831
  22 // CHECK-LABEL: define{{.*}} void @_Z2f34s3_1(i64 %x.coerce)
  23 struct s3_0 {};
  24 struct s3_1 { struct s3_0 a; long b; };
  25 void f3(struct s3_1 x) {}
  26
  27 // CHECK-LABEL: define{{.*}} i64 @_Z4f4_0M2s4i(i64 %a)
  28 // CHECK: define {{.*}} @_Z4f4_1M2s4FivE(i64 %a.coerce0, i64 %a.coerce1)
  29 struct s4 {};
  30 typedef int s4::* s4_mdp;
  31 typedef int (s4::*s4_mfp)();
  32 s4_mdp f4_0(s4_mdp a) { return a; }
  33 s4_mfp f4_1(s4_mfp a) { return a; }
  34
  35 // A struct with <= one eightbyte before a member data pointer should still
  36 // be allowed in registers.
  37 // CHECK-LABEL: define{{.*}} void @{{.*}}f_struct_with_mdp{{.*}}(ptr %a.coerce0, i64 %a.coerce1)
  38 struct struct_with_mdp { char *a; s4_mdp b; };
  39 void f_struct_with_mdp(struct_with_mdp a) { (void)a; }
  40
  41 // A struct with anything before a member function will be too big and
  42 // goes in memory.
  43 // CHECK-LABEL: define{{.*}} void @{{.*}}f_struct_with_mfp_0{{.*}}(ptr byval(%struct{{.*}}) align 8 %a)
  44 struct struct_with_mfp_0 { char a; s4_mfp b; };
  45 void f_struct_with_mfp_0(struct_with_mfp_0 a) { (void)a; }
  46
  47 // CHECK-LABEL: define{{.*}} void @{{.*}}f_struct_with_mfp_1{{.*}}(ptr byval(%struct{{.*}}) align 8 %a)
  48 struct struct_with_mfp_1 { void *a; s4_mfp b; };
  49 void f_struct_with_mfp_1(struct_with_mfp_1 a) { (void)a; }
  50
  51 namespace PR7523 {
  52 struct StringRef {
  53   char *a;
  54 };
  55
  56 void AddKeyword(StringRef, int x);
  57
  58 void foo() {
  59   // CHECK-LABEL: define{{.*}} void @_ZN6PR75233fooEv()
  60   // CHECK: call void @_ZN6PR752310AddKeywordENS_9StringRefEi(ptr {{.*}}, i32 4)
  61   AddKeyword(StringRef(), 4);
  62 }
  63 }
  64
  65 namespace PR7742 {
  66   struct s2 {
  67     float a[2];
  68   };
  69
  70   struct c2 : public s2 {};
  71
  72   // CHECK-LABEL: define{{.*}} <2 x float> @_ZN6PR77423fooEPNS_2c2E(ptr %P)
  73   c2 foo(c2 *P) {
  74     return c2();
  75   }
  76
  77 }
  78
  79 namespace PR5179 {
  80   struct B {};
  81
  82   struct B1 : B {
  83     int* pa;
  84   };
  85
  86   struct B2 : B {
  87     B1 b1;
  88   };
  89
  90   // CHECK-LABEL: define{{.*}} ptr @_ZN6PR51793barENS_2B2E(ptr %b2.coerce)
  91   const void *bar(B2 b2) {
  92     return b2.b1.pa;
  93   }
  94 }
  95
  96 namespace test5 {
  97   struct Xbase { };
  98   struct Empty { };
  99   struct Y;
 100   struct X : public Xbase {
 101     Empty empty;
 102     Y f();
 103   };
 104   struct Y : public X {
 105     Empty empty;
 106   };
 107   X getX();
 108   int takeY(const Y&, int y);
 109   void g() {
 110     // The temporary for the X object needs to have a defined address when
 111     // passed into X::f as 'this'.
 112     takeY(getX().f(), 42);
 113   }
 114   // CHECK: void @_ZN5test51gEv()
 115   // CHECK: alloca %"struct.test5::Y"
 116   // CHECK: alloca %"struct.test5::X"
 117   // CHECK: alloca %"struct.test5::Y"
 118 }
 119
 120 namespace test6 {
 121   struct outer {
 122     int x;
 123     struct epsilon_matcher {} e;
 124     int f;
 125   };
 126
 127   int test(outer x) {
 128     return x.x + x.f;
 129   }
 130   // CHECK-LABEL: define{{.*}} i32 @_ZN5test64testENS_5outerE(i64 %x.coerce0, i32 %x.coerce1)
 131 }
 132
 133 namespace test7 {
 134   struct StringRef {char* ptr; long len; };
 135   class A { public: ~A(); };
 136   A x(A, A, long, long, StringRef) { return A(); }
 137   // Check that the StringRef is passed byval instead of expanded
 138   // (which would split it between registers and memory).
 139   // CHECK: define{{.*}} void @_ZN5test71xENS_1AES0_llNS_9StringRefE({{.*}} byval({{.*}}) align 8 {{%.*}})
 140
 141   // And a couple extra related tests:
 142   A y(A, long double, long, long, StringRef) { return A(); }
 143   // CHECK: define{{.*}} void @_ZN5test71yENS_1AEellNS_9StringRefE({{.*}} ptr
 144   struct StringDouble {char * ptr; double d;};
 145   A z(A, A, A, A, A, StringDouble) { return A(); }
 146   A zz(A, A, A, A, StringDouble) { return A(); }
 147   // CHECK: define{{.*}} void @_ZN5test71zENS_1AES0_S0_S0_S0_NS_12StringDoubleE({{.*}} byval({{.*}}) align 8 {{%.*}})
 148   // CHECK: define{{.*}} void @_ZN5test72zzENS_1AES0_S0_S0_NS_12StringDoubleE({{.*}} ptr
 149 }
 150
 151 namespace test8 {
 152   // CHECK: declare void @_ZN5test83fooENS_1BE(ptr byval(%"class.test8::B") align 8)
 153   class A {
 154    char big[17];
 155   };
 156
 157   class B : public A {};
 158
 159   void foo(B b);
 160   void bar() {
 161    B b;
 162    foo(b);
 163   }
 164 }
 165
 166 // PR4242
 167 namespace test9 {
 168   // Large enough to be passed indirectly.
 169   struct S { void *data[3]; };
 170
 171   struct T { void *data[2]; };
 172
 173   // CHECK: define{{.*}} void @_ZN5test93fooEPNS_1SEPNS_1TE(ptr %0, ptr %1)
 174   void foo(S*, T*) {}
 175
 176   // CHECK: define{{.*}} void @_ZN5test91aEiiiiNS_1TEPv(ptr noalias sret([[S:%.*]]) align 8 {{%.*}}, i32 %0, i32 %1, i32 %2, i32 %3, ptr byval([[T:%.*]]) align 8 %4, ptr %5)
 177   S a(int, int, int, int, T, void*) {
 178     return S();
 179   }
 180
 181   // CHECK: define{{.*}} ptr @_ZN5test91bEPNS_1SEiiiiNS_1TEPv(ptr {{%.*}}, i32 %0, i32 %1, i32 %2, i32 %3, ptr byval([[T]]) align 8 %4, ptr %5)
 182   S* b(S* sret, int, int, int, int, T, void*) {
 183     return sret;
 184   }
 185
 186   // CHECK: define{{.*}} void @_ZN5test91cEiiiNS_1TEPv(ptr noalias sret([[S]]) align 8 {{%.*}}, i32 %0, i32 %1, i32 %2, ptr {{%.*}}, ptr {{%.*}}, ptr %3)
 187   S c(int, int, int, T, void*) {
 188     return S();
 189   }
 190
 191   // CHECK: define{{.*}} ptr @_ZN5test91dEPNS_1SEiiiNS_1TEPv(ptr {{%.*}}, i32 %0, i32 %1, i32 %2, ptr {{%.*}}, ptr {{%.*}}, ptr %3)
 192   S* d(S* sret, int, int, int, T, void*) {
 193     return sret;
 194   }
 195 }
 196
 197 namespace test10 {
 198 #pragma pack(1)
 199 struct BasePacked {
 200   char one;
 201   short two;
 202 };
 203 #pragma pack()
 204 struct DerivedPacked : public BasePacked {
 205   int three;
 206 };
 207 // CHECK-LABEL: define{{.*}} i32 @_ZN6test1020FuncForDerivedPackedENS_13DerivedPackedE(ptr byval({{.*}}) align 8
 208 int FuncForDerivedPacked(DerivedPacked d) {
 209   return d.three;
 210 }
 211 }
 212
 213 namespace test11 {
 214 union U {
 215   float f1;
 216   char __attribute__((__vector_size__(1))) f2;
 217 };
 218 int f(union U u) { return u.f2[1]; }
 219 // CHECK-LABEL: define{{.*}} i32 @_ZN6test111fENS_1UE(i32
 220 }