* Changed search for single ASCII character to use memchr.

src/runtime.cc

 // Copyright 2006-2008 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 1223 matching lines @@
       idx += shift;
     }
   } while (idx <= n - m);
 
   return -1;
 }
 
 
 template <typename schar>
 static int SingleCharIndexOf(Vector<const schar> string,
-                             uc16 pattern_char,
+                             schar pattern_char,
                              int start_index) {
-  if (sizeof(schar) == 1 && pattern_char > String::kMaxAsciiCharCode) {
-    return -1;
-  }
   for (int i = start_index, n = string.length(); i < n; i++) {
     if (pattern_char == string[i]) {
       return i;
     }
   }
   return -1;
 }
 
 // Trivial string search for shorter strings.
 // On return, if "complete" is set to true, the return value is the
@@ skipping 114 matching lines @@
     FlattenString(sub);
     sub_shape = StringShape(*sub);
   }
   StringShape pat_shape(*pat);
   // Searching for one specific character is common.  For one
   // character patterns linear search is necessary, so any smart
   // algorithm is unnecessary overhead.
   if (pattern_length == 1) {
     AssertNoAllocation no_heap_allocation;  // ensure vectors stay valid
     if (sub_shape.IsAsciiRepresentation()) {
-      return SingleCharIndexOf(sub->ToAsciiVector(),
-                               pat->Get(pat_shape, 0),
-                               start_index);
+      uc16 pchar = pat->Get(pat_shape, 0);
+      if (pchar > String::kMaxAsciiCharCode) {
+        return -1;
+      }
+      Vector<const char> ascii_vector =
+        sub->ToAsciiVector().SubVector(start_index, subject_length);
+      void* pos = memchr(ascii_vector.start(),
+                         static_cast<const char>(pchar),
+                         static_cast<size_t>(ascii_vector.length()));
+      if (pos == NULL) {
+        return -1;
+      }
+      return reinterpret_cast<char*>(pos) - ascii_vector.start() + start_index;
     }
     return SingleCharIndexOf(sub->ToUC16Vector(),
                              pat->Get(pat_shape, 0),
                              start_index);
   }
 
   if (!pat->IsFlat(pat_shape)) {
     FlattenString(pat);
     pat_shape = StringShape(*pat);
     sub_shape = StringShape(*sub);
@@ skipping 4504 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     Heap::CollectAllGarbage();
   }
 }
 
 
 } }  // namespace v8::internal