Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(453)

Unified Diff: runtime/vm/regexp_assembler.h

Issue 683433003: Integrate the Irregexp Regular Expression Engine. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: more comments Created 6 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/vm/regexp.cc ('k') | runtime/vm/regexp_assembler.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/vm/regexp_assembler.h
diff --git a/runtime/vm/regexp_assembler.h b/runtime/vm/regexp_assembler.h
index ace607b9c84400ad1691776770d1a274bd52931b..4407064cd86dac93962d9c2d2ecf298b50ef0ae7 100644
--- a/runtime/vm/regexp_assembler.h
+++ b/runtime/vm/regexp_assembler.h
@@ -5,139 +5,196 @@
#ifndef VM_REGEXP_ASSEMBLER_H_
#define VM_REGEXP_ASSEMBLER_H_
-// SNIP
+#include "vm/assembler.h"
+#include "vm/intermediate_language.h"
+#include "vm/object.h"
namespace dart {
-// SNIP
+// Utility function for the DotPrinter
+void PrintUtf16(uint16_t c);
-class RegExpMacroAssembler {
+
+/// Convenience wrapper around a BlockEntryInstr pointer.
+class BlockLabel : public ValueObject {
+ public:
+ BlockLabel()
+ : block_(new JoinEntryInstr(-1, -1)),
+ is_bound_(false),
+ is_linked_(false) { }
+
+ BlockLabel(const BlockLabel& that)
+ : ValueObject(),
+ block_(that.block_),
+ is_bound_(that.is_bound_),
+ is_linked_(that.is_linked_) { }
+
+ BlockLabel& operator=(const BlockLabel& that) {
+ block_ = that.block_;
+ is_bound_ = that.is_bound_;
+ is_linked_ = that.is_linked_;
+ return *this;
+ }
+
+ JoinEntryInstr* block() const { return block_; }
+
+ bool IsBound() const { return is_bound_; }
+ void SetBound(intptr_t block_id) {
+ ASSERT(!is_bound_);
+ block_->set_block_id(block_id);
+ is_bound_ = true;
+ }
+
+ bool IsLinked() const { return !is_bound_ && is_linked_; }
+ void SetLinked() {
+ is_linked_ = true;
+ }
+
+ intptr_t Position() const {
+ ASSERT(IsBound());
+ return block_->block_id();
+ }
+
+ private:
+ JoinEntryInstr* block_;
+
+ bool is_bound_;
+ bool is_linked_;
+};
+
+
+class RegExpMacroAssembler : public ZoneAllocated {
public:
// The implementation must be able to handle at least:
- static const int kMaxRegister = (1 << 16) - 1;
- static const int kMaxCPOffset = (1 << 15) - 1;
- static const int kMinCPOffset = -(1 << 15);
+ static const intptr_t kMaxRegister = (1 << 16) - 1;
+ static const intptr_t kMaxCPOffset = (1 << 15) - 1;
+ static const intptr_t kMinCPOffset = -(1 << 15);
- static const int kTableSizeBits = 7;
- static const int kTableSize = 1 << kTableSizeBits;
- static const int kTableMask = kTableSize - 1;
+ static const intptr_t kTableSizeBits = 7;
+ static const intptr_t kTableSize = 1 << kTableSizeBits;
+ static const intptr_t kTableMask = kTableSize - 1;
- enum IrregexpImplementation {
- kIA32Implementation,
- kARMImplementation,
- kARM64Implementation,
- kMIPSImplementation,
- kX64Implementation,
- kX87Implementation,
- kBytecodeImplementation
+ enum {
+ kParamStringIndex = 0,
+ kParamStartOffsetIndex,
+ kParamCount
};
- enum StackCheckFlag {
- kNoStackLimitCheck = false,
- kCheckStackLimit = true
+ enum IrregexpImplementation {
+ kIRImplementation
};
- explicit RegExpMacroAssembler(Zone* zone);
+ explicit RegExpMacroAssembler(Isolate* isolate);
virtual ~RegExpMacroAssembler();
// The maximal number of pushes between stack checks. Users must supply
// kCheckStackLimit flag to push operations (instead of kNoStackLimitCheck)
// at least once for every stack_limit() pushes that are executed.
- virtual int stack_limit_slack() = 0;
+ virtual intptr_t stack_limit_slack() = 0;
virtual bool CanReadUnaligned() = 0;
- virtual void AdvanceCurrentPosition(int by) = 0; // Signed cp change.
- virtual void AdvanceRegister(int reg, int by) = 0; // r[reg] += by.
+ virtual void AdvanceCurrentPosition(intptr_t by) = 0; // Signed cp change.
+ virtual void AdvanceRegister(intptr_t reg, intptr_t by) = 0; // r[reg] += by.
// Continues execution from the position pushed on the top of the backtrack
- // stack by an earlier PushBacktrack(Label*).
+ // stack by an earlier PushBacktrack(BlockLabel*).
virtual void Backtrack() = 0;
- virtual void Bind(Label* label) = 0;
- virtual void CheckAtStart(Label* on_at_start) = 0;
+ virtual void BindBlock(BlockLabel* label) = 0;
+ virtual void CheckAtStart(BlockLabel* on_at_start) = 0;
// Dispatch after looking the current character up in a 2-bits-per-entry
// map. The destinations vector has up to 4 labels.
- virtual void CheckCharacter(unsigned c, Label* on_equal) = 0;
+ virtual void CheckCharacter(unsigned c, BlockLabel* on_equal) = 0;
// Bitwise and the current character with the given constant and then
// check for a match with c.
virtual void CheckCharacterAfterAnd(unsigned c,
unsigned and_with,
- Label* on_equal) = 0;
- virtual void CheckCharacterGT(uc16 limit, Label* on_greater) = 0;
- virtual void CheckCharacterLT(uc16 limit, Label* on_less) = 0;
- virtual void CheckGreedyLoop(Label* on_tos_equals_current_position) = 0;
- virtual void CheckNotAtStart(Label* on_not_at_start) = 0;
- virtual void CheckNotBackReference(int start_reg, Label* on_no_match) = 0;
- virtual void CheckNotBackReferenceIgnoreCase(int start_reg,
- Label* on_no_match) = 0;
+ BlockLabel* on_equal) = 0;
+ virtual void CheckCharacterGT(uint16_t limit, BlockLabel* on_greater) = 0;
+ virtual void CheckCharacterLT(uint16_t limit, BlockLabel* on_less) = 0;
+ virtual void CheckGreedyLoop(BlockLabel* on_tos_equals_current_position) = 0;
+ virtual void CheckNotAtStart(BlockLabel* on_not_at_start) = 0;
+ virtual void CheckNotBackReference(
+ intptr_t start_reg, BlockLabel* on_no_match) = 0;
+ virtual void CheckNotBackReferenceIgnoreCase(intptr_t start_reg,
+ BlockLabel* on_no_match) = 0;
// Check the current character for a match with a literal character. If we
// fail to match then goto the on_failure label. End of input always
// matches. If the label is NULL then we should pop a backtrack address off
// the stack and go to that.
- virtual void CheckNotCharacter(unsigned c, Label* on_not_equal) = 0;
+ virtual void CheckNotCharacter(unsigned c, BlockLabel* on_not_equal) = 0;
virtual void CheckNotCharacterAfterAnd(unsigned c,
unsigned and_with,
- Label* on_not_equal) = 0;
+ BlockLabel* on_not_equal) = 0;
// Subtract a constant from the current character, then and with the given
// constant and then check for a match with c.
- virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
- uc16 minus,
- uc16 and_with,
- Label* on_not_equal) = 0;
- virtual void CheckCharacterInRange(uc16 from,
- uc16 to, // Both inclusive.
- Label* on_in_range) = 0;
- virtual void CheckCharacterNotInRange(uc16 from,
- uc16 to, // Both inclusive.
- Label* on_not_in_range) = 0;
+ virtual void CheckNotCharacterAfterMinusAnd(uint16_t c,
+ uint16_t minus,
+ uint16_t and_with,
+ BlockLabel* on_not_equal) = 0;
+ virtual void CheckCharacterInRange(uint16_t from,
+ uint16_t to, // Both inclusive.
+ BlockLabel* on_in_range) = 0;
+ virtual void CheckCharacterNotInRange(uint16_t from,
+ uint16_t to, // Both inclusive.
+ BlockLabel* on_not_in_range) = 0;
// The current character (modulus the kTableSize) is looked up in the byte
// array, and if the found byte is non-zero, we jump to the on_bit_set label.
- virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set) = 0;
+ virtual void CheckBitInTable(const TypedData& table,
+ BlockLabel* on_bit_set) = 0;
// Checks whether the given offset from the current position is before
// the end of the string. May overwrite the current character.
- virtual void CheckPosition(int cp_offset, Label* on_outside_input) {
+ virtual void CheckPosition(intptr_t cp_offset, BlockLabel* on_outside_input) {
LoadCurrentCharacter(cp_offset, on_outside_input, true);
}
// Check whether a standard/default character class matches the current
// character. Returns false if the type of special character class does
// not have custom support.
// May clobber the current loaded character.
- virtual bool CheckSpecialCharacterClass(uc16 type,
- Label* on_no_match) {
+ virtual bool CheckSpecialCharacterClass(uint16_t type,
+ BlockLabel* on_no_match) {
return false;
}
virtual void Fail() = 0;
- virtual Handle<HeapObject> GetCode(Handle<String> source) = 0;
- virtual void GoTo(Label* label) = 0;
// Check whether a register is >= a given constant and go to a label if it
// is. Backtracks instead if the label is NULL.
- virtual void IfRegisterGE(int reg, int comparand, Label* if_ge) = 0;
+ virtual void IfRegisterGE(
+ intptr_t reg, intptr_t comparand, BlockLabel* if_ge) = 0;
// Check whether a register is < a given constant and go to a label if it is.
// Backtracks instead if the label is NULL.
- virtual void IfRegisterLT(int reg, int comparand, Label* if_lt) = 0;
+ virtual void IfRegisterLT(
+ intptr_t reg, intptr_t comparand, BlockLabel* if_lt) = 0;
// Check whether a register is == to the current position and go to a
// label if it is.
- virtual void IfRegisterEqPos(int reg, Label* if_eq) = 0;
+ virtual void IfRegisterEqPos(intptr_t reg, BlockLabel* if_eq) = 0;
virtual IrregexpImplementation Implementation() = 0;
- virtual void LoadCurrentCharacter(int cp_offset,
- Label* on_end_of_input,
+ // The assembler is closed, iff there is no current instruction assigned.
+ virtual bool IsClosed() const = 0;
+ // Jump to the target label without setting it as the current instruction.
+ virtual void GoTo(BlockLabel* to) = 0;
+ virtual void LoadCurrentCharacter(intptr_t cp_offset,
+ BlockLabel* on_end_of_input,
bool check_bounds = true,
- int characters = 1) = 0;
+ intptr_t characters = 1) = 0;
virtual void PopCurrentPosition() = 0;
- virtual void PopRegister(int register_index) = 0;
+ virtual void PopRegister(intptr_t register_index) = 0;
+ // Prints string within the generated code. Used for debugging.
+ virtual void Print(const char* str) = 0;
+ // Prints all emitted blocks.
+ virtual void PrintBlocks() = 0;
// Pushes the label on the backtrack stack, so that a following Backtrack
// will go to this label. Always checks the backtrack stack limit.
- virtual void PushBacktrack(Label* label) = 0;
+ virtual void PushBacktrack(BlockLabel* label) = 0;
virtual void PushCurrentPosition() = 0;
- virtual void PushRegister(int register_index,
- StackCheckFlag check_stack_limit) = 0;
- virtual void ReadCurrentPositionFromRegister(int reg) = 0;
- virtual void ReadStackPointerFromRegister(int reg) = 0;
- virtual void SetCurrentPositionFromEnd(int by) = 0;
- virtual void SetRegister(int register_index, int to) = 0;
+ virtual void PushRegister(intptr_t register_index) = 0;
+ virtual void ReadCurrentPositionFromRegister(intptr_t reg) = 0;
+ virtual void ReadStackPointerFromRegister(intptr_t reg) = 0;
+ virtual void SetCurrentPositionFromEnd(intptr_t by) = 0;
+ virtual void SetRegister(intptr_t register_index, intptr_t to) = 0;
// Return whether the matching (with a global regexp) will be restarted.
virtual bool Succeed() = 0;
- virtual void WriteCurrentPositionToRegister(int reg, int cp_offset) = 0;
- virtual void ClearRegisters(int reg_from, int reg_to) = 0;
- virtual void WriteStackPointerToRegister(int reg) = 0;
+ virtual void WriteCurrentPositionToRegister(
+ intptr_t reg, intptr_t cp_offset) = 0;
+ virtual void ClearRegisters(intptr_t reg_from, intptr_t reg_to) = 0;
+ virtual void WriteStackPointerToRegister(intptr_t reg) = 0;
// Controls the generation of large inlined constants in the code.
void set_slow_safe(bool ssc) { slow_safe_compiler_ = ssc; }
@@ -152,15 +209,423 @@ class RegExpMacroAssembler {
return global_mode_ == GLOBAL;
}
- Zone* zone() const { return zone_; }
+ Isolate* isolate() const { return isolate_; }
private:
bool slow_safe_compiler_;
bool global_mode_;
- Zone* zone_;
+ Isolate* isolate_;
+};
+
+
+class IRRegExpMacroAssembler : public RegExpMacroAssembler {
+ public:
+ // Type of input string to generate code for.
+ enum Mode { ASCII = 1, UC16 = 2 };
+
+ // Result of calling generated native RegExp code.
+ // RETRY: Something significant changed during execution, and the matching
+ // should be retried from scratch.
+ // EXCEPTION: Something failed during execution. If no exception has been
+ // thrown, it's an internal out-of-memory, and the caller should
+ // throw the exception.
+ // FAILURE: Matching failed.
+ // SUCCESS: Matching succeeded, and the output array has been filled with
+ // capture positions.
+ enum Result { RETRY = -2, EXCEPTION = -1, FAILURE = 0, SUCCESS = 1 };
+
+ IRRegExpMacroAssembler(intptr_t specialization_cid,
+ intptr_t capture_count,
+ const ParsedFunction* parsed_function,
+ const ZoneGrowableArray<const ICData*>& ic_data_array,
+ Isolate* isolate);
+ virtual ~IRRegExpMacroAssembler();
+
+ virtual bool CanReadUnaligned();
+
+ // Compares two-byte strings case insensitively.
+ // Called from generated RegExp code.
+ static RawBool* CaseInsensitiveCompareUC16(
+ RawString* str_raw,
+ RawSmi* lhs_index_raw,
+ RawSmi* rhs_index_raw,
+ RawSmi* length_raw);
+
+ static RawArray* Execute(const Function& function,
+ const String& input,
+ const Smi& start_offset,
+ Isolate* isolate);
+
+ virtual bool IsClosed() const { return (current_instruction_ == NULL); }
+
+ virtual intptr_t stack_limit_slack();
+ virtual void AdvanceCurrentPosition(intptr_t by);
+ virtual void AdvanceRegister(intptr_t reg, intptr_t by);
+ virtual void Backtrack();
+ virtual void BindBlock(BlockLabel* label);
+ virtual void CheckAtStart(BlockLabel* on_at_start);
+ virtual void CheckCharacter(uint32_t c, BlockLabel* on_equal);
+ virtual void CheckCharacterAfterAnd(uint32_t c,
+ uint32_t mask,
+ BlockLabel* on_equal);
+ virtual void CheckCharacterGT(uint16_t limit, BlockLabel* on_greater);
+ virtual void CheckCharacterLT(uint16_t limit, BlockLabel* on_less);
+ // A "greedy loop" is a loop that is both greedy and with a simple
+ // body. It has a particularly simple implementation.
+ virtual void CheckGreedyLoop(BlockLabel* on_tos_equals_current_position);
+ virtual void CheckNotAtStart(BlockLabel* on_not_at_start);
+ virtual void CheckNotBackReference(intptr_t start_reg,
+ BlockLabel* on_no_match);
+ virtual void CheckNotBackReferenceIgnoreCase(intptr_t start_reg,
+ BlockLabel* on_no_match);
+ virtual void CheckNotCharacter(uint32_t c, BlockLabel* on_not_equal);
+ virtual void CheckNotCharacterAfterAnd(uint32_t c,
+ uint32_t mask,
+ BlockLabel* on_not_equal);
+ virtual void CheckNotCharacterAfterMinusAnd(uint16_t c,
+ uint16_t minus,
+ uint16_t mask,
+ BlockLabel* on_not_equal);
+ virtual void CheckCharacterInRange(uint16_t from,
+ uint16_t to,
+ BlockLabel* on_in_range);
+ virtual void CheckCharacterNotInRange(uint16_t from,
+ uint16_t to,
+ BlockLabel* on_not_in_range);
+ virtual void CheckBitInTable(const TypedData& table, BlockLabel* on_bit_set);
+
+ // Checks whether the given offset from the current position is before
+ // the end of the string.
+ virtual void CheckPosition(intptr_t cp_offset, BlockLabel* on_outside_input);
+ virtual bool CheckSpecialCharacterClass(
+ uint16_t type, BlockLabel* on_no_match);
+ virtual void Fail();
+ virtual void IfRegisterGE(intptr_t reg,
+ intptr_t comparand, BlockLabel* if_ge);
+ virtual void IfRegisterLT(intptr_t reg,
+ intptr_t comparand, BlockLabel* if_lt);
+ virtual void IfRegisterEqPos(intptr_t reg, BlockLabel* if_eq);
+ virtual IrregexpImplementation Implementation();
+ virtual void GoTo(BlockLabel* to);
+ virtual void LoadCurrentCharacter(intptr_t cp_offset,
+ BlockLabel* on_end_of_input,
+ bool check_bounds = true,
+ intptr_t characters = 1);
+ virtual void PopCurrentPosition();
+ virtual void PopRegister(intptr_t register_index);
+ virtual void Print(const char* str);
+ virtual void PushBacktrack(BlockLabel* label);
+ virtual void PushCurrentPosition();
+ virtual void PushRegister(intptr_t register_index);
+ virtual void ReadCurrentPositionFromRegister(intptr_t reg);
+ virtual void ReadStackPointerFromRegister(intptr_t reg);
+ virtual void SetCurrentPositionFromEnd(intptr_t by);
+ virtual void SetRegister(intptr_t register_index, intptr_t to);
+ virtual bool Succeed();
+ virtual void WriteCurrentPositionToRegister(intptr_t reg, intptr_t cp_offset);
+ virtual void ClearRegisters(intptr_t reg_from, intptr_t reg_to);
+ virtual void WriteStackPointerToRegister(intptr_t reg);
+
+ virtual void PrintBlocks();
+
+ GraphEntryInstr* graph_entry() const { return entry_block_; }
+
+ intptr_t num_stack_locals() const { return local_id_.Count(); }
+ intptr_t num_blocks() const { return block_id_.Count(); }
+
+ // A table mapping block ids to block offsets, used to look up offsets
+ // for indirect goto instructions.
+ void FinalizeBlockOffsetTable();
+
+ // Fill in indirect goto successors.
+ void FinalizeIndirectGotos();
+
+ private:
+ // Generate the contents of preset blocks. The entry block is the entry point
+ // of the generated code.
+ void GenerateEntryBlock();
+ // Performs backtracking, i.e. popping an offset from the stack and doing
+ // an indirect goto.
+ void GenerateBacktrackBlock();
+ // Copies capture indices into the result area and returns true.
+ void GenerateSuccessBlock();
+ // Returns false.
+ void GenerateExitBlock();
+
+ enum ComparisonKind {
+ kEQ,
+ kNE,
+ kLT,
+ kGT,
+ kLTE,
+ kGTE,
+ };
+
+ struct InstanceCallDescriptor {
+ // Standard (i.e. most non-Smi) functions.
+ explicit InstanceCallDescriptor(const String& name)
+ : name(name),
+ token_kind(Token::kILLEGAL),
+ checked_argument_count(1) { }
+
+ InstanceCallDescriptor(const String& name,
+ Token::Kind token_kind,
+ intptr_t checked_argument_count)
+ : name(name),
+ token_kind(token_kind),
+ checked_argument_count(checked_argument_count) { }
+
+ // Special cases for Smi and indexing functions.
+ static InstanceCallDescriptor FromToken(Token::Kind token_kind) {
+ switch (token_kind) {
+ case Token::kEQ: return InstanceCallDescriptor(
+ Symbols::EqualOperator(), token_kind, 2);
+ case Token::kADD: return InstanceCallDescriptor(
+ Symbols::Plus(), token_kind, 2);
+ case Token::kSUB: return InstanceCallDescriptor(
+ Symbols::Minus(), token_kind, 2);
+ case Token::kBIT_OR: return InstanceCallDescriptor(
+ Symbols::BitOr(), token_kind, 2);
+ case Token::kBIT_AND: return InstanceCallDescriptor(
+ Symbols::BitAnd(), token_kind, 2);
+ case Token::kLT: return InstanceCallDescriptor(
+ Symbols::LAngleBracket(), token_kind, 2);
+ case Token::kLTE: return InstanceCallDescriptor(
+ Symbols::LessEqualOperator(), token_kind, 2);
+ case Token::kGT: return InstanceCallDescriptor(
+ Symbols::RAngleBracket(), token_kind, 2);
+ case Token::kGTE: return InstanceCallDescriptor(
+ Symbols::GreaterEqualOperator(), token_kind, 2);
+ case Token::kNEGATE: return InstanceCallDescriptor(
+ Symbols::UnaryMinus(), token_kind, 1);
+ case Token::kINDEX: return InstanceCallDescriptor(
+ Symbols::IndexToken(), token_kind, 2);
+ case Token::kASSIGN_INDEX: return InstanceCallDescriptor(
+ Symbols::AssignIndexToken(), token_kind, 3);
+ default:
+ UNREACHABLE();
+ }
+ UNREACHABLE();
+ return InstanceCallDescriptor(Symbols::Empty());
+ }
+
+ const String& name;
+ Token::Kind token_kind;
+ intptr_t checked_argument_count;
+ };
+
+ LocalVariable* Local(const String& name);
+ LocalVariable* Parameter(const String& name, intptr_t index) const;
+
+ ConstantInstr* Int64Constant(int64_t value) const;
+ ConstantInstr* Uint64Constant(uint64_t value) const;
+ ConstantInstr* BoolConstant(bool value) const;
+ ConstantInstr* StringConstant(const char* value) const;
+
+ // The word character map static member of the RegExp class.
+ // Byte map of one byte characters with a 0xff if the character is a word
+ // character (digit, letter or underscore) and 0x00 otherwise.
+ // Used by generated RegExp code.
+ ConstantInstr* WordCharacterMapConstant() const;
+
+ ComparisonInstr* Comparison(ComparisonKind kind,
+ Definition* lhs, Definition* rhs);
+
+ InstanceCallInstr* InstanceCall(const InstanceCallDescriptor& desc,
+ PushArgumentInstr* arg1) const;
+ InstanceCallInstr* InstanceCall(const InstanceCallDescriptor& desc,
+ PushArgumentInstr* arg1,
+ PushArgumentInstr* arg2) const;
+ InstanceCallInstr* InstanceCall(const InstanceCallDescriptor& desc,
+ PushArgumentInstr* arg1,
+ PushArgumentInstr* arg2,
+ PushArgumentInstr* arg3) const;
+ InstanceCallInstr* InstanceCall(
+ const InstanceCallDescriptor& desc,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments) const;
+
+ StaticCallInstr* StaticCall(const Function& function) const;
+ StaticCallInstr* StaticCall(const Function& function,
+ PushArgumentInstr* arg1) const;
+ StaticCallInstr* StaticCall(const Function& function,
+ PushArgumentInstr* arg1,
+ PushArgumentInstr* arg2) const;
+ StaticCallInstr* StaticCall(
+ const Function& function,
+ ZoneGrowableArray<PushArgumentInstr*>* arguments) const;
+
+ // Creates a new block consisting simply of a goto to dst.
+ TargetEntryInstr* TargetWithJoinGoto(JoinEntryInstr* dst);
+ IndirectEntryInstr* IndirectWithJoinGoto(JoinEntryInstr* dst);
+
+ // Adds, respectively subtracts lhs and rhs and returns the result.
+ Definition* Add(PushArgumentInstr* lhs, PushArgumentInstr* rhs);
+ Definition* Sub(PushArgumentInstr* lhs, PushArgumentInstr* rhs);
+
+ LoadLocalInstr* LoadLocal(LocalVariable* local) const;
+ void StoreLocal(LocalVariable* local, Value* value);
+
+ PushArgumentInstr* PushArgument(Value* value);
+ PushArgumentInstr* PushLocal(LocalVariable* local);
+
+ // Load a number of characters at the given offset from the
+ // current position, into the current-character register.
+ void LoadCurrentCharacterUnchecked(intptr_t cp_offset,
+ intptr_t character_count);
+
+ // Returns the character within the passed string at the specified index.
+ Value* CharacterAt(Definition* index);
+
+ // Load a number of characters starting from index in the pattern string.
+ Value* LoadCodeUnitsAt(Value* pattern,
+ Value* index,
+ intptr_t character_count);
+
+ // Check whether preemption has been requested.
+ void CheckPreemption();
+
+ // Byte size of chars in the string to match (decided by the Mode argument)
+ inline intptr_t char_size() { return static_cast<int>(mode_); }
+
+ // Equivalent to a conditional branch to the label, unless the label
+ // is NULL, in which case it is a conditional Backtrack.
+ void BranchOrBacktrack(ComparisonInstr* comparison,
+ BlockLabel* true_successor);
+
+ // Set up all local variables and parameters.
+ void InitializeLocals();
+
+ // Allocates a new local, and returns the appropriate id for placing it
+ // on the stack.
+ intptr_t GetNextLocalIndex();
+
+ // We never have any copied parameters.
+ intptr_t num_copied_params() const {
+ return 0;
+ }
+
+ // Return the position register at the specified index, creating it if
+ // necessary. Note that the number of such registers can exceed the amount
+ // required by the number of output captures.
+ LocalVariable* position_register(intptr_t index);
+
+ void set_current_instruction(Instruction* instruction);
+
+ // The following functions are responsible for appending instructions
+ // to the current instruction in various ways. The most simple one
+ // is AppendInstruction, which simply appends an instruction and performs
+ // bookkeeping.
+ void AppendInstruction(Instruction* instruction);
+ // Similar to AppendInstruction, but closes the current block by
+ // setting current_instruction_ to NULL.
+ void CloseBlockWith(Instruction* instruction);
+ // Appends definition and allocates a temp index for the result.
+ Value* Bind(Definition* definition);
+ // Loads and binds a local variable.
+ Value* BindLoadLocal(const LocalVariable& local);
+
+ // Appends the definition.
+ void Do(Definition* definition);
+ // Closes the current block with a jump to the specified block.
+ void GoTo(JoinEntryInstr* to);
+
+ // Accessors for our local stack_.
+ void PushStack(Definition* definition);
+ Value* PopStack();
+
+ // Prints the specified argument. Used for debugging.
+ void Print(PushArgumentInstr* argument);
+
+ // A utility class tracking ids of various objects such as blocks, temps, etc.
+ class IdAllocator : public ValueObject {
+ public:
+ IdAllocator() : next_id(0) { }
+
+ intptr_t Count() const { return next_id; }
+ intptr_t Alloc(intptr_t count = 1) {
+ ASSERT(count >= 0);
+ intptr_t current_id = next_id;
+ next_id += count;
+ return current_id;
+ }
+ void Dealloc(intptr_t count = 1) {
+ ASSERT(count <= next_id);
+ next_id -= count;
+ }
+
+ private:
+ intptr_t next_id;
+ };
+
+ // Which mode to generate code for (ASCII or UC16).
+ Mode mode_;
+
+ // Which specific string class to generate code for.
+ intptr_t specialization_cid_;
+
+ // Block entries used internally.
+ GraphEntryInstr* entry_block_;
+ JoinEntryInstr* start_block_;
+ JoinEntryInstr* success_block_;
+ JoinEntryInstr* backtrack_block_;
+ JoinEntryInstr* exit_block_;
+
+ const ParsedFunction* parsed_function_;
+ const ZoneGrowableArray<const ICData*>& ic_data_array_;
+
+ // All created blocks are contained within this set. Used for printing
+ // the generated code.
+ GrowableArray<BlockEntryInstr*> blocks_;
+
+ // The current instruction to link to when new code is emitted.
+ Instruction* current_instruction_;
+
+ // A list, acting as the runtime stack for both backtrack locations and
+ // stored positions within the string.
+ LocalVariable* stack_;
+
+ // Stores the current character within the string.
+ LocalVariable* current_character_;
+
+ // Stores the current location within the string as a negative offset
+ // from the end of the string.
+ LocalVariable* current_position_;
+
+ // The string being processed, passed as a function parameter.
+ LocalVariable* string_param_;
+
+ // Stores the length of string_param_.
+ LocalVariable* string_param_length_;
+
+ // The start index within the string, passed as a function parameter.
+ LocalVariable* start_index_param_;
+
+ // An assortment of utility variables.
+ LocalVariable* capture_length_;
+ LocalVariable* match_start_index_;
+ LocalVariable* capture_start_index_;
+ LocalVariable* match_end_index_;
+ LocalVariable* char_in_capture_;
+ LocalVariable* char_in_match_;
+
+ LocalVariable* result_;
+
+ // Stored positions containing group bounds. Generated as needed.
+ const intptr_t position_registers_count_;
+ GrowableArray<LocalVariable*> position_registers_;
+
+ // The actual array object used as the stack.
+ GrowableObjectArray& stack_array_;
+
+ GrowableArray<IndirectGotoInstr*> igotos_;
+
+ IdAllocator block_id_;
+ IdAllocator temp_id_;
+ IdAllocator arg_id_;
+ IdAllocator local_id_;
+ IdAllocator indirect_id_;
};
-// SNIP
} // namespace dart
« no previous file with comments | « runtime/vm/regexp.cc ('k') | runtime/vm/regexp_assembler.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698