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