Irregexp-ia32: Fixes register misuse in frame-align code that fails on Mac.

src/regexp-macro-assembler-ia32.cc

 // 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 313 matching lines @@
     // Compute new value of character position after the matched part.
     __ sub(edi, Operand(esi));
   } else {
     ASSERT(mode_ == UC16);
     // Save registers before calling C function.
     __ push(esi);
     __ push(edi);
     __ push(backtrack_stackpointer());
     __ push(ebx);
     const int four_arguments = 4;
-    FrameAlign(four_arguments);
+    FrameAlign(four_arguments, ecx);
     // Put arguments into allocated stack area.
     __ mov(Operand(esp, 3 * kPointerSize), ebx);
     __ mov(ecx, Operand(ebp, kInputEndOffset));
     __ add(edi, Operand(ecx));
     __ mov(Operand(esp, 2 * kPointerSize), edi);
     __ add(eax, Operand(ecx));
     __ mov(Operand(esp, 1 * kPointerSize), eax);
     __ mov(eax, Operand(ebp, kInputBuffer));
     __ mov(Operand(esp, 0 * kPointerSize), eax);
     Address function_address = FUNCTION_ADDR(&CaseInsensitiveCompareUC16);
@@ skipping 294 matching lines @@
   // Check if there is room for the variable number of registers above
   // the stack limit.
   __ cmp(ecx, num_registers_ * kPointerSize);
   __ j(above_equal, &stack_ok, taken);
   // Exit with exception.
   __ mov(eax, EXCEPTION);
   __ jmp(&exit_label_);
 
   __ bind(&stack_limit_hit);
   int num_arguments = 2;
-  FrameAlign(num_arguments);
+  FrameAlign(num_arguments, ebx);
   __ mov(Operand(esp, 1 * kPointerSize), Immediate(self_));
   __ lea(eax, Operand(esp, -kPointerSize));
   __ mov(Operand(esp, 0 * kPointerSize), eax);
   CallCFunction(FUNCTION_ADDR(&CheckStackGuardState), num_arguments);
   __ or_(eax, Operand(eax));
   // If returned value is non-zero, the stack guard reports the actual
   // stack limit being hit and an exception has already been raised.
   // Otherwise it was a preemption and we just check the limit again.
   __ j(equal, &retry_stack_check);
   // Return value was non-zero. Exit with exception.
@@ skipping 102 matching lines @@
   if (check_preempt_label_.is_linked()) {
     __ bind(&check_preempt_label_);
 
     __ push(backtrack_stackpointer());
     __ push(edi);
 
     Label retry;
 
     __ bind(&retry);
     int num_arguments = 2;
-    FrameAlign(num_arguments);
+    FrameAlign(num_arguments, ebx);
     __ mov(Operand(esp, 1 * kPointerSize), Immediate(self_));
     __ lea(eax, Operand(esp, -kPointerSize));
     __ mov(Operand(esp, 0 * kPointerSize), eax);
     CallCFunction(FUNCTION_ADDR(&CheckStackGuardState), num_arguments);
     // Return value must be zero. We cannot have a stack overflow at
     // this point, since we checked the stack on entry and haven't
     // pushed anything since, that we haven't also popped again.
 
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
@@ skipping 15 matching lines @@
     __ bind(&stack_overflow_label_);
     // Reached if the backtrack-stack limit has been hit.
 
     Label grow_failed;
     // Save registers before calling C function
     __ push(esi);
     __ push(edi);
 
     // Call GrowStack(backtrack_stackpointer())
     int num_arguments = 1;
-    FrameAlign(num_arguments);
+    FrameAlign(num_arguments, ebx);
     __ mov(Operand(esp, 0), backtrack_stackpointer());
     CallCFunction(FUNCTION_ADDR(&GrowStack), num_arguments);
     // If return NULL, we have failed to grow the stack, and
     // must exit with a stack-overflow exception.
     __ or_(eax, Operand(eax));
     __ j(equal, &exit_with_exception);
     // Otherwise use return value as new stack pointer.
     __ mov(backtrack_stackpointer(), eax);
     // Restore saved registers and continue.
     __ pop(edi);
@@ skipping 343 matching lines @@
     __ cmp(backtrack_stackpointer(), Operand::StaticVariable(stack_limit));
     __ j(above, &no_stack_overflow);
 
     SafeCall(&stack_overflow_label_);
 
     __ bind(&no_stack_overflow);
   }
 }
 
 
-void RegExpMacroAssemblerIA32::FrameAlign(int num_arguments) {
+void RegExpMacroAssemblerIA32::FrameAlign(int num_arguments, Register scratch) {
   int frameAlignment = OS::ActivationFrameAlignment();
   if (frameAlignment != 0) {
     // Make stack end at alignment and make room for num_arguments words
     // and the original value of esp.
-    __ mov(ebx, esp);
+    __ mov(scratch, esp);
     __ sub(Operand(esp), Immediate((num_arguments + 1) * kPointerSize));
     ASSERT(IsPowerOf2(frameAlignment));
     __ and_(esp, -frameAlignment);
-    __ mov(Operand(esp, num_arguments * kPointerSize), ebx);
+    __ mov(Operand(esp, num_arguments * kPointerSize), scratch);
   } else {
     __ sub(Operand(esp), Immediate(num_arguments * kPointerSize));
   }
 }
 
 
 void RegExpMacroAssemblerIA32::CallCFunction(Address function_address,
                                              int num_arguments) {
   __ mov(Operand(eax), Immediate(reinterpret_cast<int32_t>(function_address)));
   __ call(Operand(eax));
@@ skipping 31 matching lines @@
 
 
 void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(Register reg,
                                                          ArraySlice* buffer) {
   __ mov(reg, buffer->array());
   __ add(Operand(reg), Immediate(buffer->base_offset()));
 }
 
 #undef __
 }}  // namespace v8::internal