Fix static initializers in cc/raster/texture_compressor_etc1_sse.cc

cc/raster/texture_compressor_etc1_sse.cc

 // Copyright 2015 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 "cc/raster/texture_compressor_etc1_sse.h"
 
 #include <emmintrin.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
   // This is used to store raw data.
   uint8_t* block;
   // This is used to store 8 bit packed values.
   __m128i* packed;
   // This is used to store 32 bit zero extended values into 4x4 arrays.
   __m128i* blue;
   __m128i* green;
   __m128i* red;
 };
 
-// Commonly used registers throughout the code.
-static const __m128i __sse_zero = _mm_set1_epi32(0);
-static const __m128i __sse_max_int = _mm_set1_epi32(0x7FFFFFFF);
-
 inline __m128i AddAndClamp(const __m128i x, const __m128i y) {
   static const __m128i color_max = _mm_set1_epi32(0xFF);
-  return _mm_max_epi16(__sse_zero,
+  return _mm_max_epi16(_mm_setzero_si128(),
                        _mm_min_epi16(_mm_add_epi16(x, y), color_max));
 }
 
 inline __m128i GetColorErrorSSE(const __m128i x, const __m128i y) {
   // Changed from _mm_mullo_epi32 (SSE4) to _mm_mullo_epi16 (SSE2).
   __m128i ret = _mm_sub_epi16(x, y);
   return _mm_mullo_epi16(ret, ret);
 }
 
 inline __m128i AddChannelError(const __m128i x,
                                const __m128i y,
                                const __m128i z) {
   return _mm_add_epi32(x, _mm_add_epi32(y, z));
 }
 
 inline uint32_t SumSSE(const __m128i x) {
   __m128i sum = _mm_add_epi32(x, _mm_shuffle_epi32(x, 0x4E));
   sum = _mm_add_epi32(sum, _mm_shuffle_epi32(sum, 0xB1));
 
   return _mm_cvtsi128_si32(sum);
 }
 
 inline uint32_t GetVerticalError(const __sse_data* data,
                                  const __m128i* blue_avg,
                                  const __m128i* green_avg,
                                  const __m128i* red_avg,
                                  uint32_t* verror) {
-  __m128i error = __sse_zero;
+  __m128i error = _mm_setzero_si128();
 
   for (int i = 0; i < 4; i++) {
     error = _mm_add_epi32(error, GetColorErrorSSE(data->blue[i], blue_avg[0]));
     error =
         _mm_add_epi32(error, GetColorErrorSSE(data->green[i], green_avg[0]));
     error = _mm_add_epi32(error, GetColorErrorSSE(data->red[i], red_avg[0]));
   }
 
   error = _mm_add_epi32(error, _mm_shuffle_epi32(error, 0x4E));
 
   verror[0] = _mm_cvtsi128_si32(error);
   verror[1] = _mm_cvtsi128_si32(_mm_shuffle_epi32(error, 0xB1));
 
   return verror[0] + verror[1];
 }
 
 inline uint32_t GetHorizontalError(const __sse_data* data,
                                    const __m128i* blue_avg,
                                    const __m128i* green_avg,
                                    const __m128i* red_avg,
                                    uint32_t* verror) {
-  __m128i error = __sse_zero;
+  __m128i error = _mm_setzero_si128();
   int first_index, second_index;
 
   for (int i = 0; i < 2; i++) {
     first_index = 2 * i;
     second_index = first_index + 1;
 
     error = _mm_add_epi32(
         error, GetColorErrorSSE(data->blue[first_index], blue_avg[i]));
     error = _mm_add_epi32(
         error, GetColorErrorSSE(data->blue[second_index], blue_avg[i]));
@@ skipping 186 matching lines @@
 
   for (unsigned int tbl_idx = 0; tbl_idx < 8; ++tbl_idx) {
     tmp = _mm_set_epi32(
         g_codeword_tables[tbl_idx][3], g_codeword_tables[tbl_idx][2],
         g_codeword_tables[tbl_idx][1], g_codeword_tables[tbl_idx][0]);
 
     test_blue = AddAndClamp(tmp, base_blue);
     test_green = AddAndClamp(tmp, base_green);
     test_red = AddAndClamp(tmp, base_red);
 
-    first_half_min = __sse_max_int;
-    second_half_min = __sse_max_int;
+    first_half_min = _mm_set1_epi32(0x7FFFFFFF);
+    second_half_min = _mm_set1_epi32(0x7FFFFFFF);
 
-    first_half_pattern = __sse_zero;
-    second_half_pattern = __sse_zero;
+    first_half_pattern = _mm_setzero_si128();
+    second_half_pattern = _mm_setzero_si128();
 
     for (uint8_t imm8 : shuffle_mask) {
       switch (imm8) {
         case 0x1B:
           tmp_blue = _mm_shuffle_epi32(test_blue, 0x1B);
           tmp_green = _mm_shuffle_epi32(test_green, 0x1B);
           tmp_red = _mm_shuffle_epi32(test_red, 0x1B);
           break;
         case 0x4E:
           tmp_blue = _mm_shuffle_epi32(test_blue, 0x4E);
@@ skipping 493 matching lines @@
         data.blue = blue;
         data.green = green;
 
         CompressBlock(dst, &data);
       }
     }
   }
 }
 
 }  // namespace cc