Line data    Source code

       1             : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* vim: set ts=8 sts=2 et sw=2 tw=80: */
       3             : /* This Source Code Form is subject to the terms of the Mozilla Public
       4             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       5             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #include <stdint.h>
       8             : 
       9             : namespace mozilla {
      10             : 
      11       17071 : inline bool IsASCII(char16_t aChar) {
      12       17071 :   return (aChar & 0xFF80) == 0;
      13             : }
      14             : 
      15             : /**
      16             :  * Provides a pointer before or equal to |aPtr| that is is suitably aligned.
      17             :  */
      18        8094 : inline const char16_t* aligned(const char16_t* aPtr, const uintptr_t aMask)
      19             : {
      20             :   return reinterpret_cast<const char16_t*>(
      21        8094 :       reinterpret_cast<const uintptr_t>(aPtr) & ~aMask);
      22             : }
      23             : 
      24             : /**
      25             :  * Structures for word-sized vectorization of ASCII checking for UTF-16
      26             :  * strings.
      27             :  */
      28             : template<size_t size> struct NonASCIIParameters;
      29             : template<> struct NonASCIIParameters<4> {
      30             :   static inline size_t mask() { return 0xff80ff80; }
      31             :   static inline uintptr_t alignMask() { return 0x3; }
      32             :   static inline size_t numUnicharsPerWord() { return 2; }
      33             : };
      34             : 
      35             : template<> struct NonASCIIParameters<8> {
      36        4047 :   static inline size_t mask() {
      37             :     static const uint64_t maskAsUint64 = UINT64_C(0xff80ff80ff80ff80);
      38             :     // We have to explicitly cast this 64-bit value to a size_t, or else
      39             :     // compilers for 32-bit platforms will warn about it being too large to fit
      40             :     // in the size_t return type. (Fortunately, this code isn't actually
      41             :     // invoked on 32-bit platforms -- they'll use the <4> specialization above.
      42             :     // So it is, in fact, OK that this value is too large for a 32-bit size_t.)
      43        4047 :     return (size_t)maskAsUint64;
      44             :   }
      45        4047 :   static inline uintptr_t alignMask() { return 0x7; }
      46        4047 :   static inline size_t numUnicharsPerWord() { return 4; }
      47             : };
      48             : 
      49             : namespace SSE2 {
      50             : 
      51             : int32_t FirstNonASCII(const char16_t* aBegin, const char16_t* aEnd);
      52             : 
      53             : } // namespace SSE2
      54             : } // namespace mozilla