Add AVX2 detection

base/cpu_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/cpu.h"
 #include "build/build_config.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if _MSC_VER >= 1700
+// C4752: found Intel(R) Advanced Vector Extensions; consider using /arch:AVX.
+#pragma warning(disable: 4752)
+#endif
+
 // Tests whether we can run extended instructions represented by the CPU
 // information. This test actually executes some extended instructions (such as
 // MMX, SSE, etc.) supported by the CPU and sees we can run them without
 // "undefined instruction" exceptions. That is, this test succeeds when this
 // test finishes without a crash.
 TEST(CPU, RunExtendedInstructions) {
 #if defined(ARCH_CPU_X86_FAMILY)
   // Retrieve the CPU information.
   base::CPU cpu;
 
+  ASSERT_TRUE(cpu.has_mmx());
+  ASSERT_TRUE(cpu.has_sse());
+  ASSERT_TRUE(cpu.has_sse2());
+
+#if  defined(__x86_64__) || defined(__i386__)

[Mark Mentovai, 2015/10/01 17:54:14]

Can you use the build/build_config.h macros for this?

This should be defined(COMPILER_GCC). (And there’s a space between if and
defined that you should get rid of.)

[fbarchard, 2015/10/01 18:42:06]

Done.
Caveat The intent here is clangcl support for intel cpus.
COMPILER_GCC is not set by clangcl.
Its not the compiler that matters, (icc and icl should also work), its the
instruction set syntax.

To test with clangcl 32 bit:
set GYP_DEFINES=clang=1 component=shared_library fastbuild=1 target_arch=ia32
test_isolation_mode=prepare
python build\gyp_chromium -fninja chrome\chrome.gyp

My goal was to add and test the AVX and AVX2 instructions.
The testing is complete, so I've changed to COMPILER_GCC but cant test with
clang or win64.
Can revisit the clang/win64 issue.

+  // Execute an MMX instruction.
+  __asm__ __volatile__("emms\n" : : : "mm0");
+
+  // Execute an SSE instruction.
+  __asm__ __volatile__("xorps %%xmm0, %%xmm0\n" : : : "xmm0");
+
+  // Execute an SSE 2 instruction.
+  __asm__ __volatile__("psrldq $0, %%xmm0\n" : : : "xmm0");
+
+  if (cpu.has_sse3()) {
+    // Execute an SSE 3 instruction.
+    __asm__ __volatile__("addsubpd %%xmm0, %%xmm0\n" : : : "xmm0");
+  }
+
+  if (cpu.has_ssse3()) {
+    // Execute a Supplimental SSE 3 instruction.
+    __asm__ __volatile__("psignb %%xmm0, %%xmm0\n" : : : "xmm0");
+  }
+
+  if (cpu.has_sse41()) {
+    // Execute an SSE 4.1 instruction.
+    __asm__ __volatile__("pmuldq %%xmm0, %%xmm0\n" : : : "xmm0");
+  }
+
+  if (cpu.has_sse42()) {
+    // Execute an SSE 4.2 instruction.
+    __asm__ __volatile__("crc32 %%eax, %%eax\n" : : : "eax");
+  }
+
+  if (cpu.has_avx()) {
+    // Execute an AVX instruction.
+    __asm__ __volatile__("vzeroupper\n" : : : "xmm0");

[Mark Mentovai, 2015/10/01 17:54:15]

This actually clobbers ymmh0 (but not the low xmm0 portion). Do clang/gcc not
allow you to express that?

[fbarchard, 2015/10/01 18:42:06]

clang/gcc do not let you say clobber ymm0.

+  }
+
+  if (cpu.has_avx2()) {
+    // Execute an AVX 2 instruction.
+    __asm__ __volatile__("vpunpcklbw %%ymm0, %%ymm0, %%ymm0\n" : : : "xmm0");

[Mark Mentovai, 2015/10/01 17:54:14]

Same here, this clobbers all of ymm0.

[fbarchard, 2015/10/01 18:42:06]

Acknowledged.

+  }
+
 // TODO(jschuh): crbug.com/168866 Find a way to enable this on Win64.
-#if defined(OS_WIN) && !defined(_M_X64)
-  ASSERT_TRUE(cpu.has_mmx());
+#elif defined(_M_IX86)

[Mark Mentovai, 2015/10/01 17:54:15]

defined(COPMILER_MSVC) && defined(ARCH_CPU_X86)

[fbarchard, 2015/10/01 18:42:06]

Done.
I'd prefer not make it specific to Microsoft Visual C?
It works with other x86 compilers.

 
   // Execute an MMX instruction.
   __asm emms;

[Mark Mentovai, 2015/10/01 17:54:15]

Are there intrinsics that you can use so that this works for 64-bit Windows too?
That’s the easiest way to fix the TODO above.

[fbarchard, 2015/10/01 18:42:06]

Acknowledged.
Its possible, but not trivial.
purpose of this CL is avx2 detect/metrics, so I used the existing framerwork to
add the tests.

 
-  if (cpu.has_sse()) {
-    // Execute an SSE instruction.
-    __asm xorps xmm0, xmm0;
-  }
+  // Execute an SSE instruction.
+  __asm xorps xmm0, xmm0;
 
-  if (cpu.has_sse2()) {
-    // Execute an SSE 2 instruction.
-    __asm psrldq xmm0, 0;
-  }
+  // Execute an SSE 2 instruction.
+  __asm psrldq xmm0, 0;
 
   if (cpu.has_sse3()) {
     // Execute an SSE 3 instruction.
     __asm addsubpd xmm0, xmm0;
   }
 
   if (cpu.has_ssse3()) {
     // Execute a Supplimental SSE 3 instruction.
     __asm psignb xmm0, xmm0;
   }
 
   if (cpu.has_sse41()) {
     // Execute an SSE 4.1 instruction.
     __asm pmuldq xmm0, xmm0;
   }
 
   if (cpu.has_sse42()) {
     // Execute an SSE 4.2 instruction.
     __asm crc32 eax, eax;
   }
-#elif defined(OS_POSIX) && defined(__x86_64__)
-  ASSERT_TRUE(cpu.has_mmx());
 
-  // Execute an MMX instruction.
-  __asm__ __volatile__("emms\n" : : : "mm0");
-
-  if (cpu.has_sse()) {
-    // Execute an SSE instruction.
-    __asm__ __volatile__("xorps %%xmm0, %%xmm0\n" : : : "xmm0");
+// Visual C 2012 required for AVX.
+#if _MSC_VER >= 1700
+  if (cpu.has_avx()) {
+    // Execute an AVX instruction.
+    __asm vzeroupper;
   }
 
-  if (cpu.has_sse2()) {
-    // Execute an SSE 2 instruction.
-    __asm__ __volatile__("psrldq $0, %%xmm0\n" : : : "xmm0");
+  if (cpu.has_avx2()) {
+    // Execute an AVX 2 instruction.
+    __asm vpunpcklbw ymm0, ymm0, ymm0
   }
-
-  if (cpu.has_sse3()) {
-    // Execute an SSE 3 instruction.
-    __asm__ __volatile__("addsubpd %%xmm0, %%xmm0\n" : : : "xmm0");
-  }
-
-  if (cpu.has_ssse3()) {
-    // Execute a Supplimental SSE 3 instruction.
-    __asm__ __volatile__("psignb %%xmm0, %%xmm0\n" : : : "xmm0");
-  }
-
-  if (cpu.has_sse41()) {
-    // Execute an SSE 4.1 instruction.
-    __asm__ __volatile__("pmuldq %%xmm0, %%xmm0\n" : : : "xmm0");
-  }
-
-  if (cpu.has_sse42()) {
-    // Execute an SSE 4.2 instruction.
-    __asm__ __volatile__("crc32 %%eax, %%eax\n" : : : "eax");
-  }
-#endif
-#endif
+#endif  // _MSC_VER >= 1700
+#endif  // defined(__x86_64__) || defined(__i386__)
+#endif  // defined(ARCH_CPU_X86_FAMILY)
 }