* Better factoring of ARM/IA32 code in irregexp.

src/regexp-macro-assembler-ia32.h

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef REGEXP_MACRO_ASSEMBLER_IA32_H_
 #define REGEXP_MACRO_ASSEMBLER_IA32_H_
 
-#if !(defined(ARM) || defined(__arm__) || defined(__thumb__))
-
-#include "regexp-macro-assembler.h"
-#include "macro-assembler-ia32.h"
-
 namespace v8 { namespace internal {
 
 class RegExpMacroAssemblerIA32: public RegExpMacroAssembler {
  public:
+  // Type of input string to generate code for.
   enum Mode {ASCII = 1, UC16 = 2};
+
   RegExpMacroAssemblerIA32(Mode mode, int registers_to_save);
   virtual ~RegExpMacroAssemblerIA32();
   virtual void AdvanceCurrentPosition(int by);
   virtual void AdvanceRegister(int reg, int by);
   virtual void Backtrack();
   virtual void Bind(Label* label);
   virtual void CheckBitmap(uc16 start, Label* bitmap, Label* on_zero);
   virtual void CheckCharacter(uc16 c, Label* on_equal);
   virtual void CheckCharacterGT(uc16 limit, Label* on_greater);
   virtual void CheckCharacterLT(uc16 limit, Label* on_less);
@@ skipping 30 matching lines @@
   virtual void PopRegister(int register_index);
   virtual void PushBacktrack(Label* label);
   virtual void PushCurrentPosition();
   virtual void PushRegister(int register_index);
   virtual void ReadCurrentPositionFromRegister(int reg);
   virtual void ReadStackPointerFromRegister(int reg);
   virtual void SetRegister(int register_index, int to);
   virtual void Succeed();
   virtual void WriteCurrentPositionToRegister(int reg);
   virtual void WriteStackPointerToRegister(int reg);
+
  private:
   // Offsets from ebp of arguments to function.
   static const int kBackup_edi = 1 * sizeof(uint32_t);
   static const int kBackup_esi= 2 * sizeof(uint32_t);
   static const int kInputBuffer = 4 * sizeof(uint32_t);
   static const int kInputStartOffset = 5 * sizeof(uint32_t);
   static const int kInputEndOffset = 6 * sizeof(uint32_t);
   static const int kRegisterOutput = 7 * sizeof(uint32_t);
 
+  // Initial size of code buffer.
+  static const size_t kRegExpCodeSize = 1024;
+  // Initial size of constant buffers allocated during compilation.
+  static const int kRegExpConstantsSize = 256;
+  // Only unroll loops up to this length.
+  static const int kMaxInlineStringTests = 8;
+  // Special "character" marking end of input.
+  static const uint32_t kEndOfInput = ~0;
+
   // The ebp-relative location of a regexp register.
   Operand register_location(int register_index);
 
   // Byte size of chars in the string to match (decided by the Mode argument)
   size_t char_size();
 
   // Records that a register is used. At the end, we need the number of
   // registers used.
   void RecordRegister(int register_index);
 
@@ skipping 13 matching lines @@
   // and an offset. Uses no extra registers.
   void LoadConstantBufferAddress(Register reg, ArraySlice* buffer);
 
   // Read the current character into the destination register.
   void ReadCurrentChar(Register destination);
 
   // Adds code that checks whether preemption has been requested
   // (and checks if we have hit the stack limit too).
   void CheckStackLimit();
 
-  // Initial size of code buffer.
-  static const size_t kRegExpCodeSize = 1024;
-  // Initial size of constant buffers allocated during compilation.
-  static const int kRegExpConstantsSize = 256;
-  // Only unroll loops up to this length.
-  static const int kMaxInlineStringTests = 8;
-  // Special "character" marking end of input.
-  static const uint32_t kEndOfInput = ~0;
-
   MacroAssembler* masm_;
+  // Constant buffer provider. Allocates external storage for storing
+  // constants.
   ByteArrayProvider constants_;
   // Which mode to generate code for (ASCII or UTF16).
   Mode mode_;
   // One greater than maximal register index actually used.
   int num_registers_;
   // Number of registers to output at the end (the saved registers
   // are always 0..num_saved_registers_-1)
   int num_saved_registers_;
-  // Whether to generate code that is case-insensitive. Only relevant for
-  // back-references.
+  // Labels used internally.
   Label entry_label_;
   Label start_label_;
   Label success_label_;
   Label exit_label_;
   // Handle used to represent the generated code object itself.
   Handle<Object> self_;
 };
-}}
 
-#endif  // !ARM
+}}  // namespace v8::internal
 
 #endif /* REGEXP_MACRO_ASSEMBLER_IA32_H_ */