src/v8/src/regexp-macro-assembler-irregexp.h

   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 #ifndef V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_H_
   6 #define V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_H_
   7
   8 #include "src/regexp-macro-assembler.h"
   9
  10 namespace v8 {
  11 namespace internal {
  12
  13 #ifdef V8_INTERPRETED_REGEXP
  14
  15 class RegExpMacroAssemblerIrregexp: public RegExpMacroAssembler {
  16  public:
  17   // Create an assembler. Instructions and relocation information are emitted
  18   // into a buffer, with the instructions starting from the beginning and the
  19   // relocation information starting from the end of the buffer. See CodeDesc
  20   // for a detailed comment on the layout (globals.h).
  21   //
  22   // If the provided buffer is NULL, the assembler allocates and grows its own
  23   // buffer, and buffer_size determines the initial buffer size. The buffer is
  24   // owned by the assembler and deallocated upon destruction of the assembler.
  25   //
  26   // If the provided buffer is not NULL, the assembler uses the provided buffer
  27   // for code generation and assumes its size to be buffer_size. If the buffer
  28   // is too small, a fatal error occurs. No deallocation of the buffer is done
  29   // upon destruction of the assembler.
  30   RegExpMacroAssemblerIrregexp(Vector<byte>, Zone* zone);
  31   virtual ~RegExpMacroAssemblerIrregexp();
  32   // The byte-code interpreter checks on each push anyway.
  33   virtual int stack_limit_slack() { return 1; }
  34   virtual bool CanReadUnaligned() { return false; }
  35   virtual void Bind(Label* label);
  36   virtual void AdvanceCurrentPosition(int by);  // Signed cp change.
  37   virtual void PopCurrentPosition();
  38   virtual void PushCurrentPosition();
  39   virtual void Backtrack();
  40   virtual void GoTo(Label* label);
  41   virtual void PushBacktrack(Label* label);
  42   virtual bool Succeed();
  43   virtual void Fail();
  44   virtual void PopRegister(int register_index);
  45   virtual void PushRegister(int register_index,
  46                             StackCheckFlag check_stack_limit);
  47   virtual void AdvanceRegister(int reg, int by);  // r[reg] += by.
  48   virtual void SetCurrentPositionFromEnd(int by);
  49   virtual void SetRegister(int register_index, int to);
  50   virtual void WriteCurrentPositionToRegister(int reg, int cp_offset);
  51   virtual void ClearRegisters(int reg_from, int reg_to);
  52   virtual void ReadCurrentPositionFromRegister(int reg);
  53   virtual void WriteStackPointerToRegister(int reg);
  54   virtual void ReadStackPointerFromRegister(int reg);
  55   virtual void LoadCurrentCharacter(int cp_offset,
  56                                     Label* on_end_of_input,
  57                                     bool check_bounds = true,
  58                                     int characters = 1);
  59   virtual void CheckCharacter(unsigned c, Label* on_equal);
  60   virtual void CheckCharacterAfterAnd(unsigned c,
  61                                       unsigned mask,
  62                                       Label* on_equal);
  63   virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
  64   virtual void CheckCharacterLT(uc16 limit, Label* on_less);
  65   virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
  66   virtual void CheckAtStart(Label* on_at_start);
  67   virtual void CheckNotAtStart(Label* on_not_at_start);
  68   virtual void CheckNotCharacter(unsigned c, Label* on_not_equal);
  69   virtual void CheckNotCharacterAfterAnd(unsigned c,
  70                                          unsigned mask,
  71                                          Label* on_not_equal);
  72   virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
  73                                               uc16 minus,
  74                                               uc16 mask,
  75                                               Label* on_not_equal);
  76   virtual void CheckCharacterInRange(uc16 from,
  77                                      uc16 to,
  78                                      Label* on_in_range);
  79   virtual void CheckCharacterNotInRange(uc16 from,
  80                                         uc16 to,
  81                                         Label* on_not_in_range);
  82   virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
  83   virtual void CheckNotBackReference(int start_reg, Label* on_no_match);
  84   virtual void CheckNotBackReferenceIgnoreCase(int start_reg,
  85                                                Label* on_no_match);
  86   virtual void IfRegisterLT(int register_index, int comparand, Label* if_lt);
  87   virtual void IfRegisterGE(int register_index, int comparand, Label* if_ge);
  88   virtual void IfRegisterEqPos(int register_index, Label* if_eq);
  89
  90   virtual IrregexpImplementation Implementation();
  91   virtual Handle<HeapObject> GetCode(Handle<String> source);
  92
  93  private:
  94   void Expand();
  95   // Code and bitmap emission.
  96   inline void EmitOrLink(Label* label);
  97   inline void Emit32(uint32_t x);
  98   inline void Emit16(uint32_t x);
  99   inline void Emit8(uint32_t x);
 100   inline void Emit(uint32_t bc, uint32_t arg);
 101   // Bytecode buffer.
 102   int length();
 103   void Copy(Address a);
 104
 105   // The buffer into which code and relocation info are generated.
 106   Vector<byte> buffer_;
 107   // The program counter.
 108   int pc_;
 109   // True if the assembler owns the buffer, false if buffer is external.
 110   bool own_buffer_;
 111   Label backtrack_;
 112
 113   int advance_current_start_;
 114   int advance_current_offset_;
 115   int advance_current_end_;
 116
 117   Isolate* isolate_;
 118
 119   static const int kInvalidPC = -1;
 120
 121   DISALLOW_IMPLICIT_CONSTRUCTORS(RegExpMacroAssemblerIrregexp);
 122 };
 123
 124 #endif  // V8_INTERPRETED_REGEXP
 125
 126 } }  // namespace v8::internal
 127
 128 #endif  // V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_H_