Add X32 port into V8

src/x64/regexp-macro-assembler-x64.cc

 // Copyright 2012 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 97 matching lines @@
  *              int start_index,
  *              Address start,
  *              Address end,
  *              int* capture_output_array,
  *              bool at_start,
  *              byte* stack_area_base,
  *              bool direct_call)
  */
 
 #define __ ACCESS_MASM((&masm_))
+#define __k __
 
 RegExpMacroAssemblerX64::RegExpMacroAssemblerX64(
     Mode mode,
     int registers_to_save,
     Zone* zone)
     : NativeRegExpMacroAssembler(zone),
       masm_(zone->isolate(), NULL, kRegExpCodeSize),
       no_root_array_scope_(&masm_),
       code_relative_fixup_positions_(4, zone),
       mode_(mode),
@@ skipping 22 matching lines @@
 }
 
 
 int RegExpMacroAssemblerX64::stack_limit_slack()  {
   return RegExpStack::kStackLimitSlack;
 }
 
 
 void RegExpMacroAssemblerX64::AdvanceCurrentPosition(int by) {
   if (by != 0) {
-    __ addq(rdi, Immediate(by * char_size()));
+    __k addq(rdi, Immediate(by * char_size()));
   }
 }
 
 
 void RegExpMacroAssemblerX64::AdvanceRegister(int reg, int by) {
   ASSERT(reg >= 0);
   ASSERT(reg < num_registers_);
   if (by != 0) {
     __ addq(register_location(reg), Immediate(by));
   }
@@ skipping 63 matching lines @@
   Drop();
   BranchOrBacktrack(no_condition, on_equal);
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerX64::CheckNotBackReferenceIgnoreCase(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
+#ifndef V8_TARGET_ARCH_X32
   __ movq(rdx, register_location(start_reg));  // Offset of start of capture
   __ movq(rbx, register_location(start_reg + 1));  // Offset of end of capture
+#else
+  __ movsxlq(rdx, register_location(start_reg));  // Offset of start of capture
+  // Offset of end of capture
+  __ movsxlq(rbx, register_location(start_reg + 1));
+#endif
   __ subq(rbx, rdx);  // Length of capture.
 
   // -----------------------
   // rdx  = Start offset of capture.
   // rbx = Length of capture
 
   // If length is negative, this code will fail (it's a symptom of a partial or
   // illegal capture where start of capture after end of capture).
   // This must not happen (no back-reference can reference a capture that wasn't
   // closed before in the reg-exp, and we must not generate code that can cause
@@ skipping 53 matching lines @@
     __ bind(&loop_increment);
     // Increment pointers into match and capture strings.
     __ addq(r11, Immediate(1));
     __ addq(r9, Immediate(1));
     // Compare to end of capture, and loop if not done.
     __ cmpq(r9, rbx);
     __ j(below, &loop);
 
     // Compute new value of character position after the matched part.
     __ movq(rdi, r11);
-    __ subq(rdi, rsi);
+    __k subq(rdi, rsi);
   } else {
     ASSERT(mode_ == UC16);
     // Save important/volatile registers before calling C function.
 #ifndef _WIN64
     // Caller save on Linux and callee save in Windows.
-    __ push(rsi);
-    __ push(rdi);
+    __k push(rsi);
+    __k push(rdi);
 #endif
-    __ push(backtrack_stackpointer());
+    __k push(backtrack_stackpointer());
 
     static const int num_arguments = 4;
     __ PrepareCallCFunction(num_arguments);
 
     // Put arguments into parameter registers. Parameters are
     //   Address byte_offset1 - Address captured substring's start.
     //   Address byte_offset2 - Address of current character position.
     //   size_t byte_length - length of capture in bytes(!)
     //   Isolate* isolate
 #ifdef _WIN64
@@ skipping 21 matching lines @@
     { // NOLINT: Can't find a way to open this scope without confusing the
       // linter.
       AllowExternalCallThatCantCauseGC scope(&masm_);
       ExternalReference compare =
           ExternalReference::re_case_insensitive_compare_uc16(isolate());
       __ CallCFunction(compare, num_arguments);
     }
 
     // Restore original values before reacting on result value.
     __ Move(code_object_pointer(), masm_.CodeObject());
-    __ pop(backtrack_stackpointer());
+    __k pop(backtrack_stackpointer());
 #ifndef _WIN64
-    __ pop(rdi);
-    __ pop(rsi);
+    __k pop(rdi);
+    __k pop(rsi);
 #endif
 
     // Check if function returned non-zero for success or zero for failure.
     __ testq(rax, rax);
     BranchOrBacktrack(zero, on_no_match);
     // On success, increment position by length of capture.
     // Requires that rbx is callee save (true for both Win64 and AMD64 ABIs).
-    __ addq(rdi, rbx);
+    __k addq(rdi, rbx);
   }
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerX64::CheckNotBackReference(
     int start_reg,
     Label* on_no_match) {
   Label fallthrough;
 
   // Find length of back-referenced capture.
+#ifndef V8_TARGET_ARCH_X32
   __ movq(rdx, register_location(start_reg));
   __ movq(rax, register_location(start_reg + 1));
+#else
+  __ movsxlq(rdx, register_location(start_reg));
+  __ movsxlq(rax, register_location(start_reg + 1));
+#endif
   __ subq(rax, rdx);  // Length to check.
 
   // Fail on partial or illegal capture (start of capture after end of capture).
   // This must not happen (no back-reference can reference a capture that wasn't
   // closed before in the reg-exp).
   __ Check(greater_equal, "Invalid capture referenced");
 
   // Succeed on empty capture (including non-participating capture)
   __ j(equal, &fallthrough);
 
@@ skipping 30 matching lines @@
   // Increment pointers into capture and match string.
   __ addq(rbx, Immediate(char_size()));
   __ addq(rdx, Immediate(char_size()));
   // Check if we have reached end of match area.
   __ cmpq(rdx, r9);
   __ j(below, &loop);
 
   // Success.
   // Set current character position to position after match.
   __ movq(rdi, rbx);
-  __ subq(rdi, rsi);
+  __k subq(rdi, rsi);
 
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerX64::CheckNotCharacter(uint32_t c,
                                                 Label* on_not_equal) {
   __ cmpl(current_character(), Immediate(c));
   BranchOrBacktrack(not_equal, on_not_equal);
 }
@@ skipping 218 matching lines @@
   FrameScope scope(&masm_, StackFrame::MANUAL);
 
   // Actually emit code to start a new stack frame.
   __ push(rbp);
   __ movq(rbp, rsp);
   // Save parameters and callee-save registers. Order here should correspond
   //  to order of kBackup_ebx etc.
 #ifdef _WIN64
   // MSVC passes arguments in rcx, rdx, r8, r9, with backing stack slots.
   // Store register parameters in pre-allocated stack slots,
-  __ movq(Operand(rbp, kInputString), rcx);
-  __ movq(Operand(rbp, kStartIndex), rdx);  // Passed as int32 in edx.
-  __ movq(Operand(rbp, kInputStart), r8);
-  __ movq(Operand(rbp, kInputEnd), r9);
+  __k movq(Operand(rbp, kInputString), rcx);
+  __k movq(Operand(rbp, kStartIndex), rdx);  // Passed as int32 in edx.
+  __k movq(Operand(rbp, kInputStart), r8);
+  __k movq(Operand(rbp, kInputEnd), r9);
   // Callee-save on Win64.
-  __ push(rsi);
-  __ push(rdi);
-  __ push(rbx);
+  __k push(rsi);
+  __k push(rdi);
+  __k push(rbx);
 #else
   // GCC passes arguments in rdi, rsi, rdx, rcx, r8, r9 (and then on stack).
   // Push register parameters on stack for reference.
+#ifndef V8_TARGET_ARCH_X32
   ASSERT_EQ(kInputString, -1 * kPointerSize);
   ASSERT_EQ(kStartIndex, -2 * kPointerSize);
   ASSERT_EQ(kInputStart, -3 * kPointerSize);
   ASSERT_EQ(kInputEnd, -4 * kPointerSize);
   ASSERT_EQ(kRegisterOutput, -5 * kPointerSize);
   ASSERT_EQ(kNumOutputRegisters, -6 * kPointerSize);
-  __ push(rdi);
-  __ push(rsi);
-  __ push(rdx);
-  __ push(rcx);
-  __ push(r8);
-  __ push(r9);
+#else
+  ASSERT_EQ(kInputString, -1 * kHWRegSize);
+  ASSERT_EQ(kStartIndex, -2 * kHWRegSize);
+  ASSERT_EQ(kInputStart, -3 * kHWRegSize);
+  ASSERT_EQ(kInputEnd, -4 * kHWRegSize);
+  ASSERT_EQ(kRegisterOutput, -5 * kHWRegSize);
+  ASSERT_EQ(kNumOutputRegisters, -6 * kHWRegSize);
+#endif
+  __k push(rdi);
+  __k push(rsi);
+  __k push(rdx);
+  __k push(rcx);
+  __k push(r8);
+  __k push(r9);
 
-  __ push(rbx);  // Callee-save
+  __k push(rbx);  // Callee-save
 #endif
 
   __ push(Immediate(0));  // Number of successful matches in a global regexp.
   __ push(Immediate(0));  // Make room for "input start - 1" constant.
 
   // Check if we have space on the stack for registers.
   Label stack_limit_hit;
   Label stack_ok;
 
   ExternalReference stack_limit =
@@ skipping 21 matching lines @@
 
   __ bind(&stack_ok);
 
   // Allocate space on stack for registers.
   __ subq(rsp, Immediate(num_registers_ * kPointerSize));
   // Load string length.
   __ movq(rsi, Operand(rbp, kInputEnd));
   // Load input position.
   __ movq(rdi, Operand(rbp, kInputStart));
   // Set up rdi to be negative offset from string end.
-  __ subq(rdi, rsi);
+  __k subq(rdi, rsi);
   // Set rax to address of char before start of the string
   // (effectively string position -1).
   __ movq(rbx, Operand(rbp, kStartIndex));
-  __ neg(rbx);
+  __k neg(rbx);
   if (mode_ == UC16) {
     __ lea(rax, Operand(rdi, rbx, times_2, -char_size()));
   } else {
     __ lea(rax, Operand(rdi, rbx, times_1, -char_size()));
   }
   // Store this value in a local variable, for use when clearing
   // position registers.
   __ movq(Operand(rbp, kInputStartMinusOne), rax);
 
 #ifdef WIN32
@@ skipping 27 matching lines @@
   // Initialize on-stack registers.
   if (num_saved_registers_ > 0) {
     // Fill saved registers with initial value = start offset - 1
     // Fill in stack push order, to avoid accessing across an unwritten
     // page (a problem on Windows).
     if (num_saved_registers_ > 8) {
       __ Set(rcx, kRegisterZero);
       Label init_loop;
       __ bind(&init_loop);
       __ movq(Operand(rbp, rcx, times_1, 0), rax);
-      __ subq(rcx, Immediate(kPointerSize));
-      __ cmpq(rcx,
+      __k subq(rcx, Immediate(kPointerSize));
+      __k cmpq(rcx,
               Immediate(kRegisterZero - num_saved_registers_ * kPointerSize));
       __ j(greater, &init_loop);
     } else {  // Unroll the loop.
       for (int i = 0; i < num_saved_registers_; i++) {
         __ movq(register_location(i), rax);
       }
     }
   }
 
   // Initialize backtrack stack pointer.
@@ skipping 10 matching lines @@
       __ movq(rdx, Operand(rbp, kStartIndex));
       __ movq(rbx, Operand(rbp, kRegisterOutput));
       __ movq(rcx, Operand(rbp, kInputEnd));
       __ subq(rcx, Operand(rbp, kInputStart));
       if (mode_ == UC16) {
         __ lea(rcx, Operand(rcx, rdx, times_2, 0));
       } else {
         __ addq(rcx, rdx);
       }
       for (int i = 0; i < num_saved_registers_; i++) {
+#ifndef V8_TARGET_ARCH_X32
         __ movq(rax, register_location(i));
+#else
+        __ movsxlq(rax, register_location(i));
+#endif
         if (i == 0 && global_with_zero_length_check()) {
           // Keep capture start in rdx for the zero-length check later.
           __ movq(rdx, rax);
         }
         __ addq(rax, rcx);  // Convert to index from start, not end.
         if (mode_ == UC16) {
           __ sar(rax, Immediate(1));  // Convert byte index to character index.
         }
         __ movl(Operand(rbx, i * kIntSize), rax);
       }
@@ skipping 23 matching lines @@
         // Special case for zero-length matches.
         // rdx: capture start index
         __ cmpq(rdi, rdx);
         // Not a zero-length match, restart.
         __ j(not_equal, &load_char_start_regexp);
         // rdi (offset from the end) is zero if we already reached the end.
         __ testq(rdi, rdi);
         __ j(zero, &exit_label_, Label::kNear);
         // Advance current position after a zero-length match.
         if (mode_ == UC16) {
-          __ addq(rdi, Immediate(2));
+          __k addq(rdi, Immediate(2));
         } else {
-          __ incq(rdi);
+          __k incq(rdi);
         }
       }
 
       __ jmp(&load_char_start_regexp);
     } else {
       __ movq(rax, Immediate(SUCCESS));
     }
   }
 
   __ bind(&exit_label_);
   if (global()) {
     // Return the number of successful captures.
     __ movq(rax, Operand(rbp, kSuccessfulCaptures));
   }
 
   __ bind(&return_rax);
 #ifdef _WIN64
   // Restore callee save registers.
   __ lea(rsp, Operand(rbp, kLastCalleeSaveRegister));
