languages/dart-sdk
languages/dart-sdk
1
0
Fork 0
mirror of https://github.com/dart-lang/sdk synced 2024-09-15 23:29:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

[vm/regexp] Ensure regex interpreter checks and yields to safepoints, handles OOB messages periodically.

Browse source 
Fixes https://github.com/flutter/flutter/issues/88063
Fixes https://github.com/dart-lang/sdk/issues/26041

TEST=benchmarks/EventLoopLatencyRegexp,
long_regexp_process_oob_messages_test

Change-Id: I2bb10b332768f794b902b58be18d437cc07a59a7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/210065
Reviewed-by: Martin Kustermann <kustermann@google.com>
Commit-Queue: Alexander Aprelev <aam@google.com>
This commit is contained in:
Alexander Aprelev 2021-08-20 16:19:16 +00:00 committed by commit-bot@chromium.org
parent 709f87e7f3
commit 064a9a50a0
6 changed files with 544 additions and 452 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
runtime/tests/vm/dart/isolates/long_regexp_process_oob_messages_test.dart Normal file
View file

@ -0,0 +1,29 @@
// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'dart:isolate';
import "package:async_helper/async_helper.dart";
import "package:expect/expect.dart";
worker(SendPort sendPort) {
final re = RegExp(r'(x+)*y');
final s = 'x' * 100 + '';
sendPort.send('worker started');
print(re.allMatches(s).iterator.moveNext());
}
main() async {
asyncStart();
ReceivePort onExit = ReceivePort();
ReceivePort workerStarted = ReceivePort();
final isolate = await Isolate.spawn(worker, workerStarted.sendPort,
onExit: onExit.sendPort, errorsAreFatal: true);
await workerStarted.first;
print('worker started, now killing worker');
isolate.kill(priority: Isolate.immediate);
await onExit.first;
print('worker exited');
asyncEnd();
}

29
runtime/tests/vm/dart_2/isolates/long_regexp_process_oob_messages_test.dart Normal file
View file

@ -0,0 +1,29 @@
// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'dart:isolate';
import "package:async_helper/async_helper.dart";
import "package:expect/expect.dart";
worker(SendPort sendPort) {
final re = RegExp(r'(x+)*y');
final s = 'x' * 100 + '';
sendPort.send('worker started');
print(re.allMatches(s).iterator.moveNext());
}
main() async {
asyncStart();
ReceivePort onExit = ReceivePort();
ReceivePort workerStarted = ReceivePort();
final isolate = await Isolate.spawn(worker, workerStarted.sendPort,
onExit: onExit.sendPort, errorsAreFatal: true);
await workerStarted.first;
print('worker started, now killing worker');
isolate.kill(priority: Isolate.immediate);
await onExit.first;
print('worker exited');
asyncEnd();
}

54
runtime/vm/regexp_assembler_bytecode.cc
View file

