Provide baseline for experimental GC implementation.

src/arm/full-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 99 matching lines @@
     for (int i = 0; i < num_parameters; i++) {
       Slot* slot = scope()->parameter(i)->AsSlot();
       if (slot != NULL && slot->type() == Slot::CONTEXT) {
         int parameter_offset = StandardFrameConstants::kCallerSPOffset +
             (num_parameters - 1 - i) * kPointerSize;
         // Load parameter from stack.
         __ ldr(r0, MemOperand(fp, parameter_offset));
         // Store it in the context.
         __ mov(r1, Operand(Context::SlotOffset(slot->index())));
         __ str(r0, MemOperand(cp, r1));
+
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
         // Update the write barrier. This clobbers all involved
         // registers, so we have to use two more registers to avoid
         // clobbering cp.
         __ mov(r2, Operand(cp));
         __ RecordWrite(r2, Operand(r1), r3, r0);
+#endif
       }
     }
   }
 
   Variable* arguments = scope()->arguments();
   if (arguments != NULL) {
     // Function uses arguments object.
     Comment cmnt(masm_, "[ Allocate arguments object");
     if (!function_in_register) {
       // Load this again, if it's used by the local context below.
@@ skipping 410 matching lines @@
 
 
 void FullCodeGenerator::Move(Slot* dst,
                              Register src,
                              Register scratch1,
                              Register scratch2) {
   ASSERT(dst->type() != Slot::LOOKUP);  // Not yet implemented.
   ASSERT(!scratch1.is(src) && !scratch2.is(src));
   MemOperand location = EmitSlotSearch(dst, scratch1);
   __ str(src, location);
+
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   // Emit the write barrier code if the location is in the heap.
   if (dst->type() == Slot::CONTEXT) {
     __ RecordWrite(scratch1,
                    Operand(Context::SlotOffset(dst->index())),
                    scratch2,
                    src);
   }
+#endif
 }
 
 
 void FullCodeGenerator::PrepareForBailoutBeforeSplit(State state,
                                                      bool should_normalize,
                                                      Label* if_true,
                                                      Label* if_false) {
   // Only prepare for bailouts before splits if we're in a test
   // context. Otherwise, we let the Visit function deal with the
   // preparation to avoid preparing with the same AST id twice.
@@ skipping 50 matching lines @@
           __ cmp(r1, cp);
           __ Check(eq, "Unexpected declaration in current context.");
         }
         if (mode == Variable::CONST) {
           __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
           __ str(ip, ContextOperand(cp, slot->index()));
           // No write barrier since the_hole_value is in old space.
         } else if (function != NULL) {
           VisitForAccumulatorValue(function);
           __ str(result_register(), ContextOperand(cp, slot->index()));
+
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
           int offset = Context::SlotOffset(slot->index());

[Erik Corry, 2010/12/14 21:05:26]

Seems like this ifdef and about 10 others could have been avoided if we had just
put the ifdef in RecordWrite.  Also there's nothing CARDMARKING about this code.
 Any other write barrier that uses the same number of registers could be called
here.

           // We know that we have written a function, which is not a smi.
           __ mov(r1, Operand(cp));
           __ RecordWrite(r1, Operand(offset), r2, result_register());
+#endif
         }
         break;
 
       case Slot::LOOKUP: {
         __ mov(r2, Operand(variable->name()));
         // Declaration nodes are always introduced in one of two modes.
         ASSERT(mode == Variable::VAR ||
                mode == Variable::CONST);
         PropertyAttributes attr =
             (mode == Variable::VAR) ? NONE : READ_ONLY;
@@ skipping 699 matching lines @@
       result_saved = true;
     }
     VisitForAccumulatorValue(subexpr);
 
     // Store the subexpression value in the array's elements.
     __ ldr(r1, MemOperand(sp));  // Copy of array literal.
     __ ldr(r1, FieldMemOperand(r1, JSObject::kElementsOffset));
     int offset = FixedArray::kHeaderSize + (i * kPointerSize);
     __ str(result_register(), FieldMemOperand(r1, offset));
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
     // Update the write barrier for the array store with r0 as the scratch
     // register.
     __ RecordWrite(r1, Operand(offset), r2, result_register());
+#endif
 
     PrepareForBailoutForId(expr->GetIdForElement(i), NO_REGISTERS);
   }
 
   if (result_saved) {
     context()->PlugTOS();
   } else {
     context()->Plug(r0);
   }
 }
@@ skipping 265 matching lines @@
         MemOperand target = EmitSlotSearch(slot, r1);
         if (op == Token::INIT_CONST) {
           // Detect const reinitialization by checking for the hole value.
           __ ldr(r2, target);
           __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);
           __ cmp(r2, ip);
           __ b(ne, &done);
         }
         // Perform the assignment and issue the write barrier.
         __ str(result_register(), target);
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
         // RecordWrite may destroy all its register arguments.
         __ mov(r3, result_register());
         int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
         __ RecordWrite(r1, Operand(offset), r2, r3);
+#endif
         break;
       }
 
       case Slot::LOOKUP:
         // Call the runtime for the assignment.  The runtime will ignore
         // const reinitialization.
         __ push(r0);  // Value.
         __ mov(r0, Operand(slot->var()->name()));
         __ Push(cp, r0);  // Context and name.
         if (op == Token::INIT_CONST) {
@@ skipping 881 matching lines @@
   Label done;
   // If the object is a smi, return the value.
   __ BranchOnSmi(r1, &done);
 
   // If the object is not a value type, return the value.
   __ CompareObjectType(r1, r2, r2, JS_VALUE_TYPE);
   __ b(ne, &done);
 
   // Store the value.
   __ str(r0, FieldMemOperand(r1, JSValue::kValueOffset));
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   // Update the write barrier.  Save the value as it will be
   // overwritten by the write barrier code and is needed afterward.
   __ RecordWrite(r1, Operand(JSValue::kValueOffset - kHeapObjectTag), r2, r3);
+#endif
 
   __ bind(&done);
   context()->Plug(r0);
 }
 
 
 void FullCodeGenerator::EmitNumberToString(ZoneList<Expression*>* args) {
   ASSERT_EQ(args->length(), 1);
 
   // Load the argument on the stack and call the stub.
@@ skipping 1030 matching lines @@
   __ mov(r1, Operand(r1, ASR, 1));  // Un-smi-tag value.
   __ add(pc, r1, Operand(masm_->CodeObject()));
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM