1 // RUN: %clang_cc1 -ffreestanding -triple x86_64-apple-macosx10.8.0 -target-feature +sse4.1 -emit-llvm %s -o - | FileCheck %s 2 3 #include <xmmintrin.h> 4 #include <emmintrin.h> 5 #include <smmintrin.h> 6 7 __m128 test_rsqrt_ss(__m128 x) { 8 // CHECK: define {{.*}} @test_rsqrt_ss 9 // CHECK: call <4 x float> @llvm.x86.sse.rsqrt.ss 10 // CHECK: extractelement <4 x float> {{.*}}, i32 0 11 // CHECK: extractelement <4 x float> {{.*}}, i32 1 12 // CHECK: extractelement <4 x float> {{.*}}, i32 2 13 // CHECK: extractelement <4 x float> {{.*}}, i32 3 14 return _mm_rsqrt_ss(x); 15 } 16 17 __m128 test_rcp_ss(__m128 x) { 18 // CHECK: define {{.*}} @test_rcp_ss 19 // CHECK: call <4 x float> @llvm.x86.sse.rcp.ss 20 // CHECK: extractelement <4 x float> {{.*}}, i32 0 21 // CHECK: extractelement <4 x float> {{.*}}, i32 1 22 // CHECK: extractelement <4 x float> {{.*}}, i32 2 23 // CHECK: extractelement <4 x float> {{.*}}, i32 3 24 return _mm_rcp_ss(x); 25 } 26 27 __m128 test_sqrt_ss(__m128 x) { 28 // CHECK: define {{.*}} @test_sqrt_ss 29 // CHECK: call <4 x float> @llvm.x86.sse.sqrt.ss 30 // CHECK: extractelement <4 x float> {{.*}}, i32 0 31 // CHECK: extractelement <4 x float> {{.*}}, i32 1 32 // CHECK: extractelement <4 x float> {{.*}}, i32 2 33 // CHECK: extractelement <4 x float> {{.*}}, i32 3 34 return _mm_sqrt_ss(x); 35 } 36 37 __m128 test_loadl_pi(__m128 x, void* y) { 38 // CHECK: define {{.*}} @test_loadl_pi 39 // CHECK: load <2 x float>* {{.*}}, align 1{{$}} 40 // CHECK: shufflevector {{.*}} <4 x i32> <i32 0, i32 1 41 // CHECK: shufflevector {{.*}} <4 x i32> <i32 4, i32 5, i32 2, i32 3> 42 return _mm_loadl_pi(x,y); 43 } 44 45 __m128 test_loadh_pi(__m128 x, void* y) { 46 // CHECK: define {{.*}} @test_loadh_pi 47 // CHECK: load <2 x float>* {{.*}}, align 1{{$}} 48 // CHECK: shufflevector {{.*}} <4 x i32> <i32 0, i32 1 49 // CHECK: shufflevector {{.*}} <4 x i32> <i32 0, i32 1, i32 4, i32 5> 50 return _mm_loadh_pi(x,y); 51 } 52 53 __m128 test_load_ss(void* y) { 54 // CHECK: define {{.*}} @test_load_ss 55 // CHECK: load float* {{.*}}, align 1{{$}} 56 return _mm_load_ss(y); 57 } 58 59 __m128 test_load1_ps(void* y) { 60 // CHECK: define {{.*}} @test_load1_ps 61 // CHECK: load float* {{.*}}, align 1{{$}} 62 return _mm_load1_ps(y); 63 } 64 65 void test_store_ss(__m128 x, void* y) { 66 // CHECK-LABEL: define void @test_store_ss 67 // CHECK: store {{.*}} float* {{.*}}, align 1{{$}} 68 _mm_store_ss(y, x); 69 } 70 71 __m128d test_load1_pd(__m128 x, void* y) { 72 // CHECK: define {{.*}} @test_load1_pd 73 // CHECK: load double* {{.*}}, align 1{{$}} 74 return _mm_load1_pd(y); 75 } 76 77 __m128d test_loadr_pd(__m128 x, void* y) { 78 // CHECK: define {{.*}} @test_loadr_pd 79 // CHECK: load <2 x double>* {{.*}}, align 16{{$}} 80 return _mm_loadr_pd(y); 81 } 82 83 __m128d test_load_sd(void* y) { 84 // CHECK: define {{.*}} @test_load_sd 85 // CHECK: load double* {{.*}}, align 1{{$}} 86 return _mm_load_sd(y); 87 } 88 89 __m128d test_loadh_pd(__m128d x, void* y) { 90 // CHECK: define {{.*}} @test_loadh_pd 91 // CHECK: load double* {{.*}}, align 1{{$}} 92 return _mm_loadh_pd(x, y); 93 } 94 95 __m128d test_loadl_pd(__m128d x, void* y) { 96 // CHECK: define {{.*}} @test_loadl_pd 97 // CHECK: load double* {{.*}}, align 1{{$}} 98 return _mm_loadl_pd(x, y); 99 } 100 101 void test_store_sd(__m128d x, void* y) { 102 // CHECK-LABEL: define void @test_store_sd 103 // CHECK: store {{.*}} double* {{.*}}, align 1{{$}} 104 _mm_store_sd(y, x); 105 } 106 107 void test_store1_pd(__m128d x, void* y) { 108 // CHECK-LABEL: define void @test_store1_pd 109 // CHECK: store {{.*}} double* {{.*}}, align 1{{$}} 110 // CHECK: store {{.*}} double* {{.*}}, align 1{{$}} 111 _mm_store1_pd(y, x); 112 } 113 114 void test_storer_pd(__m128d x, void* y) { 115 // CHECK-LABEL: define void @test_storer_pd 116 // CHECK: store {{.*}} <2 x double>* {{.*}}, align 16{{$}} 117 _mm_storer_pd(y, x); 118 } 119 120 void test_storeh_pd(__m128d x, void* y) { 121 // CHECK-LABEL: define void @test_storeh_pd 122 // CHECK: store {{.*}} double* {{.*}}, align 1{{$}} 123 _mm_storeh_pd(y, x); 124 } 125 126 void test_storel_pd(__m128d x, void* y) { 127 // CHECK-LABEL: define void @test_storel_pd 128 // CHECK: store {{.*}} double* {{.*}}, align 1{{$}} 129 _mm_storel_pd(y, x); 130 } 131 132 __m128i test_loadl_epi64(void* y) { 133 // CHECK: define {{.*}} @test_loadl_epi64 134 // CHECK: load i64* {{.*}}, align 1{{$}} 135 return _mm_loadl_epi64(y); 136 } 137 138 __m128i test_mm_minpos_epu16(__m128i x) { 139 // CHECK: define {{.*}} @test_mm_minpos_epu16 140 // CHECK: @llvm.x86.sse41.phminposuw 141 return _mm_minpos_epu16(x); 142 } 143 144 __m128i test_mm_mpsadbw_epu8(__m128i x, __m128i y) { 145 // CHECK: define {{.*}} @test_mm_mpsadbw_epu8 146 // CHECK: @llvm.x86.sse41.mpsadbw 147 return _mm_mpsadbw_epu8(x, y, 1); 148 } 149 150 __m128 test_mm_dp_ps(__m128 x, __m128 y) { 151 // CHECK: define {{.*}} @test_mm_dp_ps 152 // CHECK: @llvm.x86.sse41.dpps 153 return _mm_dp_ps(x, y, 2); 154 } 155 156 __m128d test_mm_dp_pd(__m128d x, __m128d y) { 157 // CHECK: define {{.*}} @test_mm_dp_pd 158 // CHECK: @llvm.x86.sse41.dppd 159 return _mm_dp_pd(x, y, 2); 160 } 161 162 __m128 test_mm_round_ps(__m128 x) { 163 // CHECK: define {{.*}} @test_mm_round_ps 164 // CHECK: @llvm.x86.sse41.round.ps 165 return _mm_round_ps(x, 2); 166 } 167 168 __m128 test_mm_round_ss(__m128 x, __m128 y) { 169 // CHECK: define {{.*}} @test_mm_round_ss 170 // CHECK: @llvm.x86.sse41.round.ss 171 return _mm_round_ss(x, y, 2); 172 } 173 174 __m128d test_mm_round_pd(__m128d x) { 175 // CHECK: define {{.*}} @test_mm_round_pd 176 // CHECK: @llvm.x86.sse41.round.pd 177 return _mm_round_pd(x, 2); 178 } 179 180 __m128d test_mm_round_sd(__m128d x, __m128d y) { 181 // CHECK: define {{.*}} @test_mm_round_sd 182 // CHECK: @llvm.x86.sse41.round.sd 183 return _mm_round_sd(x, y, 2); 184 } 185 186 void test_storel_epi64(__m128i x, void* y) { 187 // CHECK-LABEL: define void @test_storel_epi64 188 // CHECK: store {{.*}} i64* {{.*}}, align 1{{$}} 189 _mm_storel_epi64(y, x); 190 } 191 192 void test_stream_si32(int x, void *y) { 193 // CHECK-LABEL: define void @test_stream_si32 194 // CHECK: store {{.*}} i32* {{.*}}, align 1, !nontemporal 195 _mm_stream_si32(y, x); 196 } 197 198 void test_stream_si64(long long x, void *y) { 199 // CHECK-LABEL: define void @test_stream_si64 200 // CHECK: store {{.*}} i64* {{.*}}, align 1, !nontemporal 201 _mm_stream_si64(y, x); 202 } 203 204 void test_stream_si128(__m128i x, void *y) { 205 // CHECK-LABEL: define void @test_stream_si128 206 // CHECK: store {{.*}} <2 x i64>* {{.*}}, align 16, !nontemporal 207 _mm_stream_si128(y, x); 208 } 209 210 void test_extract_epi16(__m128i __a) { 211 // CHECK-LABEL: define void @test_extract_epi16 212 // CHECK: [[x:%.*]] = and i32 %{{.*}}, 7 213 // CHECK: extractelement <8 x i16> %{{.*}}, i32 [[x]] 214 _mm_extract_epi16(__a, 8); 215 } 216 217 int test_extract_ps(__m128i __a) { 218 // CHECK-LABEL: @test_extract_ps 219 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 220 return _mm_extract_ps(__a, 4); 221 } 222 223 int test_extract_epi8(__m128i __a) { 224 // CHECK-LABEL: @test_extract_epi8 225 // CHECK: extractelement <16 x i8> %{{.*}}, i32 0 226 return _mm_extract_epi8(__a, 16); 227 } 228 229 int test_extract_epi32(__m128i __a) { 230 // CHECK-LABEL: @test_extract_epi32 231 // CHECK: extractelement <4 x i32> %{{.*}}, i32 0 232 return _mm_extract_epi32(__a, 4); 233 } 234 235 void test_insert_epi32(__m128i __a, int b) { 236 // CHECK-LABEL: @test_insert_epi32 237 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 0 238 _mm_insert_epi32(__a, b, 4); 239 } 240 241 __m128d test_blend_pd(__m128d V1, __m128d V2) { 242 // CHECK-LABEL: @test_blend_pd 243 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> <i32 2, i32 1> 244 return _mm_blend_pd(V1, V2, 1); 245 } 246 247 __m128 test_blend_ps(__m128 V1, __m128 V2) { 248 // CHECK-LABEL: @test_blend_ps 249 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3> 250 return _mm_blend_ps(V1, V2, 5); 251 } 252 253 __m128i test_blend_epi16(__m128i V1, __m128i V2) { 254 // CHECK-LABEL: @test_blend_epi16 255 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> <i32 0, i32 9, i32 2, i32 11, i32 4, i32 13, i32 6, i32 7> 256 return _mm_blend_epi16(V1, V2, 42); 257 } 258
