Port the __SSE2__ code to Visual C++.

net/tools/balsa/balsa_frame.cc

 // Copyright 2013 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 "net/tools/balsa/balsa_frame.h"
 
+// Visual C++ defines _M_IX86_FP as 2 if the /arch:SSE2 compiler option is
+// specified.
+#if !defined(__SSE2__) && _M_IX86_FP == 2
+#define __SSE2__ 1
+#endif
+
 #include <assert.h>
 #if __SSE2__
 #include <emmintrin.h>
 #endif  // __SSE2__
 
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/port.h"
 #include "base/strings/string_piece.h"
 #include "net/tools/balsa/balsa_enums.h"
 #include "net/tools/balsa/balsa_headers.h"
 #include "net/tools/balsa/balsa_visitor_interface.h"
 #include "net/tools/balsa/buffer_interface.h"
 #include "net/tools/balsa/simple_buffer.h"
 #include "net/tools/balsa/split.h"
 #include "net/tools/balsa/string_piece_utils.h"
 
 #if defined(COMPILER_MSVC)
+#include <intrin.h>
 #include <string.h>
+
+#pragma intrinsic(_BitScanForward)
+
+static int ffs(int i) {
+  unsigned long index;
+  return _BitScanForward(&index, i) ? index + 1 : 0;
+}
+
 #define strncasecmp _strnicmp
 #else
 #include <strings.h>
 #endif
 
 namespace net {
 
 // Constants holding some header names for headers which can affect the way the
 // HTTP message is framed, and so must be processed specially:
 static const char kContentLength[] = "content-length";
@@ skipping 456 matching lines @@
   DCHECK_GE(current_header_line->last_char_idx,
             current_header_line->value_begin_idx);
 }
 
 inline void BalsaFrame::FindColonsAndParseIntoKeyValue() {
   DCHECK(!lines_.empty());
   const char* stream_begin = headers_->OriginalHeaderStreamBegin();
   // The last line is always just a newline (and is uninteresting).
   const Lines::size_type lines_size_m1 = lines_.size() - 1;
 #if __SSE2__
-  const __v16qi colons = { ':', ':', ':', ':', ':', ':', ':', ':',
-                           ':', ':', ':', ':', ':', ':', ':', ':'};
+  const __m128i colons = _mm_set1_epi8(':');
   const char* header_lines_end_m16 = headers_->OriginalHeaderStreamEnd() - 16;
 #endif  // __SSE2__
   const char* current = stream_begin + lines_[1].first;
   // This code is a bit more subtle than it may appear at first glance.
   // This code looks for a colon in the current line... but it also looks
   // beyond the current line. If there is no colon in the current line, then
   // for each subsequent line (until the colon which -has- been found is
   // associated with a line), no searching for a colon will be performed. In
   // this way, we minimize the amount of bytes we have scanned for a colon.
   for (Lines::size_type i = 1; i < lines_size_m1;) {
@@ skipping 50 matching lines @@
       // When this condition is true, the last detected colon was part of a
       // previous line.  We reset to the beginning of the line as we don't care
       // about the presence of any colon before the beginning of the current
       // line.
       current = line_begin;
     }
 #if __SSE2__
     while (current < header_lines_end_m16) {
       __m128i header_bytes =
         _mm_loadu_si128(reinterpret_cast<const __m128i *>(current));
-      __m128i colon_cmp =
-        _mm_cmpeq_epi8(header_bytes, reinterpret_cast<__m128i>(colons));
+      __m128i colon_cmp = _mm_cmpeq_epi8(header_bytes, colons);
       int colon_msk = _mm_movemask_epi8(colon_cmp);
       if (colon_msk == 0) {
         current += 16;
         continue;
       }
       current += (ffs(colon_msk) - 1);
       if (current > line_end) {
         break;
       }
       goto found_colon;
@@ skipping 385 matching lines @@
         }
         ++message_current;
       } while (message_current < message_end);
       goto bottom;  // this is necessary to skip 'last_char_was_slash_r' checks
     } else {
  read_real_message:
       // Note that SSE2 can be enabled on certain piii platforms.
 #if __SSE2__
       {
         const char* const message_end_m16 = message_end - 16;
-        __v16qi newlines = { '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n',
-                             '\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n' };
+        __m128i newlines = _mm_set1_epi8('\n');
         while (message_current < message_end_m16) {
           // What this does (using compiler intrinsics):
           //
           // Load 16 '\n's into an xmm register
           // Load 16 bytes of currennt message into an xmm register
           // Do byte-wise equals on those two xmm registers
           // Take the first bit of each byte, and put that into the first
           //   16 bits of a mask
           // If the mask is zero, no '\n' found. increment by 16 and try again
           // Else scan forward to find the first set bit.
           // Increment current by the index of the first set bit
           //   (ffs returns index of first set bit + 1)
           __m128i msg_bytes =
             _mm_loadu_si128(const_cast<__m128i *>(
                     reinterpret_cast<const __m128i *>(message_current)));
-          __m128i newline_cmp =
-            _mm_cmpeq_epi8(msg_bytes, reinterpret_cast<__m128i>(newlines));
+          __m128i newline_cmp = _mm_cmpeq_epi8(msg_bytes, newlines);
           int newline_msk = _mm_movemask_epi8(newline_cmp);
           if (newline_msk == 0) {
             message_current += 16;
             continue;
           }
           message_current += (ffs(newline_msk) - 1);
           const size_t relative_idx = message_current - message_start;
           const size_t message_current_idx = 1 + base_idx + relative_idx;
           lines_.push_back(std::make_pair(last_slash_n_idx_,
                                           message_current_idx));
@@ skipping 542 matching lines @@
     << "$$$$$$$$$$$$$$$"
     << " consumed: " << (current - input);
   if (Error()) {
     LOG(INFO) << BalsaFrameEnums::ErrorCodeToString(ErrorCode());
   }
 #endif  // DEBUGFRAMER
   return current - input;
 }
 
 }  // namespace net