build fix for 15023

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4285 matching lines @@
 
 
 bool String::IsOneByte() const {
   i::Handle<i::String> str = Utils::OpenHandle(this);
   if (IsDeadCheck(str->GetIsolate(), "v8::String::IsOneByte()")) {
     return false;
   }
   return str->HasOnlyOneByteChars();
 }
 
+// Helpers for ContainsOnlyOneByteHelper
+template<size_t size> struct OneByteMask;
+template<> struct OneByteMask<4> {
+  static const uint32_t value = 0xFF00FF00;
+};
+template<> struct OneByteMask<8> {
+  static const uint64_t value = 0xFF00FF00FF00FF00;
+};
+static const uintptr_t kOneByteMask = OneByteMask<sizeof(uintptr_t)>::value;
+static const uintptr_t kAlignmentMask = sizeof(uintptr_t) - 1;
+static inline bool Unaligned(const uint16_t* chars) {
+  return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask;
+}
+static inline const uint16_t* Align(const uint16_t* chars) {
+  return reinterpret_cast<uint16_t*>(
+    reinterpret_cast<uintptr_t>(chars) & ~kAlignmentMask);
+}
 
 class ContainsOnlyOneByteHelper {
  public:
   ContainsOnlyOneByteHelper() : is_one_byte_(true) {}
   bool Check(i::String* string) {
     i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
     if (cons_string == NULL) return is_one_byte_;
     return CheckCons(cons_string);
   }
   void VisitOneByteString(const uint8_t* chars, int length) {
@@ skipping 25 matching lines @@
     }
     // Read the rest.
     while (chars != end) {
       acc |= *chars++;
     }
     // Check result.
     if ((acc & kOneByteMask) != 0) is_one_byte_ = false;
   }
 
  private:
-  static const uintptr_t kOneByteMask =
-      static_cast<uintptr_t>(0xFF00FF00FF00FF00ULL);
-  static const uintptr_t kAlignmentMask = sizeof(uintptr_t) - 1;
-  static inline bool Unaligned(const uint16_t* chars) {
-    return reinterpret_cast<const uintptr_t>(chars) & kAlignmentMask;
-  }
-  static inline const uint16_t* Align(const uint16_t* chars) {
-    return reinterpret_cast<uint16_t*>(
-        reinterpret_cast<uintptr_t>(chars) & ~kAlignmentMask);
-  }
   bool CheckCons(i::ConsString* cons_string) {
     while (true) {
       // Check left side if flat.
       i::String* left = cons_string->first();
       i::ConsString* left_as_cons =
           i::String::VisitFlat(this, left, 0);
       if (!is_one_byte_) return false;
       // Check right side if flat.
       i::String* right = cons_string->second();
       i::ConsString* right_as_cons =
@@ skipping 3617 matching lines @@
 
   v->VisitPointers(blocks_.first(), first_block_limit_);
 
   for (int i = 1; i < blocks_.length(); i++) {
     v->VisitPointers(blocks_[i], &blocks_[i][kHandleBlockSize]);
   }
 }
 
 
 } }  // namespace v8::internal