gcc/testsuite/gcc.target/i386/builtin_target.c

   1 /* This test checks if the __builtin_cpu_is and __builtin_cpu_supports calls
   2    are recognized.  It also independently uses CPUID to get cpu type and
   3    features supported and checks if the builtins correctly identify the
   4    platform.  The code to do the identification is adapted from
   5    libgcc/config/i386/cpuinfo.c.  */
   6
   7 /* { dg-do run } */
   8
   9 #include <assert.h>
  10 #include "cpuid.h"
  11
  12 /* Check if the Intel CPU model and sub-model are identified.  */
  13 static void
  14 check_intel_cpu_model (unsigned int family, unsigned int model,
  15                        unsigned int brand_id)
  16 {
  17   /* Parse family and model only if brand ID is 0. */
  18   if (brand_id == 0)
  19     {
  20       switch (family)
  21         {
  22         case 0x5:
  23           /* Pentium.  */
  24           break;
  25         case 0x6:
  26           switch (model)
  27             {
  28             case 0x1c:
  29             case 0x26:
  30               /* Atom.  */
  31               assert (__builtin_cpu_is ("atom"));
  32               break;
  33             case 0x37:
  34             case 0x4a:
  35             case 0x4d:
  36             case 0x5a:
  37             case 0x5d:
  38               /* Silvermont.  */
  39               assert (__builtin_cpu_is ("silvermont"));
  40               break;
  41             case 0x57:
  42               /* Knights Landing.  */
  43               assert (__builtin_cpu_is ("knl"));
  44               break;
  45             case 0x1a:
  46             case 0x1e:
  47             case 0x1f:
  48             case 0x2e:
  49               /* Nehalem.  */
  50               assert (__builtin_cpu_is ("corei7"));
  51               assert (__builtin_cpu_is ("nehalem"));
  52               break;
  53             case 0x25:
  54             case 0x2c:
  55             case 0x2f:
  56               /* Westmere.  */
  57               assert (__builtin_cpu_is ("corei7"));
  58               assert (__builtin_cpu_is ("westmere"));
  59               break;
  60             case 0x2a:
  61             case 0x2d:
  62               /* Sandy Bridge.  */
  63               assert (__builtin_cpu_is ("corei7"));
  64               assert (__builtin_cpu_is ("sandybridge"));
  65               break;
  66             case 0x3a:
  67             case 0x3e:
  68               /* Ivy Bridge.  */
  69               assert (__builtin_cpu_is ("corei7"));
  70               assert (__builtin_cpu_is ("ivybridge"));
  71               break;
  72             case 0x3c:
  73             case 0x3f:
  74             case 0x45:
  75             case 0x46:
  76               /* Haswell.  */
  77               assert (__builtin_cpu_is ("corei7"));
  78               assert (__builtin_cpu_is ("haswell"));
  79               break;
  80             case 0x3d:
  81             case 0x47:
  82             case 0x4f:
  83             case 0x56:
  84               /* Broadwell.  */
  85               assert (__builtin_cpu_is ("corei7"));
  86               assert (__builtin_cpu_is ("broadwell"));
  87               break;
  88             case 0x4e:
  89             case 0x5e:
  90               /* Skylake.  */
  91               assert (__builtin_cpu_is ("corei7"));
  92               assert (__builtin_cpu_is ("skylake"));
  93               break;
  94             case 0x55:
  95               /* Skylake with AVX-512 support.  */
  96               assert (__builtin_cpu_is ("corei7"));
  97               assert (__builtin_cpu_is ("skylake-avx512"));
  98               break;
  99             case 0x17:
 100             case 0x1d:
 101               /* Penryn.  */
 102             case 0x0f:
 103               /* Merom.  */
 104               assert (__builtin_cpu_is ("core2"));
 105               break;
 106             default:
 107               break;
 108             }
 109           break;
 110         default:
 111           /* We have no idea.  */
 112           break;
 113         }
 114     }
 115 }
 116
 117 /* Check if the AMD CPU model and sub-model are identified.  */
 118 static void
 119 check_amd_cpu_model (unsigned int family, unsigned int model)
 120 {
 121   switch (family)
 122     {
 123     /* AMD Family 10h.  */
 124     case 0x10:
 125       switch (model)
 126         {
 127         case 0x2:
 128           /* Barcelona.  */
 129           assert (__builtin_cpu_is ("amdfam10h"));
 130           assert (__builtin_cpu_is ("barcelona"));
 131           break;
 132         case 0x4:
 133           /* Shanghai.  */
 134           assert (__builtin_cpu_is ("amdfam10h"));
 135           assert (__builtin_cpu_is ("shanghai"));
 136           break;
 137         case 0x8:
 138           /* Istanbul.  */
 139           assert (__builtin_cpu_is ("amdfam10h"));
 140           assert (__builtin_cpu_is ("istanbul"));
 141           break;
 142         default:
 143           break;
 144         }
 145       break;
 146     /* AMD Family 15h.  */
 147     case 0x15:
 148       assert (__builtin_cpu_is ("amdfam15h"));
 149       /* Bulldozer version 1.  */
 150       if ( model <= 0xf)
 151         assert (__builtin_cpu_is ("bdver1"));
 152       /* Bulldozer version 2.  */
 153       if (model >= 0x10 && model <= 0x1f)
 154         assert (__builtin_cpu_is ("bdver2"));
 155       break;
 156     default:
 157       break;
 158     }
 159 }
 160
 161 /* Check if the ISA features are identified.  */
 162 static void
 163 check_features (unsigned int ecx, unsigned int edx,
 164                 int max_cpuid_level)
 165 {
 166   if (edx & bit_CMOV)
 167     assert (__builtin_cpu_supports ("cmov"));
 168   if (edx & bit_MMX)
 169     assert (__builtin_cpu_supports ("mmx"));
 170   if (edx & bit_SSE)
 171     assert (__builtin_cpu_supports ("sse"));
 172   if (edx & bit_SSE2)
 173     assert (__builtin_cpu_supports ("sse2"));
 174   if (ecx & bit_POPCNT)
 175     assert (__builtin_cpu_supports ("popcnt"));
 176   if (ecx & bit_AES)
 177     assert (__builtin_cpu_supports ("aes"));
 178   if (ecx & bit_PCLMUL)
 179     assert (__builtin_cpu_supports ("pclmul"));
 180   if (ecx & bit_SSE3)
 181     assert (__builtin_cpu_supports ("sse3"));
 182   if (ecx & bit_SSSE3)
 183     assert (__builtin_cpu_supports ("ssse3"));
 184   if (ecx & bit_SSE4_1)
 185     assert (__builtin_cpu_supports ("sse4.1"));
 186   if (ecx & bit_SSE4_2)
 187     assert (__builtin_cpu_supports ("sse4.2"));
 188   if (ecx & bit_AVX)
 189     assert (__builtin_cpu_supports ("avx"));
 190
 191   /* Get advanced features at level 7 (eax = 7, ecx = 0).  */
 192   if (max_cpuid_level >= 7)
 193     {
 194       unsigned int eax, ebx, ecx, edx;
 195       __cpuid_count (7, 0, eax, ebx, ecx, edx);
 196       if (ebx & bit_AVX2)
 197         assert (__builtin_cpu_supports ("avx2"));
 198       if (ebx & bit_AVX512F)
 199         assert (__builtin_cpu_supports ("avx512f"));
 200       if (ebx & bit_AVX512VL)
 201         assert (__builtin_cpu_supports ("avx512vl"));
 202       if (ebx & bit_AVX512CD)
 203         assert (__builtin_cpu_supports ("avx512cd"));
 204       if (ebx & bit_AVX512PF)
 205         assert (__builtin_cpu_supports ("avx512pf"));
 206       if (ebx & bit_AVX512ER)
 207         assert (__builtin_cpu_supports ("avx512er"));
 208       if (ebx & bit_AVX512BW)
 209         assert (__builtin_cpu_supports ("avx512bw"));
 210       if (ebx & bit_AVX512DQ)
 211         assert (__builtin_cpu_supports ("avx512dq"));
 212       if (ecx & bit_AVX512IFMA)
 213         assert (__builtin_cpu_supports ("avx512ifma"));
 214       if (ecx & bit_AVX512VBMI)
 215         assert (__builtin_cpu_supports ("avx512vbmi"));
 216     }
 217 }
 218
 219 static int __attribute__ ((noinline))
 220 __get_cpuid_output (unsigned int __level,
 221                     unsigned int *__eax, unsigned int *__ebx,
 222                     unsigned int *__ecx, unsigned int *__edx)
 223 {
 224   return __get_cpuid (__level, __eax, __ebx, __ecx, __edx);
 225 }
 226
 227 static int
 228 check_detailed ()
 229 {
 230   unsigned int eax, ebx, ecx, edx;
 231
 232   int max_level;
 233   unsigned int vendor;
 234   unsigned int model, family, brand_id;
 235   unsigned int extended_model, extended_family;
 236
 237   /* Assume cpuid insn present. Run in level 0 to get vendor id. */
 238   if (!__get_cpuid_output (0, &eax, &ebx, &ecx, &edx))
 239     return 0;
 240
 241   vendor = ebx;
 242   max_level = eax;
 243
 244   if (max_level < 1)
 245     return 0;
 246
 247   if (!__get_cpuid_output (1, &eax, &ebx, &ecx, &edx))
 248     return 0;
 249
 250   model = (eax >> 4) & 0x0f;
 251   family = (eax >> 8) & 0x0f;
 252   brand_id = ebx & 0xff;
 253   extended_model = (eax >> 12) & 0xf0;
 254   extended_family = (eax >> 20) & 0xff;
 255
 256   if (vendor == signature_INTEL_ebx)
 257     {
 258       assert (__builtin_cpu_is ("intel"));
 259       /* Adjust family and model for Intel CPUs.  */
 260       if (family == 0x0f)
 261         {
 262           family += extended_family;
 263           model += extended_model;
 264         }
 265       else if (family == 0x06)
 266         model += extended_model;
 267       check_intel_cpu_model (family, model, brand_id);
 268       check_features (ecx, edx, max_level);
 269     }
 270   else if (vendor == signature_AMD_ebx)
 271     {
 272       assert (__builtin_cpu_is ("amd"));
 273       /* Adjust model and family for AMD CPUS. */
 274       if (family == 0x0f)
 275         {
 276           family += extended_family;
 277           model += (extended_model << 4);
 278         }
 279       check_amd_cpu_model (family, model);
 280       check_features (ecx, edx, max_level);
 281     }
 282
 283   return 0;
 284 }
 285
 286 static int
 287 quick_check ()
 288 {
 289   /* Check CPU Features.  */
 290   assert (__builtin_cpu_supports ("cmov") >= 0);
 291
 292   assert (__builtin_cpu_supports ("mmx") >= 0);
 293
 294   assert (__builtin_cpu_supports ("popcnt") >= 0);
 295
 296   assert (__builtin_cpu_supports ("sse") >= 0);
 297
 298   assert (__builtin_cpu_supports ("sse2") >= 0);
 299
 300   assert (__builtin_cpu_supports ("sse3") >= 0);
 301
 302   assert (__builtin_cpu_supports ("ssse3") >= 0);
 303
 304   assert (__builtin_cpu_supports ("sse4.1") >= 0);
 305
 306   assert (__builtin_cpu_supports ("sse4.2") >= 0);
 307
 308   assert (__builtin_cpu_supports ("avx") >= 0);
 309
 310   assert (__builtin_cpu_supports ("avx2") >= 0);
 311
 312   assert (__builtin_cpu_supports ("avx512f") >= 0);
 313
 314   /* Check CPU type.  */
 315   assert (__builtin_cpu_is ("amd") >= 0);
 316
 317   assert (__builtin_cpu_is ("intel") >= 0);
 318
 319   assert (__builtin_cpu_is ("atom") >= 0);
 320
 321   assert (__builtin_cpu_is ("core2") >= 0);
 322
 323   assert (__builtin_cpu_is ("corei7") >= 0);
 324
 325   assert (__builtin_cpu_is ("nehalem") >= 0);
 326
 327   assert (__builtin_cpu_is ("westmere") >= 0);
 328
 329   assert (__builtin_cpu_is ("sandybridge") >= 0);
 330
 331   assert (__builtin_cpu_is ("amdfam10h") >= 0);
 332
 333   assert (__builtin_cpu_is ("barcelona") >= 0);
 334
 335   assert (__builtin_cpu_is ("shanghai") >= 0);
 336
 337   assert (__builtin_cpu_is ("istanbul") >= 0);
 338
 339   assert (__builtin_cpu_is ("amdfam15h") >= 0);
 340
 341   assert (__builtin_cpu_is ("bdver1") >= 0);
 342
 343   assert (__builtin_cpu_is ("bdver2") >= 0);
 344
 345   return 0;
 346 }
 347
 348 int main ()
 349 {
 350   __builtin_cpu_init ();
 351   quick_check ();
 352   check_detailed ();
 353   return 0;
 354 }