clang/test/CodeGen/partial-reinitialization2.c

   1 // RUN: %clang_cc1 %s -triple x86_64-unknown-unknown -emit-llvm -o - | FileCheck %s
   2
   3 struct P1 { char x[6]; } g1 = { "foo" };
   4 struct LP1 { struct P1 p1; };
   5
   6 struct P2    { int a, b, c; } g2 = { 1, 2, 3 };
   7 struct LP2   { struct P2 p2; };
   8 struct LP2P2 { struct P2 p1, p2; };
   9 union  UP2   { struct P2 p2; };
  10
  11 struct LP3 { struct P1 p1[2]; } g3 = { { "dog" }, { "cat" } };
  12 struct LLP3 { struct LP3 l3; };
  13 union ULP3 { struct LP3 l3; };
  14
  15 // CHECK-LABEL: test1
  16 void test1(void)
  17 {
  18   // CHECK: call void @llvm.memcpy{{.*}}ptr align 1 @g1, i64 6, i1 false)
  19   // CHECK: store i8 120, ptr %
  20
  21   struct LP1 l = { .p1 = g1, .p1.x[2] = 'x' };
  22 }
  23
  24 // CHECK-LABEL: test2
  25 void test2(void)
  26 {
  27   // CHECK: call void @llvm.memcpy{{.*}}ptr align 1 @g1, i64 6, i1 false)
  28   // CHECK: store i8 114, ptr %
  29
  30   struct LP1 l = { .p1 = g1, .p1.x[1] = 'r' };
  31 }
  32
  33 // CHECK-LABEL: test3
  34 void test3(void)
  35 {
  36   // CHECK: call void @llvm.memcpy{{.*}}ptr align 4 @g2, i64 12, i1 false)
  37   // CHECK: store i32 10, ptr %
  38
  39   struct LP2 l = { .p2 = g2, .p2.b = 10 };
  40 }
  41
  42 // CHECK-LABEL: get235
  43 struct P2 get235(void)
  44 {
  45   struct P2 p = { 2, 3, 5 };
  46   return p;
  47 }
  48
  49 // CHECK-LABEL: get456789
  50 struct LP2P2 get456789(void)
  51 {
  52   struct LP2P2 l = { { 4, 5, 6 }, { 7, 8, 9 } };
  53   return l;
  54 }
  55
  56 // CHECK-LABEL: get123
  57 union UP2 get123(void)
  58 {
  59   union UP2 u = { { 1, 2, 3 } };
  60   return u;
  61 }
  62
  63 // CHECK-LABEL: test4
  64 void test4(void)
  65 {
  66   // CHECK: [[CALL:%[a-z0-9]+]] = call {{.*}}@get123()
  67   // CHECK: store{{.*}}[[CALL]], {{.*}}[[TMP0:%[a-z0-9.]+]]
  68   // CHECK: call void @llvm.memcpy{{.*}}[[TMP0]], i64 12, i1 false)
  69   // CHECK: store i32 100, ptr %
  70
  71   struct LUP2 { union UP2 up; } var = { get123(), .up.p2.a = 100 };
  72 }
  73
  74 // CHECK-LABEL: test5
  75 void test5(void)
  76 {
  77   // .l3 = g3
  78   // CHECK: call void @llvm.memcpy{{.*}}ptr align 1 @g3, i64 12, i1 false)
  79
  80   // .l3.p1 = { [0] = g1 } implicitly sets [1] to zero
  81   // CHECK: call void @llvm.memcpy{{.*}}ptr align 1 @g1, i64 6, i1 false)
  82   // CHECK: getelementptr{{.*}}%struct.P1, ptr{{.*}}i64 1
  83   // CHECK: call void @llvm.memset{{.*}}i8 0, i64 6, i1 false)
  84
  85   // .l3.p1[1].x[1] = 'x'
  86   // CHECK: store i8 120, ptr %
  87
  88   struct LLP3 var = { .l3 = g3, .l3.p1 = { [0] = g1 }, .l3.p1[1].x[1] = 'x' };
  89 }
  90
  91 // CHECK-LABEL: test6
  92 void test6(void)
  93 {
  94   // CHECK: [[LP:%[a-z0-9]+]] = getelementptr{{.*}}%struct.LLP2P2, ptr{{.*}}, i32 0, i32 0
  95   // CHECK: call {{.*}}get456789(ptr {{.*}}[[LP]])
  96
  97   // CHECK: [[CALL:%[a-z0-9]+]] = call {{.*}}@get235()
  98   // CHECK: store{{.*}}[[CALL]], {{.*}}[[TMP0:%[a-z0-9.]+]]
  99   // CHECK: call void @llvm.memcpy{{.*}}[[TMP0]], i64 12, i1 false)
 100
 101   // CHECK: store i32 10, ptr %
 102
 103   struct LLP2P2 { struct LP2P2 lp; } var =  { get456789(),
 104                                               .lp.p1 = get235(),
 105                                               .lp.p1.b = 10 };
 106 }