Make not sucking at regexp the default...

src/x64/codegen-x64.cc

 // Copyright 2010 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 6926 matching lines @@
     default:
       UNREACHABLE();
   }
 }
 
 
 void RegExpExecStub::Generate(MacroAssembler* masm) {
   // Just jump directly to runtime if native RegExp is not selected at compile
   // time or if regexp entry in generated code is turned off runtime switch or
   // at compilation.
-#ifndef V8_NATIVE_REGEXP
+#ifdef V8_INTERPRETED_REGEXP
   __ TailCallRuntime(Runtime::kRegExpExec, 4, 1);
-#else  // V8_NATIVE_REGEXP
+#else  // V8_INTERPRETED_REGEXP
   if (!FLAG_regexp_entry_native) {
     __ TailCallRuntime(Runtime::kRegExpExec, 4, 1);
     return;
   }
 
   // Stack frame on entry.
   //  esp[0]: return address
   //  esp[8]: last_match_info (expected JSArray)
   //  esp[16]: previous index
   //  esp[24]: subject string
@@ skipping 320 matching lines @@
   __ jmp(&next_capture);
   __ bind(&done);
 
   // Return last match info.
   __ movq(rax, Operand(rsp, kLastMatchInfoOffset));
   __ ret(4 * kPointerSize);
 
   // Do the runtime call to execute the regexp.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kRegExpExec, 4, 1);
-#endif  // V8_NATIVE_REGEXP
+#endif  // V8_INTERPRETED_REGEXP
 }
 
 
 void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm,
                                                          Register object,
                                                          Register result,
                                                          Register scratch1,
                                                          Register scratch2,
                                                          bool object_is_smi,
                                                          Label* not_found) {
@@ skipping 573 matching lines @@
   //      callee-saved register.
 
   // Simple results returned in rax (both AMD64 and Win64 calling conventions).
   // Complex results must be written to address passed as first argument.
   // AMD64 calling convention: a struct of two pointers in rax+rdx
 
   if (do_gc) {
     // Pass failure code returned from last attempt as first argument to GC.
 #ifdef _WIN64
     __ movq(rcx, rax);
-#else  // ! defined(_WIN64)
+#else  // _WIN64
     __ movq(rdi, rax);
 #endif
     __ movq(kScratchRegister,
             FUNCTION_ADDR(Runtime::PerformGC),
             RelocInfo::RUNTIME_ENTRY);
     __ call(kScratchRegister);
   }
 
   ExternalReference scope_depth =
       ExternalReference::heap_always_allocate_scope_depth();
@@ skipping 13 matching lines @@
     // Return result in single register (rax).
     __ lea(rcx, Operand(rsp, 4 * kPointerSize));
   } else {
     ASSERT_EQ(2, result_size_);
     // Pass a pointer to the result location as the first argument.
     __ lea(rcx, Operand(rsp, 6 * kPointerSize));
     // Pass a pointer to the Arguments object as the second argument.
     __ lea(rdx, Operand(rsp, 4 * kPointerSize));
   }
 
-#else  // ! defined(_WIN64)
+#else  // _WIN64
   // GCC passes arguments in rdi, rsi, rdx, rcx, r8, r9.
   __ movq(rdi, r14);  // argc.
   __ movq(rsi, r15);  // argv.
 #endif

[Søren Thygesen Gjesse, 2010/04/19 19:59:12]

Comment here as well.

   __ call(rbx);
   // Result is in rax - do not destroy this register!
 
   if (always_allocate_scope) {
     __ movq(kScratchRegister, scope_depth);
     __ decl(Operand(kScratchRegister, 0));
   }
 
   // Check for failure result.
   Label failure_returned;
@@ skipping 2124 matching lines @@
   // Call the function from C++.
   return FUNCTION_CAST<ModuloFunction>(buffer);
 }
 
 #endif
 
 
 #undef __
 
 } }  // namespace v8::internal