[regexp] Fix incorrect DCHECK in FixSingleCharacterDisjunctions

src/regexp/jsregexp.cc

 // Copyright 2012 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.
 
 #include "src/regexp/jsregexp.h"
 
 #include <memory>
 
 #include "src/base/platform/platform.h"
 #include "src/compilation-cache.h"
@@ skipping 5334 matching lines @@
   alternatives->Rewind(write_posn);  // Trim end of array.
 }
 
 
 // Optimizes b|c|z to [bcz].
 void RegExpDisjunction::FixSingleCharacterDisjunctions(
     RegExpCompiler* compiler) {
   Zone* zone = compiler->zone();
   ZoneList<RegExpTree*>* alternatives = this->alternatives();
   int length = alternatives->length();
+  const bool unicode = compiler->unicode();
 
   int write_posn = 0;
   int i = 0;
   while (i < length) {
     RegExpTree* alternative = alternatives->at(i);
     if (!alternative->IsAtom()) {
       alternatives->at(write_posn++) = alternatives->at(i);
       i++;
       continue;
     }
     RegExpAtom* atom = alternative->AsAtom();
     if (atom->length() != 1) {
       alternatives->at(write_posn++) = alternatives->at(i);
       i++;
       continue;
     }
-    DCHECK(!unibrow::Utf16::IsLeadSurrogate(atom->data().at(0)));
+    DCHECK_IMPLIES(unicode,
+                   !unibrow::Utf16::IsLeadSurrogate(atom->data().at(0)));
     bool contains_trail_surrogate =
         unibrow::Utf16::IsTrailSurrogate(atom->data().at(0));
     int first_in_run = i;
     i++;
     while (i < length) {
       alternative = alternatives->at(i);
       if (!alternative->IsAtom()) break;
       atom = alternative->AsAtom();
       if (atom->length() != 1) break;
-      DCHECK(!unibrow::Utf16::IsLeadSurrogate(atom->data().at(0)));
+      DCHECK_IMPLIES(unicode,
+                     !unibrow::Utf16::IsLeadSurrogate(atom->data().at(0)));
       contains_trail_surrogate |=
           unibrow::Utf16::IsTrailSurrogate(atom->data().at(0));
       i++;
     }
     if (i > first_in_run + 1) {
       // Found non-trivial run of single-character alternatives.
       int run_length = i - first_in_run;
       ZoneList<CharacterRange>* ranges =
           new (zone) ZoneList<CharacterRange>(2, zone);
       for (int j = 0; j < run_length; j++) {
         RegExpAtom* old_atom = alternatives->at(j + first_in_run)->AsAtom();
         DCHECK_EQ(old_atom->length(), 1);
         ranges->Add(CharacterRange::Singleton(old_atom->data().at(0)), zone);
       }
       RegExpCharacterClass::Flags flags;
-      if (compiler->unicode() && contains_trail_surrogate) {
+      if (unicode && contains_trail_surrogate) {
         flags = RegExpCharacterClass::CONTAINS_SPLIT_SURROGATE;
       }
       alternatives->at(write_posn++) =
           new (zone) RegExpCharacterClass(ranges, flags);
     } else {
       // Just copy any trivial alternatives.
       for (int j = first_in_run; j < i; j++) {
         alternatives->at(write_posn++) = alternatives->at(j);
       }
     }
@@ skipping 1524 matching lines @@
 
 
 void RegExpResultsCache::Clear(FixedArray* cache) {
   for (int i = 0; i < kRegExpResultsCacheSize; i++) {
     cache->set(i, Smi::kZero);
   }
 }
 
 }  // namespace internal
 }  // namespace v8