Line data Source code
1 : // Copyright 2012 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/regexp/jsregexp.h"
6 :
7 : #include <memory>
8 : #include <vector>
9 :
10 : #include "src/base/platform/platform.h"
11 : #include "src/code-tracer.h"
12 : #include "src/compilation-cache.h"
13 : #include "src/elements.h"
14 : #include "src/execution.h"
15 : #include "src/heap/factory.h"
16 : #include "src/heap/heap-inl.h"
17 : #include "src/isolate-inl.h"
18 : #include "src/message-template.h"
19 : #include "src/ostreams.h"
20 : #include "src/regexp/interpreter-irregexp.h"
21 : #include "src/regexp/jsregexp-inl.h"
22 : #include "src/regexp/regexp-macro-assembler-irregexp.h"
23 : #include "src/regexp/regexp-macro-assembler-tracer.h"
24 : #include "src/regexp/regexp-macro-assembler.h"
25 : #include "src/regexp/regexp-parser.h"
26 : #include "src/regexp/regexp-stack.h"
27 : #include "src/runtime/runtime.h"
28 : #include "src/splay-tree-inl.h"
29 : #include "src/string-search.h"
30 : #include "src/unicode-decoder.h"
31 : #include "src/unicode-inl.h"
32 : #include "src/zone/zone-list-inl.h"
33 :
34 : #ifdef V8_INTL_SUPPORT
35 : #include "unicode/uniset.h"
36 : #include "unicode/utypes.h"
37 : #endif // V8_INTL_SUPPORT
38 :
39 : #if V8_TARGET_ARCH_IA32
40 : #include "src/regexp/ia32/regexp-macro-assembler-ia32.h"
41 : #elif V8_TARGET_ARCH_X64
42 : #include "src/regexp/x64/regexp-macro-assembler-x64.h"
43 : #elif V8_TARGET_ARCH_ARM64
44 : #include "src/regexp/arm64/regexp-macro-assembler-arm64.h"
45 : #elif V8_TARGET_ARCH_ARM
46 : #include "src/regexp/arm/regexp-macro-assembler-arm.h"
47 : #elif V8_TARGET_ARCH_PPC
48 : #include "src/regexp/ppc/regexp-macro-assembler-ppc.h"
49 : #elif V8_TARGET_ARCH_S390
50 : #include "src/regexp/s390/regexp-macro-assembler-s390.h"
51 : #elif V8_TARGET_ARCH_MIPS
52 : #include "src/regexp/mips/regexp-macro-assembler-mips.h"
53 : #elif V8_TARGET_ARCH_MIPS64
54 : #include "src/regexp/mips64/regexp-macro-assembler-mips64.h"
55 : #else
56 : #error Unsupported target architecture.
57 : #endif
58 :
59 : namespace v8 {
60 : namespace internal {
61 :
62 : V8_WARN_UNUSED_RESULT
63 3224 : static inline MaybeHandle<Object> ThrowRegExpException(
64 : Isolate* isolate, Handle<JSRegExp> re, Handle<String> pattern,
65 : Handle<String> error_text) {
66 6448 : THROW_NEW_ERROR(isolate, NewSyntaxError(MessageTemplate::kMalformedRegExp,
67 : pattern, error_text),
68 : Object);
69 : }
70 :
71 363 : inline void ThrowRegExpException(Isolate* isolate, Handle<JSRegExp> re,
72 : Handle<String> error_text) {
73 726 : USE(ThrowRegExpException(isolate, re, Handle<String>(re->Pattern(), isolate),
74 : error_text));
75 363 : }
76 :
77 :
78 0 : ContainedInLattice AddRange(ContainedInLattice containment,
79 : const int* ranges,
80 : int ranges_length,
81 : Interval new_range) {
82 : DCHECK_EQ(1, ranges_length & 1);
83 : DCHECK_EQ(String::kMaxCodePoint + 1, ranges[ranges_length - 1]);
84 993752 : if (containment == kLatticeUnknown) return containment;
85 : bool inside = false;
86 : int last = 0;
87 10385574 : for (int i = 0; i < ranges_length; inside = !inside, last = ranges[i], i++) {
88 : // Consider the range from last to ranges[i].
89 : // We haven't got to the new range yet.
90 5633991 : if (ranges[i] <= new_range.from()) continue;
91 : // New range is wholly inside last-ranges[i]. Note that new_range.to() is
92 : // inclusive, but the values in ranges are not.
93 882408 : if (last <= new_range.from() && new_range.to() < ranges[i]) {
94 865124 : return Combine(containment, inside ? kLatticeIn : kLatticeOut);
95 : }
96 : return kLatticeUnknown;
97 : }
98 : return containment;
99 : }
100 :
101 : // More makes code generation slower, less makes V8 benchmark score lower.
102 : const int kMaxLookaheadForBoyerMoore = 8;
103 : // In a 3-character pattern you can maximally step forwards 3 characters
104 : // at a time, which is not always enough to pay for the extra logic.
105 : const int kPatternTooShortForBoyerMoore = 2;
106 :
107 : // Identifies the sort of regexps where the regexp engine is faster
108 : // than the code used for atom matches.
109 176062 : static bool HasFewDifferentCharacters(Handle<String> pattern) {
110 : int length = Min(kMaxLookaheadForBoyerMoore, pattern->length());
111 176062 : if (length <= kPatternTooShortForBoyerMoore) return false;
112 : const int kMod = 128;
113 : bool character_found[kMod];
114 : int different = 0;
115 : memset(&character_found[0], 0, sizeof(character_found));
116 851831 : for (int i = 0; i < length; i++) {
117 511601 : int ch = (pattern->Get(i) & (kMod - 1));
118 511601 : if (!character_found[ch]) {
119 511181 : character_found[ch] = true;
120 511181 : different++;
121 : // We declare a regexp low-alphabet if it has at least 3 times as many
122 : // characters as it has different characters.
123 511181 : if (different * 3 > length) return false;
124 : }
125 : }
126 : return true;
127 : }
128 :
129 : // Generic RegExp methods. Dispatches to implementation specific methods.
130 :
131 460090 : MaybeHandle<Object> RegExpImpl::Compile(Isolate* isolate, Handle<JSRegExp> re,
132 : Handle<String> pattern,
133 : JSRegExp::Flags flags) {
134 : DCHECK(pattern->IsFlat());
135 :
136 920180 : Zone zone(isolate->allocator(), ZONE_NAME);
137 : CompilationCache* compilation_cache = isolate->compilation_cache();
138 : MaybeHandle<FixedArray> maybe_cached =
139 460090 : compilation_cache->LookupRegExp(pattern, flags);
140 : Handle<FixedArray> cached;
141 460090 : if (maybe_cached.ToHandle(&cached)) {
142 391598 : re->set_data(*cached);
143 195799 : return re;
144 : }
145 :
146 : PostponeInterruptsScope postpone(isolate);
147 : RegExpCompileData parse_result;
148 264291 : FlatStringReader reader(isolate, pattern);
149 : DCHECK(!isolate->has_pending_exception());
150 264291 : if (!RegExpParser::ParseRegExp(isolate, &zone, &reader, flags,
151 : &parse_result)) {
152 : // Throw an exception if we fail to parse the pattern.
153 2831 : return ThrowRegExpException(isolate, re, pattern, parse_result.error);
154 : }
155 :
156 : bool has_been_compiled = false;
157 :
158 770062 : if (parse_result.simple && !IgnoreCase(flags) && !IsSticky(flags) &&
159 169349 : !HasFewDifferentCharacters(pattern)) {
160 : // Parse-tree is a single atom that is equal to the pattern.
161 : AtomCompile(isolate, re, pattern, flags, pattern);
162 : has_been_compiled = true;
163 106678 : } else if (parse_result.tree->IsAtom() && !IsSticky(flags) &&
164 7237 : parse_result.capture_count == 0) {
165 7227 : RegExpAtom* atom = parse_result.tree->AsAtom();
166 7227 : Vector<const uc16> atom_pattern = atom->data();
167 : Handle<String> atom_string;
168 14454 : ASSIGN_RETURN_ON_EXCEPTION(
169 : isolate, atom_string,
170 : isolate->factory()->NewStringFromTwoByte(atom_pattern), Object);
171 7227 : if (!IgnoreCase(atom->flags()) && !HasFewDifferentCharacters(atom_string)) {
172 : AtomCompile(isolate, re, pattern, flags, atom_string);
173 : has_been_compiled = true;
174 : }
175 : }
176 261460 : if (!has_been_compiled) {
177 85486 : IrregexpInitialize(isolate, re, pattern, flags, parse_result.capture_count);
178 : }
179 : DCHECK(re->data()->IsFixedArray());
180 : // Compilation succeeded so the data is set on the regexp
181 : // and we can store it in the cache.
182 : Handle<FixedArray> data(FixedArray::cast(re->data()), isolate);
183 261460 : compilation_cache->PutRegExp(pattern, flags, data);
184 :
185 261460 : return re;
186 : }
187 :
188 4352029 : MaybeHandle<Object> RegExpImpl::Exec(Isolate* isolate, Handle<JSRegExp> regexp,
189 : Handle<String> subject, int index,
190 : Handle<RegExpMatchInfo> last_match_info) {
191 4352029 : switch (regexp->TypeTag()) {
192 : case JSRegExp::ATOM:
193 286 : return AtomExec(isolate, regexp, subject, index, last_match_info);
194 : case JSRegExp::IRREGEXP: {
195 4351743 : return IrregexpExec(isolate, regexp, subject, index, last_match_info);
196 : }
197 : default:
198 0 : UNREACHABLE();
199 : }
200 : }
201 :
202 :
203 : // RegExp Atom implementation: Simple string search using indexOf.
204 :
205 0 : void RegExpImpl::AtomCompile(Isolate* isolate, Handle<JSRegExp> re,
206 : Handle<String> pattern, JSRegExp::Flags flags,
207 : Handle<String> match_pattern) {
208 175974 : isolate->factory()->SetRegExpAtomData(re, JSRegExp::ATOM, pattern, flags,
209 175974 : match_pattern);
210 0 : }
211 :
212 273 : static void SetAtomLastCapture(Isolate* isolate,
213 : Handle<RegExpMatchInfo> last_match_info,
214 : String subject, int from, int to) {
215 : SealHandleScope shs(isolate);
216 : last_match_info->SetNumberOfCaptureRegisters(2);
217 546 : last_match_info->SetLastSubject(subject);
218 546 : last_match_info->SetLastInput(subject);
219 : last_match_info->SetCapture(0, from);
220 : last_match_info->SetCapture(1, to);
221 273 : }
222 :
223 90541 : int RegExpImpl::AtomExecRaw(Isolate* isolate, Handle<JSRegExp> regexp,
224 : Handle<String> subject, int index, int32_t* output,
225 : int output_size) {
226 : DCHECK_LE(0, index);
227 : DCHECK_LE(index, subject->length());
228 :
229 90541 : subject = String::Flatten(isolate, subject);
230 : DisallowHeapAllocation no_gc; // ensure vectors stay valid
231 :
232 90541 : String needle = String::cast(regexp->DataAt(JSRegExp::kAtomPatternIndex));
233 : int needle_len = needle->length();
234 : DCHECK(needle->IsFlat());
235 : DCHECK_LT(0, needle_len);
236 :
237 181082 : if (index + needle_len > subject->length()) {
238 : return RegExpImpl::RE_FAILURE;
239 : }
240 :
241 273479 : for (int i = 0; i < output_size; i += 2) {
242 181736 : String::FlatContent needle_content = needle->GetFlatContent(no_gc);
243 181736 : String::FlatContent subject_content = subject->GetFlatContent(no_gc);
244 : DCHECK(needle_content.IsFlat());
245 : DCHECK(subject_content.IsFlat());
246 : // dispatch on type of strings
247 : index =
248 : (needle_content.IsOneByte()
249 : ? (subject_content.IsOneByte()
250 : ? SearchString(isolate, subject_content.ToOneByteVector(),
251 : needle_content.ToOneByteVector(), index)
252 : : SearchString(isolate, subject_content.ToUC16Vector(),
253 : needle_content.ToOneByteVector(), index))
254 : : (subject_content.IsOneByte()
255 : ? SearchString(isolate, subject_content.ToOneByteVector(),
256 : needle_content.ToUC16Vector(), index)
257 : : SearchString(isolate, subject_content.ToUC16Vector(),
258 363472 : needle_content.ToUC16Vector(), index)));
259 181736 : if (index == -1) {
260 90266 : return i / 2; // Return number of matches.
261 : } else {
262 91470 : output[i] = index;
263 91470 : output[i+1] = index + needle_len;
264 : index += needle_len;
265 : }
266 : }
267 273 : return output_size / 2;
268 : }
269 :
270 286 : Handle<Object> RegExpImpl::AtomExec(Isolate* isolate, Handle<JSRegExp> re,
271 : Handle<String> subject, int index,
272 : Handle<RegExpMatchInfo> last_match_info) {
273 : static const int kNumRegisters = 2;
274 : STATIC_ASSERT(kNumRegisters <= Isolate::kJSRegexpStaticOffsetsVectorSize);
275 : int32_t* output_registers = isolate->jsregexp_static_offsets_vector();
276 :
277 : int res =
278 286 : AtomExecRaw(isolate, re, subject, index, output_registers, kNumRegisters);
279 :
280 299 : if (res == RegExpImpl::RE_FAILURE) return isolate->factory()->null_value();
281 :
282 : DCHECK_EQ(res, RegExpImpl::RE_SUCCESS);
283 : SealHandleScope shs(isolate);
284 273 : SetAtomLastCapture(isolate, last_match_info, *subject, output_registers[0],
285 273 : output_registers[1]);
286 273 : return last_match_info;
287 : }
288 :
289 :
290 : // Irregexp implementation.
291 :
292 : // Ensures that the regexp object contains a compiled version of the
293 : // source for either one-byte or two-byte subject strings.
294 : // If the compiled version doesn't already exist, it is compiled
295 : // from the source pattern.
296 : // If compilation fails, an exception is thrown and this function
297 : // returns false.
298 4472686 : bool RegExpImpl::EnsureCompiledIrregexp(Isolate* isolate, Handle<JSRegExp> re,
299 : Handle<String> sample_subject,
300 : bool is_one_byte) {
301 4472686 : Object compiled_code = re->DataAt(JSRegExp::code_index(is_one_byte));
302 4472686 : if (compiled_code != Smi::FromInt(JSRegExp::kUninitializedValue)) {
303 : DCHECK(FLAG_regexp_interpret_all ? compiled_code->IsByteArray()
304 : : compiled_code->IsCode());
305 : return true;
306 : }
307 85700 : return CompileIrregexp(isolate, re, sample_subject, is_one_byte);
308 : }
309 :
310 85700 : bool RegExpImpl::CompileIrregexp(Isolate* isolate, Handle<JSRegExp> re,
311 : Handle<String> sample_subject,
312 : bool is_one_byte) {
313 : // Compile the RegExp.
314 171400 : Zone zone(isolate->allocator(), ZONE_NAME);
315 : PostponeInterruptsScope postpone(isolate);
316 : #ifdef DEBUG
317 : Object entry = re->DataAt(JSRegExp::code_index(is_one_byte));
318 : // When arriving here entry can only be a smi representing an uncompiled
319 : // regexp.
320 : DCHECK(entry->IsSmi());
321 : int entry_value = Smi::ToInt(entry);
322 : DCHECK_EQ(JSRegExp::kUninitializedValue, entry_value);
323 : #endif
324 :
325 85700 : JSRegExp::Flags flags = re->GetFlags();
326 :
327 171400 : Handle<String> pattern(re->Pattern(), isolate);
328 85700 : pattern = String::Flatten(isolate, pattern);
329 : RegExpCompileData compile_data;
330 85700 : FlatStringReader reader(isolate, pattern);
331 85700 : if (!RegExpParser::ParseRegExp(isolate, &zone, &reader, flags,
332 : &compile_data)) {
333 : // Throw an exception if we fail to parse the pattern.
334 : // THIS SHOULD NOT HAPPEN. We already pre-parsed it successfully once.
335 30 : USE(ThrowRegExpException(isolate, re, pattern, compile_data.error));
336 30 : return false;
337 : }
338 : RegExpEngine::CompilationResult result =
339 : RegExpEngine::Compile(isolate, &zone, &compile_data, flags, pattern,
340 85670 : sample_subject, is_one_byte);
341 85670 : if (result.error_message != nullptr) {
342 : // Unable to compile regexp.
343 363 : if (FLAG_abort_on_stack_or_string_length_overflow &&
344 0 : strncmp(result.error_message, "Stack overflow", 15) == 0) {
345 0 : FATAL("Aborting on stack overflow");
346 : }
347 726 : Handle<String> error_message = isolate->factory()->NewStringFromUtf8(
348 363 : CStrVector(result.error_message)).ToHandleChecked();
349 363 : ThrowRegExpException(isolate, re, error_message);
350 : return false;
351 : }
352 :
353 : Handle<FixedArray> data =
354 : Handle<FixedArray>(FixedArray::cast(re->data()), isolate);
355 85307 : data->set(JSRegExp::code_index(is_one_byte), result.code);
356 85307 : SetIrregexpCaptureNameMap(*data, compile_data.capture_name_map);
357 : int register_max = IrregexpMaxRegisterCount(*data);
358 85307 : if (result.num_registers > register_max) {
359 : SetIrregexpMaxRegisterCount(*data, result.num_registers);
360 : }
361 :
362 : return true;
363 : }
364 :
365 0 : int RegExpImpl::IrregexpMaxRegisterCount(FixedArray re) {
366 : return Smi::cast(
367 0 : re->get(JSRegExp::kIrregexpMaxRegisterCountIndex))->value();
368 : }
369 :
370 0 : void RegExpImpl::SetIrregexpMaxRegisterCount(FixedArray re, int value) {
371 : re->set(JSRegExp::kIrregexpMaxRegisterCountIndex, Smi::FromInt(value));
372 0 : }
373 :
374 85307 : void RegExpImpl::SetIrregexpCaptureNameMap(FixedArray re,
375 : Handle<FixedArray> value) {
376 85307 : if (value.is_null()) {
377 84947 : re->set(JSRegExp::kIrregexpCaptureNameMapIndex, Smi::kZero);
378 : } else {
379 360 : re->set(JSRegExp::kIrregexpCaptureNameMapIndex, *value);
380 : }
381 85307 : }
382 :
383 0 : int RegExpImpl::IrregexpNumberOfCaptures(FixedArray re) {
384 0 : return Smi::ToInt(re->get(JSRegExp::kIrregexpCaptureCountIndex));
385 : }
386 :
387 0 : int RegExpImpl::IrregexpNumberOfRegisters(FixedArray re) {
388 0 : return Smi::ToInt(re->get(JSRegExp::kIrregexpMaxRegisterCountIndex));
389 : }
390 :
391 0 : ByteArray RegExpImpl::IrregexpByteCode(FixedArray re, bool is_one_byte) {
392 0 : return ByteArray::cast(re->get(JSRegExp::code_index(is_one_byte)));
393 : }
394 :
395 0 : Code RegExpImpl::IrregexpNativeCode(FixedArray re, bool is_one_byte) {
396 0 : return Code::cast(re->get(JSRegExp::code_index(is_one_byte)));
397 : }
398 :
399 0 : void RegExpImpl::IrregexpInitialize(Isolate* isolate, Handle<JSRegExp> re,
400 : Handle<String> pattern,
401 : JSRegExp::Flags flags, int capture_count) {
402 : // Initialize compiled code entries to null.
403 : isolate->factory()->SetRegExpIrregexpData(re, JSRegExp::IRREGEXP, pattern,
404 85486 : flags, capture_count);
405 0 : }
406 :
407 4359162 : int RegExpImpl::IrregexpPrepare(Isolate* isolate, Handle<JSRegExp> regexp,
408 : Handle<String> subject) {
409 : DCHECK(subject->IsFlat());
410 :
411 : // Check representation of the underlying storage.
412 4359162 : bool is_one_byte = String::IsOneByteRepresentationUnderneath(*subject);
413 4359162 : if (!EnsureCompiledIrregexp(isolate, regexp, subject, is_one_byte)) return -1;
414 :
415 4358769 : if (FLAG_regexp_interpret_all) {
416 : // Byte-code regexp needs space allocated for all its registers.
417 : // The result captures are copied to the start of the registers array
418 : // if the match succeeds. This way those registers are not clobbered
419 : // when we set the last match info from last successful match.
420 : return IrregexpNumberOfRegisters(FixedArray::cast(regexp->data())) +
421 4251103 : (IrregexpNumberOfCaptures(FixedArray::cast(regexp->data())) + 1) * 2;
422 : } else {
423 : // Native regexp only needs room to output captures. Registers are handled
424 : // internally.
425 107666 : return (IrregexpNumberOfCaptures(FixedArray::cast(regexp->data())) + 1) * 2;
426 : }
427 : }
428 :
429 4394778 : int RegExpImpl::IrregexpExecRaw(Isolate* isolate, Handle<JSRegExp> regexp,
430 : Handle<String> subject, int index,
431 : int32_t* output, int output_size) {
432 : Handle<FixedArray> irregexp(FixedArray::cast(regexp->data()), isolate);
433 :
434 : DCHECK_LE(0, index);
435 : DCHECK_LE(index, subject->length());
436 : DCHECK(subject->IsFlat());
437 :
438 4394778 : bool is_one_byte = String::IsOneByteRepresentationUnderneath(*subject);
439 :
440 4394778 : if (!FLAG_regexp_interpret_all) {
441 : DCHECK(output_size >= (IrregexpNumberOfCaptures(*irregexp) + 1) * 2);
442 4 : do {
443 113523 : EnsureCompiledIrregexp(isolate, regexp, subject, is_one_byte);
444 : Handle<Code> code(IrregexpNativeCode(*irregexp, is_one_byte), isolate);
445 : // The stack is used to allocate registers for the compiled regexp code.
446 : // This means that in case of failure, the output registers array is left
447 : // untouched and contains the capture results from the previous successful
448 : // match. We can use that to set the last match info lazily.
449 : int res = NativeRegExpMacroAssembler::Match(code, subject, output,
450 113523 : output_size, index, isolate);
451 113523 : if (res != NativeRegExpMacroAssembler::RETRY) {
452 : DCHECK(res != NativeRegExpMacroAssembler::EXCEPTION ||
453 : isolate->has_pending_exception());
454 : STATIC_ASSERT(static_cast<int>(NativeRegExpMacroAssembler::SUCCESS) ==
455 : RE_SUCCESS);
456 : STATIC_ASSERT(static_cast<int>(NativeRegExpMacroAssembler::FAILURE) ==
457 : RE_FAILURE);
458 : STATIC_ASSERT(static_cast<int>(NativeRegExpMacroAssembler::EXCEPTION) ==
459 : RE_EXCEPTION);
460 113519 : return res;
461 : }
462 : // If result is RETRY, the string has changed representation, and we
463 : // must restart from scratch.
464 : // In this case, it means we must make sure we are prepared to handle
465 : // the, potentially, different subject (the string can switch between
466 : // being internal and external, and even between being Latin1 and UC16,
467 : // but the characters are always the same).
468 4 : IrregexpPrepare(isolate, regexp, subject);
469 4 : is_one_byte = String::IsOneByteRepresentationUnderneath(*subject);
470 : } while (true);
471 : UNREACHABLE();
472 : } else {
473 : DCHECK(FLAG_regexp_interpret_all);
474 : DCHECK(output_size >= IrregexpNumberOfRegisters(*irregexp));
475 : // We must have done EnsureCompiledIrregexp, so we can get the number of
476 : // registers.
477 : int number_of_capture_registers =
478 4281259 : (IrregexpNumberOfCaptures(*irregexp) + 1) * 2;
479 4281259 : int32_t* raw_output = &output[number_of_capture_registers];
480 :
481 1 : do {
482 : // We do not touch the actual capture result registers until we know there
483 : // has been a match so that we can use those capture results to set the
484 : // last match info.
485 13132916 : for (int i = number_of_capture_registers - 1; i >= 0; i--) {
486 8851656 : raw_output[i] = -1;
487 : }
488 : Handle<ByteArray> byte_codes(IrregexpByteCode(*irregexp, is_one_byte),
489 : isolate);
490 :
491 : IrregexpInterpreter::Result result = IrregexpInterpreter::Match(
492 4281260 : isolate, byte_codes, subject, raw_output, index);
493 : DCHECK_IMPLIES(result == IrregexpInterpreter::EXCEPTION,
494 : isolate->has_pending_exception());
495 :
496 4281260 : switch (result) {
497 : case IrregexpInterpreter::SUCCESS:
498 : // Copy capture results to the start of the registers array.
499 : MemCopy(output, raw_output,
500 : number_of_capture_registers * sizeof(int32_t));
501 8387825 : return result;
502 : case IrregexpInterpreter::EXCEPTION:
503 : case IrregexpInterpreter::FAILURE:
504 : return result;
505 : case IrregexpInterpreter::RETRY:
506 : // The string has changed representation, and we must restart the
507 : // match.
508 1 : is_one_byte = String::IsOneByteRepresentationUnderneath(*subject);
509 1 : EnsureCompiledIrregexp(isolate, regexp, subject, is_one_byte);
510 1 : break;
511 : }
512 : } while (true);
513 : UNREACHABLE();
514 : }
515 : }
516 :
517 4351743 : MaybeHandle<Object> RegExpImpl::IrregexpExec(
518 : Isolate* isolate, Handle<JSRegExp> regexp, Handle<String> subject,
519 : int previous_index, Handle<RegExpMatchInfo> last_match_info) {
520 : DCHECK_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
521 :
522 4351743 : subject = String::Flatten(isolate, subject);
523 :
524 : // Prepare space for the return values.
525 : #ifdef DEBUG
526 : if (FLAG_regexp_interpret_all && FLAG_trace_regexp_bytecodes) {
527 : String pattern = regexp->Pattern();
528 : PrintF("\n\nRegexp match: /%s/\n\n", pattern->ToCString().get());
529 : PrintF("\n\nSubject string: '%s'\n\n", subject->ToCString().get());
530 : }
531 : #endif
532 : int required_registers =
533 4351743 : RegExpImpl::IrregexpPrepare(isolate, regexp, subject);
534 4351743 : if (required_registers < 0) {
535 : // Compiling failed with an exception.
536 : DCHECK(isolate->has_pending_exception());
537 298 : return MaybeHandle<Object>();
538 : }
539 :
540 : int32_t* output_registers = nullptr;
541 4351445 : if (required_registers > Isolate::kJSRegexpStaticOffsetsVectorSize) {
542 2844 : output_registers = NewArray<int32_t>(required_registers);
543 : }
544 : std::unique_ptr<int32_t[]> auto_release(output_registers);
545 4351445 : if (output_registers == nullptr) {
546 : output_registers = isolate->jsregexp_static_offsets_vector();
547 : }
548 :
549 : int res =
550 : RegExpImpl::IrregexpExecRaw(isolate, regexp, subject, previous_index,
551 4351445 : output_registers, required_registers);
552 4351445 : if (res == RE_SUCCESS) {
553 : int capture_count =
554 : IrregexpNumberOfCaptures(FixedArray::cast(regexp->data()));
555 : return SetLastMatchInfo(isolate, last_match_info, subject, capture_count,
556 4162519 : output_registers);
557 : }
558 188926 : if (res == RE_EXCEPTION) {
559 : DCHECK(isolate->has_pending_exception());
560 68 : return MaybeHandle<Object>();
561 : }
562 : DCHECK(res == RE_FAILURE);
563 188858 : return isolate->factory()->null_value();
564 : }
565 :
566 4257278 : Handle<RegExpMatchInfo> RegExpImpl::SetLastMatchInfo(
567 : Isolate* isolate, Handle<RegExpMatchInfo> last_match_info,
568 : Handle<String> subject, int capture_count, int32_t* match) {
569 : // This is the only place where match infos can grow. If, after executing the
570 : // regexp, RegExpExecStub finds that the match info is too small, it restarts
571 : // execution in RegExpImpl::Exec, which finally grows the match info right
572 : // here.
573 :
574 4257278 : int capture_register_count = (capture_count + 1) * 2;
575 : Handle<RegExpMatchInfo> result = RegExpMatchInfo::ReserveCaptures(
576 4257278 : isolate, last_match_info, capture_register_count);
577 : result->SetNumberOfCaptureRegisters(capture_register_count);
578 :
579 4257278 : if (*result != *last_match_info) {
580 4248 : if (*last_match_info == *isolate->regexp_last_match_info()) {
581 : // This inner condition is only needed for special situations like the
582 : // regexp fuzzer, where we pass our own custom RegExpMatchInfo to
583 : // RegExpImpl::Exec; there actually want to bypass the Isolate's match
584 : // info and execute the regexp without side effects.
585 4248 : isolate->native_context()->set_regexp_last_match_info(*result);
586 : }
587 : }
588 :
589 : DisallowHeapAllocation no_allocation;
590 4257278 : if (match != nullptr) {
591 15177758 : for (int i = 0; i < capture_register_count; i += 2) {
592 5460240 : result->SetCapture(i, match[i]);
593 5460240 : result->SetCapture(i + 1, match[i + 1]);
594 : }
595 : }
596 8514556 : result->SetLastSubject(*subject);
597 8514556 : result->SetLastInput(*subject);
598 4257278 : return result;
599 : }
600 :
601 95501 : RegExpImpl::GlobalCache::GlobalCache(Handle<JSRegExp> regexp,
602 : Handle<String> subject, Isolate* isolate)
603 : : register_array_(nullptr),
604 : register_array_size_(0),
605 : regexp_(regexp),
606 : subject_(subject),
607 95501 : isolate_(isolate) {
608 95501 : bool interpreted = FLAG_regexp_interpret_all;
609 :
610 95501 : if (regexp_->TypeTag() == JSRegExp::ATOM) {
611 : static const int kAtomRegistersPerMatch = 2;
612 90255 : registers_per_match_ = kAtomRegistersPerMatch;
613 : // There is no distinction between interpreted and native for atom regexps.
614 : interpreted = false;
615 : } else {
616 : registers_per_match_ =
617 5246 : RegExpImpl::IrregexpPrepare(isolate_, regexp_, subject_);
618 5246 : if (registers_per_match_ < 0) {
619 95 : num_matches_ = -1; // Signal exception.
620 95 : return;
621 : }
622 : }
623 :
624 : DCHECK(IsGlobal(regexp->GetFlags()));
625 95406 : if (!interpreted) {
626 : register_array_size_ =
627 189500 : Max(registers_per_match_, Isolate::kJSRegexpStaticOffsetsVectorSize);
628 94750 : max_matches_ = register_array_size_ / registers_per_match_;
629 : } else {
630 : // Global loop in interpreted regexp is not implemented. We choose
631 : // the size of the offsets vector so that it can only store one match.
632 656 : register_array_size_ = registers_per_match_;
633 656 : max_matches_ = 1;
634 : }
635 :
636 95406 : if (register_array_size_ > Isolate::kJSRegexpStaticOffsetsVectorSize) {
637 1072 : register_array_ = NewArray<int32_t>(register_array_size_);
638 : } else {
639 94334 : register_array_ = isolate->jsregexp_static_offsets_vector();
640 : }
641 :
642 : // Set state so that fetching the results the first time triggers a call
643 : // to the compiled regexp.
644 95406 : current_match_index_ = max_matches_ - 1;
645 95406 : num_matches_ = max_matches_;
646 : DCHECK_LE(2, registers_per_match_); // Each match has at least one capture.
647 : DCHECK_GE(register_array_size_, registers_per_match_);
648 : int32_t* last_match =
649 95406 : ®ister_array_[current_match_index_ * registers_per_match_];
650 95406 : last_match[0] = -1;
651 95406 : last_match[1] = 0;
652 : }
653 :
654 7 : int RegExpImpl::GlobalCache::AdvanceZeroLength(int last_index) {
655 14 : if (IsUnicode(regexp_->GetFlags()) && last_index + 1 < subject_->length() &&
656 7 : unibrow::Utf16::IsLeadSurrogate(subject_->Get(last_index)) &&
657 : unibrow::Utf16::IsTrailSurrogate(subject_->Get(last_index + 1))) {
658 : // Advance over the surrogate pair.
659 0 : return last_index + 2;
660 : }
661 7 : return last_index + 1;
662 : }
663 :
664 : // -------------------------------------------------------------------
665 : // Implementation of the Irregexp regular expression engine.
666 : //
667 : // The Irregexp regular expression engine is intended to be a complete
668 : // implementation of ECMAScript regular expressions. It generates either
669 : // bytecodes or native code.
670 :
671 : // The Irregexp regexp engine is structured in three steps.
672 : // 1) The parser generates an abstract syntax tree. See ast.cc.
673 : // 2) From the AST a node network is created. The nodes are all
674 : // subclasses of RegExpNode. The nodes represent states when
675 : // executing a regular expression. Several optimizations are
676 : // performed on the node network.
677 : // 3) From the nodes we generate either byte codes or native code
678 : // that can actually execute the regular expression (perform
679 : // the search). The code generation step is described in more
680 : // detail below.
681 :
682 : // Code generation.
683 : //
684 : // The nodes are divided into four main categories.
685 : // * Choice nodes
686 : // These represent places where the regular expression can
687 : // match in more than one way. For example on entry to an
688 : // alternation (foo|bar) or a repetition (*, +, ? or {}).
689 : // * Action nodes
690 : // These represent places where some action should be
691 : // performed. Examples include recording the current position
692 : // in the input string to a register (in order to implement
693 : // captures) or other actions on register for example in order
694 : // to implement the counters needed for {} repetitions.
695 : // * Matching nodes
696 : // These attempt to match some element part of the input string.
697 : // Examples of elements include character classes, plain strings
698 : // or back references.
699 : // * End nodes
700 : // These are used to implement the actions required on finding
701 : // a successful match or failing to find a match.
702 : //
703 : // The code generated (whether as byte codes or native code) maintains
704 : // some state as it runs. This consists of the following elements:
705 : //
706 : // * The capture registers. Used for string captures.
707 : // * Other registers. Used for counters etc.
708 : // * The current position.
709 : // * The stack of backtracking information. Used when a matching node
710 : // fails to find a match and needs to try an alternative.
711 : //
712 : // Conceptual regular expression execution model:
713 : //
714 : // There is a simple conceptual model of regular expression execution
715 : // which will be presented first. The actual code generated is a more
716 : // efficient simulation of the simple conceptual model:
717 : //
718 : // * Choice nodes are implemented as follows:
719 : // For each choice except the last {
720 : // push current position
721 : // push backtrack code location
722 : // <generate code to test for choice>
723 : // backtrack code location:
724 : // pop current position
725 : // }
726 : // <generate code to test for last choice>
727 : //
728 : // * Actions nodes are generated as follows
729 : // <push affected registers on backtrack stack>
730 : // <generate code to perform action>
731 : // push backtrack code location
732 : // <generate code to test for following nodes>
733 : // backtrack code location:
734 : // <pop affected registers to restore their state>
735 : // <pop backtrack location from stack and go to it>
736 : //
737 : // * Matching nodes are generated as follows:
738 : // if input string matches at current position
739 : // update current position
740 : // <generate code to test for following nodes>
741 : // else
742 : // <pop backtrack location from stack and go to it>
743 : //
744 : // Thus it can be seen that the current position is saved and restored
745 : // by the choice nodes, whereas the registers are saved and restored by
746 : // by the action nodes that manipulate them.
747 : //
748 : // The other interesting aspect of this model is that nodes are generated
749 : // at the point where they are needed by a recursive call to Emit(). If
750 : // the node has already been code generated then the Emit() call will
751 : // generate a jump to the previously generated code instead. In order to
752 : // limit recursion it is possible for the Emit() function to put the node
753 : // on a work list for later generation and instead generate a jump. The
754 : // destination of the jump is resolved later when the code is generated.
755 : //
756 : // Actual regular expression code generation.
757 : //
758 : // Code generation is actually more complicated than the above. In order
759 : // to improve the efficiency of the generated code some optimizations are
760 : // performed
761 : //
762 : // * Choice nodes have 1-character lookahead.
763 : // A choice node looks at the following character and eliminates some of
764 : // the choices immediately based on that character. This is not yet
765 : // implemented.
766 : // * Simple greedy loops store reduced backtracking information.
767 : // A quantifier like /.*foo/m will greedily match the whole input. It will
768 : // then need to backtrack to a point where it can match "foo". The naive
769 : // implementation of this would push each character position onto the
770 : // backtracking stack, then pop them off one by one. This would use space
771 : // proportional to the length of the input string. However since the "."
772 : // can only match in one way and always has a constant length (in this case
773 : // of 1) it suffices to store the current position on the top of the stack
774 : // once. Matching now becomes merely incrementing the current position and
775 : // backtracking becomes decrementing the current position and checking the
776 : // result against the stored current position. This is faster and saves
777 : // space.
778 : // * The current state is virtualized.
779 : // This is used to defer expensive operations until it is clear that they
780 : // are needed and to generate code for a node more than once, allowing
781 : // specialized an efficient versions of the code to be created. This is
782 : // explained in the section below.
783 : //
784 : // Execution state virtualization.
785 : //
786 : // Instead of emitting code, nodes that manipulate the state can record their
787 : // manipulation in an object called the Trace. The Trace object can record a
788 : // current position offset, an optional backtrack code location on the top of
789 : // the virtualized backtrack stack and some register changes. When a node is
790 : // to be emitted it can flush the Trace or update it. Flushing the Trace
791 : // will emit code to bring the actual state into line with the virtual state.
792 : // Avoiding flushing the state can postpone some work (e.g. updates of capture
793 : // registers). Postponing work can save time when executing the regular
794 : // expression since it may be found that the work never has to be done as a
795 : // failure to match can occur. In addition it is much faster to jump to a
796 : // known backtrack code location than it is to pop an unknown backtrack
797 : // location from the stack and jump there.
798 : //
799 : // The virtual state found in the Trace affects code generation. For example
800 : // the virtual state contains the difference between the actual current
801 : // position and the virtual current position, and matching code needs to use
802 : // this offset to attempt a match in the correct location of the input
803 : // string. Therefore code generated for a non-trivial trace is specialized
804 : // to that trace. The code generator therefore has the ability to generate
805 : // code for each node several times. In order to limit the size of the
806 : // generated code there is an arbitrary limit on how many specialized sets of
807 : // code may be generated for a given node. If the limit is reached, the
808 : // trace is flushed and a generic version of the code for a node is emitted.
809 : // This is subsequently used for that node. The code emitted for non-generic
810 : // trace is not recorded in the node and so it cannot currently be reused in
811 : // the event that code generation is requested for an identical trace.
812 :
813 :
814 0 : void RegExpTree::AppendToText(RegExpText* text, Zone* zone) {
815 0 : UNREACHABLE();
816 : }
817 :
818 :
819 99371 : void RegExpAtom::AppendToText(RegExpText* text, Zone* zone) {
820 : text->AddElement(TextElement::Atom(this), zone);
821 99371 : }
822 :
823 :
824 7635 : void RegExpCharacterClass::AppendToText(RegExpText* text, Zone* zone) {
825 : text->AddElement(TextElement::CharClass(this), zone);
826 7635 : }
827 :
828 :
829 0 : void RegExpText::AppendToText(RegExpText* text, Zone* zone) {
830 0 : for (int i = 0; i < elements()->length(); i++)
831 : text->AddElement(elements()->at(i), zone);
832 0 : }
833 :
834 :
835 0 : TextElement TextElement::Atom(RegExpAtom* atom) {
836 0 : return TextElement(ATOM, atom);
837 : }
838 :
839 :
840 0 : TextElement TextElement::CharClass(RegExpCharacterClass* char_class) {
841 0 : return TextElement(CHAR_CLASS, char_class);
842 : }
843 :
844 :
845 7436807 : int TextElement::length() const {
846 7436807 : switch (text_type()) {
847 : case ATOM:
848 6603069 : return atom()->length();
849 :
850 : case CHAR_CLASS:
851 : return 1;
852 : }
853 0 : UNREACHABLE();
854 : }
855 :
856 :
857 0 : DispatchTable* ChoiceNode::GetTable(bool ignore_case) {
858 0 : if (table_ == nullptr) {
859 0 : table_ = new(zone()) DispatchTable(zone());
860 : DispatchTableConstructor cons(table_, ignore_case, zone());
861 : cons.BuildTable(this);
862 : }
863 0 : return table_;
864 : }
865 :
866 :
867 : class FrequencyCollator {
868 : public:
869 11050914 : FrequencyCollator() : total_samples_(0) {
870 22016162 : for (int i = 0; i < RegExpMacroAssembler::kTableSize; i++) {
871 10965248 : frequencies_[i] = CharacterFrequency(i);
872 : }
873 : }
874 :
875 : void CountCharacter(int character) {
876 456028 : int index = (character & RegExpMacroAssembler::kTableMask);
877 : frequencies_[index].Increment();
878 456028 : total_samples_++;
879 : }
880 :
881 : // Does not measure in percent, but rather per-128 (the table size from the
882 : // regexp macro assembler).
883 : int Frequency(int in_character) {
884 : DCHECK((in_character & RegExpMacroAssembler::kTableMask) == in_character);
885 487101 : if (total_samples_ < 1) return 1; // Division by zero.
886 : int freq_in_per128 =
887 486836 : (frequencies_[in_character].counter() * 128) / total_samples_;
888 : return freq_in_per128;
889 : }
890 :
891 : private:
892 : class CharacterFrequency {
893 : public:
894 10965248 : CharacterFrequency() : counter_(0), character_(-1) { }
895 : explicit CharacterFrequency(int character)
896 : : counter_(0), character_(character) { }
897 :
898 456028 : void Increment() { counter_++; }
899 : int counter() { return counter_; }
900 : int character() { return character_; }
901 :
902 : private:
903 : int counter_;
904 : int character_;
905 : };
906 :
907 :
908 : private:
909 : CharacterFrequency frequencies_[RegExpMacroAssembler::kTableSize];
910 : int total_samples_;
911 : };
912 :
913 :
914 : class RegExpCompiler {
915 : public:
916 : RegExpCompiler(Isolate* isolate, Zone* zone, int capture_count,
917 : bool is_one_byte);
918 :
919 : int AllocateRegister() {
920 909510 : if (next_register_ >= RegExpMacroAssembler::kMaxRegister) {
921 310203 : reg_exp_too_big_ = true;
922 : return next_register_;
923 : }
924 599307 : return next_register_++;
925 : }
926 :
927 : // Lookarounds to match lone surrogates for unicode character class matches
928 : // are never nested. We can therefore reuse registers.
929 : int UnicodeLookaroundStackRegister() {
930 2460 : if (unicode_lookaround_stack_register_ == kNoRegister) {
931 1040 : unicode_lookaround_stack_register_ = AllocateRegister();
932 : }
933 2460 : return unicode_lookaround_stack_register_;
934 : }
935 :
936 : int UnicodeLookaroundPositionRegister() {
937 2460 : if (unicode_lookaround_position_register_ == kNoRegister) {
938 1040 : unicode_lookaround_position_register_ = AllocateRegister();
939 : }
940 2460 : return unicode_lookaround_position_register_;
941 : }
942 :
943 : RegExpEngine::CompilationResult Assemble(Isolate* isolate,
944 : RegExpMacroAssembler* assembler,
945 : RegExpNode* start, int capture_count,
946 : Handle<String> pattern);
947 :
948 592608 : inline void AddWork(RegExpNode* node) {
949 946295 : if (!node->on_work_list() && !node->label()->is_bound()) {
950 : node->set_on_work_list(true);
951 210432 : work_list_->push_back(node);
952 : }
953 592608 : }
954 :
955 : static const int kImplementationOffset = 0;
956 : static const int kNumberOfRegistersOffset = 0;
957 : static const int kCodeOffset = 1;
958 :
959 : RegExpMacroAssembler* macro_assembler() { return macro_assembler_; }
960 : EndNode* accept() { return accept_; }
961 :
962 : static const int kMaxRecursion = 100;
963 : inline int recursion_depth() { return recursion_depth_; }
964 998060 : inline void IncrementRecursionDepth() { recursion_depth_++; }
965 998060 : inline void DecrementRecursionDepth() { recursion_depth_--; }
966 :
967 0 : void SetRegExpTooBig() { reg_exp_too_big_ = true; }
968 :
969 : inline bool one_byte() { return one_byte_; }
970 : inline bool optimize() { return optimize_; }
971 84502 : inline void set_optimize(bool value) { optimize_ = value; }
972 : inline bool limiting_recursion() { return limiting_recursion_; }
973 : inline void set_limiting_recursion(bool value) {
974 955270 : limiting_recursion_ = value;
975 : }
976 : bool read_backward() { return read_backward_; }
977 3336 : void set_read_backward(bool value) { read_backward_ = value; }
978 : FrequencyCollator* frequency_collator() { return &frequency_collator_; }
979 :
980 : int current_expansion_factor() { return current_expansion_factor_; }
981 : void set_current_expansion_factor(int value) {
982 85549 : current_expansion_factor_ = value;
983 : }
984 :
985 : Isolate* isolate() const { return isolate_; }
986 : Zone* zone() const { return zone_; }
987 :
988 : static const int kNoRegister = -1;
989 :
990 : private:
991 : EndNode* accept_;
992 : int next_register_;
993 : int unicode_lookaround_stack_register_;
994 : int unicode_lookaround_position_register_;
995 : std::vector<RegExpNode*>* work_list_;
996 : int recursion_depth_;
997 : RegExpMacroAssembler* macro_assembler_;
998 : bool one_byte_;
999 : bool reg_exp_too_big_;
1000 : bool limiting_recursion_;
1001 : bool optimize_;
1002 : bool read_backward_;
1003 : int current_expansion_factor_;
1004 : FrequencyCollator frequency_collator_;
1005 : Isolate* isolate_;
1006 : Zone* zone_;
1007 : };
1008 :
1009 :
1010 : class RecursionCheck {
1011 : public:
1012 : explicit RecursionCheck(RegExpCompiler* compiler) : compiler_(compiler) {
1013 : compiler->IncrementRecursionDepth();
1014 : }
1015 : ~RecursionCheck() { compiler_->DecrementRecursionDepth(); }
1016 : private:
1017 : RegExpCompiler* compiler_;
1018 : };
1019 :
1020 :
1021 : static RegExpEngine::CompilationResult IrregexpRegExpTooBig(Isolate* isolate) {
1022 : return RegExpEngine::CompilationResult(isolate, "RegExp too big");
1023 : }
1024 :
1025 :
1026 : // Attempts to compile the regexp using an Irregexp code generator. Returns
1027 : // a fixed array or a null handle depending on whether it succeeded.
1028 85666 : RegExpCompiler::RegExpCompiler(Isolate* isolate, Zone* zone, int capture_count,
1029 : bool one_byte)
1030 85666 : : next_register_(2 * (capture_count + 1)),
1031 : unicode_lookaround_stack_register_(kNoRegister),
1032 : unicode_lookaround_position_register_(kNoRegister),
1033 : work_list_(nullptr),
1034 : recursion_depth_(0),
1035 : one_byte_(one_byte),
1036 : reg_exp_too_big_(false),
1037 : limiting_recursion_(false),
1038 : optimize_(FLAG_regexp_optimization),
1039 : read_backward_(false),
1040 : current_expansion_factor_(1),
1041 : frequency_collator_(),
1042 : isolate_(isolate),
1043 171332 : zone_(zone) {
1044 85666 : accept_ = new(zone) EndNode(EndNode::ACCEPT, zone);
1045 : DCHECK_GE(RegExpMacroAssembler::kMaxRegister, next_register_ - 1);
1046 85666 : }
1047 :
1048 85312 : RegExpEngine::CompilationResult RegExpCompiler::Assemble(
1049 : Isolate* isolate, RegExpMacroAssembler* macro_assembler, RegExpNode* start,
1050 : int capture_count, Handle<String> pattern) {
1051 : #ifdef DEBUG
1052 : if (FLAG_trace_regexp_assembler)
1053 : macro_assembler_ = new RegExpMacroAssemblerTracer(isolate, macro_assembler);
1054 : else
1055 : #endif
1056 85312 : macro_assembler_ = macro_assembler;
1057 :
1058 : std::vector<RegExpNode*> work_list;
1059 85312 : work_list_ = &work_list;
1060 85312 : Label fail;
1061 85312 : macro_assembler_->PushBacktrack(&fail);
1062 : Trace new_trace;
1063 85312 : start->Emit(this, &new_trace);
1064 85312 : macro_assembler_->Bind(&fail);
1065 85312 : macro_assembler_->Fail();
1066 295744 : while (!work_list.empty()) {
1067 210432 : RegExpNode* node = work_list.back();
1068 : work_list.pop_back();
1069 : node->set_on_work_list(false);
1070 210432 : if (!node->label()->is_bound()) node->Emit(this, &new_trace);
1071 : }
1072 85312 : if (reg_exp_too_big_) {
1073 0 : macro_assembler_->AbortedCodeGeneration();
1074 0 : return IrregexpRegExpTooBig(isolate_);
1075 : }
1076 :
1077 85312 : Handle<HeapObject> code = macro_assembler_->GetCode(pattern);
1078 170624 : isolate->IncreaseTotalRegexpCodeGenerated(code->Size());
1079 85312 : work_list_ = nullptr;
1080 : #ifdef ENABLE_DISASSEMBLER
1081 : if (FLAG_print_code && !FLAG_regexp_interpret_all) {
1082 : CodeTracer::Scope trace_scope(isolate->GetCodeTracer());
1083 : OFStream os(trace_scope.file());
1084 : Handle<Code>::cast(code)->Disassemble(pattern->ToCString().get(), os);
1085 : }
1086 : #endif
1087 : #ifdef DEBUG
1088 : if (FLAG_trace_regexp_assembler) {
1089 : delete macro_assembler_;
1090 : }
1091 : #endif
1092 85312 : return RegExpEngine::CompilationResult(*code, next_register_);
1093 : }
1094 :
1095 :
1096 0 : bool Trace::DeferredAction::Mentions(int that) {
1097 2463221 : if (action_type() == ActionNode::CLEAR_CAPTURES) {
1098 : Interval range = static_cast<DeferredClearCaptures*>(this)->range();
1099 : return range.Contains(that);
1100 : } else {
1101 2415759 : return reg() == that;
1102 : }
1103 : }
1104 :
1105 :
1106 0 : bool Trace::mentions_reg(int reg) {
1107 0 : for (DeferredAction* action = actions_; action != nullptr;
1108 : action = action->next()) {
1109 0 : if (action->Mentions(reg))
1110 : return true;
1111 : }
1112 : return false;
1113 : }
1114 :
1115 :
1116 973 : bool Trace::GetStoredPosition(int reg, int* cp_offset) {
1117 : DCHECK_EQ(0, *cp_offset);
1118 1516 : for (DeferredAction* action = actions_; action != nullptr;
1119 : action = action->next()) {
1120 953 : if (action->Mentions(reg)) {
1121 410 : if (action->action_type() == ActionNode::STORE_POSITION) {
1122 410 : *cp_offset = static_cast<DeferredCapture*>(action)->cp_offset();
1123 410 : return true;
1124 : } else {
1125 : return false;
1126 : }
1127 : }
1128 : }
1129 : return false;
1130 : }
1131 :
1132 :
1133 510785 : int Trace::FindAffectedRegisters(OutSet* affected_registers,
1134 : Zone* zone) {
1135 : int max_register = RegExpCompiler::kNoRegister;
1136 930005 : for (DeferredAction* action = actions_; action != nullptr;
1137 : action = action->next()) {
1138 419220 : if (action->action_type() == ActionNode::CLEAR_CAPTURES) {
1139 : Interval range = static_cast<DeferredClearCaptures*>(action)->range();
1140 93100 : for (int i = range.from(); i <= range.to(); i++)
1141 45072 : affected_registers->Set(i, zone);
1142 2956 : if (range.to() > max_register) max_register = range.to();
1143 : } else {
1144 416264 : affected_registers->Set(action->reg(), zone);
1145 416264 : if (action->reg() > max_register) max_register = action->reg();
1146 : }
1147 : }
1148 510785 : return max_register;
1149 : }
1150 :
1151 :
1152 510785 : void Trace::RestoreAffectedRegisters(RegExpMacroAssembler* assembler,
1153 : int max_register,
1154 : const OutSet& registers_to_pop,
1155 : const OutSet& registers_to_clear) {
1156 20414187 : for (int reg = max_register; reg >= 0; reg--) {
1157 19903402 : if (registers_to_pop.Get(reg)) {
1158 52884 : assembler->PopRegister(reg);
1159 9898817 : } else if (registers_to_clear.Get(reg)) {
1160 : int clear_to = reg;
1161 470860 : while (reg > 0 && registers_to_clear.Get(reg - 1)) {
1162 105386 : reg--;
1163 : }
1164 77351 : assembler->ClearRegisters(reg, clear_to);
1165 : }
1166 : }
1167 510785 : }
1168 :
1169 :
1170 510785 : void Trace::PerformDeferredActions(RegExpMacroAssembler* assembler,
1171 : int max_register,
1172 : const OutSet& affected_registers,
1173 : OutSet* registers_to_pop,
1174 : OutSet* registers_to_clear,
1175 : Zone* zone) {
1176 : // The "+1" is to avoid a push_limit of zero if stack_limit_slack() is 1.
1177 510785 : const int push_limit = (assembler->stack_limit_slack() + 1) / 2;
1178 :
1179 : // Count pushes performed to force a stack limit check occasionally.
1180 : int pushes = 0;
1181 :
1182 20624959 : for (int reg = 0; reg <= max_register; reg++) {
1183 20114174 : if (!affected_registers.Get(reg)) {
1184 : continue;
1185 : }
1186 :
1187 : // The chronologically first deferred action in the trace
1188 : // is used to infer the action needed to restore a register
1189 : // to its previous state (or not, if it's safe to ignore it).
1190 : enum DeferredActionUndoType { IGNORE, RESTORE, CLEAR };
1191 : DeferredActionUndoType undo_action = IGNORE;
1192 :
1193 : int value = 0;
1194 : bool absolute = false;
1195 : bool clear = false;
1196 : static const int kNoStore = kMinInt;
1197 : int store_position = kNoStore;
1198 : // This is a little tricky because we are scanning the actions in reverse
1199 : // historical order (newest first).
1200 2917045 : for (DeferredAction* action = actions_; action != nullptr;
1201 : action = action->next()) {
1202 2462268 : if (action->Mentions(reg)) {
1203 461336 : switch (action->action_type()) {
1204 : case ActionNode::SET_REGISTER: {
1205 : Trace::DeferredSetRegister* psr =
1206 : static_cast<Trace::DeferredSetRegister*>(action);
1207 3465 : if (!absolute) {
1208 3465 : value += psr->value();
1209 : absolute = true;
1210 : }
1211 : // SET_REGISTER is currently only used for newly introduced loop
1212 : // counters. They can have a significant previous value if they
1213 : // occur in a loop. TODO(lrn): Propagate this information, so
1214 : // we can set undo_action to IGNORE if we know there is no value to
1215 : // restore.
1216 : undo_action = RESTORE;
1217 : DCHECK_EQ(store_position, kNoStore);
1218 : DCHECK(!clear);
1219 : break;
1220 : }
1221 : case ActionNode::INCREMENT_REGISTER:
1222 3744 : if (!absolute) {
1223 3744 : value++;
1224 : }
1225 : DCHECK_EQ(store_position, kNoStore);
1226 : DCHECK(!clear);
1227 : undo_action = RESTORE;
1228 : break;
1229 : case ActionNode::STORE_POSITION: {
1230 : Trace::DeferredCapture* pc =
1231 : static_cast<Trace::DeferredCapture*>(action);
1232 409055 : if (!clear && store_position == kNoStore) {
1233 : store_position = pc->cp_offset();
1234 : }
1235 :
1236 : // For captures we know that stores and clears alternate.
1237 : // Other register, are never cleared, and if the occur
1238 : // inside a loop, they might be assigned more than once.
1239 409055 : if (reg <= 1) {
1240 : // Registers zero and one, aka "capture zero", is
1241 : // always set correctly if we succeed. There is no
1242 : // need to undo a setting on backtrack, because we
1243 : // will set it again or fail.
1244 : undo_action = IGNORE;
1245 : } else {
1246 189899 : undo_action = pc->is_capture() ? CLEAR : RESTORE;
1247 : }
1248 : DCHECK(!absolute);
1249 : DCHECK_EQ(value, 0);
1250 : break;
1251 : }
1252 : case ActionNode::CLEAR_CAPTURES: {
1253 : // Since we're scanning in reverse order, if we've already
1254 : // set the position we have to ignore historically earlier
1255 : // clearing operations.
1256 45072 : if (store_position == kNoStore) {
1257 : clear = true;
1258 : }
1259 : undo_action = RESTORE;
1260 : DCHECK(!absolute);
1261 : DCHECK_EQ(value, 0);
1262 : break;
1263 : }
1264 : default:
1265 0 : UNREACHABLE();
1266 : break;
1267 : }
1268 : }
1269 : }
1270 : // Prepare for the undo-action (e.g., push if it's going to be popped).
1271 454777 : if (undo_action == RESTORE) {
1272 52884 : pushes++;
1273 : RegExpMacroAssembler::StackCheckFlag stack_check =
1274 : RegExpMacroAssembler::kNoStackLimitCheck;
1275 52884 : if (pushes == push_limit) {
1276 : stack_check = RegExpMacroAssembler::kCheckStackLimit;
1277 : pushes = 0;
1278 : }
1279 :
1280 52884 : assembler->PushRegister(reg, stack_check);
1281 52884 : registers_to_pop->Set(reg, zone);
1282 401893 : } else if (undo_action == CLEAR) {
1283 182737 : registers_to_clear->Set(reg, zone);
1284 : }
1285 : // Perform the chronologically last action (or accumulated increment)
1286 : // for the register.
1287 454777 : if (store_position != kNoStore) {
1288 409055 : assembler->WriteCurrentPositionToRegister(reg, store_position);
1289 45722 : } else if (clear) {
1290 38513 : assembler->ClearRegisters(reg, reg);
1291 7209 : } else if (absolute) {
1292 3465 : assembler->SetRegister(reg, value);
1293 3744 : } else if (value != 0) {
1294 3744 : assembler->AdvanceRegister(reg, value);
1295 : }
1296 : }
1297 510785 : }
1298 :
1299 :
1300 : // This is called as we come into a loop choice node and some other tricky
1301 : // nodes. It normalizes the state of the code generator to ensure we can
1302 : // generate generic code.
1303 700054 : void Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
1304 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
1305 :
1306 : DCHECK(!is_trivial());
1307 :
1308 700054 : if (actions_ == nullptr && backtrack() == nullptr) {
1309 : // Here we just have some deferred cp advances to fix and we are back to
1310 : // a normal situation. We may also have to forget some information gained
1311 : // through a quick check that was already performed.
1312 189269 : if (cp_offset_ != 0) assembler->AdvanceCurrentPosition(cp_offset_);
1313 : // Create a new trivial state and generate the node with that.
1314 : Trace new_state;
1315 189269 : successor->Emit(compiler, &new_state);
1316 : return;
1317 : }
1318 :
1319 : // Generate deferred actions here along with code to undo them again.
1320 : OutSet affected_registers;
1321 :
1322 510785 : if (backtrack() != nullptr) {
1323 : // Here we have a concrete backtrack location. These are set up by choice
1324 : // nodes and so they indicate that we have a deferred save of the current
1325 : // position which we may need to emit here.
1326 400521 : assembler->PushCurrentPosition();
1327 : }
1328 :
1329 : int max_register = FindAffectedRegisters(&affected_registers,
1330 510785 : compiler->zone());
1331 : OutSet registers_to_pop;
1332 : OutSet registers_to_clear;
1333 : PerformDeferredActions(assembler,
1334 : max_register,
1335 : affected_registers,
1336 : ®isters_to_pop,
1337 : ®isters_to_clear,
1338 510785 : compiler->zone());
1339 510785 : if (cp_offset_ != 0) {
1340 294792 : assembler->AdvanceCurrentPosition(cp_offset_);
1341 : }
1342 :
1343 : // Create a new trivial state and generate the node with that.
1344 510785 : Label undo;
1345 510785 : assembler->PushBacktrack(&undo);
1346 510785 : if (successor->KeepRecursing(compiler)) {
1347 : Trace new_state;
1348 137709 : successor->Emit(compiler, &new_state);
1349 : } else {
1350 373076 : compiler->AddWork(successor);
1351 746152 : assembler->GoTo(successor->label());
1352 : }
1353 :
1354 : // On backtrack we need to restore state.
1355 510785 : assembler->Bind(&undo);
1356 : RestoreAffectedRegisters(assembler,
1357 : max_register,
1358 : registers_to_pop,
1359 510785 : registers_to_clear);
1360 510785 : if (backtrack() == nullptr) {
1361 110264 : assembler->Backtrack();
1362 : } else {
1363 400521 : assembler->PopCurrentPosition();
1364 400521 : assembler->GoTo(backtrack());
1365 : }
1366 : }
1367 :
1368 :
1369 2843 : void NegativeSubmatchSuccess::Emit(RegExpCompiler* compiler, Trace* trace) {
1370 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
1371 :
1372 : // Omit flushing the trace. We discard the entire stack frame anyway.
1373 :
1374 2843 : if (!label()->is_bound()) {
1375 : // We are completely independent of the trace, since we ignore it,
1376 : // so this code can be used as the generic version.
1377 5604 : assembler->Bind(label());
1378 : }
1379 :
1380 : // Throw away everything on the backtrack stack since the start
1381 : // of the negative submatch and restore the character position.
1382 2843 : assembler->ReadCurrentPositionFromRegister(current_position_register_);
1383 2843 : assembler->ReadStackPointerFromRegister(stack_pointer_register_);
1384 2843 : if (clear_capture_count_ > 0) {
1385 : // Clear any captures that might have been performed during the success
1386 : // of the body of the negative look-ahead.
1387 107 : int clear_capture_end = clear_capture_start_ + clear_capture_count_ - 1;
1388 107 : assembler->ClearRegisters(clear_capture_start_, clear_capture_end);
1389 : }
1390 : // Now that we have unwound the stack we find at the top of the stack the
1391 : // backtrack that the BeginSubmatch node got.
1392 2843 : assembler->Backtrack();
1393 2843 : }
1394 :
1395 :
1396 182600 : void EndNode::Emit(RegExpCompiler* compiler, Trace* trace) {
1397 182600 : if (!trace->is_trivial()) {
1398 91150 : trace->Flush(compiler, this);
1399 91150 : return;
1400 : }
1401 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
1402 91450 : if (!label()->is_bound()) {
1403 170602 : assembler->Bind(label());
1404 : }
1405 91450 : switch (action_) {
1406 : case ACCEPT:
1407 91150 : assembler->Succeed();
1408 91150 : return;
1409 : case BACKTRACK:
1410 300 : assembler->GoTo(trace->backtrack());
1411 300 : return;
1412 : case NEGATIVE_SUBMATCH_SUCCESS:
1413 : // This case is handled in a different virtual method.
1414 0 : UNREACHABLE();
1415 : }
1416 0 : UNIMPLEMENTED();
1417 : }
1418 :
1419 :
1420 903936 : void GuardedAlternative::AddGuard(Guard* guard, Zone* zone) {
1421 1807872 : if (guards_ == nullptr) guards_ = new (zone) ZoneList<Guard*>(1, zone);
1422 903936 : guards_->Add(guard, zone);
1423 903936 : }
1424 :
1425 :
1426 903359 : ActionNode* ActionNode::SetRegister(int reg,
1427 : int val,
1428 : RegExpNode* on_success) {
1429 : ActionNode* result =
1430 : new(on_success->zone()) ActionNode(SET_REGISTER, on_success);
1431 903359 : result->data_.u_store_register.reg = reg;
1432 903359 : result->data_.u_store_register.value = val;
1433 903359 : return result;
1434 : }
1435 :
1436 :
1437 903359 : ActionNode* ActionNode::IncrementRegister(int reg, RegExpNode* on_success) {
1438 : ActionNode* result =
1439 : new(on_success->zone()) ActionNode(INCREMENT_REGISTER, on_success);
1440 903359 : result->data_.u_increment_register.reg = reg;
1441 903359 : return result;
1442 : }
1443 :
1444 :
1445 226183 : ActionNode* ActionNode::StorePosition(int reg,
1446 : bool is_capture,
1447 : RegExpNode* on_success) {
1448 : ActionNode* result =
1449 : new(on_success->zone()) ActionNode(STORE_POSITION, on_success);
1450 226183 : result->data_.u_position_register.reg = reg;
1451 226183 : result->data_.u_position_register.is_capture = is_capture;
1452 226183 : return result;
1453 : }
1454 :
1455 :
1456 2376 : ActionNode* ActionNode::ClearCaptures(Interval range,
1457 : RegExpNode* on_success) {
1458 : ActionNode* result =
1459 : new(on_success->zone()) ActionNode(CLEAR_CAPTURES, on_success);
1460 2376 : result->data_.u_clear_captures.range_from = range.from();
1461 2376 : result->data_.u_clear_captures.range_to = range.to();
1462 2376 : return result;
1463 : }
1464 :
1465 :
1466 4467 : ActionNode* ActionNode::BeginSubmatch(int stack_reg,
1467 : int position_reg,
1468 : RegExpNode* on_success) {
1469 : ActionNode* result =
1470 : new(on_success->zone()) ActionNode(BEGIN_SUBMATCH, on_success);
1471 4467 : result->data_.u_submatch.stack_pointer_register = stack_reg;
1472 4467 : result->data_.u_submatch.current_position_register = position_reg;
1473 4467 : return result;
1474 : }
1475 :
1476 :
1477 1655 : ActionNode* ActionNode::PositiveSubmatchSuccess(int stack_reg,
1478 : int position_reg,
1479 : int clear_register_count,
1480 : int clear_register_from,
1481 : RegExpNode* on_success) {
1482 : ActionNode* result =
1483 : new(on_success->zone()) ActionNode(POSITIVE_SUBMATCH_SUCCESS, on_success);
1484 1655 : result->data_.u_submatch.stack_pointer_register = stack_reg;
1485 1655 : result->data_.u_submatch.current_position_register = position_reg;
1486 1655 : result->data_.u_submatch.clear_register_count = clear_register_count;
1487 1655 : result->data_.u_submatch.clear_register_from = clear_register_from;
1488 1655 : return result;
1489 : }
1490 :
1491 :
1492 537 : ActionNode* ActionNode::EmptyMatchCheck(int start_register,
1493 : int repetition_register,
1494 : int repetition_limit,
1495 : RegExpNode* on_success) {
1496 : ActionNode* result =
1497 : new(on_success->zone()) ActionNode(EMPTY_MATCH_CHECK, on_success);
1498 537 : result->data_.u_empty_match_check.start_register = start_register;
1499 537 : result->data_.u_empty_match_check.repetition_register = repetition_register;
1500 537 : result->data_.u_empty_match_check.repetition_limit = repetition_limit;
1501 537 : return result;
1502 : }
1503 :
1504 :
1505 : #define DEFINE_ACCEPT(Type) \
1506 : void Type##Node::Accept(NodeVisitor* visitor) { \
1507 : visitor->Visit##Type(this); \
1508 : }
1509 725523 : FOR_EACH_NODE_TYPE(DEFINE_ACCEPT)
1510 : #undef DEFINE_ACCEPT
1511 :
1512 :
1513 145800 : void LoopChoiceNode::Accept(NodeVisitor* visitor) {
1514 145800 : visitor->VisitLoopChoice(this);
1515 145800 : }
1516 :
1517 :
1518 : // -------------------------------------------------------------------
1519 : // Emit code.
1520 :
1521 :
1522 3936 : void ChoiceNode::GenerateGuard(RegExpMacroAssembler* macro_assembler,
1523 : Guard* guard,
1524 : Trace* trace) {
1525 3936 : switch (guard->op()) {
1526 : case Guard::LT:
1527 : DCHECK(!trace->mentions_reg(guard->reg()));
1528 : macro_assembler->IfRegisterGE(guard->reg(),
1529 : guard->value(),
1530 2614 : trace->backtrack());
1531 2614 : break;
1532 : case Guard::GEQ:
1533 : DCHECK(!trace->mentions_reg(guard->reg()));
1534 : macro_assembler->IfRegisterLT(guard->reg(),
1535 : guard->value(),
1536 1322 : trace->backtrack());
1537 1322 : break;
1538 : }
1539 3936 : }
1540 :
1541 :
1542 : // Returns the number of characters in the equivalence class, omitting those
1543 : // that cannot occur in the source string because it is Latin1.
1544 21870 : static int GetCaseIndependentLetters(Isolate* isolate, uc16 character,
1545 : bool one_byte_subject,
1546 : unibrow::uchar* letters) {
1547 : int length =
1548 43740 : isolate->jsregexp_uncanonicalize()->get(character, '\0', letters);
1549 : // Unibrow returns 0 or 1 for characters where case independence is
1550 : // trivial.
1551 21870 : if (length == 0) {
1552 2773 : letters[0] = character;
1553 : length = 1;
1554 : }
1555 :
1556 21870 : if (one_byte_subject) {
1557 : int new_length = 0;
1558 80415 : for (int i = 0; i < length; i++) {
1559 31770 : if (letters[i] <= String::kMaxOneByteCharCode) {
1560 31360 : letters[new_length++] = letters[i];
1561 : }
1562 : }
1563 : length = new_length;
1564 : }
1565 :
1566 21870 : return length;
1567 : }
1568 :
1569 :
1570 584679 : static inline bool EmitSimpleCharacter(Isolate* isolate,
1571 : RegExpCompiler* compiler,
1572 : uc16 c,
1573 : Label* on_failure,
1574 : int cp_offset,
1575 : bool check,
1576 : bool preloaded) {
1577 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
1578 : bool bound_checked = false;
1579 584679 : if (!preloaded) {
1580 584679 : assembler->LoadCurrentCharacter(
1581 : cp_offset,
1582 : on_failure,
1583 1169358 : check);
1584 : bound_checked = true;
1585 : }
1586 584679 : assembler->CheckNotCharacter(c, on_failure);
1587 584679 : return bound_checked;
1588 : }
1589 :
1590 :
1591 : // Only emits non-letters (things that don't have case). Only used for case
1592 : // independent matches.
1593 5503 : static inline bool EmitAtomNonLetter(Isolate* isolate,
1594 : RegExpCompiler* compiler,
1595 : uc16 c,
1596 : Label* on_failure,
1597 : int cp_offset,
1598 : bool check,
1599 : bool preloaded) {
1600 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
1601 : bool one_byte = compiler->one_byte();
1602 : unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
1603 5503 : int length = GetCaseIndependentLetters(isolate, c, one_byte, chars);
1604 5503 : if (length < 1) {
1605 : // This can't match. Must be an one-byte subject and a non-one-byte
1606 : // character. We do not need to do anything since the one-byte pass
1607 : // already handled this.
1608 : return false; // Bounds not checked.
1609 : }
1610 : bool checked = false;
1611 : // We handle the length > 1 case in a later pass.
1612 5498 : if (length == 1) {
1613 371 : if (one_byte && c > String::kMaxOneByteCharCodeU) {
1614 : // Can't match - see above.
1615 : return false; // Bounds not checked.
1616 : }
1617 371 : if (!preloaded) {
1618 371 : macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
1619 : checked = check;
1620 : }
1621 371 : macro_assembler->CheckNotCharacter(c, on_failure);
1622 : }
1623 : return checked;
1624 : }
1625 :
1626 :
1627 4785 : static bool ShortCutEmitCharacterPair(RegExpMacroAssembler* macro_assembler,
1628 : bool one_byte, uc16 c1, uc16 c2,
1629 : Label* on_failure) {
1630 : uc16 char_mask;
1631 4785 : if (one_byte) {
1632 : char_mask = String::kMaxOneByteCharCode;
1633 : } else {
1634 : char_mask = String::kMaxUtf16CodeUnit;
1635 : }
1636 4785 : uc16 exor = c1 ^ c2;
1637 : // Check whether exor has only one bit set.
1638 4785 : if (((exor - 1) & exor) == 0) {
1639 : // If c1 and c2 differ only by one bit.
1640 : // Ecma262UnCanonicalize always gives the highest number last.
1641 : DCHECK(c2 > c1);
1642 4690 : uc16 mask = char_mask ^ exor;
1643 4690 : macro_assembler->CheckNotCharacterAfterAnd(c1, mask, on_failure);
1644 4690 : return true;
1645 : }
1646 : DCHECK(c2 > c1);
1647 95 : uc16 diff = c2 - c1;
1648 95 : if (((diff - 1) & diff) == 0 && c1 >= diff) {
1649 : // If the characters differ by 2^n but don't differ by one bit then
1650 : // subtract the difference from the found character, then do the or
1651 : // trick. We avoid the theoretical case where negative numbers are
1652 : // involved in order to simplify code generation.
1653 85 : uc16 mask = char_mask ^ diff;
1654 85 : macro_assembler->CheckNotCharacterAfterMinusAnd(c1 - diff,
1655 : diff,
1656 : mask,
1657 170 : on_failure);
1658 85 : return true;
1659 : }
1660 : return false;
1661 : }
1662 :
1663 :
1664 : typedef bool EmitCharacterFunction(Isolate* isolate,
1665 : RegExpCompiler* compiler,
1666 : uc16 c,
1667 : Label* on_failure,
1668 : int cp_offset,
1669 : bool check,
1670 : bool preloaded);
1671 :
1672 : // Only emits letters (things that have case). Only used for case independent
1673 : // matches.
1674 5503 : static inline bool EmitAtomLetter(Isolate* isolate,
1675 : RegExpCompiler* compiler,
1676 : uc16 c,
1677 : Label* on_failure,
1678 : int cp_offset,
1679 : bool check,
1680 : bool preloaded) {
1681 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
1682 : bool one_byte = compiler->one_byte();
1683 : unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
1684 5503 : int length = GetCaseIndependentLetters(isolate, c, one_byte, chars);
1685 5503 : if (length <= 1) return false;
1686 : // We may not need to check against the end of the input string
1687 : // if this character lies before a character that matched.
1688 5127 : if (!preloaded) {
1689 4792 : macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check);
1690 : }
1691 5127 : Label ok;
1692 : DCHECK_EQ(4, unibrow::Ecma262UnCanonicalize::kMaxWidth);
1693 5127 : switch (length) {
1694 : case 2: {
1695 4785 : if (ShortCutEmitCharacterPair(macro_assembler, one_byte, chars[0],
1696 4785 : chars[1], on_failure)) {
1697 : } else {
1698 10 : macro_assembler->CheckCharacter(chars[0], &ok);
1699 10 : macro_assembler->CheckNotCharacter(chars[1], on_failure);
1700 10 : macro_assembler->Bind(&ok);
1701 : }
1702 : break;
1703 : }
1704 : case 4:
1705 25 : macro_assembler->CheckCharacter(chars[3], &ok);
1706 : V8_FALLTHROUGH;
1707 : case 3:
1708 342 : macro_assembler->CheckCharacter(chars[0], &ok);
1709 342 : macro_assembler->CheckCharacter(chars[1], &ok);
1710 342 : macro_assembler->CheckNotCharacter(chars[2], on_failure);
1711 342 : macro_assembler->Bind(&ok);
1712 342 : break;
1713 : default:
1714 0 : UNREACHABLE();
1715 : break;
1716 : }
1717 : return true;
1718 : }
1719 :
1720 :
1721 8607 : static void EmitBoundaryTest(RegExpMacroAssembler* masm,
1722 : int border,
1723 : Label* fall_through,
1724 : Label* above_or_equal,
1725 : Label* below) {
1726 8607 : if (below != fall_through) {
1727 8243 : masm->CheckCharacterLT(border, below);
1728 8243 : if (above_or_equal != fall_through) masm->GoTo(above_or_equal);
1729 : } else {
1730 364 : masm->CheckCharacterGT(border - 1, above_or_equal);
1731 : }
1732 8607 : }
1733 :
1734 :
1735 158958 : static void EmitDoubleBoundaryTest(RegExpMacroAssembler* masm,
1736 : int first,
1737 : int last,
1738 : Label* fall_through,
1739 : Label* in_range,
1740 : Label* out_of_range) {
1741 158958 : if (in_range == fall_through) {
1742 107375 : if (first == last) {
1743 14492 : masm->CheckNotCharacter(first, out_of_range);
1744 : } else {
1745 92883 : masm->CheckCharacterNotInRange(first, last, out_of_range);
1746 : }
1747 : } else {
1748 51583 : if (first == last) {
1749 28274 : masm->CheckCharacter(first, in_range);
1750 : } else {
1751 23309 : masm->CheckCharacterInRange(first, last, in_range);
1752 : }
1753 51583 : if (out_of_range != fall_through) masm->GoTo(out_of_range);
1754 : }
1755 158958 : }
1756 :
1757 :
1758 : // even_label is for ranges[i] to ranges[i + 1] where i - start_index is even.
1759 : // odd_label is for ranges[i] to ranges[i + 1] where i - start_index is odd.
1760 5861 : static void EmitUseLookupTable(
1761 : RegExpMacroAssembler* masm,
1762 : ZoneList<int>* ranges,
1763 : int start_index,
1764 : int end_index,
1765 : int min_char,
1766 : Label* fall_through,
1767 : Label* even_label,
1768 : Label* odd_label) {
1769 : static const int kSize = RegExpMacroAssembler::kTableSize;
1770 : static const int kMask = RegExpMacroAssembler::kTableMask;
1771 :
1772 : int base = (min_char & ~kMask);
1773 : USE(base);
1774 :
1775 : // Assert that everything is on one kTableSize page.
1776 : for (int i = start_index; i <= end_index; i++) {
1777 : DCHECK_EQ(ranges->at(i) & ~kMask, base);
1778 : }
1779 : DCHECK(start_index == 0 || (ranges->at(start_index - 1) & ~kMask) <= base);
1780 :
1781 : char templ[kSize];
1782 : Label* on_bit_set;
1783 : Label* on_bit_clear;
1784 : int bit;
1785 5861 : if (even_label == fall_through) {
1786 : on_bit_set = odd_label;
1787 : on_bit_clear = even_label;
1788 : bit = 1;
1789 : } else {
1790 : on_bit_set = even_label;
1791 : on_bit_clear = odd_label;
1792 : bit = 0;
1793 : }
1794 252413 : for (int i = 0; i < (ranges->at(start_index) & kMask) && i < kSize; i++) {
1795 123276 : templ[i] = bit;
1796 : }
1797 : int j = 0;
1798 5861 : bit ^= 1;
1799 95816 : for (int i = start_index; i < end_index; i++) {
1800 1204670 : for (j = (ranges->at(i) & kMask); j < (ranges->at(i + 1) & kMask); j++) {
1801 512380 : templ[j] = bit;
1802 : }
1803 89955 : bit ^= 1;
1804 : }
1805 234965 : for (int i = j; i < kSize; i++) {
1806 114552 : templ[i] = bit;
1807 : }
1808 : Factory* factory = masm->isolate()->factory();
1809 : // TODO(erikcorry): Cache these.
1810 5861 : Handle<ByteArray> ba = factory->NewByteArray(kSize, AllocationType::kOld);
1811 1506277 : for (int i = 0; i < kSize; i++) {
1812 750208 : ba->set(i, templ[i]);
1813 : }
1814 5861 : masm->CheckBitInTable(ba, on_bit_set);
1815 5861 : if (on_bit_clear != fall_through) masm->GoTo(on_bit_clear);
1816 5861 : }
1817 :
1818 :
1819 35749 : static void CutOutRange(RegExpMacroAssembler* masm,
1820 : ZoneList<int>* ranges,
1821 : int start_index,
1822 : int end_index,
1823 : int cut_index,
1824 : Label* even_label,
1825 : Label* odd_label) {
1826 35749 : bool odd = (((cut_index - start_index) & 1) == 1);
1827 35749 : Label* in_range_label = odd ? odd_label : even_label;
1828 35749 : Label dummy;
1829 71498 : EmitDoubleBoundaryTest(masm,
1830 : ranges->at(cut_index),
1831 71498 : ranges->at(cut_index + 1) - 1,
1832 : &dummy,
1833 : in_range_label,
1834 35749 : &dummy);
1835 : DCHECK(!dummy.is_linked());
1836 : // Cut out the single range by rewriting the array. This creates a new
1837 : // range that is a merger of the two ranges on either side of the one we
1838 : // are cutting out. The oddity of the labels is preserved.
1839 74921 : for (int j = cut_index; j > start_index; j--) {
1840 39172 : ranges->at(j) = ranges->at(j - 1);
1841 : }
1842 181431 : for (int j = cut_index + 1; j < end_index; j++) {
1843 145682 : ranges->at(j) = ranges->at(j + 1);
1844 : }
1845 35749 : }
1846 :
1847 :
1848 : // Unicode case. Split the search space into kSize spaces that are handled
1849 : // with recursion.
1850 19767 : static void SplitSearchSpace(ZoneList<int>* ranges,
1851 : int start_index,
1852 : int end_index,
1853 : int* new_start_index,
1854 : int* new_end_index,
1855 : int* border) {
1856 : static const int kSize = RegExpMacroAssembler::kTableSize;
1857 : static const int kMask = RegExpMacroAssembler::kTableMask;
1858 :
1859 19767 : int first = ranges->at(start_index);
1860 19767 : int last = ranges->at(end_index) - 1;
1861 :
1862 19767 : *new_start_index = start_index;
1863 19767 : *border = (ranges->at(start_index) & ~kMask) + kSize;
1864 278407 : while (*new_start_index < end_index) {
1865 147860 : if (ranges->at(*new_start_index) > *border) break;
1866 129320 : (*new_start_index)++;
1867 : }
1868 : // new_start_index is the index of the first edge that is beyond the
1869 : // current kSize space.
1870 :
1871 : // For very large search spaces we do a binary chop search of the non-Latin1
1872 : // space instead of just going to the end of the current kSize space. The
1873 : // heuristics are complicated a little by the fact that any 128-character
1874 : // encoding space can be quickly tested with a table lookup, so we don't
1875 : // wish to do binary chop search at a smaller granularity than that. A
1876 : // 128-character space can take up a lot of space in the ranges array if,
1877 : // for example, we only want to match every second character (eg. the lower
1878 : // case characters on some Unicode pages).
1879 19767 : int binary_chop_index = (end_index + start_index) / 2;
1880 : // The first test ensures that we get to the code that handles the Latin1
1881 : // range with a single not-taken branch, speeding up this important
1882 : // character range (even non-Latin1 charset-based text has spaces and
1883 : // punctuation).
1884 54426 : if (*border - 1 > String::kMaxOneByteCharCode && // Latin1 case.
1885 27629 : end_index - start_index > (*new_start_index - start_index) * 2 &&
1886 56007 : last - first > kSize * 2 && binary_chop_index > *new_start_index &&
1887 23248 : ranges->at(binary_chop_index) >= first + 2 * kSize) {
1888 : int scan_forward_for_section_border = binary_chop_index;;
1889 9782 : int new_border = (ranges->at(binary_chop_index) | kMask) + 1;
1890 :
1891 124026 : while (scan_forward_for_section_border < end_index) {
1892 65012 : if (ranges->at(scan_forward_for_section_border) > new_border) {
1893 7890 : *new_start_index = scan_forward_for_section_border;
1894 7890 : *border = new_border;
1895 7890 : break;
1896 : }
1897 57122 : scan_forward_for_section_border++;
1898 : }
1899 : }
1900 :
1901 : DCHECK(*new_start_index > start_index);
1902 19767 : *new_end_index = *new_start_index - 1;
1903 19767 : if (ranges->at(*new_end_index) == *border) {
1904 2958 : (*new_end_index)--;
1905 : }
1906 39534 : if (*border >= ranges->at(end_index)) {
1907 1225 : *border = ranges->at(end_index);
1908 1225 : *new_start_index = end_index; // Won't be used.
1909 1225 : *new_end_index = end_index - 1;
1910 : }
1911 19767 : }
1912 :
1913 : // Gets a series of segment boundaries representing a character class. If the
1914 : // character is in the range between an even and an odd boundary (counting from
1915 : // start_index) then go to even_label, otherwise go to odd_label. We already
1916 : // know that the character is in the range of min_char to max_char inclusive.
1917 : // Either label can be nullptr indicating backtracking. Either label can also
1918 : // be equal to the fall_through label.
1919 201209 : static void GenerateBranches(RegExpMacroAssembler* masm, ZoneList<int>* ranges,
1920 : int start_index, int end_index, uc32 min_char,
1921 : uc32 max_char, Label* fall_through,
1922 : Label* even_label, Label* odd_label) {
1923 : DCHECK_LE(min_char, String::kMaxUtf16CodeUnit);
1924 : DCHECK_LE(max_char, String::kMaxUtf16CodeUnit);
1925 :
1926 201209 : int first = ranges->at(start_index);
1927 201209 : int last = ranges->at(end_index) - 1;
1928 :
1929 : DCHECK_LT(min_char, first);
1930 :
1931 : // Just need to test if the character is before or on-or-after
1932 : // a particular character.
1933 201209 : if (start_index == end_index) {
1934 8607 : EmitBoundaryTest(masm, first, fall_through, even_label, odd_label);
1935 8607 : return;
1936 : }
1937 :
1938 : // Another almost trivial case: There is one interval in the middle that is
1939 : // different from the end intervals.
1940 192602 : if (start_index + 1 == end_index) {
1941 : EmitDoubleBoundaryTest(
1942 123209 : masm, first, last, fall_through, even_label, odd_label);
1943 123209 : return;
1944 : }
1945 :
1946 : // It's not worth using table lookup if there are very few intervals in the
1947 : // character class.
1948 69393 : if (end_index - start_index <= 6) {
1949 : // It is faster to test for individual characters, so we look for those
1950 : // first, then try arbitrary ranges in the second round.
1951 : static int kNoCutIndex = -1;
1952 35749 : int cut = kNoCutIndex;
1953 109745 : for (int i = start_index; i < end_index; i++) {
1954 185992 : if (ranges->at(i) == ranges->at(i + 1) - 1) {
1955 : cut = i;
1956 : break;
1957 : }
1958 : }
1959 35749 : if (cut == kNoCutIndex) cut = start_index;
1960 : CutOutRange(
1961 35749 : masm, ranges, start_index, end_index, cut, even_label, odd_label);
1962 : DCHECK_GE(end_index - start_index, 2);
1963 35749 : GenerateBranches(masm,
1964 : ranges,
1965 : start_index + 1,
1966 : end_index - 1,
1967 : min_char,
1968 : max_char,
1969 : fall_through,
1970 : even_label,
1971 35749 : odd_label);
1972 35749 : return;
1973 : }
1974 :
1975 : // If there are a lot of intervals in the regexp, then we will use tables to
1976 : // determine whether the character is inside or outside the character class.
1977 : static const int kBits = RegExpMacroAssembler::kTableSizeBits;
1978 :
1979 33644 : if ((max_char >> kBits) == (min_char >> kBits)) {
1980 : EmitUseLookupTable(masm,
1981 : ranges,
1982 : start_index,
1983 : end_index,
1984 : min_char,
1985 : fall_through,
1986 : even_label,
1987 5861 : odd_label);
1988 5861 : return;
1989 : }
1990 :
1991 27783 : if ((min_char >> kBits) != (first >> kBits)) {
1992 8016 : masm->CheckCharacterLT(first, odd_label);
1993 : GenerateBranches(masm,
1994 : ranges,
1995 : start_index + 1,
1996 : end_index,
1997 : first,
1998 : max_char,
1999 : fall_through,
2000 : odd_label,
2001 8016 : even_label);
2002 8016 : return;
2003 : }
2004 :
2005 19767 : int new_start_index = 0;
2006 19767 : int new_end_index = 0;
2007 19767 : int border = 0;
2008 :
2009 : SplitSearchSpace(ranges,
2010 : start_index,
2011 : end_index,
2012 : &new_start_index,
2013 : &new_end_index,
2014 19767 : &border);
2015 :
2016 19767 : Label handle_rest;
2017 : Label* above = &handle_rest;
2018 19767 : if (border == last + 1) {
2019 : // We didn't find any section that started after the limit, so everything
2020 : // above the border is one of the terminal labels.
2021 1225 : above = (end_index & 1) != (start_index & 1) ? odd_label : even_label;
2022 : DCHECK(new_end_index == end_index - 1);
2023 : }
2024 :
2025 : DCHECK_LE(start_index, new_end_index);
2026 : DCHECK_LE(new_start_index, end_index);
2027 : DCHECK_LT(start_index, new_start_index);
2028 : DCHECK_LT(new_end_index, end_index);
2029 : DCHECK(new_end_index + 1 == new_start_index ||
2030 : (new_end_index + 2 == new_start_index &&
2031 : border == ranges->at(new_end_index + 1)));
2032 : DCHECK_LT(min_char, border - 1);
2033 : DCHECK_LT(border, max_char);
2034 : DCHECK_LT(ranges->at(new_end_index), border);
2035 : DCHECK(border < ranges->at(new_start_index) ||
2036 : (border == ranges->at(new_start_index) &&
2037 : new_start_index == end_index &&
2038 : new_end_index == end_index - 1 &&
2039 : border == last + 1));
2040 : DCHECK(new_start_index == 0 || border >= ranges->at(new_start_index - 1));
2041 :
2042 19767 : masm->CheckCharacterGT(border - 1, above);
2043 19767 : Label dummy;
2044 19767 : GenerateBranches(masm,
2045 : ranges,
2046 : start_index,
2047 : new_end_index,
2048 : min_char,
2049 : border - 1,
2050 : &dummy,
2051 : even_label,
2052 19767 : odd_label);
2053 19767 : if (handle_rest.is_linked()) {
2054 18542 : masm->Bind(&handle_rest);
2055 18542 : bool flip = (new_start_index & 1) != (start_index & 1);
2056 18542 : GenerateBranches(masm,
2057 : ranges,
2058 : new_start_index,
2059 : end_index,
2060 : border,
2061 : max_char,
2062 : &dummy,
2063 : flip ? odd_label : even_label,
2064 18542 : flip ? even_label : odd_label);
2065 : }
2066 : }
2067 :
2068 :
2069 210321 : static void EmitCharClass(RegExpMacroAssembler* macro_assembler,
2070 : RegExpCharacterClass* cc, bool one_byte,
2071 : Label* on_failure, int cp_offset, bool check_offset,
2072 : bool preloaded, Zone* zone) {
2073 : ZoneList<CharacterRange>* ranges = cc->ranges(zone);
2074 210321 : CharacterRange::Canonicalize(ranges);
2075 :
2076 : int max_char;
2077 210321 : if (one_byte) {
2078 : max_char = String::kMaxOneByteCharCode;
2079 : } else {
2080 : max_char = String::kMaxUtf16CodeUnit;
2081 : }
2082 :
2083 : int range_count = ranges->length();
2084 :
2085 210321 : int last_valid_range = range_count - 1;
2086 571569 : while (last_valid_range >= 0) {
2087 : CharacterRange& range = ranges->at(last_valid_range);
2088 390910 : if (range.from() <= max_char) {
2089 : break;
2090 : }
2091 180624 : last_valid_range--;
2092 : }
2093 :
2094 210321 : if (last_valid_range < 0) {
2095 35 : if (!cc->is_negated()) {
2096 10 : macro_assembler->GoTo(on_failure);
2097 : }
2098 35 : if (check_offset) {
2099 33 : macro_assembler->CheckPosition(cp_offset, on_failure);
2100 : }
2101 91186 : return;
2102 : }
2103 :
2104 398551 : if (last_valid_range == 0 &&
2105 : ranges->at(0).IsEverything(max_char)) {
2106 82556 : if (cc->is_negated()) {
2107 31 : macro_assembler->GoTo(on_failure);
2108 : } else {
2109 : // This is a common case hit by non-anchored expressions.
2110 82525 : if (check_offset) {
2111 53744 : macro_assembler->CheckPosition(cp_offset, on_failure);
2112 : }
2113 : }
2114 : return;
2115 : }
2116 :
2117 127730 : if (!preloaded) {
2118 115595 : macro_assembler->LoadCurrentCharacter(cp_offset, on_failure, check_offset);
2119 : }
2120 :
2121 138399 : if (cc->is_standard(zone) &&
2122 10669 : macro_assembler->CheckSpecialCharacterClass(cc->standard_type(),
2123 10669 : on_failure)) {
2124 : return;
2125 : }
2126 :
2127 :
2128 : // A new list with ascending entries. Each entry is a code unit
2129 : // where there is a boundary between code units that are part of
2130 : // the class and code units that are not. Normally we insert an
2131 : // entry at zero which goes to the failure label, but if there
2132 : // was already one there we fall through for success on that entry.
2133 : // Subsequent entries have alternating meaning (success/failure).
2134 : ZoneList<int>* range_boundaries =
2135 : new(zone) ZoneList<int>(last_valid_range, zone);
2136 :
2137 119135 : bool zeroth_entry_is_failure = !cc->is_negated();
2138 :
2139 560951 : for (int i = 0; i <= last_valid_range; i++) {
2140 : CharacterRange& range = ranges->at(i);
2141 220908 : if (range.from() == 0) {
2142 : DCHECK_EQ(i, 0);
2143 3340 : zeroth_entry_is_failure = !zeroth_entry_is_failure;
2144 : } else {
2145 217568 : range_boundaries->Add(range.from(), zone);
2146 : }
2147 220908 : range_boundaries->Add(range.to() + 1, zone);
2148 : }
2149 119135 : int end_index = range_boundaries->length() - 1;
2150 119135 : if (range_boundaries->at(end_index) > max_char) {
2151 3938 : end_index--;
2152 : }
2153 :
2154 119135 : Label fall_through;
2155 119135 : GenerateBranches(macro_assembler,
2156 : range_boundaries,
2157 : 0, // start_index.
2158 : end_index,
2159 : 0, // min_char.
2160 : max_char,
2161 : &fall_through,
2162 : zeroth_entry_is_failure ? &fall_through : on_failure,
2163 119135 : zeroth_entry_is_failure ? on_failure : &fall_through);
2164 119135 : macro_assembler->Bind(&fall_through);
2165 : }
2166 :
2167 : RegExpNode::~RegExpNode() = default;
2168 :
2169 1696687 : RegExpNode::LimitResult RegExpNode::LimitVersions(RegExpCompiler* compiler,
2170 : Trace* trace) {
2171 : // If we are generating a greedy loop then don't stop and don't reuse code.
2172 1696687 : if (trace->stop_node() != nullptr) {
2173 : return CONTINUE;
2174 : }
2175 :
2176 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
2177 1685008 : if (trace->is_trivial()) {
2178 1059316 : if (label_.is_bound() || on_work_list() || !KeepRecursing(compiler)) {
2179 : // If a generic version is already scheduled to be generated or we have
2180 : // recursed too deeply then just generate a jump to that code.
2181 219532 : macro_assembler->GoTo(&label_);
2182 : // This will queue it up for generation of a generic version if it hasn't
2183 : // already been queued.
2184 219532 : compiler->AddWork(this);
2185 219532 : return DONE;
2186 : }
2187 : // Generate generic version of the node and bind the label for later use.
2188 391381 : macro_assembler->Bind(&label_);
2189 391381 : return CONTINUE;
2190 : }
2191 :
2192 : // We are being asked to make a non-generic version. Keep track of how many
2193 : // non-generic versions we generate so as not to overdo it.
2194 1074095 : trace_count_++;
2195 1074095 : if (KeepRecursing(compiler) && compiler->optimize() &&
2196 : trace_count_ < kMaxCopiesCodeGenerated) {
2197 : return CONTINUE;
2198 : }
2199 :
2200 : // If we get here code has been generated for this node too many times or
2201 : // recursion is too deep. Time to switch to a generic version. The code for
2202 : // generic versions above can handle deep recursion properly.
2203 : bool was_limiting = compiler->limiting_recursion();
2204 : compiler->set_limiting_recursion(true);
2205 477635 : trace->Flush(compiler, this);
2206 : compiler->set_limiting_recursion(was_limiting);
2207 477635 : return DONE;
2208 : }
2209 :
2210 :
2211 0 : bool RegExpNode::KeepRecursing(RegExpCompiler* compiler) {
2212 2033283 : return !compiler->limiting_recursion() &&
2213 0 : compiler->recursion_depth() <= RegExpCompiler::kMaxRecursion;
2214 : }
2215 :
2216 :
2217 583324 : int ActionNode::EatsAtLeast(int still_to_find,
2218 : int budget,
2219 : bool not_at_start) {
2220 583324 : if (budget <= 0) return 0;
2221 570316 : if (action_type_ == POSITIVE_SUBMATCH_SUCCESS) return 0; // Rewinds input!
2222 565178 : return on_success()->EatsAtLeast(still_to_find,
2223 : budget - 1,
2224 1130356 : not_at_start);
2225 : }
2226 :
2227 :
2228 90541 : void ActionNode::FillInBMInfo(Isolate* isolate, int offset, int budget,
2229 : BoyerMooreLookahead* bm, bool not_at_start) {
2230 90541 : if (action_type_ != POSITIVE_SUBMATCH_SUCCESS) {
2231 90541 : on_success()->FillInBMInfo(isolate, offset, budget - 1, bm, not_at_start);
2232 : }
2233 : SaveBMInfo(bm, not_at_start, offset);
2234 90541 : }
2235 :
2236 :
2237 10161 : int AssertionNode::EatsAtLeast(int still_to_find,
2238 : int budget,
2239 : bool not_at_start) {
2240 10161 : if (budget <= 0) return 0;
2241 : // If we know we are not at the start and we are asked "how many characters
2242 : // will you match if you succeed?" then we can answer anything since false
2243 : // implies false. So lets just return the max answer (still_to_find) since
2244 : // that won't prevent us from preloading a lot of characters for the other
2245 : // branches in the node graph.
2246 9152 : if (assertion_type() == AT_START && not_at_start) return still_to_find;
2247 8930 : return on_success()->EatsAtLeast(still_to_find,
2248 : budget - 1,
2249 17860 : not_at_start);
2250 : }
2251 :
2252 :
2253 379 : void AssertionNode::FillInBMInfo(Isolate* isolate, int offset, int budget,
2254 : BoyerMooreLookahead* bm, bool not_at_start) {
2255 : // Match the behaviour of EatsAtLeast on this node.
2256 379 : if (assertion_type() == AT_START && not_at_start) return;
2257 363 : on_success()->FillInBMInfo(isolate, offset, budget - 1, bm, not_at_start);
2258 : SaveBMInfo(bm, not_at_start, offset);
2259 : }
2260 :
2261 :
2262 3111 : int BackReferenceNode::EatsAtLeast(int still_to_find,
2263 : int budget,
2264 : bool not_at_start) {
2265 3111 : if (read_backward()) return 0;
2266 3001 : if (budget <= 0) return 0;
2267 3001 : return on_success()->EatsAtLeast(still_to_find,
2268 : budget - 1,
2269 6002 : not_at_start);
2270 : }
2271 :
2272 :
2273 5764439 : int TextNode::EatsAtLeast(int still_to_find,
2274 : int budget,
2275 : bool not_at_start) {
2276 5764439 : if (read_backward()) return 0;
2277 5762587 : int answer = Length();
2278 5762587 : if (answer >= still_to_find) return answer;
2279 3398629 : if (budget <= 0) return answer;
2280 : // We are not at start after this node so we set the last argument to 'true'.
2281 2373988 : return answer + on_success()->EatsAtLeast(still_to_find - answer,
2282 : budget - 1,
2283 4747976 : true);
2284 : }
2285 :
2286 :
2287 9503 : int NegativeLookaroundChoiceNode::EatsAtLeast(int still_to_find, int budget,
2288 : bool not_at_start) {
2289 9503 : if (budget <= 0) return 0;
2290 : // Alternative 0 is the negative lookahead, alternative 1 is what comes
2291 : // afterwards.
2292 9291 : RegExpNode* node = alternatives_->at(1).node();
2293 9291 : return node->EatsAtLeast(still_to_find, budget - 1, not_at_start);
2294 : }
2295 :
2296 :
2297 3556 : void NegativeLookaroundChoiceNode::GetQuickCheckDetails(
2298 : QuickCheckDetails* details, RegExpCompiler* compiler, int filled_in,
2299 : bool not_at_start) {
2300 : // Alternative 0 is the negative lookahead, alternative 1 is what comes
2301 : // afterwards.
2302 3556 : RegExpNode* node = alternatives_->at(1).node();
2303 3556 : return node->GetQuickCheckDetails(details, compiler, filled_in, not_at_start);
2304 : }
2305 :
2306 :
2307 6945187 : int ChoiceNode::EatsAtLeastHelper(int still_to_find,
2308 : int budget,
2309 : RegExpNode* ignore_this_node,
2310 : bool not_at_start) {
2311 6945187 : if (budget <= 0) return 0;
2312 : int min = 100;
2313 4818926 : int choice_count = alternatives_->length();
2314 4818926 : budget = (budget - 1) / choice_count;
2315 16627180 : for (int i = 0; i < choice_count; i++) {
2316 10401544 : RegExpNode* node = alternatives_->at(i).node();
2317 10401544 : if (node == ignore_this_node) continue;
2318 : int node_eats_at_least =
2319 10256739 : node->EatsAtLeast(still_to_find, budget, not_at_start);
2320 10256739 : if (node_eats_at_least < min) min = node_eats_at_least;
2321 10256739 : if (min == 0) return 0;
2322 : }
2323 : return min;
2324 : }
2325 :
2326 :
2327 153250 : int LoopChoiceNode::EatsAtLeast(int still_to_find,
2328 : int budget,
2329 : bool not_at_start) {
2330 153250 : return EatsAtLeastHelper(still_to_find,
2331 : budget - 1,
2332 : loop_node_,
2333 153250 : not_at_start);
2334 : }
2335 :
2336 :
2337 6791937 : int ChoiceNode::EatsAtLeast(int still_to_find,
2338 : int budget,
2339 : bool not_at_start) {
2340 6791937 : return EatsAtLeastHelper(still_to_find, budget, nullptr, not_at_start);
2341 : }
2342 :
2343 :
2344 : // Takes the left-most 1-bit and smears it out, setting all bits to its right.
2345 : static inline uint32_t SmearBitsRight(uint32_t v) {
2346 240093 : v |= v >> 1;
2347 240093 : v |= v >> 2;
2348 240093 : v |= v >> 4;
2349 240093 : v |= v >> 8;
2350 240093 : v |= v >> 16;
2351 : return v;
2352 : }
2353 :
2354 :
2355 270850 : bool QuickCheckDetails::Rationalize(bool asc) {
2356 : bool found_useful_op = false;
2357 : uint32_t char_mask;
2358 270850 : if (asc) {
2359 : char_mask = String::kMaxOneByteCharCode;
2360 : } else {
2361 : char_mask = String::kMaxUtf16CodeUnit;
2362 : }
2363 270850 : mask_ = 0;
2364 270850 : value_ = 0;
2365 : int char_shift = 0;
2366 1133670 : for (int i = 0; i < characters_; i++) {
2367 : Position* pos = &positions_[i];
2368 431410 : if ((pos->mask & String::kMaxOneByteCharCode) != 0) {
2369 : found_useful_op = true;
2370 : }
2371 431410 : mask_ |= (pos->mask & char_mask) << char_shift;
2372 431410 : value_ |= (pos->value & char_mask) << char_shift;
2373 431410 : char_shift += asc ? 8 : 16;
2374 : }
2375 270850 : return found_useful_op;
2376 : }
2377 :
2378 :
2379 475413 : bool RegExpNode::EmitQuickCheck(RegExpCompiler* compiler,
2380 : Trace* bounds_check_trace,
2381 : Trace* trace,
2382 : bool preload_has_checked_bounds,
2383 : Label* on_possible_success,
2384 : QuickCheckDetails* details,
2385 : bool fall_through_on_failure) {
2386 475413 : if (details->characters() == 0) return false;
2387 270960 : GetQuickCheckDetails(
2388 541920 : details, compiler, 0, trace->at_start() == Trace::FALSE_VALUE);
2389 270960 : if (details->cannot_match()) return false;
2390 270850 : if (!details->Rationalize(compiler->one_byte())) return false;
2391 : DCHECK(details->characters() == 1 ||
2392 : compiler->macro_assembler()->CanReadUnaligned());
2393 : uint32_t mask = details->mask();
2394 : uint32_t value = details->value();
2395 :
2396 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
2397 :
2398 226208 : if (trace->characters_preloaded() != details->characters()) {
2399 : DCHECK(trace->cp_offset() == bounds_check_trace->cp_offset());
2400 : // We are attempting to preload the minimum number of characters
2401 : // any choice would eat, so if the bounds check fails, then none of the
2402 : // choices can succeed, so we can just immediately backtrack, rather
2403 : // than go to the next choice.
2404 63014 : assembler->LoadCurrentCharacter(trace->cp_offset(),
2405 : bounds_check_trace->backtrack(),
2406 63014 : !preload_has_checked_bounds,
2407 126028 : details->characters());
2408 : }
2409 :
2410 :
2411 : bool need_mask = true;
2412 :
2413 226208 : if (details->characters() == 1) {
2414 : // If number of characters preloaded is 1 then we used a byte or 16 bit
2415 : // load so the value is already masked down.
2416 : uint32_t char_mask;
2417 82209 : if (compiler->one_byte()) {
2418 : char_mask = String::kMaxOneByteCharCode;
2419 : } else {
2420 : char_mask = String::kMaxUtf16CodeUnit;
2421 : }
2422 82209 : if ((mask & char_mask) == char_mask) need_mask = false;
2423 : mask &= char_mask;
2424 : } else {
2425 : // For 2-character preloads in one-byte mode or 1-character preloads in
2426 : // two-byte mode we also use a 16 bit load with zero extend.
2427 : static const uint32_t kTwoByteMask = 0xFFFF;
2428 : static const uint32_t kFourByteMask = 0xFFFFFFFF;
2429 143999 : if (details->characters() == 2 && compiler->one_byte()) {
2430 127878 : if ((mask & kTwoByteMask) == kTwoByteMask) need_mask = false;
2431 16121 : } else if (details->characters() == 1 && !compiler->one_byte()) {
2432 0 : if ((mask & kTwoByteMask) == kTwoByteMask) need_mask = false;
2433 : } else {
2434 16121 : if (mask == kFourByteMask) need_mask = false;
2435 : }
2436 : }
2437 :
2438 226208 : if (fall_through_on_failure) {
2439 191792 : if (need_mask) {
2440 46376 : assembler->CheckCharacterAfterAnd(value, mask, on_possible_success);
2441 : } else {
2442 145416 : assembler->CheckCharacter(value, on_possible_success);
2443 : }
2444 : } else {
2445 34416 : if (need_mask) {
2446 3739 : assembler->CheckNotCharacterAfterAnd(value, mask, trace->backtrack());
2447 : } else {
2448 30677 : assembler->CheckNotCharacter(value, trace->backtrack());
2449 : }
2450 : }
2451 : return true;
2452 : }
2453 :
2454 :
2455 : // Here is the meat of GetQuickCheckDetails (see also the comment on the
2456 : // super-class in the .h file).
2457 : //
2458 : // We iterate along the text object, building up for each character a
2459 : // mask and value that can be used to test for a quick failure to match.
2460 : // The masks and values for the positions will be combined into a single
2461 : // machine word for the current character width in order to be used in
2462 : // generating a quick check.
2463 461861 : void TextNode::GetQuickCheckDetails(QuickCheckDetails* details,
2464 : RegExpCompiler* compiler,
2465 : int characters_filled_in,
2466 : bool not_at_start) {
2467 : // Do not collect any quick check details if the text node reads backward,
2468 : // since it reads in the opposite direction than we use for quick checks.
2469 461861 : if (read_backward()) return;
2470 : Isolate* isolate = compiler->macro_assembler()->isolate();
2471 : DCHECK(characters_filled_in < details->characters());
2472 : int characters = details->characters();
2473 : int char_mask;
2474 461861 : if (compiler->one_byte()) {
2475 : char_mask = String::kMaxOneByteCharCode;
2476 : } else {
2477 : char_mask = String::kMaxUtf16CodeUnit;
2478 : }
2479 546813 : for (int k = 0; k < elements()->length(); k++) {
2480 466390 : TextElement elm = elements()->at(k);
2481 466390 : if (elm.text_type() == TextElement::ATOM) {
2482 : Vector<const uc16> quarks = elm.atom()->data();
2483 1163457 : for (int i = 0; i < characters && i < quarks.length(); i++) {
2484 : QuickCheckDetails::Position* pos =
2485 : details->positions(characters_filled_in);
2486 949236 : uc16 c = quarks[i];
2487 474618 : if (elm.atom()->ignore_case()) {
2488 : unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
2489 6250 : int length = GetCaseIndependentLetters(isolate, c,
2490 6250 : compiler->one_byte(), chars);
2491 6250 : if (length == 0) {
2492 : // This can happen because all case variants are non-Latin1, but we
2493 : // know the input is Latin1.
2494 : details->set_cannot_match();
2495 25 : pos->determines_perfectly = false;
2496 25 : return;
2497 : }
2498 6225 : if (length == 1) {
2499 : // This letter has no case equivalents, so it's nice and simple
2500 : // and the mask-compare will determine definitely whether we have
2501 : // a match at this character position.
2502 1227 : pos->mask = char_mask;
2503 1227 : pos->value = c;
2504 1227 : pos->determines_perfectly = true;
2505 : } else {
2506 4998 : uint32_t common_bits = char_mask;
2507 4998 : uint32_t bits = chars[0];
2508 15700 : for (int j = 1; j < length; j++) {
2509 5351 : uint32_t differing_bits = ((chars[j] & common_bits) ^ bits);
2510 5351 : common_bits ^= differing_bits;
2511 5351 : bits &= common_bits;
2512 : }
2513 : // If length is 2 and common bits has only one zero in it then
2514 : // our mask and compare instruction will determine definitely
2515 : // whether we have a match at this character position. Otherwise
2516 : // it can only be an approximate check.
2517 4998 : uint32_t one_zero = (common_bits | ~char_mask);
2518 4998 : if (length == 2 && ((~one_zero) & ((~one_zero) - 1)) == 0) {
2519 4595 : pos->determines_perfectly = true;
2520 : }
2521 4998 : pos->mask = common_bits;
2522 4998 : pos->value = bits;
2523 : }
2524 : } else {
2525 : // Don't ignore case. Nice simple case where the mask-compare will
2526 : // determine definitely whether we have a match at this character
2527 : // position.
2528 468368 : if (c > char_mask) {
2529 : details->set_cannot_match();
2530 25 : pos->determines_perfectly = false;
2531 25 : return;
2532 : }
2533 468343 : pos->mask = char_mask;
2534 468343 : pos->value = c;
2535 468343 : pos->determines_perfectly = true;
2536 : }
2537 474568 : characters_filled_in++;
2538 : DCHECK(characters_filled_in <= details->characters());
2539 474568 : if (characters_filled_in == details->characters()) {
2540 : return;
2541 : }
2542 : }
2543 : } else {
2544 : QuickCheckDetails::Position* pos =
2545 : details->positions(characters_filled_in);
2546 : RegExpCharacterClass* tree = elm.char_class();
2547 : ZoneList<CharacterRange>* ranges = tree->ranges(zone());
2548 : DCHECK(!ranges->is_empty());
2549 124450 : if (tree->is_negated()) {
2550 : // A quick check uses multi-character mask and compare. There is no
2551 : // useful way to incorporate a negative char class into this scheme
2552 : // so we just conservatively create a mask and value that will always
2553 : // succeed.
2554 3504 : pos->mask = 0;
2555 3504 : pos->value = 0;
2556 : } else {
2557 : int first_range = 0;
2558 120996 : while (ranges->at(first_range).from() > char_mask) {
2559 100 : first_range++;
2560 100 : if (first_range == ranges->length()) {
2561 : details->set_cannot_match();
2562 50 : pos->determines_perfectly = false;
2563 : return;
2564 : }
2565 : }
2566 120896 : CharacterRange range = ranges->at(first_range);
2567 120896 : uc16 from = range.from();
2568 120896 : uc16 to = range.to();
2569 120896 : if (to > char_mask) {
2570 15027 : to = char_mask;
2571 : }
2572 120896 : uint32_t differing_bits = (from ^ to);
2573 : // A mask and compare is only perfect if the differing bits form a
2574 : // number like 00011111 with one single block of trailing 1s.
2575 224625 : if ((differing_bits & (differing_bits + 1)) == 0 &&
2576 103729 : from + differing_bits == to) {
2577 94046 : pos->determines_perfectly = true;
2578 : }
2579 120896 : uint32_t common_bits = ~SmearBitsRight(differing_bits);
2580 120896 : uint32_t bits = (from & common_bits);
2581 748850 : for (int i = first_range + 1; i < ranges->length(); i++) {
2582 253529 : CharacterRange range = ranges->at(i);
2583 253529 : uc16 from = range.from();
2584 253529 : uc16 to = range.to();
2585 253529 : if (from > char_mask) continue;
2586 119197 : if (to > char_mask) to = char_mask;
2587 : // Here we are combining more ranges into the mask and compare
2588 : // value. With each new range the mask becomes more sparse and
2589 : // so the chances of a false positive rise. A character class
2590 : // with multiple ranges is assumed never to be equivalent to a
2591 : // mask and compare operation.
2592 119197 : pos->determines_perfectly = false;
2593 119197 : uint32_t new_common_bits = (from ^ to);
2594 119197 : new_common_bits = ~SmearBitsRight(new_common_bits);
2595 119197 : common_bits &= new_common_bits;
2596 119197 : bits &= new_common_bits;
2597 119197 : uint32_t differing_bits = (from & common_bits) ^ bits;
2598 119197 : common_bits ^= differing_bits;
2599 119197 : bits &= common_bits;
2600 : }
2601 120896 : pos->mask = common_bits;
2602 120896 : pos->value = bits;
2603 : }
2604 124400 : characters_filled_in++;
2605 : DCHECK(characters_filled_in <= details->characters());
2606 124400 : if (characters_filled_in == details->characters()) {
2607 : return;
2608 : }
2609 : }
2610 : }
2611 : DCHECK(characters_filled_in != details->characters());
2612 37947 : if (!details->cannot_match()) {
2613 : on_success()-> GetQuickCheckDetails(details,
2614 : compiler,
2615 : characters_filled_in,
2616 37947 : true);
2617 : }
2618 : }
2619 :
2620 :
2621 0 : void QuickCheckDetails::Clear() {
2622 1796875 : for (int i = 0; i < characters_; i++) {
2623 349336 : positions_[i].mask = 0;
2624 349336 : positions_[i].value = 0;
2625 349336 : positions_[i].determines_perfectly = false;
2626 : }
2627 1098203 : characters_ = 0;
2628 0 : }
2629 :
2630 :
2631 516610 : void QuickCheckDetails::Advance(int by, bool one_byte) {
2632 516610 : if (by >= characters_ || by < 0) {
2633 : DCHECK_IMPLIES(by < 0, characters_ == 0);
2634 : Clear();
2635 : return;
2636 : }
2637 : DCHECK_LE(characters_ - by, 4);
2638 : DCHECK_LE(characters_, 4);
2639 72957 : for (int i = 0; i < characters_ - by; i++) {
2640 24886 : positions_[i] = positions_[by + i];
2641 : }
2642 72949 : for (int i = characters_ - by; i < characters_; i++) {
2643 24882 : positions_[i].mask = 0;
2644 24882 : positions_[i].value = 0;
2645 24882 : positions_[i].determines_perfectly = false;
2646 : }
2647 23185 : characters_ -= by;
2648 : // We could change mask_ and value_ here but we would never advance unless
2649 : // they had already been used in a check and they won't be used again because
2650 : // it would gain us nothing. So there's no point.
2651 : }
2652 :
2653 :
2654 156974 : void QuickCheckDetails::Merge(QuickCheckDetails* other, int from_index) {
2655 : DCHECK(characters_ == other->characters_);
2656 156974 : if (other->cannot_match_) {
2657 : return;
2658 : }
2659 156900 : if (cannot_match_) {
2660 247 : *this = *other;
2661 247 : return;
2662 : }
2663 504267 : for (int i = from_index; i < characters_; i++) {
2664 : QuickCheckDetails::Position* pos = positions(i);
2665 : QuickCheckDetails::Position* other_pos = other->positions(i);
2666 206414 : if (pos->mask != other_pos->mask ||
2667 42713 : pos->value != other_pos->value ||
2668 10106 : !other_pos->determines_perfectly) {
2669 : // Our mask-compare operation will be approximate unless we have the
2670 : // exact same operation on both sides of the alternation.
2671 166503 : pos->determines_perfectly = false;
2672 : }
2673 173807 : pos->mask &= other_pos->mask;
2674 173807 : pos->value &= pos->mask;
2675 173807 : other_pos->value &= pos->mask;
2676 173807 : uc16 differing_bits = (pos->value ^ other_pos->value);
2677 173807 : pos->mask &= ~differing_bits;
2678 173807 : pos->value &= pos->mask;
2679 : }
2680 : }
2681 :
2682 :
2683 : class VisitMarker {
2684 : public:
2685 : explicit VisitMarker(NodeInfo* info) : info_(info) {
2686 : DCHECK(!info->visited);
2687 196642 : info->visited = true;
2688 : }
2689 : ~VisitMarker() {
2690 172716 : info_->visited = false;
2691 : }
2692 : private:
2693 : NodeInfo* info_;
2694 : };
2695 :
2696 98819 : RegExpNode* SeqRegExpNode::FilterOneByte(int depth) {
2697 98819 : if (info()->replacement_calculated) return replacement();
2698 72206 : if (depth < 0) return this;
2699 : DCHECK(!info()->visited);
2700 : VisitMarker marker(info());
2701 : return FilterSuccessor(depth - 1);
2702 : }
2703 :
2704 0 : RegExpNode* SeqRegExpNode::FilterSuccessor(int depth) {
2705 132271 : RegExpNode* next = on_success_->FilterOneByte(depth - 1);
2706 132271 : if (next == nullptr) return set_replacement(nullptr);
2707 131789 : on_success_ = next;
2708 131789 : return set_replacement(this);
2709 : }
2710 :
2711 : // We need to check for the following characters: 0x39C 0x3BC 0x178.
2712 1451 : static inline bool RangeContainsLatin1Equivalents(CharacterRange range) {
2713 : // TODO(dcarney): this could be a lot more efficient.
2714 4227 : return range.Contains(0x039C) || range.Contains(0x03BC) ||
2715 1451 : range.Contains(0x0178);
2716 : }
2717 :
2718 :
2719 41 : static bool RangesContainLatin1Equivalents(ZoneList<CharacterRange>* ranges) {
2720 81 : for (int i = 0; i < ranges->length(); i++) {
2721 : // TODO(dcarney): this could be a lot more efficient.
2722 46 : if (RangeContainsLatin1Equivalents(ranges->at(i))) return true;
2723 : }
2724 : return false;
2725 : }
2726 :
2727 64942 : RegExpNode* TextNode::FilterOneByte(int depth) {
2728 64942 : if (info()->replacement_calculated) return replacement();
2729 60709 : if (depth < 0) return this;
2730 : DCHECK(!info()->visited);
2731 : VisitMarker marker(info());
2732 : int element_count = elements()->length();
2733 190134 : for (int i = 0; i < element_count; i++) {
2734 65170 : TextElement elm = elements()->at(i);
2735 65170 : if (elm.text_type() == TextElement::ATOM) {
2736 : Vector<const uc16> quarks = elm.atom()->data();
2737 144979 : for (int j = 0; j < quarks.length(); j++) {
2738 114828 : uint16_t c = quarks[j];
2739 57414 : if (elm.atom()->ignore_case()) {
2740 : c = unibrow::Latin1::TryConvertToLatin1(c);
2741 : }
2742 57414 : if (c > unibrow::Latin1::kMaxChar) return set_replacement(nullptr);
2743 : // Replace quark in case we converted to Latin-1.
2744 : uint16_t* writable_quarks = const_cast<uint16_t*>(quarks.start());
2745 57248 : writable_quarks[j] = c;
2746 : }
2747 : } else {
2748 : DCHECK(elm.text_type() == TextElement::CHAR_CLASS);
2749 : RegExpCharacterClass* cc = elm.char_class();
2750 : ZoneList<CharacterRange>* ranges = cc->ranges(zone());
2751 34687 : CharacterRange::Canonicalize(ranges);
2752 : // Now they are in order so we only need to look at the first.
2753 : int range_count = ranges->length();
2754 34687 : if (cc->is_negated()) {
2755 8390 : if (range_count != 0 &&
2756 4373 : ranges->at(0).from() == 0 &&
2757 : ranges->at(0).to() >= String::kMaxOneByteCharCode) {
2758 : // This will be handled in a later filter.
2759 40 : if (IgnoreCase(cc->flags()) && RangesContainLatin1Equivalents(ranges))
2760 : continue;
2761 39 : return set_replacement(nullptr);
2762 : }
2763 : } else {
2764 30492 : if (range_count == 0 ||
2765 : ranges->at(0).from() > String::kMaxOneByteCharCode) {
2766 : // This will be handled in a later filter.
2767 255 : if (IgnoreCase(cc->flags()) && RangesContainLatin1Equivalents(ranges))
2768 : continue;
2769 230 : return set_replacement(nullptr);
2770 : }
2771 : }
2772 : }
2773 : }
2774 60229 : return FilterSuccessor(depth - 1);
2775 : }
2776 :
2777 59694 : RegExpNode* LoopChoiceNode::FilterOneByte(int depth) {
2778 59694 : if (info()->replacement_calculated) return replacement();
2779 46066 : if (depth < 0) return this;
2780 45976 : if (info()->visited) return this;
2781 : {
2782 : VisitMarker marker(info());
2783 :
2784 24274 : RegExpNode* continue_replacement = continue_node_->FilterOneByte(depth - 1);
2785 : // If we can't continue after the loop then there is no sense in doing the
2786 : // loop.
2787 24274 : if (continue_replacement == nullptr) return set_replacement(nullptr);
2788 : }
2789 :
2790 23926 : return ChoiceNode::FilterOneByte(depth - 1);
2791 : }
2792 :
2793 29721 : RegExpNode* ChoiceNode::FilterOneByte(int depth) {
2794 29721 : if (info()->replacement_calculated) return replacement();
2795 27678 : if (depth < 0) return this;
2796 27583 : if (info()->visited) return this;
2797 : VisitMarker marker(info());
2798 27583 : int choice_count = alternatives_->length();
2799 :
2800 143743 : for (int i = 0; i < choice_count; i++) {
2801 60452 : GuardedAlternative alternative = alternatives_->at(i);
2802 62824 : if (alternative.guards() != nullptr &&
2803 : alternative.guards()->length() != 0) {
2804 2372 : set_replacement(this);
2805 : return this;
2806 : }
2807 : }
2808 :
2809 : int surviving = 0;
2810 : RegExpNode* survivor = nullptr;
2811 140667 : for (int i = 0; i < choice_count; i++) {
2812 115456 : GuardedAlternative alternative = alternatives_->at(i);
2813 57728 : RegExpNode* replacement = alternative.node()->FilterOneByte(depth - 1);
2814 : DCHECK(replacement != this); // No missing EMPTY_MATCH_CHECK.
2815 57728 : if (replacement != nullptr) {
2816 57582 : alternatives_->at(i).set_node(replacement);
2817 57582 : surviving++;
2818 : survivor = replacement;
2819 : }
2820 : }
2821 25277 : if (surviving < 2) return set_replacement(survivor);
2822 :
2823 25145 : set_replacement(this);
2824 25145 : if (surviving == choice_count) {
2825 : return this;
2826 : }
2827 : // Only some of the nodes survived the filtering. We need to rebuild the
2828 : // alternatives list.
2829 : ZoneList<GuardedAlternative>* new_alternatives =
2830 : new(zone()) ZoneList<GuardedAlternative>(surviving, zone());
2831 380 : for (int i = 0; i < choice_count; i++) {
2832 : RegExpNode* replacement =
2833 360 : alternatives_->at(i).node()->FilterOneByte(depth - 1);
2834 180 : if (replacement != nullptr) {
2835 130 : alternatives_->at(i).set_node(replacement);
2836 260 : new_alternatives->Add(alternatives_->at(i), zone());
2837 : }
2838 : }
2839 20 : alternatives_ = new_alternatives;
2840 20 : return this;
2841 : }
2842 :
2843 357 : RegExpNode* NegativeLookaroundChoiceNode::FilterOneByte(int depth) {
2844 357 : if (info()->replacement_calculated) return replacement();
2845 357 : if (depth < 0) return this;
2846 357 : if (info()->visited) return this;
2847 : VisitMarker marker(info());
2848 : // Alternative 0 is the negative lookahead, alternative 1 is what comes
2849 : // afterwards.
2850 357 : RegExpNode* node = alternatives_->at(1).node();
2851 357 : RegExpNode* replacement = node->FilterOneByte(depth - 1);
2852 362 : if (replacement == nullptr) return set_replacement(nullptr);
2853 352 : alternatives_->at(1).set_node(replacement);
2854 :
2855 352 : RegExpNode* neg_node = alternatives_->at(0).node();
2856 352 : RegExpNode* neg_replacement = neg_node->FilterOneByte(depth - 1);
2857 : // If the negative lookahead is always going to fail then
2858 : // we don't need to check it.
2859 357 : if (neg_replacement == nullptr) return set_replacement(replacement);
2860 347 : alternatives_->at(0).set_node(neg_replacement);
2861 694 : return set_replacement(this);
2862 : }
2863 :
2864 :
2865 14889 : void LoopChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
2866 : RegExpCompiler* compiler,
2867 : int characters_filled_in,
2868 : bool not_at_start) {
2869 14889 : if (body_can_be_zero_length_ || info()->visited) return;
2870 : VisitMarker marker(info());
2871 11722 : return ChoiceNode::GetQuickCheckDetails(details,
2872 : compiler,
2873 : characters_filled_in,
2874 11722 : not_at_start);
2875 : }
2876 :
2877 :
2878 5126 : void LoopChoiceNode::FillInBMInfo(Isolate* isolate, int offset, int budget,
2879 : BoyerMooreLookahead* bm, bool not_at_start) {
2880 5126 : if (body_can_be_zero_length_ || budget <= 0) {
2881 : bm->SetRest(offset);
2882 : SaveBMInfo(bm, not_at_start, offset);
2883 : return;
2884 : }
2885 4910 : ChoiceNode::FillInBMInfo(isolate, offset, budget - 1, bm, not_at_start);
2886 : SaveBMInfo(bm, not_at_start, offset);
2887 : }
2888 :
2889 :
2890 38749 : void ChoiceNode::GetQuickCheckDetails(QuickCheckDetails* details,
2891 : RegExpCompiler* compiler,
2892 : int characters_filled_in,
2893 : bool not_at_start) {
2894 38749 : not_at_start = (not_at_start || not_at_start_);
2895 38749 : int choice_count = alternatives_->length();
2896 : DCHECK_LT(0, choice_count);
2897 38749 : alternatives_->at(0).node()->GetQuickCheckDetails(details,
2898 : compiler,
2899 : characters_filled_in,
2900 77498 : not_at_start);
2901 352697 : for (int i = 1; i < choice_count; i++) {
2902 : QuickCheckDetails new_details(details->characters());
2903 156974 : RegExpNode* node = alternatives_->at(i).node();
2904 : node->GetQuickCheckDetails(&new_details, compiler,
2905 : characters_filled_in,
2906 156974 : not_at_start);
2907 : // Here we merge the quick match details of the two branches.
2908 156974 : details->Merge(&new_details, characters_filled_in);
2909 : }
2910 38749 : }
2911 :
2912 :
2913 : // Check for [0-9A-Z_a-z].
2914 557 : static void EmitWordCheck(RegExpMacroAssembler* assembler,
2915 : Label* word,
2916 : Label* non_word,
2917 : bool fall_through_on_word) {
2918 557 : if (assembler->CheckSpecialCharacterClass(
2919 : fall_through_on_word ? 'w' : 'W',
2920 557 : fall_through_on_word ? non_word : word)) {
2921 : // Optimized implementation available.
2922 : return;
2923 : }
2924 99 : assembler->CheckCharacterGT('z', non_word);
2925 99 : assembler->CheckCharacterLT('0', non_word);
2926 99 : assembler->CheckCharacterGT('a' - 1, word);
2927 99 : assembler->CheckCharacterLT('9' + 1, word);
2928 99 : assembler->CheckCharacterLT('A', non_word);
2929 99 : assembler->CheckCharacterLT('Z' + 1, word);
2930 99 : if (fall_through_on_word) {
2931 34 : assembler->CheckNotCharacter('_', non_word);
2932 : } else {
2933 65 : assembler->CheckCharacter('_', word);
2934 : }
2935 : }
2936 :
2937 :
2938 : // Emit the code to check for a ^ in multiline mode (1-character lookbehind
2939 : // that matches newline or the start of input).
2940 129 : static void EmitHat(RegExpCompiler* compiler,
2941 : RegExpNode* on_success,
2942 : Trace* trace) {
2943 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
2944 : // We will be loading the previous character into the current character
2945 : // register.
2946 129 : Trace new_trace(*trace);
2947 : new_trace.InvalidateCurrentCharacter();
2948 :
2949 129 : Label ok;
2950 129 : if (new_trace.cp_offset() == 0) {
2951 : // The start of input counts as a newline in this context, so skip to
2952 : // ok if we are at the start.
2953 119 : assembler->CheckAtStart(&ok);
2954 : }
2955 : // We already checked that we are not at the start of input so it must be
2956 : // OK to load the previous character.
2957 129 : assembler->LoadCurrentCharacter(new_trace.cp_offset() -1,
2958 : new_trace.backtrack(),
2959 258 : false);
2960 129 : if (!assembler->CheckSpecialCharacterClass('n',
2961 129 : new_trace.backtrack())) {
2962 : // Newline means \n, \r, 0x2028 or 0x2029.
2963 24 : if (!compiler->one_byte()) {
2964 2 : assembler->CheckCharacterAfterAnd(0x2028, 0xFFFE, &ok);
2965 : }
2966 24 : assembler->CheckCharacter('\n', &ok);
2967 24 : assembler->CheckNotCharacter('\r', new_trace.backtrack());
2968 : }
2969 129 : assembler->Bind(&ok);
2970 129 : on_success->Emit(compiler, &new_trace);
2971 129 : }
2972 :
2973 :
2974 : // Emit the code to handle \b and \B (word-boundary or non-word-boundary).
2975 255 : void AssertionNode::EmitBoundaryCheck(RegExpCompiler* compiler, Trace* trace) {
2976 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
2977 : Isolate* isolate = assembler->isolate();
2978 : Trace::TriBool next_is_word_character = Trace::UNKNOWN;
2979 255 : bool not_at_start = (trace->at_start() == Trace::FALSE_VALUE);
2980 : BoyerMooreLookahead* lookahead = bm_info(not_at_start);
2981 255 : if (lookahead == nullptr) {
2982 : int eats_at_least =
2983 202 : Min(kMaxLookaheadForBoyerMoore, EatsAtLeast(kMaxLookaheadForBoyerMoore,
2984 : kRecursionBudget,
2985 202 : not_at_start));
2986 202 : if (eats_at_least >= 1) {
2987 : BoyerMooreLookahead* bm =
2988 97 : new(zone()) BoyerMooreLookahead(eats_at_least, compiler, zone());
2989 97 : FillInBMInfo(isolate, 0, kRecursionBudget, bm, not_at_start);
2990 97 : if (bm->at(0)->is_non_word())
2991 : next_is_word_character = Trace::FALSE_VALUE;
2992 97 : if (bm->at(0)->is_word()) next_is_word_character = Trace::TRUE_VALUE;
2993 : }
2994 : } else {
2995 53 : if (lookahead->at(0)->is_non_word())
2996 : next_is_word_character = Trace::FALSE_VALUE;
2997 53 : if (lookahead->at(0)->is_word())
2998 : next_is_word_character = Trace::TRUE_VALUE;
2999 : }
3000 255 : bool at_boundary = (assertion_type_ == AssertionNode::AT_BOUNDARY);
3001 255 : if (next_is_word_character == Trace::UNKNOWN) {
3002 151 : Label before_non_word;
3003 151 : Label before_word;
3004 151 : if (trace->characters_preloaded() != 1) {
3005 150 : assembler->LoadCurrentCharacter(trace->cp_offset(), &before_non_word);
3006 : }
3007 : // Fall through on non-word.
3008 151 : EmitWordCheck(assembler, &before_word, &before_non_word, false);
3009 : // Next character is not a word character.
3010 151 : assembler->Bind(&before_non_word);
3011 151 : Label ok;
3012 151 : BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
3013 151 : assembler->GoTo(&ok);
3014 :
3015 151 : assembler->Bind(&before_word);
3016 151 : BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
3017 151 : assembler->Bind(&ok);
3018 104 : } else if (next_is_word_character == Trace::TRUE_VALUE) {
3019 79 : BacktrackIfPrevious(compiler, trace, at_boundary ? kIsWord : kIsNonWord);
3020 : } else {
3021 : DCHECK(next_is_word_character == Trace::FALSE_VALUE);
3022 25 : BacktrackIfPrevious(compiler, trace, at_boundary ? kIsNonWord : kIsWord);
3023 : }
3024 255 : }
3025 :
3026 :
3027 406 : void AssertionNode::BacktrackIfPrevious(
3028 : RegExpCompiler* compiler,
3029 : Trace* trace,
3030 : AssertionNode::IfPrevious backtrack_if_previous) {
3031 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
3032 406 : Trace new_trace(*trace);
3033 : new_trace.InvalidateCurrentCharacter();
3034 :
3035 406 : Label fall_through, dummy;
3036 :
3037 : Label* non_word = backtrack_if_previous == kIsNonWord ?
3038 : new_trace.backtrack() :
3039 406 : &fall_through;
3040 : Label* word = backtrack_if_previous == kIsNonWord ?
3041 : &fall_through :
3042 406 : new_trace.backtrack();
3043 :
3044 406 : if (new_trace.cp_offset() == 0) {
3045 : // The start of input counts as a non-word character, so the question is
3046 : // decided if we are at the start.
3047 169 : assembler->CheckAtStart(non_word);
3048 : }
3049 : // We already checked that we are not at the start of input so it must be
3050 : // OK to load the previous character.
3051 406 : assembler->LoadCurrentCharacter(new_trace.cp_offset() - 1, &dummy, false);
3052 406 : EmitWordCheck(assembler, word, non_word, backtrack_if_previous == kIsNonWord);
3053 :
3054 406 : assembler->Bind(&fall_through);
3055 406 : on_success()->Emit(compiler, &new_trace);
3056 406 : }
3057 :
3058 :
3059 1935 : void AssertionNode::GetQuickCheckDetails(QuickCheckDetails* details,
3060 : RegExpCompiler* compiler,
3061 : int filled_in,
3062 : bool not_at_start) {
3063 1935 : if (assertion_type_ == AT_START && not_at_start) {
3064 : details->set_cannot_match();
3065 : return;
3066 : }
3067 1604 : return on_success()->GetQuickCheckDetails(details,
3068 : compiler,
3069 : filled_in,
3070 3208 : not_at_start);
3071 : }
3072 :
3073 :
3074 5747 : void AssertionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3075 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
3076 5747 : switch (assertion_type_) {
3077 : case AT_END: {
3078 2325 : Label ok;
3079 2325 : assembler->CheckPosition(trace->cp_offset(), &ok);
3080 2325 : assembler->GoTo(trace->backtrack());
3081 2325 : assembler->Bind(&ok);
3082 : break;
3083 : }
3084 : case AT_START: {
3085 3038 : if (trace->at_start() == Trace::FALSE_VALUE) {
3086 9 : assembler->GoTo(trace->backtrack());
3087 9 : return;
3088 : }
3089 3029 : if (trace->at_start() == Trace::UNKNOWN) {
3090 3029 : assembler->CheckNotAtStart(trace->cp_offset(), trace->backtrack());
3091 3029 : Trace at_start_trace = *trace;
3092 : at_start_trace.set_at_start(Trace::TRUE_VALUE);
3093 3029 : on_success()->Emit(compiler, &at_start_trace);
3094 : return;
3095 : }
3096 : }
3097 : break;
3098 : case AFTER_NEWLINE:
3099 129 : EmitHat(compiler, on_success(), trace);
3100 129 : return;
3101 : case AT_BOUNDARY:
3102 : case AT_NON_BOUNDARY: {
3103 255 : EmitBoundaryCheck(compiler, trace);
3104 255 : return;
3105 : }
3106 : }
3107 2325 : on_success()->Emit(compiler, trace);
3108 : }
3109 :
3110 :
3111 : static bool DeterminedAlready(QuickCheckDetails* quick_check, int offset) {
3112 2749326 : if (quick_check == nullptr) return false;
3113 2749326 : if (offset >= quick_check->characters()) return false;
3114 853525 : return quick_check->positions(offset)->determines_perfectly;
3115 : }
3116 :
3117 :
3118 : static void UpdateBoundsCheck(int index, int* checked_up_to) {
3119 800446 : if (index > *checked_up_to) {
3120 414555 : *checked_up_to = index;
3121 : }
3122 : }
3123 :
3124 :
3125 : // We call this repeatedly to generate code for each pass over the text node.
3126 : // The passes are in increasing order of difficulty because we hope one
3127 : // of the first passes will fail in which case we are saved the work of the
3128 : // later passes. for example for the case independent regexp /%[asdfghjkl]a/
3129 : // we will check the '%' in the first pass, the case independent 'a' in the
3130 : // second pass and the character class in the last pass.
3131 : //
3132 : // The passes are done from right to left, so for example to test for /bar/
3133 : // we will first test for an 'r' with offset 2, then an 'a' with offset 1
3134 : // and then a 'b' with offset 0. This means we can avoid the end-of-input
3135 : // bounds check most of the time. In the example we only need to check for
3136 : // end-of-input when loading the putative 'r'.
3137 : //
3138 : // A slight complication involves the fact that the first character may already
3139 : // be fetched into a register by the previous node. In this case we want to
3140 : // do the test for that character first. We do this in separate passes. The
3141 : // 'preloaded' argument indicates that we are doing such a 'pass'. If such a
3142 : // pass has been performed then subsequent passes will have true in
3143 : // first_element_checked to indicate that that character does not need to be
3144 : // checked again.
3145 : //
3146 : // In addition to all this we are passed a Trace, which can
3147 : // contain an AlternativeGeneration object. In this AlternativeGeneration
3148 : // object we can see details of any quick check that was already passed in
3149 : // order to get to the code we are now generating. The quick check can involve
3150 : // loading characters, which means we do not need to recheck the bounds
3151 : // up to the limit the quick check already checked. In addition the quick
3152 : // check can have involved a mask and compare operation which may simplify
3153 : // or obviate the need for further checks at some character positions.
3154 2700376 : void TextNode::TextEmitPass(RegExpCompiler* compiler,
3155 : TextEmitPassType pass,
3156 : bool preloaded,
3157 : Trace* trace,
3158 : bool first_element_checked,
3159 : int* checked_up_to) {
3160 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
3161 : Isolate* isolate = assembler->isolate();
3162 : bool one_byte = compiler->one_byte();
3163 : Label* backtrack = trace->backtrack();
3164 : QuickCheckDetails* quick_check = trace->quick_check_performed();
3165 : int element_count = elements()->length();
3166 2700376 : int backward_offset = read_backward() ? -Length() : 0;
3167 5656005 : for (int i = preloaded ? 0 : element_count - 1; i >= 0; i--) {
3168 2955654 : TextElement elm = elements()->at(i);
3169 2955654 : int cp_offset = trace->cp_offset() + elm.cp_offset() + backward_offset;
3170 2955654 : if (elm.text_type() == TextElement::ATOM) {
3171 1812552 : if (SkipPass(pass, elm.atom()->ignore_case())) continue;
3172 : Vector<const uc16> quarks = elm.atom()->data();
3173 4635131 : for (int j = preloaded ? 0 : quarks.length() - 1; j >= 0; j--) {
3174 2591804 : if (first_element_checked && i == 0 && j == 0) continue;
3175 5022364 : if (DeterminedAlready(quick_check, elm.cp_offset() + j)) continue;
3176 : EmitCharacterFunction* emit_function = nullptr;
3177 3408926 : uc16 quark = quarks[j];
3178 1704463 : if (elm.atom()->ignore_case()) {
3179 : // Everywhere else we assume that a non-Latin-1 character cannot match
3180 : // a Latin-1 character. Avoid the cases where this is assumption is
3181 : // invalid by using the Latin1 equivalent instead.
3182 : quark = unibrow::Latin1::TryConvertToLatin1(quark);
3183 : }
3184 1704463 : switch (pass) {
3185 : case NON_LATIN1_MATCH:
3186 : DCHECK(one_byte);
3187 518596 : if (quark > String::kMaxOneByteCharCode) {
3188 25 : assembler->GoTo(backtrack);
3189 : return;
3190 : }
3191 : break;
3192 : case NON_LETTER_CHARACTER_MATCH:
3193 : emit_function = &EmitAtomNonLetter;
3194 5503 : break;
3195 : case SIMPLE_CHARACTER_MATCH:
3196 : emit_function = &EmitSimpleCharacter;
3197 584679 : break;
3198 : case CASE_CHARACTER_MATCH:
3199 : emit_function = &EmitAtomLetter;
3200 5503 : break;
3201 : default:
3202 : break;
3203 : }
3204 1704438 : if (emit_function != nullptr) {
3205 595685 : bool bounds_check = *checked_up_to < cp_offset + j || read_backward();
3206 : bool bound_checked =
3207 595685 : emit_function(isolate, compiler, quark, backtrack, cp_offset + j,
3208 595685 : bounds_check, preloaded);
3209 595685 : if (bound_checked) UpdateBoundsCheck(cp_offset + j, checked_up_to);
3210 : }
3211 : }
3212 : } else {
3213 : DCHECK_EQ(TextElement::CHAR_CLASS, elm.text_type());
3214 1143102 : if (pass == CHARACTER_CLASS_MATCH) {
3215 276849 : if (first_element_checked && i == 0) continue;
3216 238144 : if (DeterminedAlready(quick_check, elm.cp_offset())) continue;
3217 : RegExpCharacterClass* cc = elm.char_class();
3218 210321 : bool bounds_check = *checked_up_to < cp_offset || read_backward();
3219 210321 : EmitCharClass(assembler, cc, one_byte, backtrack, cp_offset,
3220 210321 : bounds_check, preloaded, zone());
3221 : UpdateBoundsCheck(cp_offset, checked_up_to);
3222 : }
3223 : }
3224 : }
3225 : }
3226 :
3227 :
3228 6952599 : int TextNode::Length() {
3229 6952599 : TextElement elm = elements()->last();
3230 : DCHECK_LE(0, elm.cp_offset());
3231 6952599 : return elm.cp_offset() + elm.length();
3232 : }
3233 :
3234 0 : bool TextNode::SkipPass(TextEmitPassType pass, bool ignore_case) {
3235 1812552 : if (ignore_case) {
3236 44755 : return pass == SIMPLE_CHARACTER_MATCH;
3237 : } else {
3238 1767797 : return pass == NON_LETTER_CHARACTER_MATCH || pass == CASE_CHARACTER_MATCH;
3239 : }
3240 : }
3241 :
3242 7207 : TextNode* TextNode::CreateForCharacterRanges(Zone* zone,
3243 : ZoneList<CharacterRange>* ranges,
3244 : bool read_backward,
3245 : RegExpNode* on_success,
3246 : JSRegExp::Flags flags) {
3247 : DCHECK_NOT_NULL(ranges);
3248 : ZoneList<TextElement>* elms = new (zone) ZoneList<TextElement>(1, zone);
3249 14414 : elms->Add(TextElement::CharClass(
3250 21621 : new (zone) RegExpCharacterClass(zone, ranges, flags)),
3251 7207 : zone);
3252 7207 : return new (zone) TextNode(elms, read_backward, on_success);
3253 : }
3254 :
3255 27070 : TextNode* TextNode::CreateForSurrogatePair(Zone* zone, CharacterRange lead,
3256 : CharacterRange trail,
3257 : bool read_backward,
3258 : RegExpNode* on_success,
3259 : JSRegExp::Flags flags) {
3260 27070 : ZoneList<CharacterRange>* lead_ranges = CharacterRange::List(zone, lead);
3261 27070 : ZoneList<CharacterRange>* trail_ranges = CharacterRange::List(zone, trail);
3262 : ZoneList<TextElement>* elms = new (zone) ZoneList<TextElement>(2, zone);
3263 54140 : elms->Add(TextElement::CharClass(
3264 81210 : new (zone) RegExpCharacterClass(zone, lead_ranges, flags)),
3265 27070 : zone);
3266 54140 : elms->Add(TextElement::CharClass(
3267 81210 : new (zone) RegExpCharacterClass(zone, trail_ranges, flags)),
3268 27070 : zone);
3269 27070 : return new (zone) TextNode(elms, read_backward, on_success);
3270 : }
3271 :
3272 :
3273 : // This generates the code to match a text node. A text node can contain
3274 : // straight character sequences (possibly to be matched in a case-independent
3275 : // way) and character classes. For efficiency we do not do this in a single
3276 : // pass from left to right. Instead we pass over the text node several times,
3277 : // emitting code for some character positions every time. See the comment on
3278 : // TextEmitPass for details.
3279 618231 : void TextNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3280 618231 : LimitResult limit_result = LimitVersions(compiler, trace);
3281 719852 : if (limit_result == DONE) return;
3282 : DCHECK(limit_result == CONTINUE);
3283 :
3284 516610 : if (trace->cp_offset() + Length() > RegExpMacroAssembler::kMaxCPOffset) {
3285 : compiler->SetRegExpTooBig();
3286 : return;
3287 : }
3288 :
3289 516610 : if (compiler->one_byte()) {
3290 322668 : int dummy = 0;
3291 322668 : TextEmitPass(compiler, NON_LATIN1_MATCH, false, trace, false, &dummy);
3292 : }
3293 :
3294 : bool first_elt_done = false;
3295 516610 : int bound_checked_to = trace->cp_offset() - 1;
3296 516610 : bound_checked_to += trace->bound_checked_up_to();
3297 :
3298 : // If a character is preloaded into the current character register then
3299 : // check that now.
3300 516610 : if (trace->characters_preloaded() == 1) {
3301 700353 : for (int pass = kFirstRealPass; pass <= kLastPass; pass++) {
3302 311268 : TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), true, trace,
3303 311268 : false, &bound_checked_to);
3304 : }
3305 : first_elt_done = true;
3306 : }
3307 :
3308 4649490 : for (int pass = kFirstRealPass; pass <= kLastPass; pass++) {
3309 2066440 : TextEmitPass(compiler, static_cast<TextEmitPassType>(pass), false, trace,
3310 2066440 : first_elt_done, &bound_checked_to);
3311 : }
3312 :
3313 516610 : Trace successor_trace(*trace);
3314 : // If we advance backward, we may end up at the start.
3315 521782 : successor_trace.AdvanceCurrentPositionInTrace(
3316 521782 : read_backward() ? -Length() : Length(), compiler);
3317 516610 : successor_trace.set_at_start(read_backward() ? Trace::UNKNOWN
3318 : : Trace::FALSE_VALUE);
3319 : RecursionCheck rc(compiler);
3320 516610 : on_success()->Emit(compiler, &successor_trace);
3321 : }
3322 :
3323 :
3324 0 : void Trace::InvalidateCurrentCharacter() {
3325 227920 : characters_preloaded_ = 0;
3326 0 : }
3327 :
3328 :
3329 516610 : void Trace::AdvanceCurrentPositionInTrace(int by, RegExpCompiler* compiler) {
3330 : // We don't have an instruction for shifting the current character register
3331 : // down or for using a shifted value for anything so lets just forget that
3332 : // we preloaded any characters into it.
3333 516610 : characters_preloaded_ = 0;
3334 : // Adjust the offsets of the quick check performed information. This
3335 : // information is used to find out what we already determined about the
3336 : // characters by means of mask and compare.
3337 516610 : quick_check_performed_.Advance(by, compiler->one_byte());
3338 516610 : cp_offset_ += by;
3339 516610 : if (cp_offset_ > RegExpMacroAssembler::kMaxCPOffset) {
3340 : compiler->SetRegExpTooBig();
3341 0 : cp_offset_ = 0;
3342 : }
3343 1033220 : bound_checked_up_to_ = Max(0, bound_checked_up_to_ - by);
3344 516610 : }
3345 :
3346 :
3347 317597 : void TextNode::MakeCaseIndependent(Isolate* isolate, bool is_one_byte) {
3348 : int element_count = elements()->length();
3349 1076097 : for (int i = 0; i < element_count; i++) {
3350 379250 : TextElement elm = elements()->at(i);
3351 379250 : if (elm.text_type() == TextElement::CHAR_CLASS) {
3352 : RegExpCharacterClass* cc = elm.char_class();
3353 : #ifdef V8_INTL_SUPPORT
3354 : bool case_equivalents_already_added =
3355 : NeedsUnicodeCaseEquivalents(cc->flags());
3356 : #else
3357 : bool case_equivalents_already_added = false;
3358 : #endif
3359 237631 : if (IgnoreCase(cc->flags()) && !case_equivalents_already_added) {
3360 : // None of the standard character classes is different in the case
3361 : // independent case and it slows us down if we don't know that.
3362 68981 : if (cc->is_standard(zone())) continue;
3363 : ZoneList<CharacterRange>* ranges = cc->ranges(zone());
3364 66900 : CharacterRange::AddCaseEquivalents(isolate, zone(), ranges,
3365 66900 : is_one_byte);
3366 : }
3367 : }
3368 : }
3369 317597 : }
3370 :
3371 :
3372 135183 : int TextNode::GreedyLoopTextLength() { return Length(); }
3373 :
3374 :
3375 85868 : RegExpNode* TextNode::GetSuccessorOfOmnivorousTextNode(
3376 : RegExpCompiler* compiler) {
3377 85868 : if (read_backward()) return nullptr;
3378 85743 : if (elements()->length() != 1) return nullptr;
3379 85381 : TextElement elm = elements()->at(0);
3380 85381 : if (elm.text_type() != TextElement::CHAR_CLASS) return nullptr;
3381 : RegExpCharacterClass* node = elm.char_class();
3382 : ZoneList<CharacterRange>* ranges = node->ranges(zone());
3383 84026 : CharacterRange::Canonicalize(ranges);
3384 84026 : if (node->is_negated()) {
3385 111 : return ranges->length() == 0 ? on_success() : nullptr;
3386 : }
3387 83915 : if (ranges->length() != 1) return nullptr;
3388 : uint32_t max_char;
3389 83455 : if (compiler->one_byte()) {
3390 : max_char = String::kMaxOneByteCharCode;
3391 : } else {
3392 : max_char = String::kMaxUtf16CodeUnit;
3393 : }
3394 166910 : return ranges->at(0).IsEverything(max_char) ? on_success() : nullptr;
3395 : }
3396 :
3397 :
3398 : // Finds the fixed match length of a sequence of nodes that goes from
3399 : // this alternative and back to this choice node. If there are variable
3400 : // length nodes or other complications in the way then return a sentinel
3401 : // value indicating that a greedy loop cannot be constructed.
3402 225246 : int ChoiceNode::GreedyLoopTextLengthForAlternative(
3403 : GuardedAlternative* alternative) {
3404 : int length = 0;
3405 : RegExpNode* node = alternative->node();
3406 : // Later we will generate code for all these text nodes using recursion
3407 : // so we have to limit the max number.
3408 : int recursion_depth = 0;
3409 495612 : while (node != this) {
3410 337091 : if (recursion_depth++ > RegExpCompiler::kMaxRecursion) {
3411 : return kNodeIsTooComplexForGreedyLoops;
3412 : }
3413 337091 : int node_length = node->GreedyLoopTextLength();
3414 337091 : if (node_length == kNodeIsTooComplexForGreedyLoops) {
3415 : return kNodeIsTooComplexForGreedyLoops;
3416 : }
3417 135183 : length += node_length;
3418 : SeqRegExpNode* seq_node = static_cast<SeqRegExpNode*>(node);
3419 : node = seq_node->on_success();
3420 : }
3421 23338 : return read_backward() ? -length : length;
3422 : }
3423 :
3424 :
3425 0 : void LoopChoiceNode::AddLoopAlternative(GuardedAlternative alt) {
3426 : DCHECK_NULL(loop_node_);
3427 : AddAlternative(alt);
3428 999366 : loop_node_ = alt.node();
3429 0 : }
3430 :
3431 :
3432 0 : void LoopChoiceNode::AddContinueAlternative(GuardedAlternative alt) {
3433 : DCHECK_NULL(continue_node_);
3434 : AddAlternative(alt);
3435 999366 : continue_node_ = alt.node();
3436 0 : }
3437 :
3438 :
3439 332426 : void LoopChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3440 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
3441 332426 : if (trace->stop_node() == this) {
3442 : // Back edge of greedy optimized loop node graph.
3443 : int text_length =
3444 11669 : GreedyLoopTextLengthForAlternative(&(alternatives_->at(0)));
3445 : DCHECK_NE(kNodeIsTooComplexForGreedyLoops, text_length);
3446 : // Update the counter-based backtracking info on the stack. This is an
3447 : // optimization for greedy loops (see below).
3448 : DCHECK(trace->cp_offset() == text_length);
3449 11669 : macro_assembler->AdvanceCurrentPosition(text_length);
3450 11669 : macro_assembler->GoTo(trace->loop_label());
3451 11669 : return;
3452 : }
3453 : DCHECK_NULL(trace->stop_node());
3454 320757 : if (!trace->is_trivial()) {
3455 119240 : trace->Flush(compiler, this);
3456 119240 : return;
3457 : }
3458 201517 : ChoiceNode::Emit(compiler, trace);
3459 : }
3460 :
3461 :
3462 213577 : int ChoiceNode::CalculatePreloadCharacters(RegExpCompiler* compiler,
3463 : int eats_at_least) {
3464 : int preload_characters = Min(4, eats_at_least);
3465 : DCHECK_LE(preload_characters, 4);
3466 213577 : if (compiler->macro_assembler()->CanReadUnaligned()) {
3467 : bool one_byte = compiler->one_byte();
3468 134307 : if (one_byte) {
3469 : // We can't preload 3 characters because there is no machine instruction
3470 : // to do that. We can't just load 4 because we could be reading
3471 : // beyond the end of the string, which could cause a memory fault.
3472 106724 : if (preload_characters == 3) preload_characters = 2;
3473 : } else {
3474 27583 : if (preload_characters > 2) preload_characters = 2;
3475 : }
3476 : } else {
3477 79270 : if (preload_characters > 1) preload_characters = 1;
3478 : }
3479 213577 : return preload_characters;
3480 : }
3481 :
3482 :
3483 : // This class is used when generating the alternatives in a choice node. It
3484 : // records the way the alternative is being code generated.
3485 : class AlternativeGeneration: public Malloced {
3486 : public:
3487 : AlternativeGeneration()
3488 : : possible_success(),
3489 : expects_preload(false),
3490 : after(),
3491 2178987 : quick_check_details() { }
3492 : Label possible_success;
3493 : bool expects_preload;
3494 : Label after;
3495 : QuickCheckDetails quick_check_details;
3496 : };
3497 :
3498 :
3499 : // Creates a list of AlternativeGenerations. If the list has a reasonable
3500 : // size then it is on the stack, otherwise the excess is on the heap.
3501 : class AlternativeGenerationList {
3502 : public:
3503 213577 : AlternativeGenerationList(int count, Zone* zone)
3504 2349347 : : alt_gens_(count, zone) {
3505 1360037 : for (int i = 0; i < count && i < kAFew; i++) {
3506 573230 : alt_gens_.Add(a_few_alt_gens_ + i, zone);
3507 : }
3508 300011 : for (int i = kAFew; i < count; i++) {
3509 43217 : alt_gens_.Add(new AlternativeGeneration(), zone);
3510 : }
3511 213577 : }
3512 427154 : ~AlternativeGenerationList() {
3513 300011 : for (int i = kAFew; i < alt_gens_.length(); i++) {
3514 43217 : delete alt_gens_[i];
3515 43217 : alt_gens_[i] = nullptr;
3516 : }
3517 213577 : }
3518 :
3519 : AlternativeGeneration* at(int i) {
3520 1624095 : return alt_gens_[i];
3521 : }
3522 :
3523 : private:
3524 : static const int kAFew = 10;
3525 : ZoneList<AlternativeGeneration*> alt_gens_;
3526 : AlternativeGeneration a_few_alt_gens_[kAFew];
3527 : };
3528 :
3529 :
3530 : static const uc32 kRangeEndMarker = 0x110000;
3531 :
3532 : // The '2' variant is has inclusive from and exclusive to.
3533 : // This covers \s as defined in ECMA-262 5.1, 15.10.2.12,
3534 : // which include WhiteSpace (7.2) or LineTerminator (7.3) values.
3535 : static const int kSpaceRanges[] = {
3536 : '\t', '\r' + 1, ' ', ' ' + 1, 0x00A0, 0x00A1, 0x1680,
3537 : 0x1681, 0x2000, 0x200B, 0x2028, 0x202A, 0x202F, 0x2030,
3538 : 0x205F, 0x2060, 0x3000, 0x3001, 0xFEFF, 0xFF00, kRangeEndMarker};
3539 : static const int kSpaceRangeCount = arraysize(kSpaceRanges);
3540 :
3541 : static const int kWordRanges[] = {
3542 : '0', '9' + 1, 'A', 'Z' + 1, '_', '_' + 1, 'a', 'z' + 1, kRangeEndMarker};
3543 : static const int kWordRangeCount = arraysize(kWordRanges);
3544 : static const int kDigitRanges[] = {'0', '9' + 1, kRangeEndMarker};
3545 : static const int kDigitRangeCount = arraysize(kDigitRanges);
3546 : static const int kSurrogateRanges[] = {
3547 : kLeadSurrogateStart, kLeadSurrogateStart + 1, kRangeEndMarker};
3548 : static const int kSurrogateRangeCount = arraysize(kSurrogateRanges);
3549 : static const int kLineTerminatorRanges[] = {
3550 : 0x000A, 0x000B, 0x000D, 0x000E, 0x2028, 0x202A, kRangeEndMarker};
3551 : static const int kLineTerminatorRangeCount = arraysize(kLineTerminatorRanges);
3552 :
3553 0 : void BoyerMoorePositionInfo::Set(int character) {
3554 86629 : SetInterval(Interval(character, character));
3555 0 : }
3556 :
3557 :
3558 248438 : void BoyerMoorePositionInfo::SetInterval(const Interval& interval) {
3559 496876 : s_ = AddRange(s_, kSpaceRanges, kSpaceRangeCount, interval);
3560 496876 : w_ = AddRange(w_, kWordRanges, kWordRangeCount, interval);
3561 496876 : d_ = AddRange(d_, kDigitRanges, kDigitRangeCount, interval);
3562 : surrogate_ =
3563 496876 : AddRange(surrogate_, kSurrogateRanges, kSurrogateRangeCount, interval);
3564 248438 : if (interval.to() - interval.from() >= kMapSize - 1) {
3565 13580 : if (map_count_ != kMapSize) {
3566 6296 : map_count_ = kMapSize;
3567 1618072 : for (int i = 0; i < kMapSize; i++) map_->at(i) = true;
3568 : }
3569 : return;
3570 : }
3571 1234098 : for (int i = interval.from(); i <= interval.to(); i++) {
3572 544274 : int mod_character = (i & kMask);
3573 1088548 : if (!map_->at(mod_character)) {
3574 372553 : map_count_++;
3575 372553 : map_->at(mod_character) = true;
3576 : }
3577 544274 : if (map_count_ == kMapSize) return;
3578 : }
3579 : }
3580 :
3581 :
3582 0 : void BoyerMoorePositionInfo::SetAll() {
3583 5496 : s_ = w_ = d_ = kLatticeUnknown;
3584 5496 : if (map_count_ != kMapSize) {
3585 5066 : map_count_ = kMapSize;
3586 1301962 : for (int i = 0; i < kMapSize; i++) map_->at(i) = true;
3587 : }
3588 0 : }
3589 :
3590 :
3591 80731 : BoyerMooreLookahead::BoyerMooreLookahead(
3592 : int length, RegExpCompiler* compiler, Zone* zone)
3593 : : length_(length),
3594 80731 : compiler_(compiler) {
3595 80731 : if (compiler->one_byte()) {
3596 10107 : max_char_ = String::kMaxOneByteCharCode;
3597 : } else {
3598 70624 : max_char_ = String::kMaxUtf16CodeUnit;
3599 : }
3600 80731 : bitmaps_ = new(zone) ZoneList<BoyerMoorePositionInfo*>(length, zone);
3601 279659 : for (int i = 0; i < length; i++) {
3602 99464 : bitmaps_->Add(new(zone) BoyerMoorePositionInfo(zone), zone);
3603 : }
3604 80731 : }
3605 :
3606 :
3607 : // Find the longest range of lookahead that has the fewest number of different
3608 : // characters that can occur at a given position. Since we are optimizing two
3609 : // different parameters at once this is a tradeoff.
3610 0 : bool BoyerMooreLookahead::FindWorthwhileInterval(int* from, int* to) {
3611 : int biggest_points = 0;
3612 : // If more than 32 characters out of 128 can occur it is unlikely that we can
3613 : // be lucky enough to step forwards much of the time.
3614 : const int kMaxMax = 32;
3615 241902 : for (int max_number_of_chars = 4;
3616 322536 : max_number_of_chars < kMaxMax;
3617 : max_number_of_chars *= 2) {
3618 : biggest_points =
3619 241902 : FindBestInterval(max_number_of_chars, biggest_points, from, to);
3620 : }
3621 80634 : if (biggest_points == 0) return false;
3622 0 : return true;
3623 : }
3624 :
3625 :
3626 : // Find the highest-points range between 0 and length_ where the character
3627 : // information is not too vague. 'Too vague' means that there are more than
3628 : // max_number_of_chars that can occur at this position. Calculates the number
3629 : // of points as the product of width-of-the-range and
3630 : // probability-of-finding-one-of-the-characters, where the probability is
3631 : // calculated using the frequency distribution of the sample subject string.
3632 241902 : int BoyerMooreLookahead::FindBestInterval(
3633 : int max_number_of_chars, int old_biggest_points, int* from, int* to) {
3634 : int biggest_points = old_biggest_points;
3635 : static const int kSize = RegExpMacroAssembler::kTableSize;
3636 699994 : for (int i = 0; i < length_; ) {
3637 568407 : while (i < length_ && Count(i) > max_number_of_chars) i++;
3638 256761 : if (i == length_) break;
3639 : int remembered_from = i;
3640 : bool union_map[kSize];
3641 29546934 : for (int j = 0; j < kSize; j++) union_map[j] = false;
3642 1013570 : while (i < length_ && Count(i) <= max_number_of_chars) {
3643 513110 : BoyerMoorePositionInfo* map = bitmaps_->at(i);
3644 65934635 : for (int j = 0; j < kSize; j++) union_map[j] |= map->at(j);
3645 256555 : i++;
3646 : }
3647 : int frequency = 0;
3648 58864822 : for (int j = 0; j < kSize; j++) {
3649 29317888 : if (union_map[j]) {
3650 : // Add 1 to the frequency to give a small per-character boost for
3651 : // the cases where our sampling is not good enough and many
3652 : // characters have a frequency of zero. This means the frequency
3653 : // can theoretically be up to 2*kSize though we treat it mostly as
3654 : // a fraction of kSize.
3655 974202 : frequency += compiler_->frequency_collator()->Frequency(j) + 1;
3656 : }
3657 : }
3658 : // We use the probability of skipping times the distance we are skipping to
3659 : // judge the effectiveness of this. Actually we have a cut-off: By
3660 : // dividing by 2 we switch off the skipping if the probability of skipping
3661 : // is less than 50%. This is because the multibyte mask-and-compare
3662 : // skipping in quickcheck is more likely to do well on this case.
3663 : bool in_quickcheck_range =
3664 231850 : ((i - remembered_from < 4) ||
3665 2804 : (compiler_->one_byte() ? remembered_from <= 4 : remembered_from <= 2));
3666 : // Called 'probability' but it is only a rough estimate and can actually
3667 : // be outside the 0-kSize range.
3668 229046 : int probability = (in_quickcheck_range ? kSize / 2 : kSize) - frequency;
3669 229046 : int points = (i - remembered_from) * probability;
3670 229046 : if (points > biggest_points) {
3671 5873 : *from = remembered_from;
3672 5873 : *to = i - 1;
3673 : biggest_points = points;
3674 : }
3675 : }
3676 241902 : return biggest_points;
3677 : }
3678 :
3679 :
3680 : // Take all the characters that will not prevent a successful match if they
3681 : // occur in the subject string in the range between min_lookahead and
3682 : // max_lookahead (inclusive) measured from the current position. If the
3683 : // character at max_lookahead offset is not one of these characters, then we
3684 : // can safely skip forwards by the number of characters in the range.
3685 4463 : int BoyerMooreLookahead::GetSkipTable(int min_lookahead,
3686 : int max_lookahead,
3687 : Handle<ByteArray> boolean_skip_table) {
3688 : const int kSize = RegExpMacroAssembler::kTableSize;
3689 :
3690 : const int kSkipArrayEntry = 0;
3691 : const int kDontSkipArrayEntry = 1;
3692 :
3693 1146991 : for (int i = 0; i < kSize; i++) {
3694 : boolean_skip_table->set(i, kSkipArrayEntry);
3695 : }
3696 4463 : int skip = max_lookahead + 1 - min_lookahead;
3697 :
3698 23725 : for (int i = max_lookahead; i >= min_lookahead; i--) {
3699 19262 : BoyerMoorePositionInfo* map = bitmaps_->at(i);
3700 2475167 : for (int j = 0; j < kSize; j++) {
3701 1232768 : if (map->at(j)) {
3702 : boolean_skip_table->set(j, kDontSkipArrayEntry);
3703 : }
3704 : }
3705 : }
3706 :
3707 4463 : return skip;
3708 : }
3709 :
3710 :
3711 : // See comment above on the implementation of GetSkipTable.
3712 80634 : void BoyerMooreLookahead::EmitSkipInstructions(RegExpMacroAssembler* masm) {
3713 : const int kSize = RegExpMacroAssembler::kTableSize;
3714 :
3715 80634 : int min_lookahead = 0;
3716 80634 : int max_lookahead = 0;
3717 :
3718 156805 : if (!FindWorthwhileInterval(&min_lookahead, &max_lookahead)) return;
3719 :
3720 : bool found_single_character = false;
3721 : int single_character = 0;
3722 9850 : for (int i = max_lookahead; i >= min_lookahead; i--) {
3723 17666 : BoyerMoorePositionInfo* map = bitmaps_->at(i);
3724 17666 : if (map->map_count() > 1 ||
3725 3197 : (found_single_character && map->map_count() != 0)) {
3726 : found_single_character = false;
3727 : break;
3728 : }
3729 807192 : for (int j = 0; j < kSize; j++) {
3730 405705 : if (map->at(j)) {
3731 : found_single_character = true;
3732 : single_character = j;
3733 : break;
3734 : }
3735 : }
3736 : }
3737 :
3738 5480 : int lookahead_width = max_lookahead + 1 - min_lookahead;
3739 :
3740 5480 : if (found_single_character && lookahead_width == 1 && max_lookahead < 3) {
3741 : // The mask-compare can probably handle this better.
3742 : return;
3743 : }
3744 :
3745 4559 : if (found_single_character) {
3746 96 : Label cont, again;
3747 96 : masm->Bind(&again);
3748 96 : masm->LoadCurrentCharacter(max_lookahead, &cont, true);
3749 96 : if (max_char_ > kSize) {
3750 96 : masm->CheckCharacterAfterAnd(single_character,
3751 : RegExpMacroAssembler::kTableMask,
3752 192 : &cont);
3753 : } else {
3754 0 : masm->CheckCharacter(single_character, &cont);
3755 : }
3756 96 : masm->AdvanceCurrentPosition(lookahead_width);
3757 96 : masm->GoTo(&again);
3758 96 : masm->Bind(&cont);
3759 : return;
3760 : }
3761 :
3762 : Factory* factory = masm->isolate()->factory();
3763 : Handle<ByteArray> boolean_skip_table =
3764 4463 : factory->NewByteArray(kSize, AllocationType::kOld);
3765 4463 : int skip_distance = GetSkipTable(
3766 4463 : min_lookahead, max_lookahead, boolean_skip_table);
3767 : DCHECK_NE(0, skip_distance);
3768 :
3769 4463 : Label cont, again;
3770 4463 : masm->Bind(&again);
3771 4463 : masm->LoadCurrentCharacter(max_lookahead, &cont, true);
3772 4463 : masm->CheckBitInTable(boolean_skip_table, &cont);
3773 4463 : masm->AdvanceCurrentPosition(skip_distance);
3774 4463 : masm->GoTo(&again);
3775 4463 : masm->Bind(&cont);
3776 : }
3777 :
3778 :
3779 : /* Code generation for choice nodes.
3780 : *
3781 : * We generate quick checks that do a mask and compare to eliminate a
3782 : * choice. If the quick check succeeds then it jumps to the continuation to
3783 : * do slow checks and check subsequent nodes. If it fails (the common case)
3784 : * it falls through to the next choice.
3785 : *
3786 : * Here is the desired flow graph. Nodes directly below each other imply
3787 : * fallthrough. Alternatives 1 and 2 have quick checks. Alternative
3788 : * 3 doesn't have a quick check so we have to call the slow check.
3789 : * Nodes are marked Qn for quick checks and Sn for slow checks. The entire
3790 : * regexp continuation is generated directly after the Sn node, up to the
3791 : * next GoTo if we decide to reuse some already generated code. Some
3792 : * nodes expect preload_characters to be preloaded into the current
3793 : * character register. R nodes do this preloading. Vertices are marked
3794 : * F for failures and S for success (possible success in the case of quick
3795 : * nodes). L, V, < and > are used as arrow heads.
3796 : *
3797 : * ----------> R
3798 : * |
3799 : * V
3800 : * Q1 -----> S1
3801 : * | S /
3802 : * F| /
3803 : * | F/
3804 : * | /
3805 : * | R
3806 : * | /
3807 : * V L
3808 : * Q2 -----> S2
3809 : * | S /
3810 : * F| /
3811 : * | F/
3812 : * | /
3813 : * | R
3814 : * | /
3815 : * V L
3816 : * S3
3817 : * |
3818 : * F|
3819 : * |
3820 : * R
3821 : * |
3822 : * backtrack V
3823 : * <----------Q4
3824 : * \ F |
3825 : * \ |S
3826 : * \ F V
3827 : * \-----S4
3828 : *
3829 : * For greedy loops we push the current position, then generate the code that
3830 : * eats the input specially in EmitGreedyLoop. The other choice (the
3831 : * continuation) is generated by the normal code in EmitChoices, and steps back
3832 : * in the input to the starting position when it fails to match. The loop code
3833 : * looks like this (U is the unwind code that steps back in the greedy loop).
3834 : *
3835 : * _____
3836 : * / \
3837 : * V |
3838 : * ----------> S1 |
3839 : * /| |
3840 : * / |S |
3841 : * F/ \_____/
3842 : * /
3843 : * |<-----
3844 : * | \
3845 : * V |S
3846 : * Q2 ---> U----->backtrack
3847 : * | F /
3848 : * S| /
3849 : * V F /
3850 : * S2--/
3851 : */
3852 :
3853 213577 : GreedyLoopState::GreedyLoopState(bool not_at_start) {
3854 213577 : counter_backtrack_trace_.set_backtrack(&label_);
3855 213577 : if (not_at_start) counter_backtrack_trace_.set_at_start(Trace::FALSE_VALUE);
3856 213577 : }
3857 :
3858 :
3859 0 : void ChoiceNode::AssertGuardsMentionRegisters(Trace* trace) {
3860 : #ifdef DEBUG
3861 : int choice_count = alternatives_->length();
3862 : for (int i = 0; i < choice_count - 1; i++) {
3863 : GuardedAlternative alternative = alternatives_->at(i);
3864 : ZoneList<Guard*>* guards = alternative.guards();
3865 : int guard_count = (guards == nullptr) ? 0 : guards->length();
3866 : for (int j = 0; j < guard_count; j++) {
3867 : DCHECK(!trace->mentions_reg(guards->at(j)->reg()));
3868 : }
3869 : }
3870 : #endif
3871 0 : }
3872 :
3873 :
3874 213577 : void ChoiceNode::SetUpPreLoad(RegExpCompiler* compiler,
3875 : Trace* current_trace,
3876 : PreloadState* state) {
3877 213577 : if (state->eats_at_least_ == PreloadState::kEatsAtLeastNotYetInitialized) {
3878 : // Save some time by looking at most one machine word ahead.
3879 : state->eats_at_least_ =
3880 131432 : EatsAtLeast(compiler->one_byte() ? 4 : 2, kRecursionBudget,
3881 262864 : current_trace->at_start() == Trace::FALSE_VALUE);
3882 : }
3883 : state->preload_characters_ =
3884 213577 : CalculatePreloadCharacters(compiler, state->eats_at_least_);
3885 :
3886 : state->preload_is_current_ =
3887 213577 : (current_trace->characters_preloaded() == state->preload_characters_);
3888 213577 : state->preload_has_checked_bounds_ = state->preload_is_current_;
3889 213577 : }
3890 :
3891 :
3892 583225 : void ChoiceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
3893 583225 : int choice_count = alternatives_->length();
3894 :
3895 583225 : if (choice_count == 1 && alternatives_->at(0).guards() == nullptr) {
3896 1338 : alternatives_->at(0).node()->Emit(compiler, trace);
3897 1338 : return;
3898 : }
3899 :
3900 : AssertGuardsMentionRegisters(trace);
3901 :
3902 581887 : LimitResult limit_result = LimitVersions(compiler, trace);
3903 581887 : if (limit_result == DONE) return;
3904 : DCHECK(limit_result == CONTINUE);
3905 :
3906 : // For loop nodes we already flushed (see LoopChoiceNode::Emit), but for
3907 : // other choice nodes we only flush if we are out of code size budget.
3908 215037 : if (trace->flush_budget() == 0 && trace->actions() != nullptr) {
3909 1460 : trace->Flush(compiler, this);
3910 1460 : return;
3911 : }
3912 :
3913 : RecursionCheck rc(compiler);
3914 :
3915 : PreloadState preload;
3916 : preload.init();
3917 213577 : GreedyLoopState greedy_loop_state(not_at_start());
3918 :
3919 213577 : int text_length = GreedyLoopTextLengthForAlternative(&alternatives_->at(0));
3920 427154 : AlternativeGenerationList alt_gens(choice_count, zone());
3921 :
3922 213577 : if (choice_count > 1 && text_length != kNodeIsTooComplexForGreedyLoops) {
3923 : trace = EmitGreedyLoop(compiler,
3924 : trace,
3925 : &alt_gens,
3926 : &preload,
3927 : &greedy_loop_state,
3928 11669 : text_length);
3929 : } else {
3930 : // TODO(erikcorry): Delete this. We don't need this label, but it makes us
3931 : // match the traces produced pre-cleanup.
3932 201908 : Label second_choice;
3933 201908 : compiler->macro_assembler()->Bind(&second_choice);
3934 :
3935 201908 : preload.eats_at_least_ = EmitOptimizedUnanchoredSearch(compiler, trace);
3936 :
3937 : EmitChoices(compiler,
3938 : &alt_gens,
3939 : 0,
3940 : trace,
3941 201908 : &preload);
3942 : }
3943 :
3944 : // At this point we need to generate slow checks for the alternatives where
3945 : // the quick check was inlined. We can recognize these because the associated
3946 : // label was bound.
3947 213577 : int new_flush_budget = trace->flush_budget() / choice_count;
3948 1446471 : for (int i = 0; i < choice_count; i++) {
3949 : AlternativeGeneration* alt_gen = alt_gens.at(i);
3950 616447 : Trace new_trace(*trace);
3951 : // If there are actions to be flushed we have to limit how many times
3952 : // they are flushed. Take the budget of the parent trace and distribute
3953 : // it fairly amongst the children.
3954 616447 : if (new_trace.actions() != nullptr) {
3955 : new_trace.set_flush_budget(new_flush_budget);
3956 : }
3957 : bool next_expects_preload =
3958 1019317 : i == choice_count - 1 ? false : alt_gens.at(i + 1)->expects_preload;
3959 616447 : EmitOutOfLineContinuation(compiler,
3960 : &new_trace,
3961 616447 : alternatives_->at(i),
3962 : alt_gen,
3963 : preload.preload_characters_,
3964 616447 : next_expects_preload);
3965 : }
3966 : }
3967 :
3968 :
3969 11669 : Trace* ChoiceNode::EmitGreedyLoop(RegExpCompiler* compiler,
3970 : Trace* trace,
3971 : AlternativeGenerationList* alt_gens,
3972 : PreloadState* preload,
3973 : GreedyLoopState* greedy_loop_state,
3974 : int text_length) {
3975 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
3976 : // Here we have special handling for greedy loops containing only text nodes
3977 : // and other simple nodes. These are handled by pushing the current
3978 : // position on the stack and then incrementing the current position each
3979 : // time around the switch. On backtrack we decrement the current position
3980 : // and check it against the pushed value. This avoids pushing backtrack
3981 : // information for each iteration of the loop, which could take up a lot of
3982 : // space.
3983 : DCHECK(trace->stop_node() == nullptr);
3984 11669 : macro_assembler->PushCurrentPosition();
3985 11669 : Label greedy_match_failed;
3986 : Trace greedy_match_trace;
3987 11669 : if (not_at_start()) greedy_match_trace.set_at_start(Trace::FALSE_VALUE);
3988 : greedy_match_trace.set_backtrack(&greedy_match_failed);
3989 11669 : Label loop_label;
3990 11669 : macro_assembler->Bind(&loop_label);
3991 11669 : greedy_match_trace.set_stop_node(this);
3992 : greedy_match_trace.set_loop_label(&loop_label);
3993 11669 : alternatives_->at(0).node()->Emit(compiler, &greedy_match_trace);
3994 11669 : macro_assembler->Bind(&greedy_match_failed);
3995 :
3996 11669 : Label second_choice; // For use in greedy matches.
3997 11669 : macro_assembler->Bind(&second_choice);
3998 :
3999 : Trace* new_trace = greedy_loop_state->counter_backtrack_trace();
4000 :
4001 : EmitChoices(compiler,
4002 : alt_gens,
4003 : 1,
4004 : new_trace,
4005 11669 : preload);
4006 :
4007 23338 : macro_assembler->Bind(greedy_loop_state->label());
4008 : // If we have unwound to the bottom then backtrack.
4009 11669 : macro_assembler->CheckGreedyLoop(trace->backtrack());
4010 : // Otherwise try the second priority at an earlier position.
4011 11669 : macro_assembler->AdvanceCurrentPosition(-text_length);
4012 11669 : macro_assembler->GoTo(&second_choice);
4013 11669 : return new_trace;
4014 : }
4015 :
4016 201908 : int ChoiceNode::EmitOptimizedUnanchoredSearch(RegExpCompiler* compiler,
4017 : Trace* trace) {
4018 : int eats_at_least = PreloadState::kEatsAtLeastNotYetInitialized;
4019 403816 : if (alternatives_->length() != 2) return eats_at_least;
4020 :
4021 165798 : GuardedAlternative alt1 = alternatives_->at(1);
4022 167218 : if (alt1.guards() != nullptr && alt1.guards()->length() != 0) {
4023 : return eats_at_least;
4024 : }
4025 : RegExpNode* eats_anything_node = alt1.node();
4026 164378 : if (eats_anything_node->GetSuccessorOfOmnivorousTextNode(compiler) != this) {
4027 : return eats_at_least;
4028 : }
4029 :
4030 : // Really we should be creating a new trace when we execute this function,
4031 : // but there is no need, because the code it generates cannot backtrack, and
4032 : // we always arrive here with a trivial trace (since it's the entry to a
4033 : // loop. That also implies that there are no preloaded characters, which is
4034 : // good, because it means we won't be violating any assumptions by
4035 : // overwriting those characters with new load instructions.
4036 : DCHECK(trace->is_trivial());
4037 :
4038 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
4039 : Isolate* isolate = macro_assembler->isolate();
4040 : // At this point we know that we are at a non-greedy loop that will eat
4041 : // any character one at a time. Any non-anchored regexp has such a
4042 : // loop prepended to it in order to find where it starts. We look for
4043 : // a pattern of the form ...abc... where we can look 6 characters ahead
4044 : // and step forwards 3 if the character is not one of abc. Abc need
4045 : // not be atoms, they can be any reasonably limited character class or
4046 : // small alternation.
4047 : BoyerMooreLookahead* bm = bm_info(false);
4048 82145 : if (bm == nullptr) {
4049 82145 : eats_at_least = Min(kMaxLookaheadForBoyerMoore,
4050 : EatsAtLeast(kMaxLookaheadForBoyerMoore,
4051 : kRecursionBudget,
4052 82145 : false));
4053 82145 : if (eats_at_least >= 1) {
4054 : bm = new(zone()) BoyerMooreLookahead(eats_at_least,
4055 : compiler,
4056 80634 : zone());
4057 80634 : GuardedAlternative alt0 = alternatives_->at(0);
4058 80634 : alt0.node()->FillInBMInfo(isolate, 0, kRecursionBudget, bm, false);
4059 : }
4060 : }
4061 82145 : if (bm != nullptr) {
4062 80634 : bm->EmitSkipInstructions(macro_assembler);
4063 : }
4064 : return eats_at_least;
4065 : }
4066 :
4067 :
4068 213577 : void ChoiceNode::EmitChoices(RegExpCompiler* compiler,
4069 : AlternativeGenerationList* alt_gens,
4070 : int first_choice,
4071 : Trace* trace,
4072 : PreloadState* preload) {
4073 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
4074 213577 : SetUpPreLoad(compiler, trace, preload);
4075 :
4076 : // For now we just call all choices one after the other. The idea ultimately
4077 : // is to use the Dispatch table to try only the relevant ones.
4078 213577 : int choice_count = alternatives_->length();
4079 :
4080 213577 : int new_flush_budget = trace->flush_budget() / choice_count;
4081 :
4082 1423133 : for (int i = first_choice; i < choice_count; i++) {
4083 604778 : bool is_last = i == choice_count - 1;
4084 604778 : bool fall_through_on_failure = !is_last;
4085 1209556 : GuardedAlternative alternative = alternatives_->at(i);
4086 : AlternativeGeneration* alt_gen = alt_gens->at(i);
4087 604778 : alt_gen->quick_check_details.set_characters(preload->preload_characters_);
4088 : ZoneList<Guard*>* guards = alternative.guards();
4089 604778 : int guard_count = (guards == nullptr) ? 0 : guards->length();
4090 604778 : Trace new_trace(*trace);
4091 604778 : new_trace.set_characters_preloaded(preload->preload_is_current_ ?
4092 : preload->preload_characters_ :
4093 : 0);
4094 604778 : if (preload->preload_has_checked_bounds_) {
4095 399376 : new_trace.set_bound_checked_up_to(preload->preload_characters_);
4096 : }
4097 : new_trace.quick_check_performed()->Clear();
4098 604778 : if (not_at_start_) new_trace.set_at_start(Trace::FALSE_VALUE);
4099 604778 : if (!is_last) {
4100 391201 : new_trace.set_backtrack(&alt_gen->after);
4101 : }
4102 604778 : alt_gen->expects_preload = preload->preload_is_current_;
4103 : bool generate_full_check_inline = false;
4104 1082993 : if (compiler->optimize() &&
4105 1080191 : try_to_emit_quick_check_for_alternative(i == 0) &&
4106 950826 : alternative.node()->EmitQuickCheck(
4107 475413 : compiler, trace, &new_trace, preload->preload_has_checked_bounds_,
4108 : &alt_gen->possible_success, &alt_gen->quick_check_details,
4109 : fall_through_on_failure)) {
4110 : // Quick check was generated for this choice.
4111 226208 : preload->preload_is_current_ = true;
4112 226208 : preload->preload_has_checked_bounds_ = true;
4113 : // If we generated the quick check to fall through on possible success,
4114 : // we now need to generate the full check inline.
4115 226208 : if (!fall_through_on_failure) {
4116 34416 : macro_assembler->Bind(&alt_gen->possible_success);
4117 : new_trace.set_quick_check_performed(&alt_gen->quick_check_details);
4118 34416 : new_trace.set_characters_preloaded(preload->preload_characters_);
4119 : new_trace.set_bound_checked_up_to(preload->preload_characters_);
4120 : generate_full_check_inline = true;
4121 : }
4122 378570 : } else if (alt_gen->quick_check_details.cannot_match()) {
4123 110 : if (!fall_through_on_failure) {
4124 22 : macro_assembler->GoTo(trace->backtrack());
4125 : }
4126 110 : continue;
4127 : } else {
4128 : // No quick check was generated. Put the full code here.
4129 : // If this is not the first choice then there could be slow checks from
4130 : // previous cases that go here when they fail. There's no reason to
4131 : // insist that they preload characters since the slow check we are about
4132 : // to generate probably can't use it.
4133 378460 : if (i != first_choice) {
4134 227385 : alt_gen->expects_preload = false;
4135 : new_trace.InvalidateCurrentCharacter();
4136 : }
4137 : generate_full_check_inline = true;
4138 : }
4139 604668 : if (generate_full_check_inline) {
4140 412876 : if (new_trace.actions() != nullptr) {
4141 : new_trace.set_flush_budget(new_flush_budget);
4142 : }
4143 417828 : for (int j = 0; j < guard_count; j++) {
4144 2476 : GenerateGuard(macro_assembler, guards->at(j), &new_trace);
4145 : }
4146 412876 : alternative.node()->Emit(compiler, &new_trace);
4147 412876 : preload->preload_is_current_ = false;
4148 : }
4149 604668 : macro_assembler->Bind(&alt_gen->after);
4150 : }
4151 213577 : }
4152 :
4153 :
4154 616447 : void ChoiceNode::EmitOutOfLineContinuation(RegExpCompiler* compiler,
4155 : Trace* trace,
4156 : GuardedAlternative alternative,
4157 : AlternativeGeneration* alt_gen,
4158 : int preload_characters,
4159 : bool next_expects_preload) {
4160 1041102 : if (!alt_gen->possible_success.is_linked()) return;
4161 :
4162 : RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
4163 191792 : macro_assembler->Bind(&alt_gen->possible_success);
4164 191792 : Trace out_of_line_trace(*trace);
4165 : out_of_line_trace.set_characters_preloaded(preload_characters);
4166 : out_of_line_trace.set_quick_check_performed(&alt_gen->quick_check_details);
4167 191792 : if (not_at_start_) out_of_line_trace.set_at_start(Trace::FALSE_VALUE);
4168 : ZoneList<Guard*>* guards = alternative.guards();
4169 191792 : int guard_count = (guards == nullptr) ? 0 : guards->length();
4170 191792 : if (next_expects_preload) {
4171 162190 : Label reload_current_char;
4172 : out_of_line_trace.set_backtrack(&reload_current_char);
4173 164958 : for (int j = 0; j < guard_count; j++) {
4174 1384 : GenerateGuard(macro_assembler, guards->at(j), &out_of_line_trace);
4175 : }
4176 162190 : alternative.node()->Emit(compiler, &out_of_line_trace);
4177 162190 : macro_assembler->Bind(&reload_current_char);
4178 : // Reload the current character, since the next quick check expects that.
4179 : // We don't need to check bounds here because we only get into this
4180 : // code through a quick check which already did the checked load.
4181 : macro_assembler->LoadCurrentCharacter(trace->cp_offset(), nullptr, false,
4182 162190 : preload_characters);
4183 162190 : macro_assembler->GoTo(&(alt_gen->after));
4184 : } else {
4185 29602 : out_of_line_trace.set_backtrack(&(alt_gen->after));
4186 29754 : for (int j = 0; j < guard_count; j++) {
4187 76 : GenerateGuard(macro_assembler, guards->at(j), &out_of_line_trace);
4188 : }
4189 29602 : alternative.node()->Emit(compiler, &out_of_line_trace);
4190 : }
4191 : }
4192 :
4193 :
4194 494079 : void ActionNode::Emit(RegExpCompiler* compiler, Trace* trace) {
4195 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
4196 494079 : LimitResult limit_result = LimitVersions(compiler, trace);
4197 494079 : if (limit_result == DONE) return;
4198 : DCHECK(limit_result == CONTINUE);
4199 :
4200 : RecursionCheck rc(compiler);
4201 :
4202 265583 : switch (action_type_) {
4203 : case STORE_POSITION: {
4204 : Trace::DeferredCapture
4205 : new_capture(data_.u_position_register.reg,
4206 241131 : data_.u_position_register.is_capture,
4207 241131 : trace);
4208 241131 : Trace new_trace = *trace;
4209 : new_trace.add_action(&new_capture);
4210 241131 : on_success()->Emit(compiler, &new_trace);
4211 : break;
4212 : }
4213 : case INCREMENT_REGISTER: {
4214 : Trace::DeferredIncrementRegister
4215 3744 : new_increment(data_.u_increment_register.reg);
4216 3744 : Trace new_trace = *trace;
4217 : new_trace.add_action(&new_increment);
4218 3744 : on_success()->Emit(compiler, &new_trace);
4219 : break;
4220 : }
4221 : case SET_REGISTER: {
4222 : Trace::DeferredSetRegister
4223 3465 : new_set(data_.u_store_register.reg, data_.u_store_register.value);
4224 3465 : Trace new_trace = *trace;
4225 : new_trace.add_action(&new_set);
4226 3465 : on_success()->Emit(compiler, &new_trace);
4227 : break;
4228 : }
4229 : case CLEAR_CAPTURES: {
4230 : Trace::DeferredClearCaptures
4231 : new_capture(Interval(data_.u_clear_captures.range_from,
4232 2226 : data_.u_clear_captures.range_to));
4233 2226 : Trace new_trace = *trace;
4234 : new_trace.add_action(&new_capture);
4235 2226 : on_success()->Emit(compiler, &new_trace);
4236 : break;
4237 : }
4238 : case BEGIN_SUBMATCH:
4239 9478 : if (!trace->is_trivial()) {
4240 5041 : trace->Flush(compiler, this);
4241 : } else {
4242 4437 : assembler->WriteCurrentPositionToRegister(
4243 8874 : data_.u_submatch.current_position_register, 0);
4244 4437 : assembler->WriteStackPointerToRegister(
4245 8874 : data_.u_submatch.stack_pointer_register);
4246 4437 : on_success()->Emit(compiler, trace);
4247 : }
4248 : break;
4249 : case EMPTY_MATCH_CHECK: {
4250 973 : int start_pos_reg = data_.u_empty_match_check.start_register;
4251 973 : int stored_pos = 0;
4252 973 : int rep_reg = data_.u_empty_match_check.repetition_register;
4253 : bool has_minimum = (rep_reg != RegExpCompiler::kNoRegister);
4254 973 : bool know_dist = trace->GetStoredPosition(start_pos_reg, &stored_pos);
4255 973 : if (know_dist && !has_minimum && stored_pos == trace->cp_offset()) {
4256 : // If we know we haven't advanced and there is no minimum we
4257 : // can just backtrack immediately.
4258 76 : assembler->GoTo(trace->backtrack());
4259 897 : } else if (know_dist && stored_pos < trace->cp_offset()) {
4260 : // If we know we've advanced we can generate the continuation
4261 : // immediately.
4262 247 : on_success()->Emit(compiler, trace);
4263 650 : } else if (!trace->is_trivial()) {
4264 339 : trace->Flush(compiler, this);
4265 : } else {
4266 311 : Label skip_empty_check;
4267 : // If we have a minimum number of repetitions we check the current
4268 : // number first and skip the empty check if it's not enough.
4269 311 : if (has_minimum) {
4270 206 : int limit = data_.u_empty_match_check.repetition_limit;
4271 206 : assembler->IfRegisterLT(rep_reg, limit, &skip_empty_check);
4272 : }
4273 : // If the match is empty we bail out, otherwise we fall through
4274 : // to the on-success continuation.
4275 311 : assembler->IfRegisterEqPos(data_.u_empty_match_check.start_register,
4276 622 : trace->backtrack());
4277 311 : assembler->Bind(&skip_empty_check);
4278 311 : on_success()->Emit(compiler, trace);
4279 : }
4280 : break;
4281 : }
4282 : case POSITIVE_SUBMATCH_SUCCESS: {
4283 4566 : if (!trace->is_trivial()) {
4284 2936 : trace->Flush(compiler, this);
4285 2936 : return;
4286 : }
4287 1630 : assembler->ReadCurrentPositionFromRegister(
4288 3260 : data_.u_submatch.current_position_register);
4289 1630 : assembler->ReadStackPointerFromRegister(
4290 3260 : data_.u_submatch.stack_pointer_register);
4291 1630 : int clear_register_count = data_.u_submatch.clear_register_count;
4292 1630 : if (clear_register_count == 0) {
4293 1147 : on_success()->Emit(compiler, trace);
4294 1147 : return;
4295 : }
4296 483 : int clear_registers_from = data_.u_submatch.clear_register_from;
4297 483 : Label clear_registers_backtrack;
4298 483 : Trace new_trace = *trace;
4299 : new_trace.set_backtrack(&clear_registers_backtrack);
4300 483 : on_success()->Emit(compiler, &new_trace);
4301 :
4302 483 : assembler->Bind(&clear_registers_backtrack);
4303 483 : int clear_registers_to = clear_registers_from + clear_register_count - 1;
4304 483 : assembler->ClearRegisters(clear_registers_from, clear_registers_to);
4305 :
4306 : DCHECK(trace->backtrack() == nullptr);
4307 483 : assembler->Backtrack();
4308 483 : return;
4309 : }
4310 : default:
4311 0 : UNREACHABLE();
4312 : }
4313 : }
4314 :
4315 :
4316 4743 : void BackReferenceNode::Emit(RegExpCompiler* compiler, Trace* trace) {
4317 : RegExpMacroAssembler* assembler = compiler->macro_assembler();
4318 4743 : if (!trace->is_trivial()) {
4319 2253 : trace->Flush(compiler, this);
4320 2253 : return;
4321 : }
4322 :
4323 2490 : LimitResult limit_result = LimitVersions(compiler, trace);
4324 2490 : if (limit_result == DONE) return;
4325 : DCHECK(limit_result == CONTINUE);
4326 :
4327 : RecursionCheck rc(compiler);
4328 :
4329 : DCHECK_EQ(start_reg_ + 1, end_reg_);
4330 2290 : if (IgnoreCase(flags_)) {
4331 1681 : assembler->CheckNotBackReferenceIgnoreCase(
4332 3362 : start_reg_, read_backward(), IsUnicode(flags_), trace->backtrack());
4333 : } else {
4334 609 : assembler->CheckNotBackReference(start_reg_, read_backward(),
4335 1218 : trace->backtrack());
4336 : }
4337 : // We are going to advance backward, so we may end up at the start.
4338 2290 : if (read_backward()) trace->set_at_start(Trace::UNKNOWN);
4339 :
4340 : // Check that the back reference does not end inside a surrogate pair.
4341 2290 : if (IsUnicode(flags_) && !compiler->one_byte()) {
4342 80 : assembler->CheckNotInSurrogatePair(trace->cp_offset(), trace->backtrack());
4343 : }
4344 2290 : on_success()->Emit(compiler, trace);
4345 : }
4346 :
4347 :
4348 : // -------------------------------------------------------------------
4349 : // Dot/dotty output
4350 :
4351 :
4352 : #ifdef DEBUG
4353 :
4354 :
4355 : class DotPrinter: public NodeVisitor {
4356 : public:
4357 : DotPrinter(std::ostream& os, bool ignore_case) // NOLINT
4358 : : os_(os),
4359 : ignore_case_(ignore_case) {}
4360 : void PrintNode(const char* label, RegExpNode* node);
4361 : void Visit(RegExpNode* node);
4362 : void PrintAttributes(RegExpNode* from);
4363 : void PrintOnFailure(RegExpNode* from, RegExpNode* to);
4364 : #define DECLARE_VISIT(Type) \
4365 : virtual void Visit##Type(Type##Node* that);
4366 : FOR_EACH_NODE_TYPE(DECLARE_VISIT)
4367 : #undef DECLARE_VISIT
4368 : private:
4369 : std::ostream& os_;
4370 : bool ignore_case_;
4371 : };
4372 :
4373 :
4374 : void DotPrinter::PrintNode(const char* label, RegExpNode* node) {
4375 : os_ << "digraph G {\n graph [label=\"";
4376 : for (int i = 0; label[i]; i++) {
4377 : switch (label[i]) {
4378 : case '\\':
4379 : os_ << "\\\\";
4380 : break;
4381 : case '"':
4382 : os_ << "\"";
4383 : break;
4384 : default:
4385 : os_ << label[i];
4386 : break;
4387 : }
4388 : }
4389 : os_ << "\"];\n";
4390 : Visit(node);
4391 : os_ << "}" << std::endl;
4392 : }
4393 :
4394 :
4395 : void DotPrinter::Visit(RegExpNode* node) {
4396 : if (node->info()->visited) return;
4397 : node->info()->visited = true;
4398 : node->Accept(this);
4399 : }
4400 :
4401 :
4402 : void DotPrinter::PrintOnFailure(RegExpNode* from, RegExpNode* on_failure) {
4403 : os_ << " n" << from << " -> n" << on_failure << " [style=dotted];\n";
4404 : Visit(on_failure);
4405 : }
4406 :
4407 :
4408 : class TableEntryBodyPrinter {
4409 : public:
4410 : TableEntryBodyPrinter(std::ostream& os, ChoiceNode* choice) // NOLINT
4411 : : os_(os),
4412 : choice_(choice) {}
4413 : void Call(uc16 from, DispatchTable::Entry entry) {
4414 : OutSet* out_set = entry.out_set();
4415 : for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
4416 : if (out_set->Get(i)) {
4417 : os_ << " n" << choice() << ":s" << from << "o" << i << " -> n"
4418 : << choice()->alternatives()->at(i).node() << ";\n";
4419 : }
4420 : }
4421 : }
4422 : private:
4423 : ChoiceNode* choice() { return choice_; }
4424 : std::ostream& os_;
4425 : ChoiceNode* choice_;
4426 : };
4427 :
4428 :
4429 : class TableEntryHeaderPrinter {
4430 : public:
4431 : explicit TableEntryHeaderPrinter(std::ostream& os) // NOLINT
4432 : : first_(true),
4433 : os_(os) {}
4434 : void Call(uc16 from, DispatchTable::Entry entry) {
4435 : if (first_) {
4436 : first_ = false;
4437 : } else {
4438 : os_ << "|";
4439 : }
4440 : os_ << "{\\" << AsUC16(from) << "-\\" << AsUC16(entry.to()) << "|{";
4441 : OutSet* out_set = entry.out_set();
4442 : int priority = 0;
4443 : for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
4444 : if (out_set->Get(i)) {
4445 : if (priority > 0) os_ << "|";
4446 : os_ << "<s" << from << "o" << i << "> " << priority;
4447 : priority++;
4448 : }
4449 : }
4450 : os_ << "}}";
4451 : }
4452 :
4453 : private:
4454 : bool first_;
4455 : std::ostream& os_;
4456 : };
4457 :
4458 :
4459 : class AttributePrinter {
4460 : public:
4461 : explicit AttributePrinter(std::ostream& os) // NOLINT
4462 : : os_(os),
4463 : first_(true) {}
4464 : void PrintSeparator() {
4465 : if (first_) {
4466 : first_ = false;
4467 : } else {
4468 : os_ << "|";
4469 : }
4470 : }
4471 : void PrintBit(const char* name, bool value) {
4472 : if (!value) return;
4473 : PrintSeparator();
4474 : os_ << "{" << name << "}";
4475 : }
4476 : void PrintPositive(const char* name, int value) {
4477 : if (value < 0) return;
4478 : PrintSeparator();
4479 : os_ << "{" << name << "|" << value << "}";
4480 : }
4481 :
4482 : private:
4483 : std::ostream& os_;
4484 : bool first_;
4485 : };
4486 :
4487 :
4488 : void DotPrinter::PrintAttributes(RegExpNode* that) {
4489 : os_ << " a" << that << " [shape=Mrecord, color=grey, fontcolor=grey, "
4490 : << "margin=0.1, fontsize=10, label=\"{";
4491 : AttributePrinter printer(os_);
4492 : NodeInfo* info = that->info();
4493 : printer.PrintBit("NI", info->follows_newline_interest);
4494 : printer.PrintBit("WI", info->follows_word_interest);
4495 : printer.PrintBit("SI", info->follows_start_interest);
4496 : Label* label = that->label();
4497 : if (label->is_bound())
4498 : printer.PrintPositive("@", label->pos());
4499 : os_ << "}\"];\n"
4500 : << " a" << that << " -> n" << that
4501 : << " [style=dashed, color=grey, arrowhead=none];\n";
4502 : }
4503 :
4504 :
4505 : static const bool kPrintDispatchTable = false;
4506 : void DotPrinter::VisitChoice(ChoiceNode* that) {
4507 : if (kPrintDispatchTable) {
4508 : os_ << " n" << that << " [shape=Mrecord, label=\"";
4509 : TableEntryHeaderPrinter header_printer(os_);
4510 : that->GetTable(ignore_case_)->ForEach(&header_printer);
4511 : os_ << "\"]\n";
4512 : PrintAttributes(that);
4513 : TableEntryBodyPrinter body_printer(os_, that);
4514 : that->GetTable(ignore_case_)->ForEach(&body_printer);
4515 : } else {
4516 : os_ << " n" << that << " [shape=Mrecord, label=\"?\"];\n";
4517 : for (int i = 0; i < that->alternatives()->length(); i++) {
4518 : GuardedAlternative alt = that->alternatives()->at(i);
4519 : os_ << " n" << that << " -> n" << alt.node();
4520 : }
4521 : }
4522 : for (int i = 0; i < that->alternatives()->length(); i++) {
4523 : GuardedAlternative alt = that->alternatives()->at(i);
4524 : alt.node()->Accept(this);
4525 : }
4526 : }
4527 :
4528 :
4529 : void DotPrinter::VisitText(TextNode* that) {
4530 : Zone* zone = that->zone();
4531 : os_ << " n" << that << " [label=\"";
4532 : for (int i = 0; i < that->elements()->length(); i++) {
4533 : if (i > 0) os_ << " ";
4534 : TextElement elm = that->elements()->at(i);
4535 : switch (elm.text_type()) {
4536 : case TextElement::ATOM: {
4537 : Vector<const uc16> data = elm.atom()->data();
4538 : for (int i = 0; i < data.length(); i++) {
4539 : os_ << static_cast<char>(data[i]);
4540 : }
4541 : break;
4542 : }
4543 : case TextElement::CHAR_CLASS: {
4544 : RegExpCharacterClass* node = elm.char_class();
4545 : os_ << "[";
4546 : if (node->is_negated()) os_ << "^";
4547 : for (int j = 0; j < node->ranges(zone)->length(); j++) {
4548 : CharacterRange range = node->ranges(zone)->at(j);
4549 : os_ << AsUC16(range.from()) << "-" << AsUC16(range.to());
4550 : }
4551 : os_ << "]";
4552 : break;
4553 : }
4554 : default:
4555 : UNREACHABLE();
4556 : }
4557 : }
4558 : os_ << "\", shape=box, peripheries=2];\n";
4559 : PrintAttributes(that);
4560 : os_ << " n" << that << " -> n" << that->on_success() << ";\n";
4561 : Visit(that->on_success());
4562 : }
4563 :
4564 :
4565 : void DotPrinter::VisitBackReference(BackReferenceNode* that) {
4566 : os_ << " n" << that << " [label=\"$" << that->start_register() << "..$"
4567 : << that->end_register() << "\", shape=doubleoctagon];\n";
4568 : PrintAttributes(that);
4569 : os_ << " n" << that << " -> n" << that->on_success() << ";\n";
4570 : Visit(that->on_success());
4571 : }
4572 :
4573 :
4574 : void DotPrinter::VisitEnd(EndNode* that) {
4575 : os_ << " n" << that << " [style=bold, shape=point];\n";
4576 : PrintAttributes(that);
4577 : }
4578 :
4579 :
4580 : void DotPrinter::VisitAssertion(AssertionNode* that) {
4581 : os_ << " n" << that << " [";
4582 : switch (that->assertion_type()) {
4583 : case AssertionNode::AT_END:
4584 : os_ << "label=\"$\", shape=septagon";
4585 : break;
4586 : case AssertionNode::AT_START:
4587 : os_ << "label=\"^\", shape=septagon";
4588 : break;
4589 : case AssertionNode::AT_BOUNDARY:
4590 : os_ << "label=\"\\b\", shape=septagon";
4591 : break;
4592 : case AssertionNode::AT_NON_BOUNDARY:
4593 : os_ << "label=\"\\B\", shape=septagon";
4594 : break;
4595 : case AssertionNode::AFTER_NEWLINE:
4596 : os_ << "label=\"(?<=\\n)\", shape=septagon";
4597 : break;
4598 : }
4599 : os_ << "];\n";
4600 : PrintAttributes(that);
4601 : RegExpNode* successor = that->on_success();
4602 : os_ << " n" << that << " -> n" << successor << ";\n";
4603 : Visit(successor);
4604 : }
4605 :
4606 :
4607 : void DotPrinter::VisitAction(ActionNode* that) {
4608 : os_ << " n" << that << " [";
4609 : switch (that->action_type_) {
4610 : case ActionNode::SET_REGISTER:
4611 : os_ << "label=\"$" << that->data_.u_store_register.reg
4612 : << ":=" << that->data_.u_store_register.value << "\", shape=octagon";
4613 : break;
4614 : case ActionNode::INCREMENT_REGISTER:
4615 : os_ << "label=\"$" << that->data_.u_increment_register.reg
4616 : << "++\", shape=octagon";
4617 : break;
4618 : case ActionNode::STORE_POSITION:
4619 : os_ << "label=\"$" << that->data_.u_position_register.reg
4620 : << ":=$pos\", shape=octagon";
4621 : break;
4622 : case ActionNode::BEGIN_SUBMATCH:
4623 : os_ << "label=\"$" << that->data_.u_submatch.current_position_register
4624 : << ":=$pos,begin\", shape=septagon";
4625 : break;
4626 : case ActionNode::POSITIVE_SUBMATCH_SUCCESS:
4627 : os_ << "label=\"escape\", shape=septagon";
4628 : break;
4629 : case ActionNode::EMPTY_MATCH_CHECK:
4630 : os_ << "label=\"$" << that->data_.u_empty_match_check.start_register
4631 : << "=$pos?,$" << that->data_.u_empty_match_check.repetition_register
4632 : << "<" << that->data_.u_empty_match_check.repetition_limit
4633 : << "?\", shape=septagon";
4634 : break;
4635 : case ActionNode::CLEAR_CAPTURES: {
4636 : os_ << "label=\"clear $" << that->data_.u_clear_captures.range_from
4637 : << " to $" << that->data_.u_clear_captures.range_to
4638 : << "\", shape=septagon";
4639 : break;
4640 : }
4641 : }
4642 : os_ << "];\n";
4643 : PrintAttributes(that);
4644 : RegExpNode* successor = that->on_success();
4645 : os_ << " n" << that << " -> n" << successor << ";\n";
4646 : Visit(successor);
4647 : }
4648 :
4649 :
4650 : class DispatchTableDumper {
4651 : public:
4652 : explicit DispatchTableDumper(std::ostream& os) : os_(os) {}
4653 : void Call(uc16 key, DispatchTable::Entry entry);
4654 : private:
4655 : std::ostream& os_;
4656 : };
4657 :
4658 :
4659 : void DispatchTableDumper::Call(uc16 key, DispatchTable::Entry entry) {
4660 : os_ << "[" << AsUC16(key) << "-" << AsUC16(entry.to()) << "]: {";
4661 : OutSet* set = entry.out_set();
4662 : bool first = true;
4663 : for (unsigned i = 0; i < OutSet::kFirstLimit; i++) {
4664 : if (set->Get(i)) {
4665 : if (first) {
4666 : first = false;
4667 : } else {
4668 : os_ << ", ";
4669 : }
4670 : os_ << i;
4671 : }
4672 : }
4673 : os_ << "}\n";
4674 : }
4675 :
4676 :
4677 : void DispatchTable::Dump() {
4678 : OFStream os(stderr);
4679 : DispatchTableDumper dumper(os);
4680 : tree()->ForEach(&dumper);
4681 : }
4682 :
4683 :
4684 : void RegExpEngine::DotPrint(const char* label,
4685 : RegExpNode* node,
4686 : bool ignore_case) {
4687 : StdoutStream os;
4688 : DotPrinter printer(os, ignore_case);
4689 : printer.PrintNode(label, node);
4690 : }
4691 :
4692 :
4693 : #endif // DEBUG
4694 :
4695 :
4696 : // -------------------------------------------------------------------
4697 : // Tree to graph conversion
4698 :
4699 992591 : RegExpNode* RegExpAtom::ToNode(RegExpCompiler* compiler,
4700 : RegExpNode* on_success) {
4701 : ZoneList<TextElement>* elms =
4702 : new(compiler->zone()) ZoneList<TextElement>(1, compiler->zone());
4703 992591 : elms->Add(TextElement::Atom(this), compiler->zone());
4704 : return new (compiler->zone())
4705 992591 : TextNode(elms, compiler->read_backward(), on_success);
4706 : }
4707 :
4708 :
4709 18669 : RegExpNode* RegExpText::ToNode(RegExpCompiler* compiler,
4710 : RegExpNode* on_success) {
4711 : return new (compiler->zone())
4712 18669 : TextNode(elements(), compiler->read_backward(), on_success);
4713 : }
4714 :
4715 :
4716 552541 : static bool CompareInverseRanges(ZoneList<CharacterRange>* ranges,
4717 : const int* special_class,
4718 : int length) {
4719 552541 : length--; // Remove final marker.
4720 : DCHECK_EQ(kRangeEndMarker, special_class[length]);
4721 : DCHECK_NE(0, ranges->length());
4722 : DCHECK_NE(0, length);
4723 : DCHECK_NE(0, special_class[0]);
4724 552541 : if (ranges->length() != (length >> 1) + 1) {
4725 : return false;
4726 : }
4727 9969 : CharacterRange range = ranges->at(0);
4728 9969 : if (range.from() != 0) {
4729 : return false;
4730 : }
4731 56744 : for (int i = 0; i < length; i += 2) {
4732 24859 : if (special_class[i] != (range.to() + 1)) {
4733 : return false;
4734 : }
4735 48608 : range = ranges->at((i >> 1) + 1);
4736 24304 : if (special_class[i+1] != range.from()) {
4737 : return false;
4738 : }
4739 : }
4740 7581 : if (range.to() != String::kMaxCodePoint) {
4741 : return false;
4742 : }
4743 7581 : return true;
4744 : }
4745 :
4746 :
4747 547157 : static bool CompareRanges(ZoneList<CharacterRange>* ranges,
4748 : const int* special_class,
4749 : int length) {
4750 547157 : length--; // Remove final marker.
4751 : DCHECK_EQ(kRangeEndMarker, special_class[length]);
4752 547157 : if (ranges->length() * 2 != length) {
4753 : return false;
4754 : }
4755 27760 : for (int i = 0; i < length; i += 2) {
4756 29336 : CharacterRange range = ranges->at(i >> 1);
4757 25883 : if (range.from() != special_class[i] ||
4758 11215 : range.to() != special_class[i + 1] - 1) {
4759 : return false;
4760 : }
4761 : }
4762 : return true;
4763 : }
4764 :
4765 :
4766 196711 : bool RegExpCharacterClass::is_standard(Zone* zone) {
4767 : // TODO(lrn): Remove need for this function, by not throwing away information
4768 : // along the way.
4769 196711 : if (is_negated()) {
4770 : return false;
4771 : }
4772 191054 : if (set_.is_standard()) {
4773 : return true;
4774 : }
4775 187773 : if (CompareRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
4776 : set_.set_standard_set_type('s');
4777 607 : return true;
4778 : }
4779 187166 : if (CompareInverseRanges(set_.ranges(zone), kSpaceRanges, kSpaceRangeCount)) {
4780 : set_.set_standard_set_type('S');
4781 207 : return true;
4782 : }
4783 186959 : if (CompareInverseRanges(set_.ranges(zone),
4784 : kLineTerminatorRanges,
4785 : kLineTerminatorRangeCount)) {
4786 : set_.set_standard_set_type('.');
4787 7262 : return true;
4788 : }
4789 179697 : if (CompareRanges(set_.ranges(zone),
4790 : kLineTerminatorRanges,
4791 : kLineTerminatorRangeCount)) {
4792 : set_.set_standard_set_type('n');
4793 10 : return true;
4794 : }
4795 179687 : if (CompareRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
4796 : set_.set_standard_set_type('w');
4797 1271 : return true;
4798 : }
4799 178416 : if (CompareInverseRanges(set_.ranges(zone), kWordRanges, kWordRangeCount)) {
4800 : set_.set_standard_set_type('W');
4801 112 : return true;
4802 : }
4803 : return false;
4804 : }
4805 :
4806 :
4807 2587 : UnicodeRangeSplitter::UnicodeRangeSplitter(Zone* zone,
4808 : ZoneList<CharacterRange>* base)
4809 : : zone_(zone),
4810 : table_(zone),
4811 : bmp_(nullptr),
4812 : lead_surrogates_(nullptr),
4813 : trail_surrogates_(nullptr),
4814 5174 : non_bmp_(nullptr) {
4815 : // The unicode range splitter categorizes given character ranges into:
4816 : // - Code points from the BMP representable by one code unit.
4817 : // - Code points outside the BMP that need to be split into surrogate pairs.
4818 : // - Lone lead surrogates.
4819 : // - Lone trail surrogates.
4820 : // Lone surrogates are valid code points, even though no actual characters.
4821 : // They require special matching to make sure we do not split surrogate pairs.
4822 : // We use the dispatch table to accomplish this. The base range is split up
4823 : // by the table by the overlay ranges, and the Call callback is used to
4824 : // filter and collect ranges for each category.
4825 151143 : for (int i = 0; i < base->length(); i++) {
4826 148556 : table_.AddRange(base->at(i), kBase, zone_);
4827 : }
4828 : // Add overlay ranges.
4829 2587 : table_.AddRange(CharacterRange::Range(0, kLeadSurrogateStart - 1),
4830 2587 : kBmpCodePoints, zone_);
4831 2587 : table_.AddRange(CharacterRange::Range(kLeadSurrogateStart, kLeadSurrogateEnd),
4832 2587 : kLeadSurrogates, zone_);
4833 2587 : table_.AddRange(
4834 : CharacterRange::Range(kTrailSurrogateStart, kTrailSurrogateEnd),
4835 2587 : kTrailSurrogates, zone_);
4836 2587 : table_.AddRange(
4837 : CharacterRange::Range(kTrailSurrogateEnd + 1, kNonBmpStart - 1),
4838 2587 : kBmpCodePoints, zone_);
4839 2587 : table_.AddRange(CharacterRange::Range(kNonBmpStart, kNonBmpEnd),
4840 2587 : kNonBmpCodePoints, zone_);
4841 : table_.ForEach(this);
4842 2587 : }
4843 :
4844 :
4845 159101 : void UnicodeRangeSplitter::Call(uc32 from, DispatchTable::Entry entry) {
4846 : OutSet* outset = entry.out_set();
4847 159101 : if (!outset->Get(kBase)) return;
4848 : ZoneList<CharacterRange>** target = nullptr;
4849 78283 : if (outset->Get(kBmpCodePoints)) {
4850 50718 : target = &bmp_;
4851 27565 : } else if (outset->Get(kLeadSurrogates)) {
4852 1175 : target = &lead_surrogates_;
4853 26390 : } else if (outset->Get(kTrailSurrogates)) {
4854 1175 : target = &trail_surrogates_;
4855 : } else {
4856 : DCHECK(outset->Get(kNonBmpCodePoints));
4857 25215 : target = &non_bmp_;
4858 : }
4859 78283 : if (*target == nullptr)
4860 18201 : *target = new (zone_) ZoneList<CharacterRange>(2, zone_);
4861 78283 : (*target)->Add(CharacterRange::Range(entry.from(), entry.to()), zone_);
4862 : }
4863 :
4864 2582 : void AddBmpCharacters(RegExpCompiler* compiler, ChoiceNode* result,
4865 : RegExpNode* on_success, UnicodeRangeSplitter* splitter) {
4866 : ZoneList<CharacterRange>* bmp = splitter->bmp();
4867 3037 : if (bmp == nullptr) return;
4868 : JSRegExp::Flags default_flags = JSRegExp::Flags();
4869 2127 : result->AddAlternative(GuardedAlternative(TextNode::CreateForCharacterRanges(
4870 : compiler->zone(), bmp, compiler->read_backward(), on_success,
4871 : default_flags)));
4872 : }
4873 :
4874 2582 : void AddNonBmpSurrogatePairs(RegExpCompiler* compiler, ChoiceNode* result,
4875 : RegExpNode* on_success,
4876 : UnicodeRangeSplitter* splitter) {
4877 : ZoneList<CharacterRange>* non_bmp = splitter->non_bmp();
4878 3584 : if (non_bmp == nullptr) return;
4879 : DCHECK(!compiler->one_byte());
4880 : Zone* zone = compiler->zone();
4881 : JSRegExp::Flags default_flags = JSRegExp::Flags();
4882 1580 : CharacterRange::Canonicalize(non_bmp);
4883 52000 : for (int i = 0; i < non_bmp->length(); i++) {
4884 : // Match surrogate pair.
4885 : // E.g. [\u10005-\u11005] becomes
4886 : // \ud800[\udc05-\udfff]|
4887 : // [\ud801-\ud803][\udc00-\udfff]|
4888 : // \ud804[\udc00-\udc05]
4889 : uc32 from = non_bmp->at(i).from();
4890 : uc32 to = non_bmp->at(i).to();
4891 25210 : uc16 from_l = unibrow::Utf16::LeadSurrogate(from);
4892 : uc16 from_t = unibrow::Utf16::TrailSurrogate(from);
4893 25210 : uc16 to_l = unibrow::Utf16::LeadSurrogate(to);
4894 : uc16 to_t = unibrow::Utf16::TrailSurrogate(to);
4895 25210 : if (from_l == to_l) {
4896 : // The lead surrogate is the same.
4897 : result->AddAlternative(
4898 22930 : GuardedAlternative(TextNode::CreateForSurrogatePair(
4899 : zone, CharacterRange::Singleton(from_l),
4900 : CharacterRange::Range(from_t, to_t), compiler->read_backward(),
4901 : on_success, default_flags)));
4902 : } else {
4903 2280 : if (from_t != kTrailSurrogateStart) {
4904 : // Add [from_l][from_t-\udfff]
4905 : result->AddAlternative(
4906 1155 : GuardedAlternative(TextNode::CreateForSurrogatePair(
4907 : zone, CharacterRange::Singleton(from_l),
4908 : CharacterRange::Range(from_t, kTrailSurrogateEnd),
4909 : compiler->read_backward(), on_success, default_flags)));
4910 1155 : from_l++;
4911 : }
4912 2280 : if (to_t != kTrailSurrogateEnd) {
4913 : // Add [to_l][\udc00-to_t]
4914 : result->AddAlternative(
4915 895 : GuardedAlternative(TextNode::CreateForSurrogatePair(
4916 : zone, CharacterRange::Singleton(to_l),
4917 : CharacterRange::Range(kTrailSurrogateStart, to_t),
4918 : compiler->read_backward(), on_success, default_flags)));
4919 895 : to_l--;
4920 : }
4921 2280 : if (from_l <= to_l) {
4922 : // Add [from_l-to_l][\udc00-\udfff]
4923 : result->AddAlternative(
4924 2090 : GuardedAlternative(TextNode::CreateForSurrogatePair(
4925 : zone, CharacterRange::Range(from_l, to_l),
4926 : CharacterRange::Range(kTrailSurrogateStart, kTrailSurrogateEnd),
4927 : compiler->read_backward(), on_success, default_flags)));
4928 : }
4929 : }
4930 : }
4931 : }
4932 :
4933 1175 : RegExpNode* NegativeLookaroundAgainstReadDirectionAndMatch(
4934 : RegExpCompiler* compiler, ZoneList<CharacterRange>* lookbehind,
4935 : ZoneList<CharacterRange>* match, RegExpNode* on_success, bool read_backward,
4936 : JSRegExp::Flags flags) {
4937 : Zone* zone = compiler->zone();
4938 1175 : RegExpNode* match_node = TextNode::CreateForCharacterRanges(
4939 1175 : zone, match, read_backward, on_success, flags);
4940 : int stack_register = compiler->UnicodeLookaroundStackRegister();
4941 : int position_register = compiler->UnicodeLookaroundPositionRegister();
4942 : RegExpLookaround::Builder lookaround(false, match_node, stack_register,
4943 1175 : position_register);
4944 1175 : RegExpNode* negative_match = TextNode::CreateForCharacterRanges(
4945 2350 : zone, lookbehind, !read_backward, lookaround.on_match_success(), flags);
4946 1175 : return lookaround.ForMatch(negative_match);
4947 : }
4948 :
4949 1165 : RegExpNode* MatchAndNegativeLookaroundInReadDirection(
4950 : RegExpCompiler* compiler, ZoneList<CharacterRange>* match,
4951 : ZoneList<CharacterRange>* lookahead, RegExpNode* on_success,
4952 : bool read_backward, JSRegExp::Flags flags) {
4953 : Zone* zone = compiler->zone();
4954 : int stack_register = compiler->UnicodeLookaroundStackRegister();
4955 : int position_register = compiler->UnicodeLookaroundPositionRegister();
4956 : RegExpLookaround::Builder lookaround(false, on_success, stack_register,
4957 1165 : position_register);
4958 1165 : RegExpNode* negative_match = TextNode::CreateForCharacterRanges(
4959 1165 : zone, lookahead, read_backward, lookaround.on_match_success(), flags);
4960 1165 : return TextNode::CreateForCharacterRanges(
4961 1165 : zone, match, read_backward, lookaround.ForMatch(negative_match), flags);
4962 : }
4963 :
4964 2582 : void AddLoneLeadSurrogates(RegExpCompiler* compiler, ChoiceNode* result,
4965 : RegExpNode* on_success,
4966 : UnicodeRangeSplitter* splitter) {
4967 : JSRegExp::Flags default_flags = JSRegExp::Flags();
4968 : ZoneList<CharacterRange>* lead_surrogates = splitter->lead_surrogates();
4969 3994 : if (lead_surrogates == nullptr) return;
4970 : Zone* zone = compiler->zone();
4971 : // E.g. \ud801 becomes \ud801(?![\udc00-\udfff]).
4972 : ZoneList<CharacterRange>* trail_surrogates = CharacterRange::List(
4973 1170 : zone, CharacterRange::Range(kTrailSurrogateStart, kTrailSurrogateEnd));
4974 :
4975 : RegExpNode* match;
4976 1170 : if (compiler->read_backward()) {
4977 : // Reading backward. Assert that reading forward, there is no trail
4978 : // surrogate, and then backward match the lead surrogate.
4979 : match = NegativeLookaroundAgainstReadDirectionAndMatch(
4980 : compiler, trail_surrogates, lead_surrogates, on_success, true,
4981 95 : default_flags);
4982 : } else {
4983 : // Reading forward. Forward match the lead surrogate and assert that
4984 : // no trail surrogate follows.
4985 : match = MatchAndNegativeLookaroundInReadDirection(
4986 : compiler, lead_surrogates, trail_surrogates, on_success, false,
4987 1075 : default_flags);
4988 : }
4989 : result->AddAlternative(GuardedAlternative(match));
4990 : }
4991 :
4992 2582 : void AddLoneTrailSurrogates(RegExpCompiler* compiler, ChoiceNode* result,
4993 : RegExpNode* on_success,
4994 : UnicodeRangeSplitter* splitter) {
4995 : JSRegExp::Flags default_flags = JSRegExp::Flags();
4996 : ZoneList<CharacterRange>* trail_surrogates = splitter->trail_surrogates();
4997 3994 : if (trail_surrogates == nullptr) return;
4998 : Zone* zone = compiler->zone();
4999 : // E.g. \udc01 becomes (?<![\ud800-\udbff])\udc01
5000 : ZoneList<CharacterRange>* lead_surrogates = CharacterRange::List(
5001 1170 : zone, CharacterRange::Range(kLeadSurrogateStart, kLeadSurrogateEnd));
5002 :
5003 : RegExpNode* match;
5004 1170 : if (compiler->read_backward()) {
5005 : // Reading backward. Backward match the trail surrogate and assert that no
5006 : // lead surrogate precedes it.
5007 : match = MatchAndNegativeLookaroundInReadDirection(
5008 : compiler, trail_surrogates, lead_surrogates, on_success, true,
5009 90 : default_flags);
5010 : } else {
5011 : // Reading forward. Assert that reading backward, there is no lead
5012 : // surrogate, and then forward match the trail surrogate.
5013 : match = NegativeLookaroundAgainstReadDirectionAndMatch(
5014 : compiler, lead_surrogates, trail_surrogates, on_success, false,
5015 1080 : default_flags);
5016 : }
5017 : result->AddAlternative(GuardedAlternative(match));
5018 : }
5019 :
5020 0 : RegExpNode* UnanchoredAdvance(RegExpCompiler* compiler,
5021 : RegExpNode* on_success) {
5022 : // This implements ES2015 21.2.5.2.3, AdvanceStringIndex.
5023 : DCHECK(!compiler->read_backward());
5024 : Zone* zone = compiler->zone();
5025 : // Advance any character. If the character happens to be a lead surrogate and
5026 : // we advanced into the middle of a surrogate pair, it will work out, as
5027 : // nothing will match from there. We will have to advance again, consuming
5028 : // the associated trail surrogate.
5029 : ZoneList<CharacterRange>* range = CharacterRange::List(
5030 0 : zone, CharacterRange::Range(0, String::kMaxUtf16CodeUnit));
5031 : JSRegExp::Flags default_flags = JSRegExp::Flags();
5032 : return TextNode::CreateForCharacterRanges(zone, range, false, on_success,
5033 0 : default_flags);
5034 : }
5035 :
5036 1189 : void AddUnicodeCaseEquivalents(ZoneList<CharacterRange>* ranges, Zone* zone) {
5037 : #ifdef V8_INTL_SUPPORT
5038 : DCHECK(CharacterRange::IsCanonical(ranges));
5039 :
5040 : // Micro-optimization to avoid passing large ranges to UnicodeSet::closeOver.
5041 : // See also https://crbug.com/v8/6727.
5042 : // TODO(jgruber): This only covers the special case of the {0,0x10FFFF} range,
5043 : // which we use frequently internally. But large ranges can also easily be
5044 : // created by the user. We might want to have a more general caching mechanism
5045 : // for such ranges.
5046 1728 : if (ranges->length() == 1 && ranges->at(0).IsEverything(kNonBmpEnd)) return;
5047 :
5048 : // Use ICU to compute the case fold closure over the ranges.
5049 2378 : icu::UnicodeSet set;
5050 246407 : for (int i = 0; i < ranges->length(); i++) {
5051 122609 : set.add(ranges->at(i).from(), ranges->at(i).to());
5052 : }
5053 : ranges->Clear();
5054 1189 : set.closeOver(USET_CASE_INSENSITIVE);
5055 : // Full case mapping map single characters to multiple characters.
5056 : // Those are represented as strings in the set. Remove them so that
5057 : // we end up with only simple and common case mappings.
5058 1189 : set.removeAllStrings();
5059 37531 : for (int i = 0; i < set.getRangeCount(); i++) {
5060 36342 : ranges->Add(CharacterRange::Range(set.getRangeStart(i), set.getRangeEnd(i)),
5061 18171 : zone);
5062 : }
5063 : // No errors and everything we collected have been ranges.
5064 1189 : CharacterRange::Canonicalize(ranges);
5065 : #endif // V8_INTL_SUPPORT
5066 : }
5067 :
5068 :
5069 176130 : RegExpNode* RegExpCharacterClass::ToNode(RegExpCompiler* compiler,
5070 : RegExpNode* on_success) {
5071 : set_.Canonicalize();
5072 : Zone* zone = compiler->zone();
5073 : ZoneList<CharacterRange>* ranges = this->ranges(zone);
5074 176130 : if (NeedsUnicodeCaseEquivalents(flags_)) {
5075 949 : AddUnicodeCaseEquivalents(ranges, zone);
5076 : }
5077 178752 : if (IsUnicode(flags_) && !compiler->one_byte() &&
5078 : !contains_split_surrogate()) {
5079 2612 : if (is_negated()) {
5080 : ZoneList<CharacterRange>* negated =
5081 : new (zone) ZoneList<CharacterRange>(2, zone);
5082 140 : CharacterRange::Negate(ranges, negated, zone);
5083 : ranges = negated;
5084 : }
5085 2612 : if (ranges->length() == 0) {
5086 : JSRegExp::Flags default_flags;
5087 : RegExpCharacterClass* fail =
5088 60 : new (zone) RegExpCharacterClass(zone, ranges, default_flags);
5089 60 : return new (zone) TextNode(fail, compiler->read_backward(), on_success);
5090 : }
5091 2582 : if (standard_type() == '*') {
5092 0 : return UnanchoredAdvance(compiler, on_success);
5093 : } else {
5094 2582 : ChoiceNode* result = new (zone) ChoiceNode(2, zone);
5095 2582 : UnicodeRangeSplitter splitter(zone, ranges);
5096 2582 : AddBmpCharacters(compiler, result, on_success, &splitter);
5097 2582 : AddNonBmpSurrogatePairs(compiler, result, on_success, &splitter);
5098 2582 : AddLoneLeadSurrogates(compiler, result, on_success, &splitter);
5099 2582 : AddLoneTrailSurrogates(compiler, result, on_success, &splitter);
5100 : return result;
5101 : }
5102 : } else {
5103 347036 : return new (zone) TextNode(this, compiler->read_backward(), on_success);
5104 : }
5105 : }
5106 :
5107 :
5108 146822 : int CompareFirstChar(RegExpTree* const* a, RegExpTree* const* b) {
5109 146822 : RegExpAtom* atom1 = (*a)->AsAtom();
5110 146822 : RegExpAtom* atom2 = (*b)->AsAtom();
5111 146822 : uc16 character1 = atom1->data().at(0);
5112 146822 : uc16 character2 = atom2->data().at(0);
5113 146822 : if (character1 < character2) return -1;
5114 129859 : if (character1 > character2) return 1;
5115 17383 : return 0;
5116 : }
5117 :
5118 :
5119 : static unibrow::uchar Canonical(
5120 : unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize,
5121 : unibrow::uchar c) {
5122 : unibrow::uchar chars[unibrow::Ecma262Canonicalize::kMaxWidth];
5123 101306 : int length = canonicalize->get(c, '\0', chars);
5124 : DCHECK_LE(length, 1);
5125 : unibrow::uchar canonical = c;
5126 101306 : if (length == 1) canonical = chars[0];
5127 : return canonical;
5128 : }
5129 :
5130 :
5131 63973 : int CompareFirstCharCaseIndependent(
5132 : unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize,
5133 : RegExpTree* const* a, RegExpTree* const* b) {
5134 63973 : RegExpAtom* atom1 = (*a)->AsAtom();
5135 63973 : RegExpAtom* atom2 = (*b)->AsAtom();
5136 63973 : unibrow::uchar character1 = atom1->data().at(0);
5137 63973 : unibrow::uchar character2 = atom2->data().at(0);
5138 63973 : if (character1 == character2) return 0;
5139 46025 : if (character1 >= 'a' || character2 >= 'a') {
5140 : character1 = Canonical(canonicalize, character1);
5141 : character2 = Canonical(canonicalize, character2);
5142 : }
5143 46025 : return static_cast<int>(character1) - static_cast<int>(character2);
5144 : }
5145 :
5146 :
5147 : // We can stable sort runs of atoms, since the order does not matter if they
5148 : // start with different characters.
5149 : // Returns true if any consecutive atoms were found.
5150 9297 : bool RegExpDisjunction::SortConsecutiveAtoms(RegExpCompiler* compiler) {
5151 : ZoneList<RegExpTree*>* alternatives = this->alternatives();
5152 : int length = alternatives->length();
5153 : bool found_consecutive_atoms = false;
5154 26551 : for (int i = 0; i < length; i++) {
5155 62443 : while (i < length) {
5156 35127 : RegExpTree* alternative = alternatives->at(i);
5157 35127 : if (alternative->IsAtom()) break;
5158 26500 : i++;
5159 : }
5160 : // i is length or it is the index of an atom.
5161 9443 : if (i == length) break;
5162 : int first_atom = i;
5163 8627 : JSRegExp::Flags flags = alternatives->at(i)->AsAtom()->flags();
5164 8627 : i++;
5165 120869 : while (i < length) {
5166 56362 : RegExpTree* alternative = alternatives->at(i);
5167 56362 : if (!alternative->IsAtom()) break;
5168 56121 : if (alternative->AsAtom()->flags() != flags) break;
5169 56121 : i++;
5170 : }
5171 : // Sort atoms to get ones with common prefixes together.
5172 : // This step is more tricky if we are in a case-independent regexp,
5173 : // because it would change /is|I/ to /I|is/, and order matters when
5174 : // the regexp parts don't match only disjoint starting points. To fix
5175 : // this we have a version of CompareFirstChar that uses case-
5176 : // independent character classes for comparison.
5177 : DCHECK_LT(first_atom, alternatives->length());
5178 : DCHECK_LE(i, alternatives->length());
5179 : DCHECK_LE(first_atom, i);
5180 8627 : if (IgnoreCase(flags)) {
5181 : unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize =
5182 : compiler->isolate()->regexp_macro_assembler_canonicalize();
5183 : auto compare_closure =
5184 63973 : [canonicalize](RegExpTree* const* a, RegExpTree* const* b) {
5185 : return CompareFirstCharCaseIndependent(canonicalize, a, b);
5186 63973 : };
5187 474 : alternatives->StableSort(compare_closure, first_atom, i - first_atom);
5188 : } else {
5189 8153 : alternatives->StableSort(CompareFirstChar, first_atom, i - first_atom);
5190 : }
5191 8627 : if (i - first_atom > 1) found_consecutive_atoms = true;
5192 : }
5193 9297 : return found_consecutive_atoms;
5194 : }
5195 :
5196 :
5197 : // Optimizes ab|ac|az to a(?:b|c|d).
5198 8370 : void RegExpDisjunction::RationalizeConsecutiveAtoms(RegExpCompiler* compiler) {
5199 : Zone* zone = compiler->zone();
5200 : ZoneList<RegExpTree*>* alternatives = this->alternatives();
5201 : int length = alternatives->length();
5202 :
5203 : int write_posn = 0;
5204 : int i = 0;
5205 73522 : while (i < length) {
5206 65152 : RegExpTree* alternative = alternatives->at(i);
5207 65152 : if (!alternative->IsAtom()) {
5208 18582 : alternatives->at(write_posn++) = alternatives->at(i);
5209 9291 : i++;
5210 : continue;
5211 : }
5212 55861 : RegExpAtom* const atom = alternative->AsAtom();
5213 : JSRegExp::Flags flags = atom->flags();
5214 55861 : unibrow::uchar common_prefix = atom->data().at(0);
5215 : int first_with_prefix = i;
5216 : int prefix_length = atom->length();
5217 55861 : i++;
5218 73121 : while (i < length) {
5219 56221 : alternative = alternatives->at(i);
5220 56221 : if (!alternative->IsAtom()) break;
5221 56121 : RegExpAtom* const atom = alternative->AsAtom();
5222 56121 : if (atom->flags() != flags) break;
5223 56121 : unibrow::uchar new_prefix = atom->data().at(0);
5224 56121 : if (new_prefix != common_prefix) {
5225 47695 : if (!IgnoreCase(flags)) break;
5226 : unibrow::Mapping<unibrow::Ecma262Canonicalize>* canonicalize =
5227 : compiler->isolate()->regexp_macro_assembler_canonicalize();
5228 : new_prefix = Canonical(canonicalize, new_prefix);
5229 : common_prefix = Canonical(canonicalize, common_prefix);
5230 4628 : if (new_prefix != common_prefix) break;
5231 : }
5232 : prefix_length = Min(prefix_length, atom->length());
5233 8630 : i++;
5234 : }
5235 55861 : if (i > first_with_prefix + 2) {
5236 : // Found worthwhile run of alternatives with common prefix of at least one
5237 : // character. The sorting function above did not sort on more than one
5238 : // character for reasons of correctness, but there may still be a longer
5239 : // common prefix if the terms were similar or presorted in the input.
5240 : // Find out how long the common prefix is.
5241 268 : int run_length = i - first_with_prefix;
5242 268 : RegExpAtom* const atom = alternatives->at(first_with_prefix)->AsAtom();
5243 742 : for (int j = 1; j < run_length && prefix_length > 1; j++) {
5244 : RegExpAtom* old_atom =
5245 474 : alternatives->at(j + first_with_prefix)->AsAtom();
5246 477 : for (int k = 1; k < prefix_length; k++) {
5247 711 : if (atom->data().at(k) != old_atom->data().at(k)) {
5248 : prefix_length = k;
5249 : break;
5250 : }
5251 : }
5252 : }
5253 : RegExpAtom* prefix = new (zone)
5254 268 : RegExpAtom(atom->data().SubVector(0, prefix_length), flags);
5255 : ZoneList<RegExpTree*>* pair = new (zone) ZoneList<RegExpTree*>(2, zone);
5256 268 : pair->Add(prefix, zone);
5257 : ZoneList<RegExpTree*>* suffixes =
5258 : new (zone) ZoneList<RegExpTree*>(run_length, zone);
5259 17600 : for (int j = 0; j < run_length; j++) {
5260 : RegExpAtom* old_atom =
5261 17332 : alternatives->at(j + first_with_prefix)->AsAtom();
5262 : int len = old_atom->length();
5263 8666 : if (len == prefix_length) {
5264 302 : suffixes->Add(new (zone) RegExpEmpty(), zone);
5265 : } else {
5266 : RegExpTree* suffix = new (zone) RegExpAtom(
5267 8515 : old_atom->data().SubVector(prefix_length, old_atom->length()),
5268 8515 : flags);
5269 8515 : suffixes->Add(suffix, zone);
5270 : }
5271 : }
5272 268 : pair->Add(new (zone) RegExpDisjunction(suffixes), zone);
5273 536 : alternatives->at(write_posn++) = new (zone) RegExpAlternative(pair);
5274 : } else {
5275 : // Just copy any non-worthwhile alternatives.
5276 167243 : for (int j = first_with_prefix; j < i; j++) {
5277 111650 : alternatives->at(write_posn++) = alternatives->at(j);
5278 : }
5279 : }
5280 : }
5281 : alternatives->Rewind(write_posn); // Trim end of array.
5282 8370 : }
5283 :
5284 :
5285 : // Optimizes b|c|z to [bcz].
5286 9297 : void RegExpDisjunction::FixSingleCharacterDisjunctions(
5287 : RegExpCompiler* compiler) {
5288 : Zone* zone = compiler->zone();
5289 : ZoneList<RegExpTree*>* alternatives = this->alternatives();
5290 : int length = alternatives->length();
5291 :
5292 : int write_posn = 0;
5293 : int i = 0;
5294 83951 : while (i < length) {
5295 74654 : RegExpTree* alternative = alternatives->at(i);
5296 74654 : if (!alternative->IsAtom()) {
5297 54018 : alternatives->at(write_posn++) = alternatives->at(i);
5298 27009 : i++;
5299 27009 : continue;
5300 : }
5301 47645 : RegExpAtom* const atom = alternative->AsAtom();
5302 47645 : if (atom->length() != 1) {
5303 78592 : alternatives->at(write_posn++) = alternatives->at(i);
5304 39296 : i++;
5305 39296 : continue;
5306 : }
5307 : JSRegExp::Flags flags = atom->flags();
5308 : DCHECK_IMPLIES(IsUnicode(flags),
5309 : !unibrow::Utf16::IsLeadSurrogate(atom->data().at(0)));
5310 : bool contains_trail_surrogate =
5311 8349 : unibrow::Utf16::IsTrailSurrogate(atom->data().at(0));
5312 : int first_in_run = i;
5313 8349 : i++;
5314 : // Find a run of single-character atom alternatives that have identical
5315 : // flags (case independence and unicode-ness).
5316 25223 : while (i < length) {
5317 16454 : alternative = alternatives->at(i);
5318 16454 : if (!alternative->IsAtom()) break;
5319 16223 : RegExpAtom* const atom = alternative->AsAtom();
5320 16223 : if (atom->length() != 1) break;
5321 8437 : if (atom->flags() != flags) break;
5322 : DCHECK_IMPLIES(IsUnicode(flags),
5323 : !unibrow::Utf16::IsLeadSurrogate(atom->data().at(0)));
5324 : contains_trail_surrogate |=
5325 16874 : unibrow::Utf16::IsTrailSurrogate(atom->data().at(0));
5326 8437 : i++;
5327 : }
5328 8349 : if (i > first_in_run + 1) {
5329 : // Found non-trivial run of single-character alternatives.
5330 271 : int run_length = i - first_in_run;
5331 : ZoneList<CharacterRange>* ranges =
5332 : new (zone) ZoneList<CharacterRange>(2, zone);
5333 17687 : for (int j = 0; j < run_length; j++) {
5334 17416 : RegExpAtom* old_atom = alternatives->at(j + first_in_run)->AsAtom();
5335 : DCHECK_EQ(old_atom->length(), 1);
5336 8708 : ranges->Add(CharacterRange::Singleton(old_atom->data().at(0)), zone);
5337 : }
5338 : RegExpCharacterClass::CharacterClassFlags character_class_flags;
5339 271 : if (IsUnicode(flags) && contains_trail_surrogate) {
5340 : character_class_flags = RegExpCharacterClass::CONTAINS_SPLIT_SURROGATE;
5341 : }
5342 271 : alternatives->at(write_posn++) = new (zone)
5343 813 : RegExpCharacterClass(zone, ranges, flags, character_class_flags);
5344 : } else {
5345 : // Just copy any trivial alternatives.
5346 24234 : for (int j = first_in_run; j < i; j++) {
5347 16156 : alternatives->at(write_posn++) = alternatives->at(j);
5348 : }
5349 : }
5350 : }
5351 : alternatives->Rewind(write_posn); // Trim end of array.
5352 9297 : }
5353 :
5354 :
5355 10913 : RegExpNode* RegExpDisjunction::ToNode(RegExpCompiler* compiler,
5356 : RegExpNode* on_success) {
5357 : ZoneList<RegExpTree*>* alternatives = this->alternatives();
5358 :
5359 10913 : if (alternatives->length() > 2) {
5360 9297 : bool found_consecutive_atoms = SortConsecutiveAtoms(compiler);
5361 9297 : if (found_consecutive_atoms) RationalizeConsecutiveAtoms(compiler);
5362 9297 : FixSingleCharacterDisjunctions(compiler);
5363 9297 : if (alternatives->length() == 1) {
5364 242 : return alternatives->at(0)->ToNode(compiler, on_success);
5365 : }
5366 : }
5367 :
5368 : int length = alternatives->length();
5369 :
5370 : ChoiceNode* result =
5371 10671 : new(compiler->zone()) ChoiceNode(length, compiler->zone());
5372 165953 : for (int i = 0; i < length; i++) {
5373 : GuardedAlternative alternative(alternatives->at(i)->ToNode(compiler,
5374 77641 : on_success));
5375 : result->AddAlternative(alternative);
5376 : }
5377 : return result;
5378 : }
5379 :
5380 :
5381 926280 : RegExpNode* RegExpQuantifier::ToNode(RegExpCompiler* compiler,
5382 : RegExpNode* on_success) {
5383 926280 : return ToNode(min(),
5384 : max(),
5385 : is_greedy(),
5386 : body(),
5387 : compiler,
5388 926280 : on_success);
5389 : }
5390 :
5391 :
5392 : // Scoped object to keep track of how much we unroll quantifier loops in the
5393 : // regexp graph generator.
5394 : class RegExpExpansionLimiter {
5395 : public:
5396 : static const int kMaxExpansionFactor = 6;
5397 : RegExpExpansionLimiter(RegExpCompiler* compiler, int factor)
5398 : : compiler_(compiler),
5399 : saved_expansion_factor_(compiler->current_expansion_factor()),
5400 62408 : ok_to_expand_(saved_expansion_factor_ <= kMaxExpansionFactor) {
5401 : DCHECK_LT(0, factor);
5402 71951 : if (ok_to_expand_) {
5403 71951 : if (factor > kMaxExpansionFactor) {
5404 : // Avoid integer overflow of the current expansion factor.
5405 : ok_to_expand_ = false;
5406 : compiler->set_current_expansion_factor(kMaxExpansionFactor + 1);
5407 : } else {
5408 71823 : int new_factor = saved_expansion_factor_ * factor;
5409 71823 : ok_to_expand_ = (new_factor <= kMaxExpansionFactor);
5410 : compiler->set_current_expansion_factor(new_factor);
5411 : }
5412 : }
5413 : }
5414 :
5415 : ~RegExpExpansionLimiter() {
5416 : compiler_->set_current_expansion_factor(saved_expansion_factor_);
5417 : }
5418 :
5419 : bool ok_to_expand() { return ok_to_expand_; }
5420 :
5421 : private:
5422 : RegExpCompiler* compiler_;
5423 : int saved_expansion_factor_;
5424 : bool ok_to_expand_;
5425 :
5426 : DISALLOW_IMPLICIT_CONSTRUCTORS(RegExpExpansionLimiter);
5427 : };
5428 :
5429 :
5430 1013319 : RegExpNode* RegExpQuantifier::ToNode(int min,
5431 : int max,
5432 : bool is_greedy,
5433 : RegExpTree* body,
5434 : RegExpCompiler* compiler,
5435 : RegExpNode* on_success,
5436 : bool not_at_start) {
5437 : // x{f, t} becomes this:
5438 : //
5439 : // (r++)<-.
5440 : // | `
5441 : // | (x)
5442 : // v ^
5443 : // (r=0)-->(?)---/ [if r < t]
5444 : // |
5445 : // [if r >= f] \----> ...
5446 : //
5447 :
5448 : // 15.10.2.5 RepeatMatcher algorithm.
5449 : // The parser has already eliminated the case where max is 0. In the case
5450 : // where max_match is zero the parser has removed the quantifier if min was
5451 : // > 0 and removed the atom if min was 0. See AddQuantifierToAtom.
5452 :
5453 : // If we know that we cannot match zero length then things are a little
5454 : // simpler since we don't need to make the special zero length match check
5455 : // from step 2.1. If the min and max are small we can unroll a little in
5456 : // this case.
5457 : static const int kMaxUnrolledMinMatches = 3; // Unroll (foo)+ and (foo){3,}
5458 : static const int kMaxUnrolledMaxMatches = 3; // Unroll (foo)? and (foo){x,3}
5459 1013319 : if (max == 0) return on_success; // This can happen due to recursion.
5460 1012964 : bool body_can_be_empty = (body->min_match() == 0);
5461 : int body_start_reg = RegExpCompiler::kNoRegister;
5462 1012964 : Interval capture_registers = body->CaptureRegisters();
5463 : bool needs_capture_clearing = !capture_registers.is_empty();
5464 : Zone* zone = compiler->zone();
5465 :
5466 1012964 : if (body_can_be_empty) {
5467 : body_start_reg = compiler->AllocateRegister();
5468 1012427 : } else if (compiler->optimize() && !needs_capture_clearing) {
5469 : // Only unroll if there are no captures and the body can't be
5470 : // empty.
5471 : {
5472 : RegExpExpansionLimiter limiter(
5473 62408 : compiler, min + ((max != min) ? 1 : 0));
5474 62408 : if (min > 0 && min <= kMaxUnrolledMinMatches && limiter.ok_to_expand()) {
5475 4316 : int new_max = (max == kInfinity) ? max : max - min;
5476 : // Recurse once to get the loop or optional matches after the fixed
5477 : // ones.
5478 4316 : RegExpNode* answer = ToNode(
5479 4316 : 0, new_max, is_greedy, body, compiler, on_success, true);
5480 : // Unroll the forced matches from 0 to min. This can cause chains of
5481 : // TextNodes (which the parser does not generate). These should be
5482 : // combined if it turns out they hinder good code generation.
5483 14348 : for (int i = 0; i < min; i++) {
5484 5016 : answer = body->ToNode(compiler, answer);
5485 : }
5486 : return answer;
5487 : }
5488 : }
5489 58092 : if (max <= kMaxUnrolledMaxMatches && min == 0) {
5490 : DCHECK_LT(0, max); // Due to the 'if' above.
5491 : RegExpExpansionLimiter limiter(compiler, max);
5492 9543 : if (limiter.ok_to_expand()) {
5493 : // Unroll the optional matches up to max.
5494 : RegExpNode* answer = on_success;
5495 28040 : for (int i = 0; i < max; i++) {
5496 9379 : ChoiceNode* alternation = new(zone) ChoiceNode(2, zone);
5497 9379 : if (is_greedy) {
5498 9233 : alternation->AddAlternative(
5499 9233 : GuardedAlternative(body->ToNode(compiler, answer)));
5500 : alternation->AddAlternative(GuardedAlternative(on_success));
5501 : } else {
5502 : alternation->AddAlternative(GuardedAlternative(on_success));
5503 146 : alternation->AddAlternative(
5504 146 : GuardedAlternative(body->ToNode(compiler, answer)));
5505 : }
5506 : answer = alternation;
5507 9379 : if (not_at_start && !compiler->read_backward()) {
5508 : alternation->set_not_at_start();
5509 : }
5510 : }
5511 : return answer;
5512 : }
5513 : }
5514 : }
5515 999366 : bool has_min = min > 0;
5516 999366 : bool has_max = max < RegExpTree::kInfinity;
5517 999366 : bool needs_counter = has_min || has_max;
5518 : int reg_ctr = needs_counter
5519 : ? compiler->AllocateRegister()
5520 999366 : : RegExpCompiler::kNoRegister;
5521 : LoopChoiceNode* center = new (zone)
5522 999366 : LoopChoiceNode(body->min_match() == 0, compiler->read_backward(), zone);
5523 999366 : if (not_at_start && !compiler->read_backward()) center->set_not_at_start();
5524 : RegExpNode* loop_return = needs_counter
5525 : ? static_cast<RegExpNode*>(ActionNode::IncrementRegister(reg_ctr, center))
5526 999366 : : static_cast<RegExpNode*>(center);
5527 999366 : if (body_can_be_empty) {
5528 : // If the body can be empty we need to check if it was and then
5529 : // backtrack.
5530 : loop_return = ActionNode::EmptyMatchCheck(body_start_reg,
5531 : reg_ctr,
5532 : min,
5533 537 : loop_return);
5534 : }
5535 999366 : RegExpNode* body_node = body->ToNode(compiler, loop_return);
5536 999366 : if (body_can_be_empty) {
5537 : // If the body can be empty we need to store the start position
5538 : // so we can bail out if it was empty.
5539 537 : body_node = ActionNode::StorePosition(body_start_reg, false, body_node);
5540 : }
5541 999366 : if (needs_capture_clearing) {
5542 : // Before entering the body of this loop we need to clear captures.
5543 2376 : body_node = ActionNode::ClearCaptures(capture_registers, body_node);
5544 : }
5545 : GuardedAlternative body_alt(body_node);
5546 999366 : if (has_max) {
5547 : Guard* body_guard =
5548 : new(zone) Guard(reg_ctr, Guard::LT, max);
5549 902614 : body_alt.AddGuard(body_guard, zone);
5550 : }
5551 : GuardedAlternative rest_alt(on_success);
5552 999366 : if (has_min) {
5553 : Guard* rest_guard = new(compiler->zone()) Guard(reg_ctr, Guard::GEQ, min);
5554 1322 : rest_alt.AddGuard(rest_guard, zone);
5555 : }
5556 999366 : if (is_greedy) {
5557 : center->AddLoopAlternative(body_alt);
5558 : center->AddContinueAlternative(rest_alt);
5559 : } else {
5560 : center->AddContinueAlternative(rest_alt);
5561 : center->AddLoopAlternative(body_alt);
5562 : }
5563 999366 : if (needs_counter) {
5564 903359 : return ActionNode::SetRegister(reg_ctr, 0, center);
5565 : } else {
5566 : return center;
5567 : }
5568 : }
5569 :
5570 : namespace {
5571 : // Desugar \b to (?<=\w)(?=\W)|(?<=\W)(?=\w) and
5572 : // \B to (?<=\w)(?=\w)|(?<=\W)(?=\W)
5573 80 : RegExpNode* BoundaryAssertionAsLookaround(RegExpCompiler* compiler,
5574 : RegExpNode* on_success,
5575 : RegExpAssertion::AssertionType type,
5576 : JSRegExp::Flags flags) {
5577 : DCHECK(NeedsUnicodeCaseEquivalents(flags));
5578 : Zone* zone = compiler->zone();
5579 : ZoneList<CharacterRange>* word_range =
5580 : new (zone) ZoneList<CharacterRange>(2, zone);
5581 80 : CharacterRange::AddClassEscape('w', word_range, true, zone);
5582 : int stack_register = compiler->UnicodeLookaroundStackRegister();
5583 : int position_register = compiler->UnicodeLookaroundPositionRegister();
5584 80 : ChoiceNode* result = new (zone) ChoiceNode(2, zone);
5585 : // Add two choices. The (non-)boundary could start with a word or
5586 : // a non-word-character.
5587 400 : for (int i = 0; i < 2; i++) {
5588 160 : bool lookbehind_for_word = i == 0;
5589 : bool lookahead_for_word =
5590 160 : (type == RegExpAssertion::BOUNDARY) ^ lookbehind_for_word;
5591 : // Look to the left.
5592 : RegExpLookaround::Builder lookbehind(lookbehind_for_word, on_success,
5593 160 : stack_register, position_register);
5594 : RegExpNode* backward = TextNode::CreateForCharacterRanges(
5595 160 : zone, word_range, true, lookbehind.on_match_success(), flags);
5596 : // Look to the right.
5597 : RegExpLookaround::Builder lookahead(lookahead_for_word,
5598 : lookbehind.ForMatch(backward),
5599 160 : stack_register, position_register);
5600 : RegExpNode* forward = TextNode::CreateForCharacterRanges(
5601 160 : zone, word_range, false, lookahead.on_match_success(), flags);
5602 160 : result->AddAlternative(GuardedAlternative(lookahead.ForMatch(forward)));
5603 : }
5604 80 : return result;
5605 : }
5606 : } // anonymous namespace
5607 :
5608 5506 : RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,
5609 : RegExpNode* on_success) {
5610 : NodeInfo info;
5611 : Zone* zone = compiler->zone();
5612 :
5613 5506 : switch (assertion_type()) {
5614 : case START_OF_LINE:
5615 129 : return AssertionNode::AfterNewline(on_success);
5616 : case START_OF_INPUT:
5617 3041 : return AssertionNode::AtStart(on_success);
5618 : case BOUNDARY:
5619 : return NeedsUnicodeCaseEquivalents(flags_)
5620 : ? BoundaryAssertionAsLookaround(compiler, on_success, BOUNDARY,
5621 : flags_)
5622 176 : : AssertionNode::AtBoundary(on_success);
5623 : case NON_BOUNDARY:
5624 : return NeedsUnicodeCaseEquivalents(flags_)
5625 : ? BoundaryAssertionAsLookaround(compiler, on_success,
5626 : NON_BOUNDARY, flags_)
5627 154 : : AssertionNode::AtNonBoundary(on_success);
5628 : case END_OF_INPUT:
5629 1907 : return AssertionNode::AtEnd(on_success);
5630 : case END_OF_LINE: {
5631 : // Compile $ in multiline regexps as an alternation with a positive
5632 : // lookahead in one side and an end-of-input on the other side.
5633 : // We need two registers for the lookahead.
5634 : int stack_pointer_register = compiler->AllocateRegister();
5635 : int position_register = compiler->AllocateRegister();
5636 : // The ChoiceNode to distinguish between a newline and end-of-input.
5637 99 : ChoiceNode* result = new(zone) ChoiceNode(2, zone);
5638 : // Create a newline atom.
5639 : ZoneList<CharacterRange>* newline_ranges =
5640 : new(zone) ZoneList<CharacterRange>(3, zone);
5641 99 : CharacterRange::AddClassEscape('n', newline_ranges, false, zone);
5642 : JSRegExp::Flags default_flags = JSRegExp::Flags();
5643 : RegExpCharacterClass* newline_atom =
5644 : new (zone) RegExpCharacterClass('n', default_flags);
5645 : TextNode* newline_matcher = new (zone) TextNode(
5646 : newline_atom, false, ActionNode::PositiveSubmatchSuccess(
5647 : stack_pointer_register, position_register,
5648 : 0, // No captures inside.
5649 : -1, // Ignored if no captures.
5650 198 : on_success));
5651 : // Create an end-of-input matcher.
5652 : RegExpNode* end_of_line = ActionNode::BeginSubmatch(
5653 : stack_pointer_register,
5654 : position_register,
5655 99 : newline_matcher);
5656 : // Add the two alternatives to the ChoiceNode.
5657 : GuardedAlternative eol_alternative(end_of_line);
5658 : result->AddAlternative(eol_alternative);
5659 99 : GuardedAlternative end_alternative(AssertionNode::AtEnd(on_success));
5660 : result->AddAlternative(end_alternative);
5661 : return result;
5662 : }
5663 : default:
5664 0 : UNREACHABLE();
5665 : }
5666 : return on_success;
5667 : }
5668 :
5669 :
5670 2380 : RegExpNode* RegExpBackReference::ToNode(RegExpCompiler* compiler,
5671 : RegExpNode* on_success) {
5672 : return new (compiler->zone())
5673 : BackReferenceNode(RegExpCapture::StartRegister(index()),
5674 : RegExpCapture::EndRegister(index()), flags_,
5675 4760 : compiler->read_backward(), on_success);
5676 : }
5677 :
5678 :
5679 1026 : RegExpNode* RegExpEmpty::ToNode(RegExpCompiler* compiler,
5680 : RegExpNode* on_success) {
5681 1026 : return on_success;
5682 : }
5683 :
5684 :
5685 4368 : RegExpLookaround::Builder::Builder(bool is_positive, RegExpNode* on_success,
5686 : int stack_pointer_register,
5687 : int position_register,
5688 : int capture_register_count,
5689 : int capture_register_start)
5690 : : is_positive_(is_positive),
5691 : on_success_(on_success),
5692 : stack_pointer_register_(stack_pointer_register),
5693 4368 : position_register_(position_register) {
5694 4368 : if (is_positive_) {
5695 1556 : on_match_success_ = ActionNode::PositiveSubmatchSuccess(
5696 : stack_pointer_register, position_register, capture_register_count,
5697 1556 : capture_register_start, on_success_);
5698 : } else {
5699 : Zone* zone = on_success_->zone();
5700 : on_match_success_ = new (zone) NegativeSubmatchSuccess(
5701 : stack_pointer_register, position_register, capture_register_count,
5702 2812 : capture_register_start, zone);
5703 : }
5704 4368 : }
5705 :
5706 :
5707 4368 : RegExpNode* RegExpLookaround::Builder::ForMatch(RegExpNode* match) {
5708 4368 : if (is_positive_) {
5709 1556 : return ActionNode::BeginSubmatch(stack_pointer_register_,
5710 1556 : position_register_, match);
5711 : } else {
5712 2812 : Zone* zone = on_success_->zone();
5713 : // We use a ChoiceNode to represent the negative lookaround. The first
5714 : // alternative is the negative match. On success, the end node backtracks.
5715 : // On failure, the second alternative is tried and leads to success.
5716 : // NegativeLookaheadChoiceNode is a special ChoiceNode that ignores the
5717 : // first exit when calculating quick checks.
5718 : ChoiceNode* choice_node = new (zone) NegativeLookaroundChoiceNode(
5719 2812 : GuardedAlternative(match), GuardedAlternative(on_success_), zone);
5720 2812 : return ActionNode::BeginSubmatch(stack_pointer_register_,
5721 2812 : position_register_, choice_node);
5722 : }
5723 : }
5724 :
5725 :
5726 1668 : RegExpNode* RegExpLookaround::ToNode(RegExpCompiler* compiler,
5727 : RegExpNode* on_success) {
5728 : int stack_pointer_register = compiler->AllocateRegister();
5729 : int position_register = compiler->AllocateRegister();
5730 :
5731 : const int registers_per_capture = 2;
5732 : const int register_of_first_capture = 2;
5733 1668 : int register_count = capture_count_ * registers_per_capture;
5734 : int register_start =
5735 1668 : register_of_first_capture + capture_from_ * registers_per_capture;
5736 :
5737 : RegExpNode* result;
5738 : bool was_reading_backward = compiler->read_backward();
5739 1668 : compiler->set_read_backward(type() == LOOKBEHIND);
5740 : Builder builder(is_positive(), on_success, stack_pointer_register,
5741 1668 : position_register, register_count, register_start);
5742 1668 : RegExpNode* match = body_->ToNode(compiler, builder.on_match_success());
5743 1668 : result = builder.ForMatch(match);
5744 : compiler->set_read_backward(was_reading_backward);
5745 1668 : return result;
5746 : }
5747 :
5748 :
5749 27157 : RegExpNode* RegExpCapture::ToNode(RegExpCompiler* compiler,
5750 : RegExpNode* on_success) {
5751 27157 : return ToNode(body(), index(), compiler, on_success);
5752 : }
5753 :
5754 :
5755 112823 : RegExpNode* RegExpCapture::ToNode(RegExpTree* body,
5756 : int index,
5757 : RegExpCompiler* compiler,
5758 : RegExpNode* on_success) {
5759 : DCHECK_NOT_NULL(body);
5760 : int start_reg = RegExpCapture::StartRegister(index);
5761 : int end_reg = RegExpCapture::EndRegister(index);
5762 112823 : if (compiler->read_backward()) std::swap(start_reg, end_reg);
5763 112823 : RegExpNode* store_end = ActionNode::StorePosition(end_reg, true, on_success);
5764 112823 : RegExpNode* body_node = body->ToNode(compiler, store_end);
5765 112823 : return ActionNode::StorePosition(start_reg, true, body_node);
5766 : }
5767 :
5768 :
5769 21323 : RegExpNode* RegExpAlternative::ToNode(RegExpCompiler* compiler,
5770 : RegExpNode* on_success) {
5771 : ZoneList<RegExpTree*>* children = nodes();
5772 : RegExpNode* current = on_success;
5773 21323 : if (compiler->read_backward()) {
5774 1905 : for (int i = 0; i < children->length(); i++) {
5775 790 : current = children->at(i)->ToNode(compiler, current);
5776 : }
5777 : } else {
5778 997716 : for (int i = children->length() - 1; i >= 0; i--) {
5779 976718 : current = children->at(i)->ToNode(compiler, current);
5780 : }
5781 : }
5782 21323 : return current;
5783 : }
5784 :
5785 :
5786 7409 : static void AddClass(const int* elmv,
5787 : int elmc,
5788 : ZoneList<CharacterRange>* ranges,
5789 : Zone* zone) {
5790 7409 : elmc--;
5791 : DCHECK_EQ(kRangeEndMarker, elmv[elmc]);
5792 71721 : for (int i = 0; i < elmc; i += 2) {
5793 : DCHECK(elmv[i] < elmv[i + 1]);
5794 32156 : ranges->Add(CharacterRange::Range(elmv[i], elmv[i + 1] - 1), zone);
5795 : }
5796 7409 : }
5797 :
5798 :
5799 20035 : static void AddClassNegated(const int *elmv,
5800 : int elmc,
5801 : ZoneList<CharacterRange>* ranges,
5802 : Zone* zone) {
5803 20035 : elmc--;
5804 : DCHECK_EQ(kRangeEndMarker, elmv[elmc]);
5805 : DCHECK_NE(0x0000, elmv[0]);
5806 : DCHECK_NE(String::kMaxCodePoint, elmv[elmc - 1]);
5807 : uc16 last = 0x0000;
5808 150595 : for (int i = 0; i < elmc; i += 2) {
5809 : DCHECK(last <= elmv[i] - 1);
5810 : DCHECK(elmv[i] < elmv[i + 1]);
5811 65280 : ranges->Add(CharacterRange::Range(last, elmv[i] - 1), zone);
5812 65280 : last = elmv[i + 1];
5813 : }
5814 20035 : ranges->Add(CharacterRange::Range(last, String::kMaxCodePoint), zone);
5815 20035 : }
5816 :
5817 110491 : void CharacterRange::AddClassEscape(char type, ZoneList<CharacterRange>* ranges,
5818 : bool add_unicode_case_equivalents,
5819 : Zone* zone) {
5820 110491 : if (add_unicode_case_equivalents && (type == 'w' || type == 'W')) {
5821 : // See #sec-runtime-semantics-wordcharacters-abstract-operation
5822 : // In case of unicode and ignore_case, we need to create the closure over
5823 : // case equivalent characters before negating.
5824 : ZoneList<CharacterRange>* new_ranges =
5825 : new (zone) ZoneList<CharacterRange>(2, zone);
5826 240 : AddClass(kWordRanges, kWordRangeCount, new_ranges, zone);
5827 240 : AddUnicodeCaseEquivalents(new_ranges, zone);
5828 240 : if (type == 'W') {
5829 : ZoneList<CharacterRange>* negated =
5830 : new (zone) ZoneList<CharacterRange>(2, zone);
5831 90 : CharacterRange::Negate(new_ranges, negated, zone);
5832 : new_ranges = negated;
5833 : }
5834 : ranges->AddAll(*new_ranges, zone);
5835 : return;
5836 : }
5837 110251 : AddClassEscape(type, ranges, zone);
5838 : }
5839 :
5840 110286 : void CharacterRange::AddClassEscape(char type, ZoneList<CharacterRange>* ranges,
5841 : Zone* zone) {
5842 110286 : switch (type) {
5843 : case 's':
5844 1697 : AddClass(kSpaceRanges, kSpaceRangeCount, ranges, zone);
5845 1697 : break;
5846 : case 'S':
5847 772 : AddClassNegated(kSpaceRanges, kSpaceRangeCount, ranges, zone);
5848 772 : break;
5849 : case 'w':
5850 2786 : AddClass(kWordRanges, kWordRangeCount, ranges, zone);
5851 2786 : break;
5852 : case 'W':
5853 307 : AddClassNegated(kWordRanges, kWordRangeCount, ranges, zone);
5854 307 : break;
5855 : case 'd':
5856 2488 : AddClass(kDigitRanges, kDigitRangeCount, ranges, zone);
5857 2488 : break;
5858 : case 'D':
5859 268 : AddClassNegated(kDigitRanges, kDigitRangeCount, ranges, zone);
5860 268 : break;
5861 : case '.':
5862 : AddClassNegated(kLineTerminatorRanges,
5863 : kLineTerminatorRangeCount,
5864 : ranges,
5865 18688 : zone);
5866 18688 : break;
5867 : // This is not a character range as defined by the spec but a
5868 : // convenient shorthand for a character class that matches any
5869 : // character.
5870 : case '*':
5871 83082 : ranges->Add(CharacterRange::Everything(), zone);
5872 83082 : break;
5873 : // This is the set of characters matched by the $ and ^ symbols
5874 : // in multiline mode.
5875 : case 'n':
5876 : AddClass(kLineTerminatorRanges,
5877 : kLineTerminatorRangeCount,
5878 : ranges,
5879 198 : zone);
5880 198 : break;
5881 : default:
5882 0 : UNREACHABLE();
5883 : }
5884 110286 : }
5885 :
5886 :
5887 0 : Vector<const int> CharacterRange::GetWordBounds() {
5888 0 : return Vector<const int>(kWordRanges, kWordRangeCount - 1);
5889 : }
5890 :
5891 : // static
5892 66955 : void CharacterRange::AddCaseEquivalents(Isolate* isolate, Zone* zone,
5893 : ZoneList<CharacterRange>* ranges,
5894 : bool is_one_byte) {
5895 66955 : CharacterRange::Canonicalize(ranges);
5896 : int range_count = ranges->length();
5897 210861 : for (int i = 0; i < range_count; i++) {
5898 71953 : CharacterRange range = ranges->at(i);
5899 : uc32 bottom = range.from();
5900 74100 : if (bottom > String::kMaxUtf16CodeUnit) continue;
5901 : uc32 top = Min(range.to(), String::kMaxUtf16CodeUnit);
5902 : // Nothing to be done for surrogates.
5903 71953 : if (bottom >= kLeadSurrogateStart && top <= kTrailSurrogateEnd) continue;
5904 69906 : if (is_one_byte && !RangeContainsLatin1Equivalents(range)) {
5905 1343 : if (bottom > String::kMaxOneByteCharCode) continue;
5906 1243 : if (top > String::kMaxOneByteCharCode) top = String::kMaxOneByteCharCode;
5907 : }
5908 : unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
5909 69806 : if (top == bottom) {
5910 : // If this is a singleton we just expand the one character.
5911 9216 : int length = isolate->jsregexp_uncanonicalize()->get(bottom, '\0', chars);
5912 10016 : for (int i = 0; i < length; i++) {
5913 2704 : uc32 chr = chars[i];
5914 2704 : if (chr != bottom) {
5915 1382 : ranges->Add(CharacterRange::Singleton(chars[i]), zone);
5916 : }
5917 : }
5918 : } else {
5919 : // If this is a range we expand the characters block by block, expanding
5920 : // contiguous subranges (blocks) one at a time. The approach is as
5921 : // follows. For a given start character we look up the remainder of the
5922 : // block that contains it (represented by the end point), for instance we
5923 : // find 'z' if the character is 'c'. A block is characterized by the
5924 : // property that all characters uncanonicalize in the same way, except
5925 : // that each entry in the result is incremented by the distance from the
5926 : // first element. So a-z is a block because 'a' uncanonicalizes to ['a',
5927 : // 'A'] and the k'th letter uncanonicalizes to ['a' + k, 'A' + k]. Once
5928 : // we've found the end point we look up its uncanonicalization and
5929 : // produce a range for each element. For instance for [c-f] we look up
5930 : // ['z', 'Z'] and produce [c-f] and [C-F]. We then only add a range if
5931 : // it is not already contained in the input, so [c-f] will be skipped but
5932 : // [C-F] will be added. If this range is not completely contained in a
5933 : // block we do this for all the blocks covered by the range (handling
5934 : // characters that is not in a block as a "singleton block").
5935 : unibrow::uchar equivalents[unibrow::Ecma262UnCanonicalize::kMaxWidth];
5936 : int pos = bottom;
5937 15528016 : while (pos <= top) {
5938 : int length =
5939 15462818 : isolate->jsregexp_canonrange()->get(pos, '\0', equivalents);
5940 : uc32 block_end;
5941 7731409 : if (length == 0) {
5942 : block_end = pos;
5943 : } else {
5944 : DCHECK_EQ(1, length);
5945 6349 : block_end = equivalents[0];
5946 : }
5947 7731409 : int end = (block_end > top) ? top : block_end;
5948 7731409 : length = isolate->jsregexp_uncanonicalize()->get(block_end, '\0',
5949 7731409 : equivalents);
5950 8398373 : for (int i = 0; i < length; i++) {
5951 333482 : uc32 c = equivalents[i];
5952 333482 : uc32 range_from = c - (block_end - pos);
5953 333482 : uc32 range_to = c - (block_end - end);
5954 333482 : if (!(bottom <= range_from && range_to <= top)) {
5955 6669 : ranges->Add(CharacterRange::Range(range_from, range_to), zone);
5956 : }
5957 : }
5958 7731409 : pos = end + 1;
5959 : }
5960 : }
5961 : }
5962 66955 : }
5963 :
5964 :
5965 10 : bool CharacterRange::IsCanonical(ZoneList<CharacterRange>* ranges) {
5966 : DCHECK_NOT_NULL(ranges);
5967 : int n = ranges->length();
5968 10 : if (n <= 1) return true;
5969 : int max = ranges->at(0).to();
5970 590 : for (int i = 1; i < n; i++) {
5971 290 : CharacterRange next_range = ranges->at(i);
5972 290 : if (next_range.from() <= max + 1) return false;
5973 : max = next_range.to();
5974 : }
5975 : return true;
5976 : }
5977 :
5978 :
5979 1900724 : ZoneList<CharacterRange>* CharacterSet::ranges(Zone* zone) {
5980 1900724 : if (ranges_ == nullptr) {
5981 82971 : ranges_ = new(zone) ZoneList<CharacterRange>(2, zone);
5982 82971 : CharacterRange::AddClassEscape(standard_set_type_, ranges_, false, zone);
5983 : }
5984 1900724 : return ranges_;
5985 : }
5986 :
5987 :
5988 : // Move a number of elements in a zonelist to another position
5989 : // in the same list. Handles overlapping source and target areas.
5990 92250 : static void MoveRanges(ZoneList<CharacterRange>* list,
5991 : int from,
5992 : int to,
5993 : int count) {
5994 : // Ranges are potentially overlapping.
5995 92250 : if (from < to) {
5996 10119845 : for (int i = count - 1; i >= 0; i--) {
5997 30118101 : list->at(to + i) = list->at(from + i);
5998 : }
5999 : } else {
6000 7210016 : for (int i = 0; i < count; i++) {
6001 10797366 : list->at(to + i) = list->at(from + i);
6002 : }
6003 : }
6004 92250 : }
6005 :
6006 :
6007 173176 : static int InsertRangeInCanonicalList(ZoneList<CharacterRange>* list,
6008 : int count,
6009 : CharacterRange insert) {
6010 : // Inserts a range into list[0..count[, which must be sorted
6011 : // by from value and non-overlapping and non-adjacent, using at most
6012 : // list[0..count] for the result. Returns the number of resulting
6013 : // canonicalized ranges. Inserting a range may collapse existing ranges into
6014 : // fewer ranges, so the return value can be anything in the range 1..count+1.
6015 : uc32 from = insert.from();
6016 : uc32 to = insert.to();
6017 : int start_pos = 0;
6018 : int end_pos = count;
6019 18092687 : for (int i = count - 1; i >= 0; i--) {
6020 18009142 : CharacterRange current = list->at(i);
6021 18009142 : if (current.from() > to + 1) {
6022 : end_pos = i;
6023 142194 : } else if (current.to() + 1 < from) {
6024 89631 : start_pos = i + 1;
6025 : break;
6026 : }
6027 : }
6028 :
6029 : // Inserted range overlaps, or is adjacent to, ranges at positions
6030 : // [start_pos..end_pos[. Ranges before start_pos or at or after end_pos are
6031 : // not affected by the insertion.
6032 : // If start_pos == end_pos, the range must be inserted before start_pos.
6033 : // if start_pos < end_pos, the entire range from start_pos to end_pos
6034 : // must be merged with the insert range.
6035 :
6036 173176 : if (start_pos == end_pos) {
6037 : // Insert between existing ranges at position start_pos.
6038 132771 : if (start_pos < count) {
6039 80478 : MoveRanges(list, start_pos, start_pos + 1, count - start_pos);
6040 : }
6041 132771 : list->at(start_pos) = insert;
6042 132771 : return count + 1;
6043 : }
6044 40405 : if (start_pos + 1 == end_pos) {
6045 : // Replace single existing range at position start_pos.
6046 28492 : CharacterRange to_replace = list->at(start_pos);
6047 : int new_from = Min(to_replace.from(), from);
6048 : int new_to = Max(to_replace.to(), to);
6049 28492 : list->at(start_pos) = CharacterRange::Range(new_from, new_to);
6050 : return count;
6051 : }
6052 : // Replace a number of existing ranges from start_pos to end_pos - 1.
6053 : // Move the remaining ranges down.
6054 :
6055 : int new_from = Min(list->at(start_pos).from(), from);
6056 11913 : int new_to = Max(list->at(end_pos - 1).to(), to);
6057 11913 : if (end_pos < count) {
6058 11772 : MoveRanges(list, end_pos, start_pos + 1, count - end_pos);
6059 : }
6060 11913 : list->at(start_pos) = CharacterRange::Range(new_from, new_to);
6061 11913 : return count - (end_pos - start_pos) + 1;
6062 : }
6063 :
6064 :
6065 20 : void CharacterSet::Canonicalize() {
6066 : // Special/default classes are always considered canonical. The result
6067 : // of calling ranges() will be sorted.
6068 176150 : if (ranges_ == nullptr) return;
6069 93427 : CharacterRange::Canonicalize(ranges_);
6070 : }
6071 :
6072 :
6073 497441 : void CharacterRange::Canonicalize(ZoneList<CharacterRange>* character_ranges) {
6074 497441 : if (character_ranges->length() <= 1) return;
6075 : // Check whether ranges are already canonical (increasing, non-overlapping,
6076 : // non-adjacent).
6077 : int n = character_ranges->length();
6078 : int max = character_ranges->at(0).to();
6079 : int i = 1;
6080 2619592 : while (i < n) {
6081 1286968 : CharacterRange current = character_ranges->at(i);
6082 1286968 : if (current.from() <= max + 1) {
6083 : break;
6084 : }
6085 : max = current.to();
6086 1277854 : i++;
6087 : }
6088 : // Canonical until the i'th range. If that's all of them, we are done.
6089 63884 : if (i == n) return;
6090 :
6091 : // The ranges at index i and forward are not canonicalized. Make them so by
6092 : // doing the equivalent of insertion sort (inserting each into the previous
6093 : // list, in order).
6094 : // Notice that inserting a range can reduce the number of ranges in the
6095 : // result due to combining of adjacent and overlapping ranges.
6096 : int read = i; // Range to insert.
6097 : int num_canonical = i; // Length of canonicalized part of list.
6098 : do {
6099 : num_canonical = InsertRangeInCanonicalList(character_ranges,
6100 : num_canonical,
6101 173176 : character_ranges->at(read));
6102 173176 : read++;
6103 173176 : } while (read < n);
6104 : character_ranges->Rewind(num_canonical);
6105 :
6106 : DCHECK(CharacterRange::IsCanonical(character_ranges));
6107 : }
6108 :
6109 :
6110 230 : void CharacterRange::Negate(ZoneList<CharacterRange>* ranges,
6111 : ZoneList<CharacterRange>* negated_ranges,
6112 : Zone* zone) {
6113 : DCHECK(CharacterRange::IsCanonical(ranges));
6114 : DCHECK_EQ(0, negated_ranges->length());
6115 : int range_count = ranges->length();
6116 : uc32 from = 0;
6117 : int i = 0;
6118 230 : if (range_count > 0 && ranges->at(0).from() == 0) {
6119 40 : from = ranges->at(0).to() + 1;
6120 : i = 1;
6121 : }
6122 14730 : while (i < range_count) {
6123 7250 : CharacterRange range = ranges->at(i);
6124 7250 : negated_ranges->Add(CharacterRange::Range(from, range.from() - 1), zone);
6125 7250 : from = range.to() + 1;
6126 7250 : i++;
6127 : }
6128 230 : if (from < String::kMaxCodePoint) {
6129 360 : negated_ranges->Add(CharacterRange::Range(from, String::kMaxCodePoint),
6130 180 : zone);
6131 : }
6132 230 : }
6133 :
6134 :
6135 : // -------------------------------------------------------------------
6136 : // Splay tree
6137 :
6138 :
6139 236859 : OutSet* OutSet::Extend(unsigned value, Zone* zone) {
6140 236859 : if (Get(value))
6141 : return this;
6142 236854 : if (successors(zone) != nullptr) {
6143 619610 : for (int i = 0; i < successors(zone)->length(); i++) {
6144 414087 : OutSet* successor = successors(zone)->at(i);
6145 414087 : if (successor->Get(value))
6146 : return successor;
6147 : }
6148 : } else {
6149 5694 : successors_ = new(zone) ZoneList<OutSet*>(2, zone);
6150 : }
6151 33984 : OutSet* result = new(zone) OutSet(first_, remaining_);
6152 16992 : result->Set(value, zone);
6153 16992 : successors(zone)->Add(result, zone);
6154 16992 : return result;
6155 : }
6156 :
6157 :
6158 713949 : void OutSet::Set(unsigned value, Zone *zone) {
6159 713949 : if (value < kFirstLimit) {
6160 389315 : first_ |= (1 << value);
6161 : } else {
6162 324634 : if (remaining_ == nullptr)
6163 84582 : remaining_ = new(zone) ZoneList<unsigned>(1, zone);
6164 889320 : if (remaining_->is_empty() || !remaining_->Contains(value))
6165 323584 : remaining_->Add(value, zone);
6166 : }
6167 713949 : }
6168 :
6169 :
6170 90010 : bool OutSet::Get(unsigned value) const {
6171 30831298 : if (value < kFirstLimit) {
6172 6621150 : return (first_ & (1 << value)) != 0;
6173 24501487 : } else if (remaining_ == nullptr) {
6174 : return false;
6175 : } else {
6176 0 : return remaining_->Contains(value);
6177 : }
6178 : }
6179 :
6180 :
6181 : const uc32 DispatchTable::Config::kNoKey = unibrow::Utf8::kBadChar;
6182 :
6183 :
6184 88433 : void DispatchTable::AddRange(CharacterRange full_range, int value,
6185 : Zone* zone) {
6186 88433 : CharacterRange current = full_range;
6187 88433 : if (tree()->is_empty()) {
6188 : // If this is the first range we just insert into the table.
6189 : ZoneSplayTree<Config>::Locator loc;
6190 2647 : bool inserted = tree()->Insert(current.from(), &loc);
6191 : DCHECK(inserted);
6192 : USE(inserted);
6193 5294 : loc.set_value(Entry(current.from(), current.to(),
6194 : empty()->Extend(value, zone)));
6195 : return;
6196 : }
6197 : // First see if there is a range to the left of this one that
6198 : // overlaps.
6199 : ZoneSplayTree<Config>::Locator loc;
6200 85786 : if (tree()->FindGreatestLessThan(current.from(), &loc)) {
6201 : Entry* entry = &loc.value();
6202 : // If we've found a range that overlaps with this one, and it
6203 : // starts strictly to the left of this one, we have to fix it
6204 : // because the following code only handles ranges that start on
6205 : // or after the start point of the range we're adding.
6206 84184 : if (entry->from() < current.from() && entry->to() >= current.from()) {
6207 : // Snap the overlapping range in half around the start point of
6208 : // the range we're adding.
6209 : CharacterRange left =
6210 400 : CharacterRange::Range(entry->from(), current.from() - 1);
6211 : CharacterRange right = CharacterRange::Range(current.from(), entry->to());
6212 : // The left part of the overlapping range doesn't overlap.
6213 : // Truncate the whole entry to be just the left part.
6214 : entry->set_to(left.to());
6215 : // The right part is the one that overlaps. We add this part
6216 : // to the map and let the next step deal with merging it with
6217 : // the range we're adding.
6218 : ZoneSplayTree<Config>::Locator loc;
6219 400 : bool inserted = tree()->Insert(right.from(), &loc);
6220 : DCHECK(inserted);
6221 : USE(inserted);
6222 : loc.set_value(Entry(right.from(),
6223 : right.to(),
6224 : entry->out_set()));
6225 : }
6226 : }
6227 166674 : while (current.is_valid()) {
6228 406291 : if (tree()->FindLeastGreaterThan(current.from(), &loc) &&
6229 242002 : (loc.value().from() <= current.to()) &&
6230 : (loc.value().to() >= current.from())) {
6231 : Entry* entry = &loc.value();
6232 : // We have overlap. If there is space between the start point of
6233 : // the range we're adding and where the overlapping range starts
6234 : // then we have to add a range covering just that space.
6235 80888 : if (current.from() < entry->from()) {
6236 : ZoneSplayTree<Config>::Locator ins;
6237 73098 : bool inserted = tree()->Insert(current.from(), &ins);
6238 : DCHECK(inserted);
6239 : USE(inserted);
6240 146196 : ins.set_value(Entry(current.from(),
6241 : entry->from() - 1,
6242 : empty()->Extend(value, zone)));
6243 : current.set_from(entry->from());
6244 : }
6245 : DCHECK_EQ(current.from(), entry->from());
6246 : // If the overlapping range extends beyond the one we want to add
6247 : // we have to snap the right part off and add it separately.
6248 80888 : if (entry->to() > current.to()) {
6249 : ZoneSplayTree<Config>::Locator ins;
6250 4430 : bool inserted = tree()->Insert(current.to() + 1, &ins);
6251 : DCHECK(inserted);
6252 : USE(inserted);
6253 : ins.set_value(Entry(current.to() + 1,
6254 : entry->to(),
6255 : entry->out_set()));
6256 : entry->set_to(current.to());
6257 : }
6258 : DCHECK(entry->to() <= current.to());
6259 : // The overlapping range is now completely contained by the range
6260 : // we're adding so we can just update it and move the start point
6261 : // of the range we're adding just past it.
6262 : entry->AddValue(value, zone);
6263 : DCHECK(entry->to() + 1 > current.from());
6264 80888 : current.set_from(entry->to() + 1);
6265 : } else {
6266 : // There is no overlap so we can just add the range
6267 : ZoneSplayTree<Config>::Locator ins;
6268 80226 : bool inserted = tree()->Insert(current.from(), &ins);
6269 : DCHECK(inserted);
6270 : USE(inserted);
6271 160452 : ins.set_value(Entry(current.from(),
6272 : current.to(),
6273 : empty()->Extend(value, zone)));
6274 : break;
6275 : }
6276 : }
6277 : }
6278 :
6279 :
6280 55010 : OutSet* DispatchTable::Get(uc32 value) {
6281 : ZoneSplayTree<Config>::Locator loc;
6282 55010 : if (!tree()->FindGreatestLessThan(value, &loc))
6283 0 : return empty();
6284 : Entry* entry = &loc.value();
6285 55010 : if (value <= entry->to())
6286 38885 : return entry->out_set();
6287 : else
6288 16125 : return empty();
6289 : }
6290 :
6291 :
6292 : // -------------------------------------------------------------------
6293 : // Analysis
6294 :
6295 :
6296 1075682 : void Analysis::EnsureAnalyzed(RegExpNode* that) {
6297 : StackLimitCheck check(isolate());
6298 1075682 : if (check.HasOverflowed()) {
6299 : fail("Stack overflow");
6300 : return;
6301 : }
6302 1075328 : if (that->info()->been_analyzed || that->info()->being_analyzed)
6303 : return;
6304 871323 : that->info()->being_analyzed = true;
6305 871323 : that->Accept(this);
6306 871323 : that->info()->being_analyzed = false;
6307 871323 : that->info()->been_analyzed = true;
6308 : }
6309 :
6310 :
6311 88114 : void Analysis::VisitEnd(EndNode* that) {
6312 : // nothing to do
6313 88114 : }
6314 :
6315 :
6316 315549 : void TextNode::CalculateOffsets() {
6317 : int element_count = elements()->length();
6318 : // Set up the offsets of the elements relative to the start. This is a fixed
6319 : // quantity since a TextNode can only contain fixed-width things.
6320 : int cp_offset = 0;
6321 1069953 : for (int i = 0; i < element_count; i++) {
6322 : TextElement& elm = elements()->at(i);
6323 : elm.set_cp_offset(cp_offset);
6324 377202 : cp_offset += elm.length();
6325 : }
6326 315549 : }
6327 :
6328 :
6329 317597 : void Analysis::VisitText(TextNode* that) {
6330 317597 : that->MakeCaseIndependent(isolate(), is_one_byte_);
6331 317597 : EnsureAnalyzed(that->on_success());
6332 317597 : if (!has_failed()) {
6333 315549 : that->CalculateOffsets();
6334 : }
6335 317597 : }
6336 :
6337 :
6338 286316 : void Analysis::VisitAction(ActionNode* that) {
6339 : RegExpNode* target = that->on_success();
6340 286316 : EnsureAnalyzed(target);
6341 286316 : if (!has_failed()) {
6342 : // If the next node is interested in what it follows then this node
6343 : // has to be interested too so it can pass the information on.
6344 : that->info()->AddFromFollowing(target->info());
6345 : }
6346 286316 : }
6347 :
6348 :
6349 25751 : void Analysis::VisitChoice(ChoiceNode* that) {
6350 : NodeInfo* info = that->info();
6351 293961 : for (int i = 0; i < that->alternatives()->length(); i++) {
6352 : RegExpNode* node = that->alternatives()->at(i).node();
6353 134105 : EnsureAnalyzed(node);
6354 134105 : if (has_failed()) return;
6355 : // Anything the following nodes need to know has to be known by
6356 : // this node also, so it can pass it on.
6357 : info->AddFromFollowing(node->info());
6358 : }
6359 : }
6360 :
6361 :
6362 145800 : void Analysis::VisitLoopChoice(LoopChoiceNode* that) {
6363 : NodeInfo* info = that->info();
6364 633878 : for (int i = 0; i < that->alternatives()->length(); i++) {
6365 : RegExpNode* node = that->alternatives()->at(i).node();
6366 291386 : if (node != that->loop_node()) {
6367 145800 : EnsureAnalyzed(node);
6368 145800 : if (has_failed()) return;
6369 : info->AddFromFollowing(node->info());
6370 : }
6371 : }
6372 : // Check the loop last since it may need the value of this node
6373 : // to get a correct result.
6374 98453 : EnsureAnalyzed(that->loop_node());
6375 98453 : if (!has_failed()) {
6376 : info->AddFromFollowing(that->loop_node()->info());
6377 : }
6378 : }
6379 :
6380 :
6381 2320 : void Analysis::VisitBackReference(BackReferenceNode* that) {
6382 2320 : EnsureAnalyzed(that->on_success());
6383 2320 : }
6384 :
6385 :
6386 5425 : void Analysis::VisitAssertion(AssertionNode* that) {
6387 5425 : EnsureAnalyzed(that->on_success());
6388 5425 : }
6389 :
6390 :
6391 188 : void BackReferenceNode::FillInBMInfo(Isolate* isolate, int offset, int budget,
6392 : BoyerMooreLookahead* bm,
6393 : bool not_at_start) {
6394 : // Working out the set of characters that a backreference can match is too
6395 : // hard, so we just say that any character can match.
6396 : bm->SetRest(offset);
6397 : SaveBMInfo(bm, not_at_start, offset);
6398 188 : }
6399 :
6400 :
6401 : STATIC_ASSERT(BoyerMoorePositionInfo::kMapSize ==
6402 : RegExpMacroAssembler::kTableSize);
6403 :
6404 :
6405 7809 : void ChoiceNode::FillInBMInfo(Isolate* isolate, int offset, int budget,
6406 : BoyerMooreLookahead* bm, bool not_at_start) {
6407 : ZoneList<GuardedAlternative>* alts = alternatives();
6408 15618 : budget = (budget - 1) / alts->length();
6409 90195 : for (int i = 0; i < alts->length(); i++) {
6410 : GuardedAlternative& alt = alts->at(i);
6411 41665 : if (alt.guards() != nullptr && alt.guards()->length() != 0) {
6412 : bm->SetRest(offset); // Give up trying to fill in info.
6413 : SaveBMInfo(bm, not_at_start, offset);
6414 : return;
6415 : }
6416 41193 : alt.node()->FillInBMInfo(isolate, offset, budget, bm, not_at_start);
6417 : }
6418 : SaveBMInfo(bm, not_at_start, offset);
6419 : }
6420 :
6421 :
6422 122981 : void TextNode::FillInBMInfo(Isolate* isolate, int initial_offset, int budget,
6423 : BoyerMooreLookahead* bm, bool not_at_start) {
6424 122981 : if (initial_offset >= bm->length()) return;
6425 : int offset = initial_offset;
6426 : int max_char = bm->max_char();
6427 403303 : for (int i = 0; i < elements()->length(); i++) {
6428 163519 : if (offset >= bm->length()) {
6429 17007 : if (initial_offset == 0) set_bm_info(not_at_start, bm);
6430 : return;
6431 : }
6432 146512 : TextElement text = elements()->at(i);
6433 146512 : if (text.text_type() == TextElement::ATOM) {
6434 : RegExpAtom* atom = text.atom();
6435 213580 : for (int j = 0; j < atom->length(); j++, offset++) {
6436 89008 : if (offset >= bm->length()) {
6437 6351 : if (initial_offset == 0) set_bm_info(not_at_start, bm);
6438 : return;
6439 : }
6440 165314 : uc16 character = atom->data()[j];
6441 82657 : if (IgnoreCase(atom->flags())) {
6442 : unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
6443 4614 : int length = GetCaseIndependentLetters(
6444 : isolate, character, bm->max_char() == String::kMaxOneByteCharCode,
6445 4614 : chars);
6446 21786 : for (int j = 0; j < length; j++) {
6447 8586 : bm->Set(offset, chars[j]);
6448 : }
6449 : } else {
6450 78043 : if (character <= max_char) bm->Set(offset, character);
6451 : }
6452 : }
6453 : } else {
6454 : DCHECK_EQ(TextElement::CHAR_CLASS, text.text_type());
6455 : RegExpCharacterClass* char_class = text.char_class();
6456 : ZoneList<CharacterRange>* ranges = char_class->ranges(zone());
6457 98246 : if (char_class->is_negated()) {
6458 4373 : bm->SetAll(offset);
6459 : } else {
6460 671633 : for (int k = 0; k < ranges->length(); k++) {
6461 : CharacterRange& range = ranges->at(k);
6462 288880 : if (range.from() > max_char) continue;
6463 : int to = Min(max_char, static_cast<int>(range.to()));
6464 161809 : bm->SetInterval(offset, Interval(range.from(), to));
6465 : }
6466 : }
6467 98246 : offset++;
6468 : }
6469 : }
6470 99623 : if (offset >= bm->length()) {
6471 90337 : if (initial_offset == 0) set_bm_info(not_at_start, bm);
6472 : return;
6473 : }
6474 9286 : on_success()->FillInBMInfo(isolate, offset, budget - 1, bm,
6475 18572 : true); // Not at start after a text node.
6476 9286 : if (initial_offset == 0) set_bm_info(not_at_start, bm);
6477 : }
6478 :
6479 :
6480 : // -------------------------------------------------------------------
6481 : // Dispatch table construction
6482 :
6483 :
6484 0 : void DispatchTableConstructor::VisitEnd(EndNode* that) {
6485 : AddRange(CharacterRange::Everything());
6486 0 : }
6487 :
6488 :
6489 0 : void DispatchTableConstructor::BuildTable(ChoiceNode* node) {
6490 : node->set_being_calculated(true);
6491 : ZoneList<GuardedAlternative>* alternatives = node->alternatives();
6492 0 : for (int i = 0; i < alternatives->length(); i++) {
6493 : set_choice_index(i);
6494 0 : alternatives->at(i).node()->Accept(this);
6495 : }
6496 : node->set_being_calculated(false);
6497 0 : }
6498 :
6499 :
6500 : class AddDispatchRange {
6501 : public:
6502 : explicit AddDispatchRange(DispatchTableConstructor* constructor)
6503 0 : : constructor_(constructor) { }
6504 : void Call(uc32 from, DispatchTable::Entry entry);
6505 : private:
6506 : DispatchTableConstructor* constructor_;
6507 : };
6508 :
6509 :
6510 0 : void AddDispatchRange::Call(uc32 from, DispatchTable::Entry entry) {
6511 0 : constructor_->AddRange(CharacterRange::Range(from, entry.to()));
6512 0 : }
6513 :
6514 :
6515 0 : void DispatchTableConstructor::VisitChoice(ChoiceNode* node) {
6516 0 : if (node->being_calculated())
6517 0 : return;
6518 0 : DispatchTable* table = node->GetTable(ignore_case_);
6519 : AddDispatchRange adder(this);
6520 : table->ForEach(&adder);
6521 : }
6522 :
6523 :
6524 0 : void DispatchTableConstructor::VisitBackReference(BackReferenceNode* that) {
6525 : // TODO(160): Find the node that we refer back to and propagate its start
6526 : // set back to here. For now we just accept anything.
6527 : AddRange(CharacterRange::Everything());
6528 0 : }
6529 :
6530 :
6531 0 : void DispatchTableConstructor::VisitAssertion(AssertionNode* that) {
6532 : RegExpNode* target = that->on_success();
6533 0 : target->Accept(this);
6534 0 : }
6535 :
6536 :
6537 3935 : static int CompareRangeByFrom(const CharacterRange* a,
6538 : const CharacterRange* b) {
6539 7870 : return Compare<uc16>(a->from(), b->from());
6540 : }
6541 :
6542 :
6543 55 : void DispatchTableConstructor::AddInverse(ZoneList<CharacterRange>* ranges) {
6544 : ranges->Sort(CompareRangeByFrom);
6545 : uc16 last = 0;
6546 1665 : for (int i = 0; i < ranges->length(); i++) {
6547 805 : CharacterRange range = ranges->at(i);
6548 805 : if (last < range.from())
6549 525 : AddRange(CharacterRange::Range(last, range.from() - 1));
6550 805 : if (range.to() >= last) {
6551 715 : if (range.to() == String::kMaxCodePoint) {
6552 : return;
6553 : } else {
6554 715 : last = range.to() + 1;
6555 : }
6556 : }
6557 : }
6558 55 : AddRange(CharacterRange::Range(last, String::kMaxCodePoint));
6559 : }
6560 :
6561 :
6562 0 : void DispatchTableConstructor::VisitText(TextNode* that) {
6563 0 : TextElement elm = that->elements()->at(0);
6564 0 : switch (elm.text_type()) {
6565 : case TextElement::ATOM: {
6566 0 : uc16 c = elm.atom()->data()[0];
6567 0 : AddRange(CharacterRange::Range(c, c));
6568 : break;
6569 : }
6570 : case TextElement::CHAR_CLASS: {
6571 : RegExpCharacterClass* tree = elm.char_class();
6572 : ZoneList<CharacterRange>* ranges = tree->ranges(that->zone());
6573 0 : if (tree->is_negated()) {
6574 0 : AddInverse(ranges);
6575 : } else {
6576 0 : for (int i = 0; i < ranges->length(); i++)
6577 : AddRange(ranges->at(i));
6578 : }
6579 : break;
6580 : }
6581 : default: {
6582 0 : UNIMPLEMENTED();
6583 : }
6584 : }
6585 0 : }
6586 :
6587 :
6588 0 : void DispatchTableConstructor::VisitAction(ActionNode* that) {
6589 : RegExpNode* target = that->on_success();
6590 0 : target->Accept(this);
6591 0 : }
6592 :
6593 40 : RegExpNode* OptionallyStepBackToLeadSurrogate(RegExpCompiler* compiler,
6594 : RegExpNode* on_success,
6595 : JSRegExp::Flags flags) {
6596 : // If the regexp matching starts within a surrogate pair, step back
6597 : // to the lead surrogate and start matching from there.
6598 : DCHECK(!compiler->read_backward());
6599 : Zone* zone = compiler->zone();
6600 : ZoneList<CharacterRange>* lead_surrogates = CharacterRange::List(
6601 40 : zone, CharacterRange::Range(kLeadSurrogateStart, kLeadSurrogateEnd));
6602 : ZoneList<CharacterRange>* trail_surrogates = CharacterRange::List(
6603 40 : zone, CharacterRange::Range(kTrailSurrogateStart, kTrailSurrogateEnd));
6604 :
6605 40 : ChoiceNode* optional_step_back = new (zone) ChoiceNode(2, zone);
6606 :
6607 : int stack_register = compiler->UnicodeLookaroundStackRegister();
6608 : int position_register = compiler->UnicodeLookaroundPositionRegister();
6609 : RegExpNode* step_back = TextNode::CreateForCharacterRanges(
6610 40 : zone, lead_surrogates, true, on_success, flags);
6611 : RegExpLookaround::Builder builder(true, step_back, stack_register,
6612 40 : position_register);
6613 : RegExpNode* match_trail = TextNode::CreateForCharacterRanges(
6614 40 : zone, trail_surrogates, false, builder.on_match_success(), flags);
6615 :
6616 40 : optional_step_back->AddAlternative(
6617 : GuardedAlternative(builder.ForMatch(match_trail)));
6618 : optional_step_back->AddAlternative(GuardedAlternative(on_success));
6619 :
6620 40 : return optional_step_back;
6621 : }
6622 :
6623 :
6624 85675 : RegExpEngine::CompilationResult RegExpEngine::Compile(
6625 : Isolate* isolate, Zone* zone, RegExpCompileData* data,
6626 : JSRegExp::Flags flags, Handle<String> pattern,
6627 : Handle<String> sample_subject, bool is_one_byte) {
6628 85675 : if ((data->capture_count + 1) * 2 - 1 > RegExpMacroAssembler::kMaxRegister) {
6629 : return IrregexpRegExpTooBig(isolate);
6630 : }
6631 : bool is_sticky = IsSticky(flags);
6632 : bool is_global = IsGlobal(flags);
6633 : bool is_unicode = IsUnicode(flags);
6634 85666 : RegExpCompiler compiler(isolate, zone, data->capture_count, is_one_byte);
6635 :
6636 85666 : if (compiler.optimize())
6637 84502 : compiler.set_optimize(!TooMuchRegExpCode(isolate, pattern));
6638 :
6639 : // Sample some characters from the middle of the string.
6640 : static const int kSampleSize = 128;
6641 :
6642 85666 : sample_subject = String::Flatten(isolate, sample_subject);
6643 : int chars_sampled = 0;
6644 85666 : int half_way = (sample_subject->length() - kSampleSize) / 2;
6645 997722 : for (int i = Max(0, half_way);
6646 541694 : i < sample_subject->length() && chars_sampled < kSampleSize;
6647 : i++, chars_sampled++) {
6648 : compiler.frequency_collator()->CountCharacter(sample_subject->Get(i));
6649 : }
6650 :
6651 : // Wrap the body of the regexp in capture #0.
6652 85666 : RegExpNode* captured_body = RegExpCapture::ToNode(data->tree,
6653 : 0,
6654 : &compiler,
6655 85666 : compiler.accept());
6656 : RegExpNode* node = captured_body;
6657 85666 : bool is_end_anchored = data->tree->IsAnchoredAtEnd();
6658 85666 : bool is_start_anchored = data->tree->IsAnchoredAtStart();
6659 85666 : int max_length = data->tree->max_match();
6660 85666 : if (!is_start_anchored && !is_sticky) {
6661 : // Add a .*? at the beginning, outside the body capture, unless
6662 : // this expression is anchored at the beginning or sticky.
6663 : JSRegExp::Flags default_flags = JSRegExp::Flags();
6664 82723 : RegExpNode* loop_node = RegExpQuantifier::ToNode(
6665 : 0, RegExpTree::kInfinity, false,
6666 : new (zone) RegExpCharacterClass('*', default_flags), &compiler,
6667 165446 : captured_body, data->contains_anchor);
6668 :
6669 82723 : if (data->contains_anchor) {
6670 : // Unroll loop once, to take care of the case that might start
6671 : // at the start of input.
6672 149 : ChoiceNode* first_step_node = new(zone) ChoiceNode(2, zone);
6673 : first_step_node->AddAlternative(GuardedAlternative(captured_body));
6674 : first_step_node->AddAlternative(GuardedAlternative(new (zone) TextNode(
6675 : new (zone) RegExpCharacterClass('*', default_flags), false,
6676 149 : loop_node)));
6677 : node = first_step_node;
6678 : } else {
6679 : node = loop_node;
6680 : }
6681 : }
6682 85666 : if (is_one_byte) {
6683 14611 : node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
6684 : // Do it again to propagate the new nodes to places where they were not
6685 : // put because they had not been calculated yet.
6686 14611 : if (node != nullptr) {
6687 14311 : node = node->FilterOneByte(RegExpCompiler::kMaxRecursion);
6688 : }
6689 71055 : } else if (is_unicode && (is_global || is_sticky)) {
6690 40 : node = OptionallyStepBackToLeadSurrogate(&compiler, node, flags);
6691 : }
6692 :
6693 85666 : if (node == nullptr) node = new (zone) EndNode(EndNode::BACKTRACK, zone);
6694 85666 : data->node = node;
6695 : Analysis analysis(isolate, is_one_byte);
6696 85666 : analysis.EnsureAnalyzed(node);
6697 85666 : if (analysis.has_failed()) {
6698 : const char* error_message = analysis.error_message();
6699 : return CompilationResult(isolate, error_message);
6700 : }
6701 :
6702 : // Create the correct assembler for the architecture.
6703 : std::unique_ptr<RegExpMacroAssembler> macro_assembler;
6704 85312 : if (!FLAG_regexp_interpret_all) {
6705 : // Native regexp implementation.
6706 : DCHECK(!FLAG_jitless);
6707 :
6708 : NativeRegExpMacroAssembler::Mode mode =
6709 : is_one_byte ? NativeRegExpMacroAssembler::LATIN1
6710 82055 : : NativeRegExpMacroAssembler::UC16;
6711 :
6712 : #if V8_TARGET_ARCH_IA32
6713 : macro_assembler.reset(new RegExpMacroAssemblerIA32(
6714 : isolate, zone, mode, (data->capture_count + 1) * 2));
6715 : #elif V8_TARGET_ARCH_X64
6716 82055 : macro_assembler.reset(new RegExpMacroAssemblerX64(
6717 82055 : isolate, zone, mode, (data->capture_count + 1) * 2));
6718 : #elif V8_TARGET_ARCH_ARM
6719 : macro_assembler.reset(new RegExpMacroAssemblerARM(
6720 : isolate, zone, mode, (data->capture_count + 1) * 2));
6721 : #elif V8_TARGET_ARCH_ARM64
6722 : macro_assembler.reset(new RegExpMacroAssemblerARM64(
6723 : isolate, zone, mode, (data->capture_count + 1) * 2));
6724 : #elif V8_TARGET_ARCH_S390
6725 : macro_assembler.reset(new RegExpMacroAssemblerS390(
6726 : isolate, zone, mode, (data->capture_count + 1) * 2));
6727 : #elif V8_TARGET_ARCH_PPC
6728 : macro_assembler.reset(new RegExpMacroAssemblerPPC(
6729 : isolate, zone, mode, (data->capture_count + 1) * 2));
6730 : #elif V8_TARGET_ARCH_MIPS
6731 : macro_assembler.reset(new RegExpMacroAssemblerMIPS(
6732 : isolate, zone, mode, (data->capture_count + 1) * 2));
6733 : #elif V8_TARGET_ARCH_MIPS64
6734 : macro_assembler.reset(new RegExpMacroAssemblerMIPS(
6735 : isolate, zone, mode, (data->capture_count + 1) * 2));
6736 : #else
6737 : #error "Unsupported architecture"
6738 : #endif
6739 : } else {
6740 : DCHECK(FLAG_regexp_interpret_all);
6741 :
6742 : // Interpreted regexp implementation.
6743 3257 : macro_assembler.reset(new RegExpMacroAssemblerIrregexp(isolate, zone));
6744 : }
6745 :
6746 85312 : macro_assembler->set_slow_safe(TooMuchRegExpCode(isolate, pattern));
6747 :
6748 : // Inserted here, instead of in Assembler, because it depends on information
6749 : // in the AST that isn't replicated in the Node structure.
6750 : static const int kMaxBacksearchLimit = 1024;
6751 85855 : if (is_end_anchored && !is_start_anchored && !is_sticky &&
6752 543 : max_length < kMaxBacksearchLimit) {
6753 210 : macro_assembler->SetCurrentPositionFromEnd(max_length);
6754 : }
6755 :
6756 85312 : if (is_global) {
6757 : RegExpMacroAssembler::GlobalMode mode = RegExpMacroAssembler::GLOBAL;
6758 3819 : if (data->tree->min_match() > 0) {
6759 : mode = RegExpMacroAssembler::GLOBAL_NO_ZERO_LENGTH_CHECK;
6760 138 : } else if (is_unicode) {
6761 : mode = RegExpMacroAssembler::GLOBAL_UNICODE;
6762 : }
6763 : macro_assembler->set_global_mode(mode);
6764 : }
6765 :
6766 : return compiler.Assemble(isolate, macro_assembler.get(), node,
6767 85312 : data->capture_count, pattern);
6768 : }
6769 :
6770 169814 : bool RegExpEngine::TooMuchRegExpCode(Isolate* isolate, Handle<String> pattern) {
6771 : Heap* heap = isolate->heap();
6772 169814 : bool too_much = pattern->length() > RegExpImpl::kRegExpTooLargeToOptimize;
6773 169814 : if (isolate->total_regexp_code_generated() >
6774 298367 : RegExpImpl::kRegExpCompiledLimit &&
6775 128553 : heap->CommittedMemoryExecutable() >
6776 : RegExpImpl::kRegExpExecutableMemoryLimit) {
6777 : too_much = true;
6778 : }
6779 169814 : return too_much;
6780 : }
6781 :
6782 36147 : Object RegExpResultsCache::Lookup(Heap* heap, String key_string,
6783 : Object key_pattern,
6784 : FixedArray* last_match_cache,
6785 : ResultsCacheType type) {
6786 : FixedArray cache;
6787 36147 : if (!key_string->IsInternalizedString()) return Smi::kZero;
6788 5230 : if (type == STRING_SPLIT_SUBSTRINGS) {
6789 : DCHECK(key_pattern->IsString());
6790 5230 : if (!key_pattern->IsInternalizedString()) return Smi::kZero;
6791 : cache = heap->string_split_cache();
6792 : } else {
6793 : DCHECK(type == REGEXP_MULTIPLE_INDICES);
6794 : DCHECK(key_pattern->IsFixedArray());
6795 : cache = heap->regexp_multiple_cache();
6796 : }
6797 :
6798 5230 : uint32_t hash = key_string->Hash();
6799 : uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
6800 5230 : ~(kArrayEntriesPerCacheEntry - 1));
6801 14432 : if (cache->get(index + kStringOffset) != key_string ||
6802 3972 : cache->get(index + kPatternOffset) != key_pattern) {
6803 : index =
6804 1289 : ((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize - 1));
6805 2597 : if (cache->get(index + kStringOffset) != key_string ||
6806 19 : cache->get(index + kPatternOffset) != key_pattern) {
6807 1281 : return Smi::kZero;
6808 : }
6809 : }
6810 :
6811 7898 : *last_match_cache = FixedArray::cast(cache->get(index + kLastMatchOffset));
6812 3949 : return cache->get(index + kArrayOffset);
6813 : }
6814 :
6815 32198 : void RegExpResultsCache::Enter(Isolate* isolate, Handle<String> key_string,
6816 : Handle<Object> key_pattern,
6817 : Handle<FixedArray> value_array,
6818 : Handle<FixedArray> last_match_cache,
6819 : ResultsCacheType type) {
6820 : Factory* factory = isolate->factory();
6821 : Handle<FixedArray> cache;
6822 32198 : if (!key_string->IsInternalizedString()) return;
6823 1281 : if (type == STRING_SPLIT_SUBSTRINGS) {
6824 : DCHECK(key_pattern->IsString());
6825 1281 : if (!key_pattern->IsInternalizedString()) return;
6826 : cache = factory->string_split_cache();
6827 : } else {
6828 : DCHECK(type == REGEXP_MULTIPLE_INDICES);
6829 : DCHECK(key_pattern->IsFixedArray());
6830 : cache = factory->regexp_multiple_cache();
6831 : }
6832 :
6833 1281 : uint32_t hash = key_string->Hash();
6834 : uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
6835 1281 : ~(kArrayEntriesPerCacheEntry - 1));
6836 2562 : if (cache->get(index + kStringOffset) == Smi::kZero) {
6837 2288 : cache->set(index + kStringOffset, *key_string);
6838 2288 : cache->set(index + kPatternOffset, *key_pattern);
6839 2288 : cache->set(index + kArrayOffset, *value_array);
6840 2288 : cache->set(index + kLastMatchOffset, *last_match_cache);
6841 : } else {
6842 : uint32_t index2 =
6843 137 : ((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize - 1));
6844 274 : if (cache->get(index2 + kStringOffset) == Smi::kZero) {
6845 188 : cache->set(index2 + kStringOffset, *key_string);
6846 188 : cache->set(index2 + kPatternOffset, *key_pattern);
6847 188 : cache->set(index2 + kArrayOffset, *value_array);
6848 188 : cache->set(index2 + kLastMatchOffset, *last_match_cache);
6849 : } else {
6850 43 : cache->set(index2 + kStringOffset, Smi::kZero);
6851 86 : cache->set(index2 + kPatternOffset, Smi::kZero);
6852 86 : cache->set(index2 + kArrayOffset, Smi::kZero);
6853 86 : cache->set(index2 + kLastMatchOffset, Smi::kZero);
6854 86 : cache->set(index + kStringOffset, *key_string);
6855 86 : cache->set(index + kPatternOffset, *key_pattern);
6856 86 : cache->set(index + kArrayOffset, *value_array);
6857 86 : cache->set(index + kLastMatchOffset, *last_match_cache);
6858 : }
6859 : }
6860 : // If the array is a reasonably short list of substrings, convert it into a
6861 : // list of internalized strings.
6862 2562 : if (type == STRING_SPLIT_SUBSTRINGS && value_array->length() < 100) {
6863 12729 : for (int i = 0; i < value_array->length(); i++) {
6864 : Handle<String> str(String::cast(value_array->get(i)), isolate);
6865 5740 : Handle<String> internalized_str = factory->InternalizeString(str);
6866 11480 : value_array->set(i, *internalized_str);
6867 : }
6868 : }
6869 : // Convert backing store to a copy-on-write array.
6870 : value_array->set_map_no_write_barrier(
6871 : ReadOnlyRoots(isolate).fixed_cow_array_map());
6872 : }
6873 :
6874 147910 : void RegExpResultsCache::Clear(FixedArray cache) {
6875 75877830 : for (int i = 0; i < kRegExpResultsCacheSize; i++) {
6876 37864960 : cache->set(i, Smi::kZero);
6877 : }
6878 147910 : }
6879 :
6880 : } // namespace internal
6881 120216 : } // namespace v8
|
