test/CodeGen/X86/memcpy.ll

   1 ; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -mcpu=core2 | FileCheck %s -check-prefix=LINUX
   2 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=core2 | FileCheck %s -check-prefix=DARWIN
   3
   4 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind
   5
   6
   7 ; Variable memcpy's should lower to calls.
   8 define i8* @test1(i8* %a, i8* %b, i64 %n) nounwind {
   9 entry:
  10         tail call void @llvm.memcpy.p0i8.p0i8.i64( i8* %a, i8* %b, i64 %n, i32 1, i1 0 )
  11         ret i8* %a
  12
  13 ; LINUX-LABEL: test1:
  14 ; LINUX: memcpy
  15 }
  16
  17 ; Variable memcpy's should lower to calls.
  18 define i8* @test2(i64* %a, i64* %b, i64 %n) nounwind {
  19 entry:
  20         %tmp14 = bitcast i64* %a to i8*
  21         %tmp25 = bitcast i64* %b to i8*
  22         tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %tmp14, i8* %tmp25, i64 %n, i32 8, i1 0 )
  23         ret i8* %tmp14
  24
  25 ; LINUX-LABEL: test2:
  26 ; LINUX: memcpy
  27 }
  28
  29 ; Large constant memcpy's should lower to a call when optimizing for size.
  30 ; PR6623
  31
  32 ; On the other hand, Darwin's definition of -Os is optimizing for size without
  33 ; hurting performance so it should just ignore optsize when expanding memcpy.
  34 ; rdar://8821501
  35 define void @test3(i8* nocapture %A, i8* nocapture %B) nounwind optsize noredzone {
  36 entry:
  37   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i32 1, i1 false)
  38   ret void
  39 ; LINUX-LABEL: test3:
  40 ; LINUX: memcpy
  41
  42 ; DARWIN-LABEL: test3:
  43 ; DARWIN-NOT: memcpy
  44 ; DARWIN: movq
  45 ; DARWIN: movq
  46 ; DARWIN: movq
  47 ; DARWIN: movq
  48 ; DARWIN: movq
  49 ; DARWIN: movq
  50 ; DARWIN: movq
  51 ; DARWIN: movq
  52 ; DARWIN: movq
  53 ; DARWIN: movq
  54 ; DARWIN: movq
  55 ; DARWIN: movq
  56 ; DARWIN: movq
  57 ; DARWIN: movq
  58 ; DARWIN: movq
  59 ; DARWIN: movq
  60 }
  61
  62 ; FIXME: Both Linux and Darwin should lower to a memcpy call; minsize is on.
  63 define void @test3_minsize(i8* nocapture %A, i8* nocapture %B) nounwind minsize noredzone {
  64   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i32 1, i1 false)
  65   ret void
  66 ; LINUX-LABEL: test3_minsize:
  67 ; LINUX: movq
  68 ; LINUX: movq
  69 ; LINUX: movq
  70 ; LINUX: movq
  71 ; LINUX: movq
  72 ; LINUX: movq
  73 ; LINUX: movq
  74 ; LINUX: movq
  75 ; LINUX: movq
  76 ; LINUX: movq
  77 ; LINUX: movq
  78 ; LINUX: movq
  79 ; LINUX: movq
  80 ; LINUX: movq
  81 ; LINUX: movq
  82 ; LINUX: movq
  83
  84 ; DARWIN-LABEL: test3_minsize:
  85 ; DARWIN: movq
  86 ; DARWIN: movq
  87 ; DARWIN: movq
  88 ; DARWIN: movq
  89 ; DARWIN: movq
  90 ; DARWIN: movq
  91 ; DARWIN: movq
  92 ; DARWIN: movq
  93 ; DARWIN: movq
  94 ; DARWIN: movq
  95 ; DARWIN: movq
  96 ; DARWIN: movq
  97 ; DARWIN: movq
  98 ; DARWIN: movq
  99 ; DARWIN: movq
 100 ; DARWIN: movq
 101 }
 102
 103 ; FIXME: Darwin should lower to a memcpy call; minsize is on.
 104 define void @test3_minsize_optsize(i8* nocapture %A, i8* nocapture %B) nounwind optsize minsize noredzone {
 105   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i32 1, i1 false)
 106   ret void
 107 ; LINUX-LABEL: test3_minsize_optsize:
 108 ; LINUX: memcpy
 109
 110 ; DARWIN-LABEL: test3_minsize_optsize:
 111 ; DARWIN: movq
 112 ; DARWIN: movq
 113 ; DARWIN: movq
 114 ; DARWIN: movq
 115 ; DARWIN: movq
 116 ; DARWIN: movq
 117 ; DARWIN: movq
 118 ; DARWIN: movq
 119 ; DARWIN: movq
 120 ; DARWIN: movq
 121 ; DARWIN: movq
 122 ; DARWIN: movq
 123 ; DARWIN: movq
 124 ; DARWIN: movq
 125 ; DARWIN: movq
 126 ; DARWIN: movq
 127 }
 128
 129 ; Large constant memcpy's should be inlined when not optimizing for size.
 130 define void @test4(i8* nocapture %A, i8* nocapture %B) nounwind noredzone {
 131 entry:
 132   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %A, i8* %B, i64 64, i32 1, i1 false)
 133   ret void
 134 ; LINUX-LABEL: test4:
 135 ; LINUX: movq
 136 ; LINUX: movq
 137 ; LINUX: movq
 138 ; LINUX: movq
 139 ; LINUX: movq
 140 ; LINUX: movq
 141 ; LINUX: movq
 142 ; LINUX: movq
 143 ; LINUX: movq
 144 ; LINUX: movq
 145 ; LINUX: movq
 146 ; LINUX: movq
 147 }
 148
 149
 150 @.str = private unnamed_addr constant [30 x i8] c"\00aaaaaaaaaaaaaaaaaaaaaaaaaaaa\00", align 1
 151
 152 define void @test5(i8* nocapture %C) nounwind uwtable ssp {
 153 entry:
 154   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %C, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i64 16, i32 1, i1 false)
 155   ret void
 156
 157 ; DARWIN-LABEL: test5:
 158 ; DARWIN: movabsq       $7016996765293437281
 159 ; DARWIN: movabsq       $7016996765293437184
 160 }
 161
 162
 163 ; PR14896
 164 @.str2 = private unnamed_addr constant [2 x i8] c"x\00", align 1
 165
 166 define void @test6() nounwind uwtable {
 167 entry:
 168 ; DARWIN: test6
 169 ; DARWIN: movw $0, 8
 170 ; DARWIN: movq $120, 0
 171   tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str2, i64 0, i64 0), i64 10, i32 1, i1 false)
 172   ret void
 173 }
 174
 175 define void @PR15348(i8* %a, i8* %b) {
 176 ; Ensure that alignment of '0' in an @llvm.memcpy intrinsic results in
 177 ; unaligned loads and stores.
 178 ; LINUX: PR15348
 179 ; LINUX: movb
 180 ; LINUX: movb
 181 ; LINUX: movq
 182 ; LINUX: movq
 183 ; LINUX: movq
 184 ; LINUX: movq
 185   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 17, i32 0, i1 false)
 186   ret void
 187 }