Provide baseline for experimental GC implementation.

src/arm/codegen-arm.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 114 matching lines @@
 }
 
 
 TypeInfoCodeGenState::~TypeInfoCodeGenState() {
   owner()->set_type_info(slot_, old_type_info_);
 }
 
 // -------------------------------------------------------------------------
 // CodeGenerator implementation
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
 int CodeGenerator::inlined_write_barrier_size_ = -1;
+#endif
 
 CodeGenerator::CodeGenerator(MacroAssembler* masm)
     : deferred_(8),
       masm_(masm),
       info_(NULL),
       frame_(NULL),
       allocator_(NULL),
       cc_reg_(al),
       state_(NULL),
       loop_nesting_(0),
@@ skipping 103 matching lines @@
       // the function.
       frame_->AssertIsSpilled();
       for (int i = 0; i < scope()->num_parameters(); i++) {
         Variable* par = scope()->parameter(i);
         Slot* slot = par->AsSlot();
         if (slot != NULL && slot->type() == Slot::CONTEXT) {
           ASSERT(!scope()->is_global_scope());  // No params in global scope.
           __ ldr(r1, frame_->ParameterAt(i));
           // Loads r2 with context; used below in RecordWrite.
           __ str(r1, SlotOperand(slot, r2));
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
           // Load the offset into r3.
           int slot_offset =
               FixedArray::kHeaderSize + slot->index() * kPointerSize;
           __ RecordWrite(r2, Operand(slot_offset), r3, r1);
+#endif
         }
       }
     }
 
     // Store the arguments object.  This must happen after context
     // initialization because the arguments object may be stored in
     // the context.
     if (ArgumentsMode() != NO_ARGUMENTS_ALLOCATION) {
       StoreArgumentsObject(true);
     }
@@ skipping 3055 matching lines @@
     // calling this code.  r2 may be loaded with context; used below in
     // RecordWrite.
     Register tos = frame_->Peek();
     __ str(tos, SlotOperand(slot, scratch));
     if (slot->type() == Slot::CONTEXT) {
       // Skip write barrier if the written value is a smi.
       __ tst(tos, Operand(kSmiTagMask));
       // We don't use tos any more after here.
       exit.Branch(eq);
       // scratch is loaded with context when calling SlotOperand above.
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
       int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
       // We need an extra register.  Until we have a way to do that in the
       // virtual frame we will cheat and ask for a free TOS register.
       Register scratch3 = frame_->GetTOSRegister();
       __ RecordWrite(scratch, Operand(offset), scratch2, scratch3);
+#endif
     }
     // If we definitely did not jump over the assignment, we do not need
     // to bind the exit label.  Doing so can defeat peephole
     // optimization.
     if (init_state == CONST_INIT || slot->type() == Slot::CONTEXT) {
       exit.Bind();
     }
   }
 }
 
@@ skipping 367 matching lines @@
     // Fetch the object literal.
     frame_->SpillAllButCopyTOSToR1();
 
     // Get the elements array.
     __ ldr(r1, FieldMemOperand(r1, JSObject::kElementsOffset));
 
     // Write to the indexed properties array.
     int offset = i * kPointerSize + FixedArray::kHeaderSize;
     __ str(r0, FieldMemOperand(r1, offset));
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
     // Update the write barrier for the array address.
     __ RecordWrite(r1, Operand(offset), r3, r2);
+#endif
   }
   ASSERT_EQ(original_height + 1, frame_->height());
 }
 
 
 void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   // Call runtime routine to allocate the catch extension object and
@@ skipping 799 matching lines @@
   Register value = frame_->PopToRegister();
   Register object = frame_->PopToRegister(value);
   // if (object->IsSmi()) return object.
   __ tst(object, Operand(kSmiTagMask));
   leave.Branch(eq);
   // It is a heap object - get map. If (!object->IsJSValue()) return the object.
   __ CompareObjectType(object, scratch1, scratch1, JS_VALUE_TYPE);
   leave.Branch(ne);
   // Store the value.
   __ str(value, FieldMemOperand(object, JSValue::kValueOffset));
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   // Update the write barrier.
   __ RecordWrite(object,
                  Operand(JSValue::kValueOffset - kHeapObjectTag),
                  scratch1,
                  scratch2);
