Avoid calling memchr with a zero range as this is undefined behavior.

src/string-search.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_STRING_SEARCH_H_
 #define V8_STRING_SEARCH_H_
 
 namespace v8 {
 namespace internal {
 
@@ skipping 84 matching lines @@
       StringSearch<PatternChar, SubjectChar>*,
       Vector<const SubjectChar>,
       int);
 
   static int FailSearch(StringSearch<PatternChar, SubjectChar>*,
                         Vector<const SubjectChar>,
                         int) {
     return -1;
   }
 
+  static inline const SubjectChar* SafeMemChr(const SubjectChar* string,
+                                              PatternChar pattern_char,
+                                              size_t search_length) {
+    if (search_length == 0) {
+      return NULL;
+    } else {
+      return reinterpret_cast<const SubjectChar*>(
+          memchr(string, pattern_char, search_length));
+    }
+  }
+
   static int SingleCharSearch(StringSearch<PatternChar, SubjectChar>* search,
                               Vector<const SubjectChar> subject,
                               int start_index);
 
   static int LinearSearch(StringSearch<PatternChar, SubjectChar>* search,
                           Vector<const SubjectChar> subject,
                           int start_index);
 
   static int InitialSearch(StringSearch<PatternChar, SubjectChar>* search,
                            Vector<const SubjectChar> subject,
@@ skipping 78 matching lines @@
 
 template <typename PatternChar, typename SubjectChar>
 int StringSearch<PatternChar, SubjectChar>::SingleCharSearch(
     StringSearch<PatternChar, SubjectChar>* search,
     Vector<const SubjectChar> subject,
     int index) {
   ASSERT_EQ(1, search->pattern_.length());
   PatternChar pattern_first_char = search->pattern_[0];
   int i = index;
   if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
-    const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
-        memchr(subject.start() + i,
-               pattern_first_char,
-               subject.length() - i));
+    const SubjectChar* pos = SafeMemChr(subject.start() + i, pattern_first_char,
+                                        subject.length() - i);
     if (pos == NULL) return -1;
     return static_cast<int>(pos - subject.start());
   } else {
     if (sizeof(PatternChar) > sizeof(SubjectChar)) {
       if (exceedsOneByte(pattern_first_char)) {
         return -1;
       }
     }
     SubjectChar search_char = static_cast<SubjectChar>(pattern_first_char);
     int n = subject.length();
@@ skipping 32 matching lines @@
     Vector<const SubjectChar> subject,
     int index) {
   Vector<const PatternChar> pattern = search->pattern_;
   ASSERT(pattern.length() > 1);
   int pattern_length = pattern.length();
   PatternChar pattern_first_char = pattern[0];
   int i = index;
   int n = subject.length() - pattern_length;
   while (i <= n) {
     if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
-      const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
-          memchr(subject.start() + i,
-                 pattern_first_char,
-                 n - i + 1));
+      const SubjectChar* pos =
+          SafeMemChr(subject.start() + i, pattern_first_char, n - i + 1);
       if (pos == NULL) return -1;
       i = static_cast<int>(pos - subject.start()) + 1;
     } else {
       if (subject[i++] != pattern_first_char) continue;
     }
     // Loop extracted to separate function to allow using return to do
     // a deeper break.
     if (CharCompare(pattern.start() + 1,
                     subject.start() + i,
                     pattern_length - 1)) {
@@ skipping 227 matching lines @@
   // algorithm.
   int badness = -10 - (pattern_length << 2);
 
   // We know our pattern is at least 2 characters, we cache the first so
   // the common case of the first character not matching is faster.
   PatternChar pattern_first_char = pattern[0];
   for (int i = index, n = subject.length() - pattern_length; i <= n; i++) {
     badness++;
     if (badness <= 0) {
       if (sizeof(SubjectChar) == 1 && sizeof(PatternChar) == 1) {
-        const SubjectChar* pos = reinterpret_cast<const SubjectChar*>(
-            memchr(subject.start() + i,
-                   pattern_first_char,
-                   n - i + 1));
+        const SubjectChar* pos =
+            SafeMemChr(subject.start() + i, pattern_first_char, n - i + 1);
         if (pos == NULL) {
           return -1;
         }
         i = static_cast<int>(pos - subject.start());
       } else {
         if (subject[i] != pattern_first_char) continue;
       }
       int j = 1;
       do {
         if (pattern[j] != subject[i + j]) {
@@ skipping 24 matching lines @@
                  Vector<const SubjectChar> subject,
                  Vector<const PatternChar> pattern,
                  int start_index) {
   StringSearch<PatternChar, SubjectChar> search(isolate, pattern);
   return search.Search(subject, start_index);
 }
 
 }}  // namespace v8::internal
 
 #endif  // V8_STRING_SEARCH_H_