clang/test/CodeGen/attr-cpuspecific.c

   1 // RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,LINUX
   2 // RUN: %clang_cc1 -triple x86_64-apple-macos -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,LINUX
   3 // RUN: %clang_cc1 -triple x86_64-windows-pc -fms-compatibility -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,WINDOWS
   4
   5 #ifdef _WIN64
   6 #define ATTR(X) __declspec(X)
   7 #else
   8 #define ATTR(X) __attribute__((X))
   9 #endif // _WIN64
  10
  11 // Each version should have an IFunc and an alias.
  12 // LINUX: @SingleVersion = weak_odr alias void (), ptr @SingleVersion.ifunc
  13 // LINUX: @TwoVersions = weak_odr alias void (), ptr @TwoVersions.ifunc
  14 // LINUX: @OrderDispatchUsageSpecific = weak_odr alias void (), ptr @OrderDispatchUsageSpecific.ifunc
  15 // LINUX: @TwoVersionsSameAttr = weak_odr alias void (), ptr @TwoVersionsSameAttr.ifunc
  16 // LINUX: @ThreeVersionsSameAttr = weak_odr alias void (), ptr @ThreeVersionsSameAttr.ifunc
  17 // LINUX: @OrderSpecificUsageDispatch = weak_odr alias void (), ptr @OrderSpecificUsageDispatch.ifunc
  18 // LINUX: @NoSpecifics = weak_odr alias void (), ptr @NoSpecifics.ifunc
  19 // LINUX: @HasGeneric = weak_odr alias void (), ptr @HasGeneric.ifunc
  20 // LINUX: @HasParams = weak_odr alias void (i32, double), ptr @HasParams.ifunc
  21 // LINUX: @HasParamsAndReturn = weak_odr alias i32 (i32, double), ptr @HasParamsAndReturn.ifunc
  22 // LINUX: @GenericAndPentium = weak_odr alias i32 (i32, double), ptr @GenericAndPentium.ifunc
  23 // LINUX: @DispatchFirst = weak_odr alias i32 (), ptr @DispatchFirst.ifunc
  24
  25 // LINUX: @SingleVersion.ifunc = weak_odr ifunc void (), ptr @SingleVersion.resolver
  26 // LINUX: @TwoVersions.ifunc = weak_odr ifunc void (), ptr @TwoVersions.resolver
  27 // LINUX: @OrderDispatchUsageSpecific.ifunc = weak_odr ifunc void (), ptr @OrderDispatchUsageSpecific.resolver
  28 // LINUX: @TwoVersionsSameAttr.ifunc = weak_odr ifunc void (), ptr @TwoVersionsSameAttr.resolver
  29 // LINUX: @ThreeVersionsSameAttr.ifunc = weak_odr ifunc void (), ptr @ThreeVersionsSameAttr.resolver
  30 // LINUX: @OrderSpecificUsageDispatch.ifunc = weak_odr ifunc void (), ptr @OrderSpecificUsageDispatch.resolver
  31 // LINUX: @NoSpecifics.ifunc = weak_odr ifunc void (), ptr @NoSpecifics.resolver
  32 // LINUX: @HasGeneric.ifunc = weak_odr ifunc void (), ptr @HasGeneric.resolver
  33 // LINUX: @HasParams.ifunc = weak_odr ifunc void (i32, double), ptr @HasParams.resolver
  34 // LINUX: @HasParamsAndReturn.ifunc = weak_odr ifunc i32 (i32, double), ptr @HasParamsAndReturn.resolver
  35 // LINUX: @GenericAndPentium.ifunc = weak_odr ifunc i32 (i32, double), ptr @GenericAndPentium.resolver
  36 // LINUX: @DispatchFirst.ifunc = weak_odr ifunc i32 (), ptr @DispatchFirst.resolver
  37
  38 ATTR(cpu_specific(ivybridge))
  39 void SingleVersion(void){}
  40 // LINUX: define{{.*}} void @SingleVersion.S() #[[S:[0-9]+]]
  41 // WINDOWS: define dso_local void @SingleVersion.S() #[[S:[0-9]+]]
  42
  43 ATTR(cpu_dispatch(ivybridge))
  44 void SingleVersion(void);
  45 // LINUX: define weak_odr ptr @SingleVersion.resolver()
  46 // LINUX: call void @__cpu_indicator_init
  47 // LINUX: %[[FEAT_INIT:.+]] = load i32, ptr getelementptr inbounds ({ i32, i32, i32, [1 x i32] }, ptr @__cpu_model, i32 0, i32 3, i32 0), align 4
  48 // LINUX: %[[FEAT_JOIN:.+]] = and i32 %[[FEAT_INIT]], 525311
  49 // LINUX: %[[FEAT_CHECK:.+]] = icmp eq i32 %[[FEAT_JOIN]], 525311
  50 // LINUX: ret ptr @SingleVersion.S
  51 // LINUX: call void @llvm.trap
  52 // LINUX: unreachable
  53
  54 // WINDOWS: define weak_odr dso_local void @SingleVersion() comdat
  55 // WINDOWS: call void @__cpu_indicator_init()
  56 // WINDOWS: %[[FEAT_INIT:.+]] = load i32, ptr getelementptr inbounds ({ i32, i32, i32, [1 x i32] }, ptr @__cpu_model, i32 0, i32 3, i32 0), align 4
  57 // WINDOWS: %[[FEAT_JOIN:.+]] = and i32 %[[FEAT_INIT]], 525311
  58 // WINDOWS: %[[FEAT_CHECK:.+]] = icmp eq i32 %[[FEAT_JOIN]], 525311
  59 // WINDOWS: call void @SingleVersion.S()
  60 // WINDOWS-NEXT: ret void
  61 // WINDOWS: call void @llvm.trap
  62 // WINDOWS: unreachable
  63
  64 ATTR(cpu_specific(ivybridge))
  65 void NotCalled(void){}
  66 // LINUX: define{{.*}} void @NotCalled.S() #[[S]]
  67 // WINDOWS: define dso_local void @NotCalled.S() #[[S:[0-9]+]]
  68
  69 // Done before any of the implementations.  Also has an undecorated forward
  70 // declaration.
  71 void TwoVersions(void);
  72
  73 ATTR(cpu_dispatch(ivybridge, knl))
  74 void TwoVersions(void);
  75 // LINUX: define weak_odr ptr @TwoVersions.resolver()
  76 // LINUX: call void @__cpu_indicator_init
  77 // LINUX: %[[FEAT_INIT:.+]] = load i32, ptr getelementptr inbounds ({ i32, i32, i32, [1 x i32] }, ptr @__cpu_model, i32 0, i32 3, i32 0), align 4
  78 // LINUX: %[[FEAT_JOIN:.+]] = and i32 %[[FEAT_INIT]], 9422847
  79 // LINUX: %[[FEAT_CHECK:.+]] = icmp eq i32 %[[FEAT_JOIN]], 9422847
  80 // LINUX: ret ptr @TwoVersions.Z
  81 // LINUX: ret ptr @TwoVersions.S
  82 // LINUX: call void @llvm.trap
  83 // LINUX: unreachable
  84
  85 // WINDOWS: define weak_odr dso_local void @TwoVersions() comdat
  86 // WINDOWS: call void @__cpu_indicator_init()
  87 // WINDOWS: %[[FEAT_INIT:.+]] = load i32, ptr getelementptr inbounds ({ i32, i32, i32, [1 x i32] }, ptr @__cpu_model, i32 0, i32 3, i32 0), align 4
  88 // WINDOWS: %[[FEAT_JOIN:.+]] = and i32 %[[FEAT_INIT]], 9422847
  89 // WINDOWS: %[[FEAT_CHECK:.+]] = icmp eq i32 %[[FEAT_JOIN]], 9422847
  90 // WINDOWS: call void @TwoVersions.Z()
  91 // WINDOWS-NEXT: ret void
  92 // WINDOWS: call void @TwoVersions.S()
  93 // WINDOWS-NEXT: ret void
  94 // WINDOWS: call void @llvm.trap
  95 // WINDOWS: unreachable
  96
  97 ATTR(cpu_specific(ivybridge))
  98 void TwoVersions(void){}
  99 // CHECK: define {{.*}}void @TwoVersions.S() #[[S]]
 100
 101 ATTR(cpu_specific(knl))
 102 void TwoVersions(void){}
 103 // CHECK: define {{.*}}void @TwoVersions.Z() #[[K:[0-9]+]]
 104
 105 ATTR(cpu_specific(ivybridge, knl))
 106 void TwoVersionsSameAttr(void){}
 107 // CHECK: define {{.*}}void @TwoVersionsSameAttr.S() #[[S]]
 108 // CHECK: define {{.*}}void @TwoVersionsSameAttr.Z() #[[K]]
 109
 110 ATTR(cpu_specific(atom, ivybridge, knl))
 111 void ThreeVersionsSameAttr(void){}
 112 // CHECK: define {{.*}}void @ThreeVersionsSameAttr.O() #[[O:[0-9]+]]
 113 // CHECK: define {{.*}}void @ThreeVersionsSameAttr.S() #[[S]]
 114 // CHECK: define {{.*}}void @ThreeVersionsSameAttr.Z() #[[K]]
 115
 116 ATTR(cpu_specific(knl))
 117 void CpuSpecificNoDispatch(void) {}
 118 // CHECK: define {{.*}}void @CpuSpecificNoDispatch.Z() #[[K:[0-9]+]]
 119
 120 ATTR(cpu_dispatch(knl))
 121 void OrderDispatchUsageSpecific(void);
 122 // LINUX: define weak_odr ptr @OrderDispatchUsageSpecific.resolver()
 123 // LINUX: call void @__cpu_indicator_init
 124 // LINUX: ret ptr @OrderDispatchUsageSpecific.Z
 125 // LINUX: call void @llvm.trap
 126 // LINUX: unreachable
 127
 128 // WINDOWS: define weak_odr dso_local void @OrderDispatchUsageSpecific() comdat
 129 // WINDOWS: call void @__cpu_indicator_init()
 130 // WINDOWS: call void @OrderDispatchUsageSpecific.Z()
 131 // WINDOWS-NEXT: ret void
 132 // WINDOWS: call void @llvm.trap
 133 // WINDOWS: unreachable
 134
 135 // CHECK: define {{.*}}void @OrderDispatchUsageSpecific.Z()
 136
 137 ATTR(cpu_specific(knl))
 138 void OrderSpecificUsageDispatch(void) {}
 139 // CHECK: define {{.*}}void @OrderSpecificUsageDispatch.Z() #[[K:[0-9]+]]
 140
 141 void usages(void) {
 142   SingleVersion();
 143   // LINUX: @SingleVersion.ifunc()
 144   // WINDOWS: @SingleVersion()
 145   TwoVersions();
 146   // LINUX: @TwoVersions.ifunc()
 147   // WINDOWS: @TwoVersions()
 148   TwoVersionsSameAttr();
 149   // LINUX: @TwoVersionsSameAttr.ifunc()
 150   // WINDOWS: @TwoVersionsSameAttr()
 151   ThreeVersionsSameAttr();
 152   // LINUX: @ThreeVersionsSameAttr.ifunc()
 153   // WINDOWS: @ThreeVersionsSameAttr()
 154   CpuSpecificNoDispatch();
 155   // LINUX: @CpuSpecificNoDispatch.ifunc()
 156   // WINDOWS: @CpuSpecificNoDispatch()
 157   OrderDispatchUsageSpecific();
 158   // LINUX: @OrderDispatchUsageSpecific.ifunc()
 159   // WINDOWS: @OrderDispatchUsageSpecific()
 160   OrderSpecificUsageDispatch();
 161   // LINUX: @OrderSpecificUsageDispatch.ifunc()
 162   // WINDOWS: @OrderSpecificUsageDispatch()
 163 }
 164
 165 // LINUX: declare void @CpuSpecificNoDispatch.ifunc()
 166
 167 // has an extra config to emit!
 168 ATTR(cpu_dispatch(ivybridge, knl, atom))
 169 void TwoVersionsSameAttr(void);
 170 // LINUX: define weak_odr ptr @TwoVersionsSameAttr.resolver()
 171 // LINUX: ret ptr @TwoVersionsSameAttr.Z
 172 // LINUX: ret ptr @TwoVersionsSameAttr.S
 173 // LINUX: ret ptr @TwoVersionsSameAttr.O
 174 // LINUX: call void @llvm.trap
 175 // LINUX: unreachable
 176
 177 // WINDOWS: define weak_odr dso_local void @TwoVersionsSameAttr() comdat
 178 // WINDOWS: call void @TwoVersionsSameAttr.Z
 179 // WINDOWS-NEXT: ret void
 180 // WINDOWS: call void @TwoVersionsSameAttr.S
 181 // WINDOWS-NEXT: ret void
 182 // WINDOWS: call void @TwoVersionsSameAttr.O
 183 // WINDOWS-NEXT: ret void
 184 // WINDOWS: call void @llvm.trap
 185 // WINDOWS: unreachable
 186
 187 ATTR(cpu_dispatch(atom, ivybridge, knl))
 188 void ThreeVersionsSameAttr(void){}
 189 // LINUX: define weak_odr ptr @ThreeVersionsSameAttr.resolver()
 190 // LINUX: call void @__cpu_indicator_init
 191 // LINUX: ret ptr @ThreeVersionsSameAttr.Z
 192 // LINUX: ret ptr @ThreeVersionsSameAttr.S
 193 // LINUX: ret ptr @ThreeVersionsSameAttr.O
 194 // LINUX: call void @llvm.trap
 195 // LINUX: unreachable
 196
 197 // WINDOWS: define weak_odr dso_local void @ThreeVersionsSameAttr() comdat
 198 // WINDOWS: call void @__cpu_indicator_init
 199 // WINDOWS: call void @ThreeVersionsSameAttr.Z
 200 // WINDOWS-NEXT: ret void
 201 // WINDOWS: call void @ThreeVersionsSameAttr.S
 202 // WINDOWS-NEXT: ret void
 203 // WINDOWS: call void @ThreeVersionsSameAttr.O
 204 // WINDOWS-NEXT: ret void
 205 // WINDOWS: call void @llvm.trap
 206 // WINDOWS: unreachable
 207
 208 ATTR(cpu_dispatch(knl))
 209 void OrderSpecificUsageDispatch(void);
 210 // LINUX: define weak_odr ptr @OrderSpecificUsageDispatch.resolver()
 211 // LINUX: ret ptr @OrderSpecificUsageDispatch.Z
 212
 213 // WINDOWS: define weak_odr dso_local void @OrderSpecificUsageDispatch() comdat
 214 // WINDOWS: call void @__cpu_indicator_init
 215 // WINDOWS: call void @OrderSpecificUsageDispatch.Z
 216 // WINDOWS-NEXT: ret void
 217
 218 // No Cpu Specific options.
 219 ATTR(cpu_dispatch(atom, ivybridge, knl))
 220 void NoSpecifics(void);
 221 // LINUX: define weak_odr ptr @NoSpecifics.resolver()
 222 // LINUX: call void @__cpu_indicator_init
 223 // LINUX: ret ptr @NoSpecifics.Z
 224 // LINUX: ret ptr @NoSpecifics.S
 225 // LINUX: ret ptr @NoSpecifics.O
 226 // LINUX: call void @llvm.trap
 227 // LINUX: unreachable
 228
 229 // WINDOWS: define weak_odr dso_local void @NoSpecifics() comdat
 230 // WINDOWS: call void @__cpu_indicator_init
 231 // WINDOWS: call void @NoSpecifics.Z
 232 // WINDOWS-NEXT: ret void
 233 // WINDOWS: call void @NoSpecifics.S
 234 // WINDOWS-NEXT: ret void
 235 // WINDOWS: call void @NoSpecifics.O
 236 // WINDOWS-NEXT: ret void
 237 // WINDOWS: call void @llvm.trap
 238 // WINDOWS: unreachable
 239
 240 ATTR(cpu_dispatch(atom, generic, ivybridge, knl))
 241 void HasGeneric(void);
 242 // LINUX: define weak_odr ptr @HasGeneric.resolver()
 243 // LINUX: call void @__cpu_indicator_init
 244 // LINUX: ret ptr @HasGeneric.Z
 245 // LINUX: ret ptr @HasGeneric.S
 246 // LINUX: ret ptr @HasGeneric.O
 247 // LINUX: ret ptr @HasGeneric.A
 248 // LINUX-NOT: call void @llvm.trap
 249
 250 // WINDOWS: define weak_odr dso_local void @HasGeneric() comdat
 251 // WINDOWS: call void @__cpu_indicator_init
 252 // WINDOWS: call void @HasGeneric.Z
 253 // WINDOWS-NEXT: ret void
 254 // WINDOWS: call void @HasGeneric.S
 255 // WINDOWS-NEXT: ret void
 256 // WINDOWS: call void @HasGeneric.O
 257 // WINDOWS-NEXT: ret void
 258 // WINDOWS: call void @HasGeneric.A
 259 // WINDOWS-NEXT: ret void
 260 // WINDOWS-NOT: call void @llvm.trap
 261
 262 ATTR(cpu_dispatch(atom, generic, ivybridge, knl))
 263 void HasParams(int i, double d);
 264 // LINUX: define weak_odr ptr @HasParams.resolver()
 265 // LINUX: call void @__cpu_indicator_init
 266 // LINUX: ret ptr @HasParams.Z
 267 // LINUX: ret ptr @HasParams.S
 268 // LINUX: ret ptr @HasParams.O
 269 // LINUX: ret ptr @HasParams.A
 270 // LINUX-NOT: call void @llvm.trap
 271
 272 // WINDOWS: define weak_odr dso_local void @HasParams(i32 %0, double %1) comdat
 273 // WINDOWS: call void @__cpu_indicator_init
 274 // WINDOWS: call void @HasParams.Z(i32 %0, double %1)
 275 // WINDOWS-NEXT: ret void
 276 // WINDOWS: call void @HasParams.S(i32 %0, double %1)
 277 // WINDOWS-NEXT: ret void
 278 // WINDOWS: call void @HasParams.O(i32 %0, double %1)
 279 // WINDOWS-NEXT: ret void
 280 // WINDOWS: call void @HasParams.A(i32 %0, double %1)
 281 // WINDOWS-NEXT: ret void
 282 // WINDOWS-NOT: call void @llvm.trap
 283
 284 ATTR(cpu_dispatch(atom, generic, ivybridge, knl))
 285 int HasParamsAndReturn(int i, double d);
 286 // LINUX: define weak_odr ptr @HasParamsAndReturn.resolver()
 287 // LINUX: call void @__cpu_indicator_init
 288 // LINUX: ret ptr @HasParamsAndReturn.Z
 289 // LINUX: ret ptr @HasParamsAndReturn.S
 290 // LINUX: ret ptr @HasParamsAndReturn.O
 291 // LINUX: ret ptr @HasParamsAndReturn.A
 292 // LINUX-NOT: call void @llvm.trap
 293
 294 // WINDOWS: define weak_odr dso_local i32 @HasParamsAndReturn(i32 %0, double %1) comdat
 295 // WINDOWS: call void @__cpu_indicator_init
 296 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.Z(i32 %0, double %1)
 297 // WINDOWS-NEXT: ret i32 %[[RET]]
 298 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.S(i32 %0, double %1)
 299 // WINDOWS-NEXT: ret i32 %[[RET]]
 300 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.O(i32 %0, double %1)
 301 // WINDOWS-NEXT: ret i32 %[[RET]]
 302 // WINDOWS: %[[RET:.+]] = musttail call i32 @HasParamsAndReturn.A(i32 %0, double %1)
 303 // WINDOWS-NEXT: ret i32 %[[RET]]
 304 // WINDOWS-NOT: call void @llvm.trap
 305
 306 ATTR(cpu_dispatch(atom, generic, pentium))
 307 int GenericAndPentium(int i, double d);
 308 // LINUX: define weak_odr ptr @GenericAndPentium.resolver()
 309 // LINUX: call void @__cpu_indicator_init
 310 // LINUX: ret ptr @GenericAndPentium.O
 311 // LINUX: ret ptr @GenericAndPentium.B
 312 // LINUX-NOT: ret ptr @GenericAndPentium.A
 313 // LINUX-NOT: call void @llvm.trap
 314
 315 // WINDOWS: define weak_odr dso_local i32 @GenericAndPentium(i32 %0, double %1) comdat
 316 // WINDOWS: call void @__cpu_indicator_init
 317 // WINDOWS: %[[RET:.+]] = musttail call i32 @GenericAndPentium.O(i32 %0, double %1)
 318 // WINDOWS-NEXT: ret i32 %[[RET]]
 319 // WINDOWS: %[[RET:.+]] = musttail call i32 @GenericAndPentium.B(i32 %0, double %1)
 320 // WINDOWS-NEXT: ret i32 %[[RET]]
 321 // WINDOWS-NOT: call i32 @GenericAndPentium.A
 322 // WINDOWS-NOT: call void @llvm.trap
 323
 324 ATTR(cpu_dispatch(atom, pentium))
 325 int DispatchFirst(void);
 326 // LINUX: define weak_odr ptr @DispatchFirst.resolver
 327 // LINUX: ret ptr @DispatchFirst.O
 328 // LINUX: ret ptr @DispatchFirst.B
 329
 330 // WINDOWS: define weak_odr dso_local i32 @DispatchFirst() comdat
 331 // WINDOWS: %[[RET:.+]] = musttail call i32 @DispatchFirst.O()
 332 // WINDOWS-NEXT: ret i32 %[[RET]]
 333 // WINDOWS: %[[RET:.+]] = musttail call i32 @DispatchFirst.B()
 334 // WINDOWS-NEXT: ret i32 %[[RET]]
 335
 336 ATTR(cpu_specific(atom))
 337 int DispatchFirst(void) {return 0;}
 338 // LINUX: define{{.*}} i32 @DispatchFirst.O
 339 // LINUX: ret i32 0
 340
 341 // WINDOWS: define dso_local i32 @DispatchFirst.O()
 342 // WINDOWS: ret i32 0
 343
 344 ATTR(cpu_specific(pentium))
 345 int DispatchFirst(void) {return 1;}
 346 // LINUX: define{{.*}} i32 @DispatchFirst.B
 347 // LINUX: ret i32 1
 348
 349 // WINDOWS: define dso_local i32 @DispatchFirst.B
 350 // WINDOWS: ret i32 1
 351
 352 ATTR(cpu_specific(knl))
 353 void OrderDispatchUsageSpecific(void) {}
 354
 355 // CHECK: attributes #[[S]] = {{.*}}"target-features"="+avx,+cmov,+crc32,+cx16,+cx8,+f16c,+fsgsbase,+fxsr,+mmx,+pclmul,+popcnt,+rdrnd,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt"
 356 // CHECK-SAME: "tune-cpu"="ivybridge"
 357 // CHECK: attributes #[[K]] = {{.*}}"target-features"="+adx,+aes,+avx,+avx2,+avx512cd,+avx512f,+bmi,+bmi2,+cmov,+crc32,+cx16,+cx8,+evex512,+f16c,+fma,+fsgsbase,+fxsr,+invpcid,+lzcnt,+mmx,+movbe,+pclmul,+popcnt,+prfchw,+rdrnd,+rdseed,+sahf,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+ssse3,+x87,+xsave,+xsaveopt"
 358 // CHECK-SAME: "tune-cpu"="knl"
 359 // CHECK: attributes #[[O]] = {{.*}}"target-features"="+cmov,+cx16,+cx8,+fxsr,+mmx,+movbe,+sahf,+sse,+sse2,+sse3,+ssse3,+x87"
 360 // CHECK-SAME: "tune-cpu"="atom"