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

   1 // Copyright 2013 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_ARM64_REGEXP_MACRO_ASSEMBLER_ARM64_H_
   6 #define V8_ARM64_REGEXP_MACRO_ASSEMBLER_ARM64_H_
   7
   8 #include "src/macro-assembler.h"
   9
  10 #include "src/arm64/assembler-arm64.h"
  11 #include "src/arm64/assembler-arm64-inl.h"
  12
  13 namespace v8 {
  14 namespace internal {
  15
  16
  17 #ifndef V8_INTERPRETED_REGEXP
  18 class RegExpMacroAssemblerARM64: public NativeRegExpMacroAssembler {
  19  public:
  20   RegExpMacroAssemblerARM64(Mode mode, int registers_to_save, Zone* zone);
  21   virtual ~RegExpMacroAssemblerARM64();
  22   virtual int stack_limit_slack();
  23   virtual void AdvanceCurrentPosition(int by);
  24   virtual void AdvanceRegister(int reg, int by);
  25   virtual void Backtrack();
  26   virtual void Bind(Label* label);
  27   virtual void CheckAtStart(Label* on_at_start);
  28   virtual void CheckCharacter(unsigned c, Label* on_equal);
  29   virtual void CheckCharacterAfterAnd(unsigned c,
  30                                       unsigned mask,
  31                                       Label* on_equal);
  32   virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
  33   virtual void CheckCharacterLT(uc16 limit, Label* on_less);
  34   virtual void CheckCharacters(Vector<const uc16> str,
  35                                int cp_offset,
  36                                Label* on_failure,
  37                                bool check_end_of_string);
  38   // A "greedy loop" is a loop that is both greedy and with a simple
  39   // body. It has a particularly simple implementation.
  40   virtual void CheckGreedyLoop(Label* on_tos_equals_current_position);
  41   virtual void CheckNotAtStart(Label* on_not_at_start);
  42   virtual void CheckNotBackReference(int start_reg, Label* on_no_match);
  43   virtual void CheckNotBackReferenceIgnoreCase(int start_reg,
  44                                                Label* on_no_match);
  45   virtual void CheckNotCharacter(unsigned c, Label* on_not_equal);
  46   virtual void CheckNotCharacterAfterAnd(unsigned c,
  47                                          unsigned mask,
  48                                          Label* on_not_equal);
  49   virtual void CheckNotCharacterAfterMinusAnd(uc16 c,
  50                                               uc16 minus,
  51                                               uc16 mask,
  52                                               Label* on_not_equal);
  53   virtual void CheckCharacterInRange(uc16 from,
  54                                      uc16 to,
  55                                      Label* on_in_range);
  56   virtual void CheckCharacterNotInRange(uc16 from,
  57                                         uc16 to,
  58                                         Label* on_not_in_range);
  59   virtual void CheckBitInTable(Handle<ByteArray> table, Label* on_bit_set);
  60
  61   // Checks whether the given offset from the current position is before
  62   // the end of the string.
  63   virtual void CheckPosition(int cp_offset, Label* on_outside_input);
  64   virtual bool CheckSpecialCharacterClass(uc16 type,
  65                                           Label* on_no_match);
  66   virtual void Fail();
  67   virtual Handle<HeapObject> GetCode(Handle<String> source);
  68   virtual void GoTo(Label* label);
  69   virtual void IfRegisterGE(int reg, int comparand, Label* if_ge);
  70   virtual void IfRegisterLT(int reg, int comparand, Label* if_lt);
  71   virtual void IfRegisterEqPos(int reg, Label* if_eq);
  72   virtual IrregexpImplementation Implementation();
  73   virtual void LoadCurrentCharacter(int cp_offset,
  74                                     Label* on_end_of_input,
  75                                     bool check_bounds = true,
  76                                     int characters = 1);
  77   virtual void PopCurrentPosition();
  78   virtual void PopRegister(int register_index);
  79   virtual void PushBacktrack(Label* label);
  80   virtual void PushCurrentPosition();
  81   virtual void PushRegister(int register_index,
  82                             StackCheckFlag check_stack_limit);
  83   virtual void ReadCurrentPositionFromRegister(int reg);
  84   virtual void ReadStackPointerFromRegister(int reg);
  85   virtual void SetCurrentPositionFromEnd(int by);
  86   virtual void SetRegister(int register_index, int to);
  87   virtual bool Succeed();
  88   virtual void WriteCurrentPositionToRegister(int reg, int cp_offset);
  89   virtual void ClearRegisters(int reg_from, int reg_to);
  90   virtual void WriteStackPointerToRegister(int reg);
  91   virtual bool CanReadUnaligned();
  92
  93   // Called from RegExp if the stack-guard is triggered.
  94   // If the code object is relocated, the return address is fixed before
  95   // returning.
  96   static int CheckStackGuardState(Address* return_address,
  97                                   Code* re_code,
  98                                   Address re_frame,
  99                                   int start_offset,
 100                                   const byte** input_start,
 101                                   const byte** input_end);
 102
 103  private:
 104   // Above the frame pointer - Stored registers and stack passed parameters.
 105   // Callee-saved registers x19-x29, where x29 is the old frame pointer.
 106   static const int kCalleeSavedRegisters = 0;
 107   // Return address.
 108   // It is placed above the 11 callee-saved registers.
 109   static const int kReturnAddress = kCalleeSavedRegisters + 11 * kPointerSize;
 110   static const int kSecondaryReturnAddress = kReturnAddress + kPointerSize;
 111   // Stack parameter placed by caller.
 112   static const int kIsolate = kSecondaryReturnAddress + kPointerSize;
 113
 114   // Below the frame pointer.
 115   // Register parameters stored by setup code.
 116   static const int kDirectCall = kCalleeSavedRegisters - kPointerSize;
 117   static const int kStackBase = kDirectCall - kPointerSize;
 118   static const int kOutputSize = kStackBase - kPointerSize;
 119   static const int kInput = kOutputSize - kPointerSize;
 120   // When adding local variables remember to push space for them in
 121   // the frame in GetCode.
 122   static const int kSuccessCounter = kInput - kPointerSize;
 123   // First position register address on the stack. Following positions are
 124   // below it. A position is a 32 bit value.
 125   static const int kFirstRegisterOnStack = kSuccessCounter - kWRegSize;
 126   // A capture is a 64 bit value holding two position.
 127   static const int kFirstCaptureOnStack = kSuccessCounter - kXRegSize;
 128
 129   // Initial size of code buffer.
 130   static const size_t kRegExpCodeSize = 1024;
 131
 132   // When initializing registers to a non-position value we can unroll
 133   // the loop. Set the limit of registers to unroll.
 134   static const int kNumRegistersToUnroll = 16;
 135
 136   // We are using x0 to x7 as a register cache. Each hardware register must
 137   // contain one capture, that is two 32 bit registers. We can cache at most
 138   // 16 registers.
 139   static const int kNumCachedRegisters = 16;
 140
 141   // Load a number of characters at the given offset from the
 142   // current position, into the current-character register.
 143   void LoadCurrentCharacterUnchecked(int cp_offset, int character_count);
 144
 145   // Check whether preemption has been requested.
 146   void CheckPreemption();
 147
 148   // Check whether we are exceeding the stack limit on the backtrack stack.
 149   void CheckStackLimit();
 150
 151   // Generate a call to CheckStackGuardState.
 152   void CallCheckStackGuardState(Register scratch);
 153
 154   // Location of a 32 bit position register.
 155   MemOperand register_location(int register_index);
 156
 157   // Location of a 64 bit capture, combining two position registers.
 158   MemOperand capture_location(int register_index, Register scratch);
 159
 160   // Register holding the current input position as negative offset from
 161   // the end of the string.
 162   Register current_input_offset() { return w21; }
 163
 164   // The register containing the current character after LoadCurrentCharacter.
 165   Register current_character() { return w22; }
 166
 167   // Register holding address of the end of the input string.
 168   Register input_end() { return x25; }
 169
 170   // Register holding address of the start of the input string.
 171   Register input_start() { return x26; }
 172
 173   // Register holding the offset from the start of the string where we should
 174   // start matching.
 175   Register start_offset() { return w27; }
 176
 177   // Pointer to the output array's first element.
 178   Register output_array() { return x28; }
 179
 180   // Register holding the frame address. Local variables, parameters and
 181   // regexp registers are addressed relative to this.
 182   Register frame_pointer() { return fp; }
 183
 184   // The register containing the backtrack stack top. Provides a meaningful
 185   // name to the register.
 186   Register backtrack_stackpointer() { return x23; }
 187
 188   // Register holding pointer to the current code object.
 189   Register code_pointer() { return x20; }
 190
 191   // Register holding the value used for clearing capture registers.
 192   Register non_position_value() { return w24; }
 193   // The top 32 bit of this register is used to store this value
 194   // twice. This is used for clearing more than one register at a time.
 195   Register twice_non_position_value() { return x24; }
 196
 197   // Byte size of chars in the string to match (decided by the Mode argument)
 198   int char_size() { return static_cast<int>(mode_); }
 199
 200   // Equivalent to a conditional branch to the label, unless the label
 201   // is NULL, in which case it is a conditional Backtrack.
 202   void BranchOrBacktrack(Condition condition, Label* to);
 203
 204   // Compares reg against immmediate before calling BranchOrBacktrack.
 205   // It makes use of the Cbz and Cbnz instructions.
 206   void CompareAndBranchOrBacktrack(Register reg,
 207                                    int immediate,
 208                                    Condition condition,
 209                                    Label* to);
 210
 211   inline void CallIf(Label* to, Condition condition);
 212
 213   // Save and restore the link register on the stack in a way that
 214   // is GC-safe.
 215   inline void SaveLinkRegister();
 216   inline void RestoreLinkRegister();
 217
 218   // Pushes the value of a register on the backtrack stack. Decrements the
 219   // stack pointer by a word size and stores the register's value there.
 220   inline void Push(Register source);
 221
 222   // Pops a value from the backtrack stack. Reads the word at the stack pointer
 223   // and increments it by a word size.
 224   inline void Pop(Register target);
 225
 226   // This state indicates where the register actually is.
 227   enum RegisterState {
 228     STACKED,     // Resides in memory.
 229     CACHED_LSW,  // Least Significant Word of a 64 bit hardware register.
 230     CACHED_MSW   // Most Significant Word of a 64 bit hardware register.
 231   };
 232
 233   RegisterState GetRegisterState(int register_index) {
 234     DCHECK(register_index >= 0);
 235     if (register_index >= kNumCachedRegisters) {
 236       return STACKED;
 237     } else {
 238       if ((register_index % 2) == 0) {
 239         return CACHED_LSW;
 240       } else {
 241         return CACHED_MSW;
 242       }
 243     }
 244   }
 245
 246   // Store helper that takes the state of the register into account.
 247   inline void StoreRegister(int register_index, Register source);
 248
 249   // Returns a hardware W register that holds the value of the capture
 250   // register.
 251   //
 252   // This function will try to use an existing cache register (w0-w7) for the
 253   // result. Otherwise, it will load the value into maybe_result.
 254   //
 255   // If the returned register is anything other than maybe_result, calling code
 256   // must not write to it.
 257   inline Register GetRegister(int register_index, Register maybe_result);
 258
 259   // Returns the harware register (x0-x7) holding the value of the capture
 260   // register.
 261   // This assumes that the state of the register is not STACKED.
 262   inline Register GetCachedRegister(int register_index);
 263
 264   Isolate* isolate() const { return masm_->isolate(); }
 265
 266   MacroAssembler* masm_;
 267
 268   // Which mode to generate code for (LATIN1 or UC16).
 269   Mode mode_;
 270
 271   // One greater than maximal register index actually used.
 272   int num_registers_;
 273
 274   // Number of registers to output at the end (the saved registers
 275   // are always 0..num_saved_registers_-1)
 276   int num_saved_registers_;
 277
 278   // Labels used internally.
 279   Label entry_label_;
 280   Label start_label_;
 281   Label success_label_;
 282   Label backtrack_label_;
 283   Label exit_label_;
 284   Label check_preempt_label_;
 285   Label stack_overflow_label_;
 286 };
 287
 288 #endif  // V8_INTERPRETED_REGEXP
 289
 290
 291 }}  // namespace v8::internal
 292
 293 #endif  // V8_ARM64_REGEXP_MACRO_ASSEMBLER_ARM64_H_