-  __ pop(rbx);
-  __ pop(rdi);
-  __ pop(rsi);
+  __k pop(rbx);
+  __k pop(rdi);
+  __k pop(rsi);
   // Stack now at rbp.
 #else
   // Restore callee save register.
   __ movq(rbx, Operand(rbp, kBackup_rbx));
   // Skip rsp to rbp.
   __ movq(rsp, rbp);
 #endif
   // Exit function frame, restore previous one.
   __ pop(rbp);
   __ ret(0);
 
   // Backtrack code (branch target for conditional backtracks).
   if (backtrack_label_.is_linked()) {
     __ bind(&backtrack_label_);
     Backtrack();
   }
 
   Label exit_with_exception;
 
   // Preempt-code
   if (check_preempt_label_.is_linked()) {
     SafeCallTarget(&check_preempt_label_);
 
-    __ push(backtrack_stackpointer());
-    __ push(rdi);
+    __k push(backtrack_stackpointer());
+    __k push(rdi);
 
     CallCheckStackGuardState();
     __ testq(rax, rax);
     // If returning non-zero, we should end execution with the given
     // result as return value.
     __ j(not_zero, &return_rax);
 
     // Restore registers.
     __ Move(code_object_pointer(), masm_.CodeObject());
-    __ pop(rdi);
-    __ pop(backtrack_stackpointer());
+    __k pop(rdi);
+    __k pop(backtrack_stackpointer());
     // String might have moved: Reload esi from frame.
     __ movq(rsi, Operand(rbp, kInputEnd));
     SafeReturn();
   }
 
   // Backtrack stack overflow code.
   if (stack_overflow_label_.is_linked()) {
     SafeCallTarget(&stack_overflow_label_);
     // Reached if the backtrack-stack limit has been hit.
 
     Label grow_failed;
     // Save registers before calling C function
 #ifndef _WIN64
     // Callee-save in Microsoft 64-bit ABI, but not in AMD64 ABI.
-    __ push(rsi);
-    __ push(rdi);
+    __k push(rsi);
+    __k push(rdi);
 #endif
 
     // Call GrowStack(backtrack_stackpointer())
     static const int num_arguments = 3;
     __ PrepareCallCFunction(num_arguments);
 #ifdef _WIN64
     // Microsoft passes parameters in rcx, rdx, r8.
     // First argument, backtrack stackpointer, is already in rcx.
     __ lea(rdx, Operand(rbp, kStackHighEnd));  // Second argument
     __ LoadAddress(r8, ExternalReference::isolate_address(isolate()));
 #else
     // AMD64 ABI passes parameters in rdi, rsi, rdx.
     __ movq(rdi, backtrack_stackpointer());   // First argument.
     __ lea(rsi, Operand(rbp, kStackHighEnd));  // Second argument.
     __ LoadAddress(rdx, ExternalReference::isolate_address(isolate()));
 #endif
     ExternalReference grow_stack =
         ExternalReference::re_grow_stack(isolate());
     __ CallCFunction(grow_stack, num_arguments);
     // If return NULL, we have failed to grow the stack, and
     // must exit with a stack-overflow exception.
     __ testq(rax, rax);
     __ j(equal, &exit_with_exception);
     // Otherwise use return value as new stack pointer.
     __ movq(backtrack_stackpointer(), rax);
     // Restore saved registers and continue.
     __ Move(code_object_pointer(), masm_.CodeObject());
 #ifndef _WIN64
-    __ pop(rdi);
-    __ pop(rsi);
+    __k pop(rdi);
+    __k pop(rsi);
 #endif
     SafeReturn();
   }
 
   if (exit_with_exception.is_linked()) {
     // If any of the code above needed to exit with an exception.
     __ bind(&exit_with_exception);
     // Exit with Result EXCEPTION(-1) to signal thrown exception.
     __ Set(rax, EXCEPTION);
     __ jmp(&return_rax);
@@ skipping 83 matching lines @@
 
 void RegExpMacroAssemblerX64::PushRegister(int register_index,
                                            StackCheckFlag check_stack_limit) {
   __ movq(rax, register_location(register_index));
   Push(rax);
   if (check_stack_limit) CheckStackLimit();
 }
 
 
 void RegExpMacroAssemblerX64::ReadCurrentPositionFromRegister(int reg) {
+#ifndef V8_TARGET_ARCH_X32
   __ movq(rdi, register_location(reg));
+#else
+  __ movsxlq(rdi, register_location(reg));
+#endif
 }
 
 
 void RegExpMacroAssemblerX64::ReadStackPointerFromRegister(int reg) {
+#ifndef V8_TARGET_ARCH_X32
   __ movq(backtrack_stackpointer(), register_location(reg));
   __ addq(backtrack_stackpointer(), Operand(rbp, kStackHighEnd));
+#else
+  __ movsxlq(backtrack_stackpointer(), register_location(reg));
+  __ addl(backtrack_stackpointer(), Operand(rbp, kStackHighEnd));
+#endif
 }
 
 
 void RegExpMacroAssemblerX64::SetCurrentPositionFromEnd(int by) {
   Label after_position;
   __ cmpq(rdi, Immediate(-by * char_size()));
   __ j(greater_equal, &after_position, Label::kNear);
-  __ movq(rdi, Immediate(-by * char_size()));
+  __k movq(rdi, Immediate(-by * char_size()));
   // On RegExp code entry (where this operation is used), the character before
   // the current position is expected to be already loaded.
   // We have advanced the position, so it's safe to read backwards.
   LoadCurrentCharacterUnchecked(-1, 1);
   __ bind(&after_position);
 }
 
 
 void RegExpMacroAssemblerX64::SetRegister(int register_index, int to) {
   ASSERT(register_index >= num_saved_registers_);  // Reserved for positions!
@@ skipping 49 matching lines @@
   // First argument: Next address on the stack (will be address of
   // return address).
   __ lea(rcx, Operand(rsp, -kPointerSize));
 #else
   // Third argument: RegExp code frame pointer.
   __ movq(rdx, rbp);
   // Second argument: Code* of self.
   __ movq(rsi, code_object_pointer());
   // First argument: Next address on the stack (will be address of
   // return address).
+#ifndef V8_TARGET_ARCH_X32
   __ lea(rdi, Operand(rsp, -kPointerSize));
+#else
+  __ leal(rdi, Operand(rsp, -kHWRegSize));
+#endif
 #endif
   ExternalReference stack_check =
       ExternalReference::re_check_stack_guard_state(isolate());
   __ CallCFunction(stack_check, num_arguments);
 }
 
 
 // Helper function for reading a value out of a stack frame.
 template <typename T>
 static T& frame_entry(Address re_frame, int frame_offset) {
@@ skipping 186 matching lines @@
 
 void RegExpMacroAssemblerX64::Push(Label* backtrack_target) {
   __ subq(backtrack_stackpointer(), Immediate(kIntSize));
   __ movl(Operand(backtrack_stackpointer(), 0), backtrack_target);
   MarkPositionForCodeRelativeFixup();
 }
 
 
 void RegExpMacroAssemblerX64::Pop(Register target) {
   ASSERT(!target.is(backtrack_stackpointer()));
-  __ movsxlq(target, Operand(backtrack_stackpointer(), 0));
+  __k movsxlq(target, Operand(backtrack_stackpointer(), 0));
   // Notice: This updates flags, unlike normal Pop.
   __ addq(backtrack_stackpointer(), Immediate(kIntSize));
 }
 
 
 void RegExpMacroAssemblerX64::Drop() {
   __ addq(backtrack_stackpointer(), Immediate(kIntSize));
 }
 
 
@@ skipping 43 matching lines @@
       __ movl(current_character(),
               Operand(rsi, rdi, times_1, cp_offset * sizeof(uc16)));
     } else {
       ASSERT(characters == 1);
       __ movzxwl(current_character(),
                  Operand(rsi, rdi, times_1, cp_offset * sizeof(uc16)));
     }
   }
 }
 
+#undef __k
 #undef __
 
 #endif  // V8_INTERPRETED_REGEXP
 
 }}  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64