@ -468,13 +468,13 @@ static intptr_t Prepare(const RegExp& regexp,
(regexp.num_bracket_expressions() + 1) * 2; (regexp.num_bracket_expressions() + 1) * 2;
} }
static IrregexpInterpreter::IrregexpResult ExecRaw(const RegExp& regexp, static ObjectPtr ExecRaw(const RegExp& regexp,
const String& subject, const String& subject,
intptr_t index, intptr_t index,
bool sticky, bool sticky,
int32_t* output, int32_t* output,
intptr_t output_size, intptr_t output_size,
Zone* zone) { Zone* zone) {
bool is_one_byte = bool is_one_byte =
subject.IsOneByteString() || subject.IsExternalOneByteString(); subject.IsOneByteString() || subject.IsExternalOneByteString();
@ -493,14 +493,16 @@ static IrregexpInterpreter::IrregexpResult ExecRaw(const RegExp& regexp,
const TypedData& bytecode = const TypedData& bytecode =
TypedData::Handle(zone, regexp.bytecode(is_one_byte, sticky)); TypedData::Handle(zone, regexp.bytecode(is_one_byte, sticky));
ASSERT(!bytecode.IsNull()); ASSERT(!bytecode.IsNull());
IrregexpInterpreter::IrregexpResult result = const Object& result = Object::Handle(
IrregexpInterpreter::Match(bytecode, subject, raw_output, index, zone); zone,
IrregexpInterpreter::Match(bytecode, subject, raw_output, index, zone));
if (result == IrregexpInterpreter::RE_SUCCESS) { if (result.ptr() == Bool::True().ptr()) {
// Copy capture results to the start of the registers array. // Copy capture results to the start of the registers array.
memmove(output, raw_output, number_of_capture_registers * sizeof(int32_t)); memmove(output, raw_output, number_of_capture_registers * sizeof(int32_t));
} }
if (result == IrregexpInterpreter::RE_EXCEPTION) { if (result.ptr() == Object::null()) {
// Exception during regexp processing
Thread* thread = Thread::Current(); Thread* thread = Thread::Current();
auto isolate_group = thread->isolate_group(); auto isolate_group = thread->isolate_group();
const Instance& exception = const Instance& exception =
@ -508,14 +510,14 @@ static IrregexpInterpreter::IrregexpResult ExecRaw(const RegExp& regexp,
Exceptions::Throw(thread, exception); Exceptions::Throw(thread, exception);
UNREACHABLE(); UNREACHABLE();
} }
return result; return result.ptr();
} }
InstancePtr BytecodeRegExpMacroAssembler::Interpret(const RegExp& regexp, ObjectPtr BytecodeRegExpMacroAssembler::Interpret(const RegExp& regexp,
const String& subject, const String& subject,
const Smi& start_index, const Smi& start_index,
bool sticky, bool sticky,
Zone* zone) { Zone* zone) {
intptr_t required_registers = Prepare(regexp, subject, sticky, zone); intptr_t required_registers = Prepare(regexp, subject, sticky, zone);
if (required_registers < 0) { if (required_registers < 0) {
// Compiling failed with an exception. // Compiling failed with an exception.
@ -525,11 +527,10 @@ InstancePtr BytecodeRegExpMacroAssembler::Interpret(const RegExp& regexp,
// V8 uses a shared copy on the isolate when smaller than some threshold. // V8 uses a shared copy on the isolate when smaller than some threshold.
int32_t* output_registers = zone->Alloc<int32_t>(required_registers); int32_t* output_registers = zone->Alloc<int32_t>(required_registers);
IrregexpInterpreter::IrregexpResult result = const Object& result =
ExecRaw(regexp, subject, start_index.Value(), sticky, output_registers, Object::Handle(zone, ExecRaw(regexp, subject, start_index.Value(), sticky,
required_registers, zone); output_registers, required_registers, zone));
if (result.ptr() == Bool::True().ptr()) {
if (result == IrregexpInterpreter::RE_SUCCESS) {
intptr_t capture_count = regexp.num_bracket_expressions(); intptr_t capture_count = regexp.num_bracket_expressions();
intptr_t capture_register_count = (capture_count + 1) * 2; intptr_t capture_register_count = (capture_count + 1) * 2;
ASSERT(required_registers >= capture_register_count); ASSERT(required_registers >= capture_register_count);
@ -553,10 +554,15 @@ InstancePtr BytecodeRegExpMacroAssembler::Interpret(const RegExp& regexp,
return result.ptr(); return result.ptr();
} }
if (result == IrregexpInterpreter::RE_EXCEPTION) { if (result.ptr() == Object::null()) {
// internal exception
UNREACHABLE(); UNREACHABLE();
} }
ASSERT(result == IrregexpInterpreter::RE_FAILURE); if (result.IsError()) {
Exceptions::PropagateError(Error::Cast(result));
UNREACHABLE();
}
ASSERT(result.ptr() == Bool::False().ptr());
return Instance::null(); return Instance::null();
} }

10
runtime/vm/regexp_assembler_bytecode.h
View file

@ -107,11 +107,11 @@ class BytecodeRegExpMacroAssembler : public RegExpMacroAssembler {
virtual void PrintBlocks() { UNIMPLEMENTED(); } virtual void PrintBlocks() { UNIMPLEMENTED(); }
///// /////
static InstancePtr Interpret(const RegExp& regexp, static ObjectPtr Interpret(const RegExp& regexp,
const String& str, const String& str,
const Smi& start_index, const Smi& start_index,
bool is_sticky, bool is_sticky,
Zone* zone); Zone* zone);
private: private:
void Expand(); void Expand();

859
runtime/vm/regexp_interpreter.cc
View file

@ -4,11 +4,12 @@
// A simple interpreter for the Irregexp byte code. // A simple interpreter for the Irregexp byte code.
#include "vm/regexp_interpreter.h"
#include <memory> #include <memory>
#include <utility> #include <utility>
#include "heap/safepoint.h"
#include "vm/regexp_interpreter.h"
#include "platform/unicode.h" #include "platform/unicode.h"
#include "vm/object.h" #include "vm/object.h"
#include "vm/regexp_assembler.h" #include "vm/regexp_assembler.h"
@ -169,14 +170,16 @@ class BacktrackStack {
DISALLOW_COPY_AND_ASSIGN(BacktrackStack); DISALLOW_COPY_AND_ASSIGN(BacktrackStack);
}; };
// Returns True if success, False if failure, Null if internal exception,
// Error if VM error needs to be propagated up the callchain.
template <typename Char> template <typename Char>
static IrregexpInterpreter::IrregexpResult RawMatch(const uint8_t* code_base, static ObjectPtr RawMatch(const TypedData& bytecode,
const String& subject, const String& subject,
int32_t* registers, int32_t* registers,
intptr_t current, intptr_t current,
uint32_t current_char, uint32_t current_char,
Zone* zone) { Zone* zone) {
const uint8_t* pc = code_base; const auto thread = Thread::Current();
// BacktrackStack ensures that the memory allocated for the backtracking stack // BacktrackStack ensures that the memory allocated for the backtracking stack
// is returned to the system or cached if there is no stack being cached at // is returned to the system or cached if there is no stack being cached at
// the moment. // the moment.
@ -196,482 +199,506 @@ static IrregexpInterpreter::IrregexpResult RawMatch(const uint8_t* code_base,
OS::PrintErr("Start irregexp bytecode interpreter\n"); OS::PrintErr("Start irregexp bytecode interpreter\n");
} }
#endif #endif
const uint8_t* code_base;
const uint8_t* pc;
{
NoSafepointScope no_safepoint;
code_base = reinterpret_cast<uint8_t*>(bytecode.DataAddr(0));
pc = code_base;
}
while (true) { while (true) {
int32_t insn = Load32Aligned(pc); if (UNLIKELY(thread->HasScheduledInterrupts())) {
switch (insn & BYTECODE_MASK) { intptr_t pc_offset = pc - code_base;
BYTECODE(BREAK) ErrorPtr error = thread->HandleInterrupts();
UNREACHABLE(); if (error != Object::null()) {
return IrregexpInterpreter::RE_FAILURE; // Needs to be propagated to the Dart native invoking the
BYTECODE(PUSH_CP) // regex matcher.
if (--backtrack_stack_space < 0) { return error;
return IrregexpInterpreter::RE_EXCEPTION;
} }
*backtrack_sp++ = current; NoSafepointScope no_safepoint;
pc += BC_PUSH_CP_LENGTH; code_base = reinterpret_cast<uint8_t*>(bytecode.DataAddr(0));
break; pc = code_base + pc_offset;
BYTECODE(PUSH_BT) }
if (--backtrack_stack_space < 0) { NoSafepointScope no_safepoint;
return IrregexpInterpreter::RE_EXCEPTION; bool check_for_safepoint_now = false;
} while (!check_for_safepoint_now) {
*backtrack_sp++ = Load32Aligned(pc + 4); int32_t insn = Load32Aligned(pc);
pc += BC_PUSH_BT_LENGTH; switch (insn & BYTECODE_MASK) {
break; BYTECODE(BREAK)
BYTECODE(PUSH_REGISTER) UNREACHABLE();
if (--backtrack_stack_space < 0) { return Bool::False().ptr();
return IrregexpInterpreter::RE_EXCEPTION; BYTECODE(PUSH_CP)
} if (--backtrack_stack_space < 0) {
*backtrack_sp++ = registers[insn >> BYTECODE_SHIFT]; return Object::null();
pc += BC_PUSH_REGISTER_LENGTH; }
break; *backtrack_sp++ = current;
BYTECODE(SET_REGISTER) pc += BC_PUSH_CP_LENGTH;
registers[insn >> BYTECODE_SHIFT] = Load32Aligned(pc + 4); break;
pc += BC_SET_REGISTER_LENGTH; BYTECODE(PUSH_BT)
break; if (--backtrack_stack_space < 0) {
BYTECODE(ADVANCE_REGISTER) return Object::null();
registers[insn >> BYTECODE_SHIFT] += Load32Aligned(pc + 4); }
pc += BC_ADVANCE_REGISTER_LENGTH; *backtrack_sp++ = Load32Aligned(pc + 4);
break; pc += BC_PUSH_BT_LENGTH;
BYTECODE(SET_REGISTER_TO_CP) break;
registers[insn >> BYTECODE_SHIFT] = current + Load32Aligned(pc + 4); BYTECODE(PUSH_REGISTER)
pc += BC_SET_REGISTER_TO_CP_LENGTH; if (--backtrack_stack_space < 0) {
break; return Object::null();
BYTECODE(SET_CP_TO_REGISTER) }
current = registers[insn >> BYTECODE_SHIFT]; *backtrack_sp++ = registers[insn >> BYTECODE_SHIFT];
pc += BC_SET_CP_TO_REGISTER_LENGTH; pc += BC_PUSH_REGISTER_LENGTH;
break; break;
BYTECODE(SET_REGISTER_TO_SP) BYTECODE(SET_REGISTER)
registers[insn >> BYTECODE_SHIFT] = registers[insn >> BYTECODE_SHIFT] = Load32Aligned(pc + 4);
static_cast<int>(backtrack_sp - backtrack_stack_base); pc += BC_SET_REGISTER_LENGTH;
pc += BC_SET_REGISTER_TO_SP_LENGTH; break;
break; BYTECODE(ADVANCE_REGISTER)
BYTECODE(SET_SP_TO_REGISTER) registers[insn >> BYTECODE_SHIFT] += Load32Aligned(pc + 4);
backtrack_sp = backtrack_stack_base + registers[insn >> BYTECODE_SHIFT]; pc += BC_ADVANCE_REGISTER_LENGTH;
backtrack_stack_space = break;
backtrack_stack.max_size() - BYTECODE(SET_REGISTER_TO_CP)
static_cast<int>(backtrack_sp - backtrack_stack_base); registers[insn >> BYTECODE_SHIFT] = current + Load32Aligned(pc + 4);
pc += BC_SET_SP_TO_REGISTER_LENGTH; pc += BC_SET_REGISTER_TO_CP_LENGTH;
break; break;
BYTECODE(POP_CP) BYTECODE(SET_CP_TO_REGISTER)
backtrack_stack_space++; current = registers[insn >> BYTECODE_SHIFT];
--backtrack_sp; pc += BC_SET_CP_TO_REGISTER_LENGTH;
current = *backtrack_sp; break;
pc += BC_POP_CP_LENGTH; BYTECODE(SET_REGISTER_TO_SP)
break; registers[insn >> BYTECODE_SHIFT] =
BYTECODE(POP_BT) static_cast<int>(backtrack_sp - backtrack_stack_base);
backtrack_stack_space++; pc += BC_SET_REGISTER_TO_SP_LENGTH;
--backtrack_sp; break;
pc = code_base + *backtrack_sp; BYTECODE(SET_SP_TO_REGISTER)
break; backtrack_sp = backtrack_stack_base + registers[insn >> BYTECODE_SHIFT];
BYTECODE(POP_REGISTER) backtrack_stack_space =
backtrack_stack_space++; backtrack_stack.max_size() -
--backtrack_sp; static_cast<int>(backtrack_sp - backtrack_stack_base);
registers[insn >> BYTECODE_SHIFT] = *backtrack_sp; pc += BC_SET_SP_TO_REGISTER_LENGTH;
pc += BC_POP_REGISTER_LENGTH; break;
break; BYTECODE(POP_CP)
BYTECODE(FAIL)
return IrregexpInterpreter::RE_FAILURE;
BYTECODE(SUCCEED)
return IrregexpInterpreter::RE_SUCCESS;
BYTECODE(ADVANCE_CP)
current += insn >> BYTECODE_SHIFT;
pc += BC_ADVANCE_CP_LENGTH;
break;
BYTECODE(GOTO)
pc = code_base + Load32Aligned(pc + 4);
break;
BYTECODE(ADVANCE_CP_AND_GOTO)
current += insn >> BYTECODE_SHIFT;
pc = code_base + Load32Aligned(pc + 4);
break;
BYTECODE(CHECK_GREEDY)
if (current == backtrack_sp[-1]) {
backtrack_sp--;
backtrack_stack_space++; backtrack_stack_space++;
--backtrack_sp;
current = *backtrack_sp;
pc += BC_POP_CP_LENGTH;
break;
BYTECODE(POP_BT)
backtrack_stack_space++;
--backtrack_sp;
pc = code_base + *backtrack_sp;
// This should match check cadence in JIT irregexp implementation.
check_for_safepoint_now = true;
break;
BYTECODE(POP_REGISTER)
backtrack_stack_space++;
--backtrack_sp;
registers[insn >> BYTECODE_SHIFT] = *backtrack_sp;
pc += BC_POP_REGISTER_LENGTH;
break;
BYTECODE(FAIL)
return Bool::False().ptr();
BYTECODE(SUCCEED)
return Bool::True().ptr();
BYTECODE(ADVANCE_CP)
current += insn >> BYTECODE_SHIFT;
pc += BC_ADVANCE_CP_LENGTH;
break;
BYTECODE(GOTO)
pc = code_base + Load32Aligned(pc + 4); pc = code_base + Load32Aligned(pc + 4);
} else { break;
pc += BC_CHECK_GREEDY_LENGTH; BYTECODE(ADVANCE_CP_AND_GOTO)
} current += insn >> BYTECODE_SHIFT;
break; pc = code_base + Load32Aligned(pc + 4);
BYTECODE(LOAD_CURRENT_CHAR) { break;
int pos = current + (insn >> BYTECODE_SHIFT); BYTECODE(CHECK_GREEDY)
if (pos < 0 || pos >= subject_length) { if (current == backtrack_sp[-1]) {
backtrack_sp--;
backtrack_stack_space++;
pc = code_base + Load32Aligned(pc + 4); pc = code_base + Load32Aligned(pc + 4);
} else { } else {
current_char = subject.CharAt(pos); pc += BC_CHECK_GREEDY_LENGTH;
pc += BC_LOAD_CURRENT_CHAR_LENGTH;
} }
break; break;
} BYTECODE(LOAD_CURRENT_CHAR) {
BYTECODE(LOAD_CURRENT_CHAR_UNCHECKED) { int pos = current + (insn >> BYTECODE_SHIFT);
int pos = current + (insn >> BYTECODE_SHIFT); if (pos < 0 || pos >= subject_length) {
current_char = subject.CharAt(pos); pc = code_base + Load32Aligned(pc + 4);
pc += BC_LOAD_CURRENT_CHAR_UNCHECKED_LENGTH; } else {
break; current_char = subject.CharAt(pos);
} pc += BC_LOAD_CURRENT_CHAR_LENGTH;
BYTECODE(LOAD_2_CURRENT_CHARS) { }
int pos = current + (insn >> BYTECODE_SHIFT); break;
if (pos + 2 > subject_length) { }
pc = code_base + Load32Aligned(pc + 4); BYTECODE(LOAD_CURRENT_CHAR_UNCHECKED) {
} else { int pos = current + (insn >> BYTECODE_SHIFT);
current_char = subject.CharAt(pos);
pc += BC_LOAD_CURRENT_CHAR_UNCHECKED_LENGTH;
break;
}
BYTECODE(LOAD_2_CURRENT_CHARS) {
int pos = current + (insn >> BYTECODE_SHIFT);
if (pos + 2 > subject_length) {
pc = code_base + Load32Aligned(pc + 4);
} else {
Char next = subject.CharAt(pos + 1);
current_char =
subject.CharAt(pos) | (next << (kBitsPerByte * sizeof(Char)));
pc += BC_LOAD_2_CURRENT_CHARS_LENGTH;
}
break;
}
BYTECODE(LOAD_2_CURRENT_CHARS_UNCHECKED) {
int pos = current + (insn >> BYTECODE_SHIFT);
Char next = subject.CharAt(pos + 1); Char next = subject.CharAt(pos + 1);
current_char = current_char =
subject.CharAt(pos) | (next << (kBitsPerByte * sizeof(Char))); subject.CharAt(pos) | (next << (kBitsPerByte * sizeof(Char)));
pc += BC_LOAD_2_CURRENT_CHARS_LENGTH; pc += BC_LOAD_2_CURRENT_CHARS_UNCHECKED_LENGTH;
break;
} }
break; BYTECODE(LOAD_4_CURRENT_CHARS) {
} ASSERT(sizeof(Char) == 1);
BYTECODE(LOAD_2_CURRENT_CHARS_UNCHECKED) { int pos = current + (insn >> BYTECODE_SHIFT);
int pos = current + (insn >> BYTECODE_SHIFT); if (pos + 4 > subject_length) {
Char next = subject.CharAt(pos + 1); pc = code_base + Load32Aligned(pc + 4);
current_char = } else {
subject.CharAt(pos) | (next << (kBitsPerByte * sizeof(Char))); Char next1 = subject.CharAt(pos + 1);
pc += BC_LOAD_2_CURRENT_CHARS_UNCHECKED_LENGTH; Char next2 = subject.CharAt(pos + 2);
break; Char next3 = subject.CharAt(pos + 3);
} current_char = (subject.CharAt(pos) | (next1 << 8) | (next2 << 16) |
BYTECODE(LOAD_4_CURRENT_CHARS) { (next3 << 24));
ASSERT(sizeof(Char) == 1); pc += BC_LOAD_4_CURRENT_CHARS_LENGTH;
int pos = current + (insn >> BYTECODE_SHIFT); }
if (pos + 4 > subject_length) { break;
pc = code_base + Load32Aligned(pc + 4); }
} else { BYTECODE(LOAD_4_CURRENT_CHARS_UNCHECKED) {
ASSERT(sizeof(Char) == 1);
int pos = current + (insn >> BYTECODE_SHIFT);
Char next1 = subject.CharAt(pos + 1); Char next1 = subject.CharAt(pos + 1);
Char next2 = subject.CharAt(pos + 2); Char next2 = subject.CharAt(pos + 2);
Char next3 = subject.CharAt(pos + 3); Char next3 = subject.CharAt(pos + 3);
current_char = (subject.CharAt(pos) | (next1 << 8) | (next2 << 16) | current_char = (subject.CharAt(pos) | (next1 << 8) | (next2 << 16) |
(next3 << 24)); (next3 << 24));
pc += BC_LOAD_4_CURRENT_CHARS_LENGTH; pc += BC_LOAD_4_CURRENT_CHARS_UNCHECKED_LENGTH;
break;
} }
break; BYTECODE(CHECK_4_CHARS) {
} uint32_t c = Load32Aligned(pc + 4);
BYTECODE(LOAD_4_CURRENT_CHARS_UNCHECKED) { if (c == current_char) {
ASSERT(sizeof(Char) == 1); pc = code_base + Load32Aligned(pc + 8);
int pos = current + (insn >> BYTECODE_SHIFT); } else {
Char next1 = subject.CharAt(pos + 1); pc += BC_CHECK_4_CHARS_LENGTH;
Char next2 = subject.CharAt(pos + 2); }
Char next3 = subject.CharAt(pos + 3); break;
current_char = (subject.CharAt(pos) | (next1 << 8) | (next2 << 16) | }
(next3 << 24)); BYTECODE(CHECK_CHAR) {
pc += BC_LOAD_4_CURRENT_CHARS_UNCHECKED_LENGTH; uint32_t c = (insn >> BYTECODE_SHIFT);
break; if (c == current_char) {
} pc = code_base + Load32Aligned(pc + 4);
BYTECODE(CHECK_4_CHARS) { } else {
uint32_t c = Load32Aligned(pc + 4); pc += BC_CHECK_CHAR_LENGTH;
if (c == current_char) { }
break;
}
BYTECODE(CHECK_NOT_4_CHARS) {
uint32_t c = Load32Aligned(pc + 4);
if (c != current_char) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_NOT_4_CHARS_LENGTH;
}
break;
}
BYTECODE(CHECK_NOT_CHAR) {
uint32_t c = (insn >> BYTECODE_SHIFT);
if (c != current_char) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_NOT_CHAR_LENGTH;
}
break;
}
BYTECODE(AND_CHECK_4_CHARS) {
uint32_t c = Load32Aligned(pc + 4);
if (c == (current_char & Load32Aligned(pc + 8))) {
pc = code_base + Load32Aligned(pc + 12);
} else {
pc += BC_AND_CHECK_4_CHARS_LENGTH;
}
break;
}
BYTECODE(AND_CHECK_CHAR) {
uint32_t c = (insn >> BYTECODE_SHIFT);
if (c == (current_char & Load32Aligned(pc + 4))) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_AND_CHECK_CHAR_LENGTH;
}
break;
}
BYTECODE(AND_CHECK_NOT_4_CHARS) {
uint32_t c = Load32Aligned(pc + 4);
if (c != (current_char & Load32Aligned(pc + 8))) {
pc = code_base + Load32Aligned(pc + 12);
} else {
pc += BC_AND_CHECK_NOT_4_CHARS_LENGTH;
}
break;
}
BYTECODE(AND_CHECK_NOT_CHAR) {
uint32_t c = (insn >> BYTECODE_SHIFT);
if (c != (current_char & Load32Aligned(pc + 4))) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_AND_CHECK_NOT_CHAR_LENGTH;
}
break;
}
BYTECODE(MINUS_AND_CHECK_NOT_CHAR) {
uint32_t c = (insn >> BYTECODE_SHIFT);
uint32_t minus = Load16Aligned(pc + 4);
uint32_t mask = Load16Aligned(pc + 6);
if (c != ((current_char - minus) & mask)) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_MINUS_AND_CHECK_NOT_CHAR_LENGTH;
}
break;
}
BYTECODE(CHECK_CHAR_IN_RANGE) {
uint32_t from = Load16Aligned(pc + 4);
uint32_t to = Load16Aligned(pc + 6);
if (from <= current_char && current_char <= to) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_CHAR_IN_RANGE_LENGTH;
}
break;
}
BYTECODE(CHECK_CHAR_NOT_IN_RANGE) {
uint32_t from = Load16Aligned(pc + 4);
uint32_t to = Load16Aligned(pc + 6);
if (from > current_char || current_char > to) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_CHAR_NOT_IN_RANGE_LENGTH;
}
break;
}
BYTECODE(CHECK_BIT_IN_TABLE) {
int mask = RegExpMacroAssembler::kTableMask;
uint8_t b = pc[8 + ((current_char & mask) >> kBitsPerByteLog2)];
int bit = (current_char & (kBitsPerByte - 1));
if ((b & (1 << bit)) != 0) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_BIT_IN_TABLE_LENGTH;
}
break;
}
BYTECODE(CHECK_LT) {
uint32_t limit = (insn >> BYTECODE_SHIFT);
if (current_char < limit) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_LT_LENGTH;
}
break;
}
BYTECODE(CHECK_GT) {
uint32_t limit = (insn >> BYTECODE_SHIFT);
if (current_char > limit) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_GT_LENGTH;
}
break;
}
BYTECODE(CHECK_REGISTER_LT)
if (registers[insn >> BYTECODE_SHIFT] < Load32Aligned(pc + 4)) {
pc = code_base + Load32Aligned(pc + 8); pc = code_base + Load32Aligned(pc + 8);
} else { } else {
pc += BC_CHECK_4_CHARS_LENGTH; pc += BC_CHECK_REGISTER_LT_LENGTH;
} }
break; break;
} BYTECODE(CHECK_REGISTER_GE)
BYTECODE(CHECK_CHAR) { if (registers[insn >> BYTECODE_SHIFT] >= Load32Aligned(pc + 4)) {
uint32_t c = (insn >> BYTECODE_SHIFT); pc = code_base + Load32Aligned(pc + 8);
if (c == current_char) { } else {
pc += BC_CHECK_REGISTER_GE_LENGTH;
}
break;
BYTECODE(CHECK_REGISTER_EQ_POS)
if (registers[insn >> BYTECODE_SHIFT] == current) {
pc = code_base + Load32Aligned(pc + 4); pc = code_base + Load32Aligned(pc + 4);
} else { } else {
pc += BC_CHECK_CHAR_LENGTH; pc += BC_CHECK_REGISTER_EQ_POS_LENGTH;
} }
break; break;
} BYTECODE(CHECK_NOT_REGS_EQUAL)
BYTECODE(CHECK_NOT_4_CHARS) { if (registers[insn >> BYTECODE_SHIFT] ==
uint32_t c = Load32Aligned(pc + 4); registers[Load32Aligned(pc + 4)]) {
if (c != current_char) { pc += BC_CHECK_NOT_REGS_EQUAL_LENGTH;
} else {
pc = code_base + Load32Aligned(pc + 8); pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_NOT_4_CHARS_LENGTH;
} }
break; break;
} BYTECODE(CHECK_NOT_BACK_REF) {
BYTECODE(CHECK_NOT_CHAR) { int from = registers[insn >> BYTECODE_SHIFT];
uint32_t c = (insn >> BYTECODE_SHIFT); int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
if (c != current_char) { if (from < 0 || len <= 0) {
pc = code_base + Load32Aligned(pc + 4); pc += BC_CHECK_NOT_BACK_REF_LENGTH;
} else { break;
pc += BC_CHECK_NOT_CHAR_LENGTH; }
} if (current + len > subject_length) {
break; pc = code_base + Load32Aligned(pc + 4);
} break;
BYTECODE(AND_CHECK_4_CHARS) { } else {
uint32_t c = Load32Aligned(pc + 4); int i;
if (c == (current_char & Load32Aligned(pc + 8))) { for (i = 0; i < len; i++) {
pc = code_base + Load32Aligned(pc + 12); if (subject.CharAt(from + i) != subject.CharAt(current + i)) {
} else { pc = code_base + Load32Aligned(pc + 4);
pc += BC_AND_CHECK_4_CHARS_LENGTH; break;
} }
break; }
} if (i < len) break;
BYTECODE(AND_CHECK_CHAR) { current += len;
uint32_t c = (insn >> BYTECODE_SHIFT); }
if (c == (current_char & Load32Aligned(pc + 4))) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_AND_CHECK_CHAR_LENGTH;
}
break;
}
BYTECODE(AND_CHECK_NOT_4_CHARS) {
uint32_t c = Load32Aligned(pc + 4);
if (c != (current_char & Load32Aligned(pc + 8))) {
pc = code_base + Load32Aligned(pc + 12);
} else {
pc += BC_AND_CHECK_NOT_4_CHARS_LENGTH;
}
break;
}
BYTECODE(AND_CHECK_NOT_CHAR) {
uint32_t c = (insn >> BYTECODE_SHIFT);
if (c != (current_char & Load32Aligned(pc + 4))) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_AND_CHECK_NOT_CHAR_LENGTH;
}
break;
}
BYTECODE(MINUS_AND_CHECK_NOT_CHAR) {
uint32_t c = (insn >> BYTECODE_SHIFT);
uint32_t minus = Load16Aligned(pc + 4);
uint32_t mask = Load16Aligned(pc + 6);
if (c != ((current_char - minus) & mask)) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_MINUS_AND_CHECK_NOT_CHAR_LENGTH;
}
break;
}
BYTECODE(CHECK_CHAR_IN_RANGE) {
uint32_t from = Load16Aligned(pc + 4);
uint32_t to = Load16Aligned(pc + 6);
if (from <= current_char && current_char <= to) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_CHAR_IN_RANGE_LENGTH;
}
break;
}
BYTECODE(CHECK_CHAR_NOT_IN_RANGE) {
uint32_t from = Load16Aligned(pc + 4);
uint32_t to = Load16Aligned(pc + 6);
if (from > current_char || current_char > to) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_CHAR_NOT_IN_RANGE_LENGTH;
}
break;
}
BYTECODE(CHECK_BIT_IN_TABLE) {
int mask = RegExpMacroAssembler::kTableMask;
uint8_t b = pc[8 + ((current_char & mask) >> kBitsPerByteLog2)];
int bit = (current_char & (kBitsPerByte - 1));
if ((b & (1 << bit)) != 0) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_BIT_IN_TABLE_LENGTH;
}
break;
}
BYTECODE(CHECK_LT) {
uint32_t limit = (insn >> BYTECODE_SHIFT);
if (current_char < limit) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_LT_LENGTH;
}
break;
}
BYTECODE(CHECK_GT) {
uint32_t limit = (insn >> BYTECODE_SHIFT);
if (current_char > limit) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_GT_LENGTH;
}
break;
}
BYTECODE(CHECK_REGISTER_LT)
if (registers[insn >> BYTECODE_SHIFT] < Load32Aligned(pc + 4)) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_REGISTER_LT_LENGTH;
}
break;
BYTECODE(CHECK_REGISTER_GE)
if (registers[insn >> BYTECODE_SHIFT] >= Load32Aligned(pc + 4)) {
pc = code_base + Load32Aligned(pc + 8);
} else {
pc += BC_CHECK_REGISTER_GE_LENGTH;
}
break;
BYTECODE(CHECK_REGISTER_EQ_POS)
if (registers[insn >> BYTECODE_SHIFT] == current) {
pc = code_base + Load32Aligned(pc + 4);
} else {
pc += BC_CHECK_REGISTER_EQ_POS_LENGTH;
}
break;
BYTECODE(CHECK_NOT_REGS_EQUAL)
if (registers[insn >> BYTECODE_SHIFT] ==
registers[Load32Aligned(pc + 4)]) {
pc += BC_CHECK_NOT_REGS_EQUAL_LENGTH;
} else {
pc = code_base + Load32Aligned(pc + 8);
}
break;
BYTECODE(CHECK_NOT_BACK_REF) {
int from = registers[insn >> BYTECODE_SHIFT];
int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
if (from < 0 || len <= 0) {
pc += BC_CHECK_NOT_BACK_REF_LENGTH; pc += BC_CHECK_NOT_BACK_REF_LENGTH;
break; break;
} }
if (current + len > subject_length) { BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE)
pc = code_base + Load32Aligned(pc + 4); FALL_THROUGH;
break; BYTECODE(CHECK_NOT_BACK_REF_NO_CASE) {
} else { const bool unicode =
int i; (insn & BYTECODE_MASK) == BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE;
for (i = 0; i < len; i++) { int from = registers[insn >> BYTECODE_SHIFT];
if (subject.CharAt(from + i) != subject.CharAt(current + i)) { int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
if (from < 0 || len <= 0) {
pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
break;
}
if (current + len > subject_length) {
pc = code_base + Load32Aligned(pc + 4);
break;
} else {
if (BackRefMatchesNoCase<Char>(&canonicalize, from, current, len,
subject, unicode)) {
current += len;
pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
} else {
pc = code_base + Load32Aligned(pc + 4); pc = code_base + Load32Aligned(pc + 4);
break;
} }
} }
if (i < len) break;
current += len;
}
pc += BC_CHECK_NOT_BACK_REF_LENGTH;
break;
}
BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE)
FALL_THROUGH;
BYTECODE(CHECK_NOT_BACK_REF_NO_CASE) {
const bool unicode =
(insn & BYTECODE_MASK) == BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE;
int from = registers[insn >> BYTECODE_SHIFT];
int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
if (from < 0 || len <= 0) {
pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH;
break; break;
} }
if (current + len > subject_length) { BYTECODE(CHECK_NOT_BACK_REF_BACKWARD) {
pc = code_base + Load32Aligned(pc + 4); const int from = registers[insn >> BYTECODE_SHIFT];
break; const int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
} else { if (from < 0 || len <= 0) {
if (BackRefMatchesNoCase<Char>(&canonicalize, from, current, len, pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH;
subject, unicode)) { break;
current += len; }
pc += BC_CHECK_NOT_BACK_REF_NO_CASE_LENGTH; if ((current - len) < 0) {
} else { pc = code_base + Load32Aligned(pc + 4);
pc = code_base + Load32Aligned(pc + 4); break;
} else {
// When looking behind, the string to match (if it is there) lies
// before the current position, so we will check the [len]
// characters before the current position, excluding the current
// position itself.
const int start = current - len;
int i;
for (i = 0; i < len; i++) {
if (subject.CharAt(from + i) != subject.CharAt(start + i)) {
pc = code_base + Load32Aligned(pc + 4);
break;
}
}
if (i < len) break;
current -= len;
} }
}
break;
}
BYTECODE(CHECK_NOT_BACK_REF_BACKWARD) {
const int from = registers[insn >> BYTECODE_SHIFT];
const int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
if (from < 0 || len <= 0) {
pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH; pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH;
break; break;
} }
if ((current - len) < 0) { BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD)
pc = code_base + Load32Aligned(pc + 4); FALL_THROUGH;
break; BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_BACKWARD) {
} else { bool unicode = (insn & BYTECODE_MASK) ==
// When looking behind, the string to match (if it is there) lies BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD;
// before the current position, so we will check the [len] characters int from = registers[insn >> BYTECODE_SHIFT];
// before the current position, excluding the current position itself. int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
const int start = current - len; if (from < 0 || len <= 0) {
int i; pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH;
for (i = 0; i < len; i++) { break;
if (subject.CharAt(from + i) != subject.CharAt(start + i)) { }
if (current < len) {
pc = code_base + Load32Aligned(pc + 4);
break;
} else {
if (BackRefMatchesNoCase<Char>(&canonicalize, from, current - len,
len, subject, unicode)) {
current -= len;
pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH;
} else {
pc = code_base + Load32Aligned(pc + 4); pc = code_base + Load32Aligned(pc + 4);
break;
} }
} }
if (i < len) break;
current -= len;
}
pc += BC_CHECK_NOT_BACK_REF_BACKWARD_LENGTH;
break;
}
BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD)
FALL_THROUGH;
BYTECODE(CHECK_NOT_BACK_REF_NO_CASE_BACKWARD) {
bool unicode = (insn & BYTECODE_MASK) ==
BC_CHECK_NOT_BACK_REF_NO_CASE_UNICODE_BACKWARD;
int from = registers[insn >> BYTECODE_SHIFT];
int len = registers[(insn >> BYTECODE_SHIFT) + 1] - from;
if (from < 0 || len <= 0) {
pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH;
break; break;
} }
if (current < len) { BYTECODE(CHECK_AT_START)
if (current == 0) {
pc = code_base + Load32Aligned(pc + 4); pc = code_base + Load32Aligned(pc + 4);
break;
} else { } else {
if (BackRefMatchesNoCase<Char>(&canonicalize, from, current - len, pc += BC_CHECK_AT_START_LENGTH;
len, subject, unicode)) { }
current -= len; break;
pc += BC_CHECK_NOT_BACK_REF_NO_CASE_BACKWARD_LENGTH; BYTECODE(CHECK_NOT_AT_START) {
const int32_t cp_offset = insn >> BYTECODE_SHIFT;
if (current + cp_offset == 0) {
pc += BC_CHECK_NOT_AT_START_LENGTH;
} else { } else {
pc = code_base + Load32Aligned(pc + 4); pc = code_base + Load32Aligned(pc + 4);
} }
break;
} }
break; BYTECODE(SET_CURRENT_POSITION_FROM_END) {
} int by = static_cast<uint32_t>(insn) >> BYTECODE_SHIFT;
BYTECODE(CHECK_AT_START) if (subject_length - current > by) {
if (current == 0) { current = subject_length - by;
pc = code_base + Load32Aligned(pc + 4); current_char = subject.CharAt(current - 1);
} else { }
pc += BC_CHECK_AT_START_LENGTH; pc += BC_SET_CURRENT_POSITION_FROM_END_LENGTH;
} break;
break;
BYTECODE(CHECK_NOT_AT_START) {
const int32_t cp_offset = insn >> BYTECODE_SHIFT;
if (current + cp_offset == 0) {
pc += BC_CHECK_NOT_AT_START_LENGTH;
} else {
pc = code_base + Load32Aligned(pc + 4);
} }
break; default:
UNREACHABLE();
break;
} }
BYTECODE(SET_CURRENT_POSITION_FROM_END) {
int by = static_cast<uint32_t>(insn) >> BYTECODE_SHIFT;
if (subject_length - current > by) {
current = subject_length - by;
current_char = subject.CharAt(current - 1);
}
pc += BC_SET_CURRENT_POSITION_FROM_END_LENGTH;
break;
}
default:
UNREACHABLE();
break;
} }
} }
} }
IrregexpInterpreter::IrregexpResult IrregexpInterpreter::Match( // Returns True if success, False if failure, Null if internal exception,
const TypedData& bytecode, // Error if VM error needs to be propagated up the callchain.
const String& subject, ObjectPtr IrregexpInterpreter::Match(const TypedData& bytecode,
int32_t* registers, const String& subject,
intptr_t start_position, int32_t* registers,
Zone* zone) { intptr_t start_position,
NoSafepointScope no_safepoint; Zone* zone) {
const uint8_t* code_base = reinterpret_cast<uint8_t*>(bytecode.DataAddr(0));
uint16_t previous_char = '\n'; uint16_t previous_char = '\n';
if (start_position != 0) { if (start_position != 0) {
previous_char = subject.CharAt(start_position - 1); previous_char = subject.CharAt(start_position - 1);
} }
if (subject.IsOneByteString() || subject.IsExternalOneByteString()) { if (subject.IsOneByteString() || subject.IsExternalOneByteString()) {
return RawMatch<uint8_t>(code_base, subject, registers, start_position, return RawMatch<uint8_t>(bytecode, subject, registers, start_position,
previous_char, zone); previous_char, zone);
} else if (subject.IsTwoByteString() || subject.IsExternalTwoByteString()) { } else if (subject.IsTwoByteString() || subject.IsExternalTwoByteString()) {
return RawMatch<uint16_t>(code_base, subject, registers, start_position, return RawMatch<uint16_t>(bytecode, subject, registers, start_position,
previous_char, zone); previous_char, zone);
} else { } else {
UNREACHABLE(); UNREACHABLE();
return IrregexpInterpreter::RE_FAILURE; return Bool::False().ptr();
} }
} }

15
runtime/vm/regexp_interpreter.h
View file

@ -15,13 +15,14 @@ namespace dart {
class IrregexpInterpreter : public AllStatic { class IrregexpInterpreter : public AllStatic {
public: public:
enum IrregexpResult { RE_FAILURE = 0, RE_SUCCESS = 1, RE_EXCEPTION = -1 }; // Returns True in case of a success, False in case of a failure,
// Null in case of internal exception,
static IrregexpResult Match(const TypedData& bytecode, // Error in case VM error has to propagated up to the caller.
const String& subject, static ObjectPtr Match(const TypedData& bytecode,
int32_t* captures, const String& subject,
intptr_t start_position, int32_t* captures,
Zone* zone); intptr_t start_position,
Zone* zone);
}; };
} // namespace dart } // namespace dart