src/test/codegen/packed.rs

   1 // ignore-tidy-linelength
   2 // compile-flags: -C no-prepopulate-passes
   3 // min-llvm-version 7.0
   4
   5 #![crate_type = "lib"]
   6
   7 #[repr(packed)]
   8 pub struct Packed1 {
   9     dealign: u8,
  10     data: u32
  11 }
  12
  13 #[repr(packed(2))]
  14 pub struct Packed2 {
  15     dealign: u8,
  16     data: u32
  17 }
  18
  19 // CHECK-LABEL: @write_pkd1
  20 #[no_mangle]
  21 pub fn write_pkd1(pkd: &mut Packed1) -> u32 {
  22 // CHECK: %{{.*}} = load i32, i32* %{{.*}}, align 1
  23 // CHECK: store i32 42, i32* %{{.*}}, align 1
  24     let result = pkd.data;
  25     pkd.data = 42;
  26     result
  27 }
  28
  29 // CHECK-LABEL: @write_pkd2
  30 #[no_mangle]
  31 pub fn write_pkd2(pkd: &mut Packed2) -> u32 {
  32 // CHECK: %{{.*}} = load i32, i32* %{{.*}}, align 2
  33 // CHECK: store i32 42, i32* %{{.*}}, align 2
  34     let result = pkd.data;
  35     pkd.data = 42;
  36     result
  37 }
  38
  39 pub struct Array([i32; 8]);
  40 #[repr(packed)]
  41 pub struct BigPacked1 {
  42     dealign: u8,
  43     data: Array
  44 }
  45
  46 #[repr(packed(2))]
  47 pub struct BigPacked2 {
  48     dealign: u8,
  49     data: Array
  50 }
  51
  52 // CHECK-LABEL: @call_pkd1
  53 #[no_mangle]
  54 pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 {
  55 // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array
  56 // CHECK: call void %{{.*}}(%Array* noalias nocapture sret dereferenceable(32) [[ALLOCA]])
  57 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
  58     // check that calls whose destination is a field of a packed struct
  59     // go through an alloca rather than calling the function with an
  60     // unaligned destination.
  61     BigPacked1 { dealign: 0, data: f() }
  62 }
  63
  64 // CHECK-LABEL: @call_pkd2
  65 #[no_mangle]
  66 pub fn call_pkd2(f: fn() -> Array) -> BigPacked2 {
  67 // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array
  68 // CHECK: call void %{{.*}}(%Array* noalias nocapture sret dereferenceable(32) [[ALLOCA]])
  69 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
  70     // check that calls whose destination is a field of a packed struct
  71     // go through an alloca rather than calling the function with an
  72     // unaligned destination.
  73     BigPacked2 { dealign: 0, data: f() }
  74 }
  75
  76 // CHECK-LABEL: @write_packed_array1
  77 // CHECK: store i32 0, i32* %{{.+}}, align 1
  78 // CHECK: store i32 1, i32* %{{.+}}, align 1
  79 // CHECK: store i32 2, i32* %{{.+}}, align 1
  80 #[no_mangle]
  81 pub fn write_packed_array1(p: &mut BigPacked1) {
  82     p.data.0[0] = 0;
  83     p.data.0[1] = 1;
  84     p.data.0[2] = 2;
  85 }
  86
  87 // CHECK-LABEL: @write_packed_array2
  88 // CHECK: store i32 0, i32* %{{.+}}, align 2
  89 // CHECK: store i32 1, i32* %{{.+}}, align 2
  90 // CHECK: store i32 2, i32* %{{.+}}, align 2
  91 #[no_mangle]
  92 pub fn write_packed_array2(p: &mut BigPacked2) {
  93     p.data.0[0] = 0;
  94     p.data.0[1] = 1;
  95     p.data.0[2] = 2;
  96 }
  97
  98 // CHECK-LABEL: @repeat_packed_array1
  99 // CHECK: store i32 42, i32* %{{.+}}, align 1
 100 #[no_mangle]
 101 pub fn repeat_packed_array1(p: &mut BigPacked1) {
 102     p.data.0 = [42; 8];
 103 }
 104
 105 // CHECK-LABEL: @repeat_packed_array2
 106 // CHECK: store i32 42, i32* %{{.+}}, align 2
 107 #[no_mangle]
 108 pub fn repeat_packed_array2(p: &mut BigPacked2) {
 109     p.data.0 = [42; 8];
 110 }
 111
 112 #[repr(packed)]
 113 #[derive(Copy, Clone)]
 114 pub struct Packed1Pair(u8, u32);
 115
 116 #[repr(packed(2))]
 117 #[derive(Copy, Clone)]
 118 pub struct Packed2Pair(u8, u32);
 119
 120 // CHECK-LABEL: @pkd1_pair
 121 #[no_mangle]
 122 pub fn pkd1_pair(pair1: &mut Packed1Pair, pair2: &mut Packed1Pair) {
 123 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 1 %{{.*}}, i{{[0-9]+}} 5, i1 false)
 124     *pair2 = *pair1;
 125 }
 126
 127 // CHECK-LABEL: @pkd2_pair
 128 #[no_mangle]
 129 pub fn pkd2_pair(pair1: &mut Packed2Pair, pair2: &mut Packed2Pair) {
 130 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 2 %{{.*}}, i{{[0-9]+}} 6, i1 false)
 131     *pair2 = *pair1;
 132 }
 133
 134 #[repr(packed)]
 135 #[derive(Copy, Clone)]
 136 pub struct Packed1NestedPair((u32, u32));
 137
 138 #[repr(packed(2))]
 139 #[derive(Copy, Clone)]
 140 pub struct Packed2NestedPair((u32, u32));
 141
 142 // CHECK-LABEL: @pkd1_nested_pair
 143 #[no_mangle]
 144 pub fn pkd1_nested_pair(pair1: &mut Packed1NestedPair, pair2: &mut Packed1NestedPair) {
 145 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 1 %{{.*}}, i{{[0-9]+}} 8, i1 false)
 146     *pair2 = *pair1;
 147 }
 148
 149 // CHECK-LABEL: @pkd2_nested_pair
 150 #[no_mangle]
 151 pub fn pkd2_nested_pair(pair1: &mut Packed2NestedPair, pair2: &mut Packed2NestedPair) {
 152 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 2 %{{.*}}, i{{[0-9]+}} 8, i1 false)
 153     *pair2 = *pair1;
 154 }