Don't pass the "at start" parameter to native RegExp...

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

 // Copyright 2009 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 45 matching lines @@
  * - r13/sp : points to tip of C stack.
  *
  * The remaining registers are free for computations.
  *
  * Each call to a public method should retain this convention.
  * The stack will have the following structure:
  *       - direct_call        (if 1, direct call from JavaScript code, if 0 call
  *                             through the runtime system)
  *       - stack_area_base    (High end of the memory area to use as
  *                             backtracking stack)
- *       - at_start           (if 1, we are starting at the start of the
- *                             string, otherwise 0)
  *       - int* capture_array (int[num_saved_registers_], for output).
  *       --- sp when called ---
  *       - link address
  *       - backup of registers r4..r11
  *       - end of input       (Address of end of string)
  *       - start of input     (Address of first character in string)
  *       - start index        (character index of start)
  *       --- frame pointer ----
  *       - void* input_string (location of a handle containing the string)
  *       - Offset of location before start of input (effectively character
  *         position -1). Used to initialize capture registers to a non-position.
+ *       - At start (if 1, we are starting at the start of the
+ *         string, otherwise 0)
  *       - register 0         (Only positions must be stored in the first
  *       - register 1          num_saved_registers_ registers)
  *       - ...
  *       - register num_registers-1
  *       --- sp ---
  *
  * The first num_saved_registers_ registers are initialized to point to
  * "character -1" in the string (i.e., char_size() bytes before the first
  * character of the string). The remaining registers start out as garbage.
  *
@@ skipping 514 matching lines @@
   // Save callee-save registers.
   // Start new stack frame.
   // Order here should correspond to order of offset constants in header file.
   RegList registers_to_retain = r4.bit() | r5.bit() | r6.bit() |
       r7.bit() | r8.bit() | r9.bit() | r10.bit() | fp.bit();
   RegList argument_registers = r0.bit() | r1.bit() | r2.bit() | r3.bit();
   __ stm(db_w, sp, argument_registers | registers_to_retain | lr.bit());
   // Set frame pointer just above the arguments.
   __ add(frame_pointer(), sp, Operand(4 * kPointerSize));
   __ push(r0);  // Make room for "position - 1" constant (value is irrelevant).
+  __ push(r0);  // Make room for "at start" constant (value is irrelevant).
 
   // Check if we have space on the stack for registers.
   Label stack_limit_hit;
   Label stack_ok;
 
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit();
   __ mov(r0, Operand(stack_limit));
   __ ldr(r0, MemOperand(r0));
   __ sub(r0, sp, r0, SetCC);
@@ skipping 23 matching lines @@
   // Load input start.
   __ ldr(r0, MemOperand(frame_pointer(), kInputStart));
   // Find negative length (offset of start relative to end).
   __ sub(current_input_offset(), r0, end_of_input_address());
   // Set r0 to address of char before start of input
   // (effectively string position -1).
   __ sub(r0, current_input_offset(), Operand(char_size()));
   // Store this value in a local variable, for use when clearing
   // position registers.
   __ str(r0, MemOperand(frame_pointer(), kInputStartMinusOne));
+
+  // Determine whether the start index is zero, that is at the start of the
+  // string, and store that value in a local variable.
+  __ ldr(r1, MemOperand(frame_pointer(), kStartIndex));
+  __ tst(r1, Operand(r1));
+  __ mov(r1, Operand(1), LeaveCC, eq);
+  __ mov(r1, Operand(0), LeaveCC, ne);
+  __ str(r1, MemOperand(frame_pointer(), kAtStart));
+
   if (num_saved_registers_ > 0) {  // Always is, if generated from a regexp.
     // Fill saved registers with initial value = start offset - 1
 
     // Address of register 0.
     __ add(r1, frame_pointer(), Operand(kRegisterZero));
     __ mov(r2, Operand(num_saved_registers_));
     Label init_loop;
     __ bind(&init_loop);
     __ str(r0, MemOperand(r1, kPointerSize, NegPostIndex));
     __ sub(r2, r2, Operand(1), SetCC);
@@ skipping 581 matching lines @@
   __ mov(r0, sp);
   __ Call(r5);
   __ ldr(pc, MemOperand(sp, stack_alignment, PostIndex));
 }
 
 #undef __
 
 #endif  // V8_NATIVE_REGEXP
 
 }}  // namespace v8::internal