+#endif
   // Leave.
   leave.Bind();
   frame_->EmitPush(value);
 }
 
 
 void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   Load(args->at(0));
   Register reg = frame_->PopToRegister();
@@ skipping 1033 matching lines @@
   __ add(index2, tmp2, Operand(index2, LSL, kPointerSizeLog2 - kSmiTagSize));
 
   // Swap elements.
   Register tmp3 = object;
   object = no_reg;
   __ ldr(tmp3, MemOperand(tmp1, index1));
   __ ldr(tmp2, MemOperand(tmp1, index2));
   __ str(tmp3, MemOperand(tmp1, index2));
   __ str(tmp2, MemOperand(tmp1, index1));
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   Label done;
   __ InNewSpace(tmp1, tmp2, eq, &done);
   // Possible optimization: do a check that both values are Smis
   // (or them and test against Smi mask.)
 
   __ mov(tmp2, tmp1);
   RecordWriteStub recordWrite1(tmp1, index1, tmp3);
   __ CallStub(&recordWrite1);
 
   RecordWriteStub recordWrite2(tmp2, index2, tmp3);
   __ CallStub(&recordWrite2);
 
   __ bind(&done);
+#endif
 
   deferred->BindExit();
   __ LoadRoot(tmp1, Heap::kUndefinedValueRootIndex);
   frame_->EmitPush(tmp1);
 }
 
 
 void CodeGenerator::GenerateCallFunction(ZoneList<Expression*>* args) {
   Comment cmnt(masm_, "[ GenerateCallFunction");
 
@@ skipping 1325 matching lines @@
       __ mov(scratch0, Operand(Factory::null_value()));
       __ cmp(scratch0, scratch1);
       deferred->Branch(ne);
 
       int offset = 0;
       __ str(value, MemOperand(receiver, offset));
 
       // Update the write barrier and record its size. We do not use
       // the RecordWrite macro here because we want the offset
       // addition instruction first to make it easy to patch.
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
       Label record_write_start, record_write_done;
       __ bind(&record_write_start);
       // Add offset into the object.
       __ add(scratch0, receiver, Operand(offset));
       // Test that the object is not in the new space.  We cannot set
       // region marks for new space pages.
       __ InNewSpace(receiver, scratch1, eq, &record_write_done);
       // Record the actual write.
       __ RecordWriteHelper(receiver, scratch0, scratch1);
       __ bind(&record_write_done);
       // Clobber all input registers when running with the debug-code flag
       // turned on to provoke errors.
       if (FLAG_debug_code) {
         __ mov(receiver, Operand(BitCast<int32_t>(kZapValue)));
         __ mov(scratch0, Operand(BitCast<int32_t>(kZapValue)));
         __ mov(scratch1, Operand(BitCast<int32_t>(kZapValue)));
       }
       // Check that this is the first inlined write barrier or that
       // this inlined write barrier has the same size as all the other
       // inlined write barriers.
       ASSERT((inlined_write_barrier_size_ == -1) ||
              (inlined_write_barrier_size_ ==
               masm()->InstructionsGeneratedSince(&record_write_start)));
       inlined_write_barrier_size_ =
           masm()->InstructionsGeneratedSince(&record_write_start);
+#endif
 
       // Make sure that the expected number of instructions are generated.
       ASSERT_EQ(GetInlinedNamedStoreInstructionsAfterPatch(),
                 masm()->InstructionsGeneratedSince(&check_inlined_codesize));
     }
     deferred->BindExit();
   }
   ASSERT_EQ(expected_height, frame()->height());
 }
 
@@ skipping 362 matching lines @@
                BinaryOpIC::GetName(runtime_operands_type_));
   return name_;
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM