Fix incorrectly disabled SSE2 WebAudio optimizations for Windows.

Source/platform/audio/VectorMath.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 17 matching lines @@
 
 #include "platform/audio/VectorMath.h"
 #include "wtf/Assertions.h"
 #include "wtf/CPU.h"
 #include <stdint.h>
 
 #if OS(MACOSX)
 #include <Accelerate/Accelerate.h>
 #endif
 
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
 #include <emmintrin.h>
 #endif
 
 #if HAVE(ARM_NEON_INTRINSICS)
 #include <arm_neon.h>
 #endif
 
 #include <math.h>
 #include <algorithm>
 
@@ skipping 79 matching lines @@
 #pragma float_control(except, off, push)
 #pragma float_control(precise, off, push)
 #pragma fp_contract(on)
 #pragma fenv_access(off)
 #endif
 
 void vsma(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess)
 {
     int n = framesToProcess;
 
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     if ((sourceStride == 1) && (destStride == 1)) {
         float k = *scale;
 
         // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
         while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
             *destP += k * *sourceP;
             sourceP++;
             destP++;
             n--;
         }
@@ skipping 52 matching lines @@
         sourceP += sourceStride;
         destP += destStride;
         n--;
     }
 }
 
 void vsmul(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess)
 {
     int n = framesToProcess;
 
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     if ((sourceStride == 1) && (destStride == 1)) {
         float k = *scale;
 
         // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
         while ((reinterpret_cast<size_t>(sourceP) & 0x0F) && n) {
             *destP = k * *sourceP;
             sourceP++;
             destP++;
             n--;
         }
@@ skipping 50 matching lines @@
         }
         n = tailFrames;
     }
 #endif
     float k = *scale;
     while (n--) {
         *destP = k * *sourceP;
         sourceP += sourceStride;
         destP += destStride;
     }
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     }
 #endif
 }
 
 void vadd(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess)
 {
     int n = framesToProcess;
 
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     if ((sourceStride1 ==1) && (sourceStride2 == 1) && (destStride == 1)) {
         // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
         while ((reinterpret_cast<size_t>(source1P) & 0x0F) && n) {
             *destP = *source1P + *source2P;
             source1P++;
             source2P++;
             destP++;
             n--;
         }
 
@@ skipping 82 matching lines @@
         }
         n = tailFrames;
     }
 #endif
     while (n--) {
         *destP = *source1P + *source2P;
         source1P += sourceStride1;
         source2P += sourceStride2;
         destP += destStride;
     }
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     }
 #endif
 }
 
 void vmul(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess)
 {
 
     int n = framesToProcess;
 
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
         // If the source1P address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
         while ((reinterpret_cast<uintptr_t>(source1P) & 0x0F) && n) {
             *destP = *source1P * *source2P;
             source1P++;
             source2P++;
             destP++;
             n--;
         }
 
@@ skipping 52 matching lines @@
         source1P += sourceStride1;
         source2P += sourceStride2;
         destP += destStride;
         n--;
     }
 }
 
 void zvmul(const float* real1P, const float* imag1P, const float* real2P, const float* imag2P, float* realDestP, float* imagDestP, size_t framesToProcess)
 {
     unsigned i = 0;
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     // Only use the SSE optimization in the very common case that all addresses are 16-byte aligned.
     // Otherwise, fall through to the scalar code below.
     if (!(reinterpret_cast<uintptr_t>(real1P) & 0x0F)
         && !(reinterpret_cast<uintptr_t>(imag1P) & 0x0F)
         && !(reinterpret_cast<uintptr_t>(real2P) & 0x0F)
         && !(reinterpret_cast<uintptr_t>(imag2P) & 0x0F)
         && !(reinterpret_cast<uintptr_t>(realDestP) & 0x0F)
         && !(reinterpret_cast<uintptr_t>(imagDestP) & 0x0F)) {
 
         unsigned endSize = framesToProcess - framesToProcess % 4;
@@ skipping 37 matching lines @@
         realDestP[i] = realResult;
         imagDestP[i] = imagResult;
     }
 }
 
 void vsvesq(const float* sourceP, int sourceStride, float* sumP, size_t framesToProcess)
 {
     int n = framesToProcess;
     float sum = 0;
 
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     if (sourceStride == 1) {
         // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
         while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
             float sample = *sourceP;
             sum += sample * sample;
             sourceP++;
             n--;
         }
 
         // Now the sourceP is aligned, use SSE.
@@ skipping 44 matching lines @@
 
     ASSERT(sumP);
     *sumP = sum;
 }
 
 void vmaxmgv(const float* sourceP, int sourceStride, float* maxP, size_t framesToProcess)
 {
     int n = framesToProcess;
     float max = 0;
 
-#ifdef __SSE2__
+#if CPU(X86) || CPU(X86_64)
     if (sourceStride == 1) {
         // If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
         while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
             max = std::max(max, fabsf(*sourceP));
             sourceP++;
             n--;
         }
 
         // Now the sourceP is aligned, use SSE.
         int tailFrames = n % 4;
@@ skipping 80 matching lines @@
     }
 }
 
 #endif // OS(MACOSX)
 
 } // namespace VectorMath
 
 } // namespace WebCore
 
 #endif // ENABLE(WEB_AUDIO)