src/test/codegen/packed.rs

   1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // ignore-tidy-linelength
  12 // compile-flags: -C no-prepopulate-passes
  13 // min-llvm-version 7.0
  14
  15 #![crate_type = "lib"]
  16 #![feature(repr_packed)]
  17
  18 #[repr(packed)]
  19 pub struct Packed1 {
  20     dealign: u8,
  21     data: u32
  22 }
  23
  24 #[repr(packed(2))]
  25 pub struct Packed2 {
  26     dealign: u8,
  27     data: u32
  28 }
  29
  30 // CHECK-LABEL: @write_pkd1
  31 #[no_mangle]
  32 pub fn write_pkd1(pkd: &mut Packed1) -> u32 {
  33 // CHECK: %{{.*}} = load i32, i32* %{{.*}}, align 1
  34 // CHECK: store i32 42, i32* %{{.*}}, align 1
  35     let result = pkd.data;
  36     pkd.data = 42;
  37     result
  38 }
  39
  40 // CHECK-LABEL: @write_pkd2
  41 #[no_mangle]
  42 pub fn write_pkd2(pkd: &mut Packed2) -> u32 {
  43 // CHECK: %{{.*}} = load i32, i32* %{{.*}}, align 2
  44 // CHECK: store i32 42, i32* %{{.*}}, align 2
  45     let result = pkd.data;
  46     pkd.data = 42;
  47     result
  48 }
  49
  50 pub struct Array([i32; 8]);
  51 #[repr(packed)]
  52 pub struct BigPacked1 {
  53     dealign: u8,
  54     data: Array
  55 }
  56
  57 #[repr(packed(2))]
  58 pub struct BigPacked2 {
  59     dealign: u8,
  60     data: Array
  61 }
  62
  63 // CHECK-LABEL: @call_pkd1
  64 #[no_mangle]
  65 pub fn call_pkd1(f: fn() -> Array) -> BigPacked1 {
  66 // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array
  67 // CHECK: call void %{{.*}}(%Array* noalias nocapture sret dereferenceable(32) [[ALLOCA]])
  68 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
  69     // check that calls whose destination is a field of a packed struct
  70     // go through an alloca rather than calling the function with an
  71     // unaligned destination.
  72     BigPacked1 { dealign: 0, data: f() }
  73 }
  74
  75 // CHECK-LABEL: @call_pkd2
  76 #[no_mangle]
  77 pub fn call_pkd2(f: fn() -> Array) -> BigPacked2 {
  78 // CHECK: [[ALLOCA:%[_a-z0-9]+]] = alloca %Array
  79 // CHECK: call void %{{.*}}(%Array* noalias nocapture sret dereferenceable(32) [[ALLOCA]])
  80 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 4 %{{.*}}, i{{[0-9]+}} 32, i1 false)
  81     // check that calls whose destination is a field of a packed struct
  82     // go through an alloca rather than calling the function with an
  83     // unaligned destination.
  84     BigPacked2 { dealign: 0, data: f() }
  85 }
  86
  87 #[repr(packed)]
  88 #[derive(Copy, Clone)]
  89 pub struct Packed1Pair(u8, u32);
  90
  91 #[repr(packed(2))]
  92 #[derive(Copy, Clone)]
  93 pub struct Packed2Pair(u8, u32);
  94
  95 // CHECK-LABEL: @pkd1_pair
  96 #[no_mangle]
  97 pub fn pkd1_pair(pair1: &mut Packed1Pair, pair2: &mut Packed1Pair) {
  98 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 1 %{{.*}}, i{{[0-9]+}} 5, i1 false)
  99     *pair2 = *pair1;
 100 }
 101
 102 // CHECK-LABEL: @pkd2_pair
 103 #[no_mangle]
 104 pub fn pkd2_pair(pair1: &mut Packed2Pair, pair2: &mut Packed2Pair) {
 105 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 2 %{{.*}}, i{{[0-9]+}} 6, i1 false)
 106     *pair2 = *pair1;
 107 }
 108
 109 #[repr(packed)]
 110 #[derive(Copy, Clone)]
 111 pub struct Packed1NestedPair((u32, u32));
 112
 113 #[repr(packed(2))]
 114 #[derive(Copy, Clone)]
 115 pub struct Packed2NestedPair((u32, u32));
 116
 117 // CHECK-LABEL: @pkd1_nested_pair
 118 #[no_mangle]
 119 pub fn pkd1_nested_pair(pair1: &mut Packed1NestedPair, pair2: &mut Packed1NestedPair) {
 120 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 1 %{{.*}}, i8* align 1 %{{.*}}, i{{[0-9]+}} 8, i1 false)
 121     *pair2 = *pair1;
 122 }
 123
 124 // CHECK-LABEL: @pkd2_nested_pair
 125 #[no_mangle]
 126 pub fn pkd2_nested_pair(pair1: &mut Packed2NestedPair, pair2: &mut Packed2NestedPair) {
 127 // CHECK: call void @llvm.memcpy.{{.*}}(i8* align 2 %{{.*}}, i8* align 2 %{{.*}}, i{{[0-9]+}} 8, i1 false)
 128     *pair2 = *pair1;
 129 }
 130