Fixes to RegExp-IA32.

src/jsregexp.cc

 // Copyright 2006-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 24 matching lines @@
 #include "factory.h"
 #include "jsregexp-inl.h"
 #include "platform.h"
 #include "runtime.h"
 #include "top.h"
 #include "compilation-cache.h"
 #include "string-stream.h"
 #include "parser.h"
 #include "assembler-irregexp.h"
 #include "regexp-macro-assembler.h"
+#include "regexp-macro-assembler-tracer.h"
 #include "regexp-macro-assembler-irregexp.h"
 
 #ifdef ARM
 #include "regexp-macro-assembler-arm.h"
 #else  // IA32
 #include "macro-assembler-ia32.h"
 #include "regexp-macro-assembler-ia32.h"
 #endif
 
 #include "interpreter-irregexp.h"
@@ skipping 882 matching lines @@
       ignore_case_(ignore_case) {
   accept_ = new EndNode(EndNode::ACCEPT);
   backtrack_ = new EndNode(EndNode::BACKTRACK);
 }
 
 
 Handle<FixedArray> RegExpCompiler::Assemble(
     RegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     int capture_count) {
-  macro_assembler_ = macro_assembler;
+#ifdef DEBUG
+  if (FLAG_trace_regexp_assembler) {
+    macro_assembler_ = new RegExpMacroAssemblerTracer(macro_assembler);
+  } else
+#endif
+    macro_assembler_ = macro_assembler;
   List <RegExpNode*> work_list(0);
   work_list_ = &work_list;
   Label fail;
-  macro_assembler->PushBacktrack(&fail);
+  macro_assembler_->PushBacktrack(&fail);
   if (!start->GoTo(this)) {
     fail.Unuse();
     return Handle<FixedArray>::null();
   }
   while (!work_list.is_empty()) {
     if (!work_list.RemoveLast()->GoTo(this)) {
       fail.Unuse();
       return Handle<FixedArray>::null();
     }
   }
-  macro_assembler->Bind(&fail);
-  macro_assembler->Fail();
+  macro_assembler_->Bind(&fail);
+  macro_assembler_->Fail();
   Handle<FixedArray> array =
       Factory::NewFixedArray(RegExpImpl::kIrregexpDataLength);
   array->set(RegExpImpl::kIrregexpImplementationIndex,
-             Smi::FromInt(macro_assembler->Implementation()));
+             Smi::FromInt(macro_assembler_->Implementation()));
   array->set(RegExpImpl::kIrregexpNumberOfRegistersIndex,
              Smi::FromInt(next_register_));
   array->set(RegExpImpl::kIrregexpNumberOfCapturesIndex,
              Smi::FromInt(capture_count));
-  Handle<Object> code = macro_assembler->GetCode();
+  Handle<Object> code = macro_assembler_->GetCode();
   array->set(RegExpImpl::kIrregexpCodeIndex, *code);
   work_list_ = NULL;
+#ifdef DEBUG
+  if (FLAG_trace_regexp_assembler) {
+    delete macro_assembler_;
+  }
+#endif
   return array;
 }
 
 
 bool RegExpNode::GoTo(RegExpCompiler* compiler) {
   // TODO(erikcorry): Implement support.
   if (info_.follows_word_interest ||
       info_.follows_newline_interest ||
       info_.follows_start_interest) {
     return false;
@@ skipping 1664 matching lines @@
   byte codes[1024];
   IrregexpAssembler assembler(Vector<byte>(codes, 1024));
   RegExpMacroAssemblerIrregexp macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count);
 }
 
 
 }}  // namespace v8::internal