- Pass the knowledge whether the old GC is compacting to the GC prologue and ...

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 81 matching lines @@
     int registers_to_save)
     : masm_(new MacroAssembler(NULL, kRegExpCodeSize)),
       constants_(kRegExpConstantsSize),
       mode_(mode),
       num_registers_(registers_to_save),
       num_saved_registers_(registers_to_save),
       entry_label_(),
       start_label_(),
       success_label_(),
       backtrack_label_(),
-      exit_label_(),
-      self_(Heap::undefined_value()) {
+      exit_label_() {
   __ jmp(&entry_label_);   // We'll write the entry code later.
   __ bind(&start_label_);  // And then continue from here.
 }
 
 
 RegExpMacroAssemblerIA32::~RegExpMacroAssemblerIA32() {
   delete masm_;
   // Unuse labels in case we throw away the assembler without calling GetCode.
   entry_label_.Unuse();
   start_label_.Unuse();
@@ skipping 24 matching lines @@
   if (by != 0) {
     __ add(register_location(reg), Immediate(by));
   }
 }
 
 
 void RegExpMacroAssemblerIA32::Backtrack() {
   CheckPreemption();
   // Pop Code* offset from backtrack stack, add Code* and jump to location.
   Pop(ebx);
-  __ add(Operand(ebx), Immediate(self_));
+  __ add(Operand(ebx), Immediate(masm_->CodeObject()));
   __ jmp(Operand(ebx));
 }
 
 
 void RegExpMacroAssemblerIA32::Bind(Label* label) {
   __ bind(label);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckBitmap(uc16 start,
@@ skipping 495 matching lines @@
   // 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, ebx);
-  __ mov(Operand(esp, 1 * kPointerSize), Immediate(self_));
+  __ mov(Operand(esp, 1 * kPointerSize), Immediate(masm_->CodeObject()));
   __ 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.
   __ mov(eax, EXCEPTION);
@@ skipping 102 matching lines @@
     __ bind(&check_preempt_label_);
 
     __ push(backtrack_stackpointer());
     __ push(edi);
 
     Label retry;
 
     __ bind(&retry);
     int num_arguments = 2;
     FrameAlign(num_arguments, ebx);
-    __ mov(Operand(esp, 1 * kPointerSize), Immediate(self_));
+    __ mov(Operand(esp, 1 * kPointerSize), Immediate(masm_->CodeObject()));
     __ 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();
     // Check if we are still preempted.
@@ skipping 44 matching lines @@
     // Exit with Result EXCEPTION(-1) to signal thrown exception.
     __ mov(eax, EXCEPTION);
     __ jmp(&exit_label_);
   }
 
   CodeDesc code_desc;
   masm_->GetCode(&code_desc);
   Handle<Code> code = Factory::NewCode(code_desc,
                                        NULL,
                                        Code::ComputeFlags(Code::REGEXP),
-                                       self_);
+                                       masm_->CodeObject());
   LOG(CodeCreateEvent("RegExp", *code, *(source->ToCString())));
   return Handle<Object>::cast(code);
 }
 
 
 void RegExpMacroAssemblerIA32::GoTo(Label* to) {
   BranchOrBacktrack(no_condition, to);
 }
 
 
@@ skipping 269 matching lines @@
 void RegExpMacroAssemblerIA32::SafeCall(Label* to) {
   Label return_to;
   __ push(Immediate::CodeRelativeOffset(&return_to));
   __ jmp(to);
   __ bind(&return_to);
 }
 
 
 void RegExpMacroAssemblerIA32::SafeReturn() {
   __ pop(ebx);
-  __ add(Operand(ebx), Immediate(self_));
+  __ add(Operand(ebx), Immediate(masm_->CodeObject()));
   __ jmp(Operand(ebx));
 }
 
 
 void RegExpMacroAssemblerIA32::Push(Register source) {
   ASSERT(!source.is(backtrack_stackpointer()));
   // Notice: This updates flags, unlike normal Push.
   __ sub(Operand(backtrack_stackpointer()), Immediate(kPointerSize));
   __ mov(Operand(backtrack_stackpointer(), 0), source);
 }
@@ skipping 100 matching lines @@
 
 
 void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(Register reg,
                                                          ArraySlice* buffer) {
   __ mov(reg, buffer->array());
   __ add(Operand(reg), Immediate(buffer->base_offset()));
 }
 
 #undef __
 }}  // namespace v8::internal