Fixes to IA32 code generator to cope with new

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 132 matching lines @@
   __ sub(Operand(eax), Immediate(start));
   __ cmp(eax, 64);  // FIXME: 64 = length_of_bitmap_in_bits.
   BranchOrBacktrack(greater_equal, on_zero);
   __ mov(ebx, eax);
   __ shr(ebx, 3);
   // TODO(lrn): Where is the bitmap stored? Pass the bitmap as argument instead.
   // __ mov(ecx, position_of_bitmap);
   __ movzx_b(ebx, Operand(ecx, ebx, times_1, 0));
   __ and_(eax, (1<<3)-1);
   __ bt(Operand(ebx), eax);
-  __ j(carry, on_zero);
+  BranchOrBacktrack(carry, on_zero);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCharacter(uc16 c, Label* on_equal) {
   __ cmp(current_character(), c);
   BranchOrBacktrack(equal, on_equal);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCharacterGT(uc16 limit, Label* on_greater) {
@@ skipping 32 matching lines @@
   if (str.length() <= kMaxInlineStringTests) {
     for (int i = 0; i < str.length(); i++) {
       if (mode_ == ASCII) {
         __ cmpb(Operand(esi, edi, times_1, byte_offset + i),
                 static_cast<int8_t>(str[i]));
       } else {
         ASSERT(mode_ == UC16);
         __ cmpw(Operand(esi, edi, times_1, byte_offset + i * sizeof(uc16)),
                 Immediate(str[i]));
       }
-      __ j(not_equal, on_failure);
+      BranchOrBacktrack(not_equal, on_failure);
     }
     return;
   }
 
   ArraySlice constant_buffer = constants_.GetBuffer(str.length(), char_size());
   if (mode_ == ASCII) {
     for (int i = 0; i < str.length(); i++) {
       constant_buffer.at<char>(i) = static_cast<char>(str[i]);
     }
   } else {
@@ skipping 350 matching lines @@
   Handle<Code> code = Factory::NewCode(code_desc,
                                        NULL,
                                        Code::ComputeFlags(Code::REGEXP),
                                        self_);
   LOG(CodeCreateEvent("RegExp", *code, *(source->ToCString())));
   return Handle<Object>::cast(code);
 }
 
 
 void RegExpMacroAssemblerIA32::GoTo(Label* to) {
-  __ jmp(to);
+  BranchOrBacktrack(no_condition, to);
 }
 
 
 void RegExpMacroAssemblerIA32::IfRegisterGE(int reg,
                                             int comparand,
                                             Label* if_ge) {
   __ cmp(register_location(reg), Immediate(comparand));
   BranchOrBacktrack(greater_equal, if_ge);
 }
 
@@ skipping 67 matching lines @@
 void RegExpMacroAssemblerIA32::Succeed() {
   __ jmp(&success_label_);
 }
 
 
 void RegExpMacroAssemblerIA32::WriteCurrentPositionToRegister(int reg,
                                                               int cp_offset) {
   if (cp_offset == 0) {
     __ mov(register_location(reg), edi);
   } else {
-    __ lea(eax, Operand(edi, cp_offset));
+    if (mode_ == ASCII) {
+      __ lea(eax, Operand(edi, cp_offset));

[Lasse Reichstein, 2008/12/08 10:25:44]

You can use char_size() to generalize code that only differ on character size,
not opcode, without switching on mode:
 __ lea(eax, Operand(edi, cp_offset * char_size());

+    } else {
+      ASSERT(mode_ == UC16);
+      __ lea(eax, Operand(edi, 2 * cp_offset));
+    }
     __ mov(register_location(reg), eax);
   }
 }
 
 
 void RegExpMacroAssemblerIA32::WriteStackPointerToRegister(int reg) {
   __ mov(register_location(reg), esp);
 }
 
 
@@ skipping 119 matching lines @@
 
 
 void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(Register reg,
                                                          ArraySlice* buffer) {
   __ mov(reg, buffer->array());
   __ add(Operand(reg), Immediate(buffer->base_offset()));
 }
 
 #undef __
 }}  // namespace v8::internal