Provide baseline for experimental GC implementation.

src/ia32/codegen-ia32.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 247 matching lines @@
           ASSERT(!scope()->is_global_scope());
           frame_->PushParameterAt(i);
           Result value = frame_->Pop();
           value.ToRegister();
 
           // SlotOperand loads context.reg() with the context object
           // stored to, used below in RecordWrite.
           Result context = allocator_->Allocate();
           ASSERT(context.is_valid());
           __ mov(SlotOperand(slot, context.reg()), value.reg());
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
           int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
           Result scratch = allocator_->Allocate();
           ASSERT(scratch.is_valid());
           frame_->Spill(context.reg());
           frame_->Spill(value.reg());
           __ RecordWrite(context.reg(), offset, value.reg(), scratch.reg());
+#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 5017 matching lines @@
       //
       // The use of SlotOperand below is safe for an unspilled frame
       // because the slot is a context slot.
       ASSERT(slot->type() == Slot::CONTEXT);
       frame_->Dup();
       Result value = frame_->Pop();
       value.ToRegister();
       Result start = allocator_->Allocate();
       ASSERT(start.is_valid());
       __ mov(SlotOperand(slot, start.reg()), value.reg());
+
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
       // RecordWrite may destroy the value registers.
       //
       // TODO(204): Avoid actually spilling when the value is not
       // needed (probably the common case).
       frame_->Spill(value.reg());
       int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
       Result temp = allocator_->Allocate();
       ASSERT(temp.is_valid());
       __ RecordWrite(start.reg(), offset, value.reg(), temp.reg());
       // The results start, value, and temp are unused by going out of
       // scope.
+#endif
     }
 
     exit.Bind();
   }
 }
 
 
 void CodeGenerator::VisitSlot(Slot* slot) {
   Comment cmnt(masm_, "[ Slot");
   if (in_safe_int32_mode()) {
@@ skipping 366 matching lines @@
     elements.ToRegister();
     frame_->Spill(elements.reg());
     // Get the elements array.
     __ mov(elements.reg(),
            FieldOperand(elements.reg(), JSObject::kElementsOffset));
 
     // Write to the indexed properties array.
     int offset = i * kPointerSize + FixedArray::kHeaderSize;
     __ mov(FieldOperand(elements.reg(), offset), prop_value.reg());
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
     // Update the write barrier for the array address.
     frame_->Spill(prop_value.reg());  // Overwritten by the write barrier.
     Result scratch = allocator_->Allocate();
     ASSERT(scratch.is_valid());
     __ RecordWrite(elements.reg(), offset, prop_value.reg(), scratch.reg());
+#endif
   }
 }
 
 
 void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* node) {
   ASSERT(!in_safe_int32_mode());
   ASSERT(!in_spilled_code());
   // Call runtime routine to allocate the catch extension object and
   // assign the exception value to the catch variable.
   Comment cmnt(masm_, "[ CatchExtensionObject");
@@ skipping 1508 matching lines @@
 
   // It is a heap object - get its map.
   Result scratch = allocator_->Allocate();
   ASSERT(scratch.is_valid());
   // if (!object->IsJSValue()) return value.
   __ CmpObjectType(object.reg(), JS_VALUE_TYPE, scratch.reg());
   leave.Branch(not_equal, &value, not_taken);
 
   // Store the value.
   __ mov(FieldOperand(object.reg(), JSValue::kValueOffset), value.reg());
+
+#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.
   Result duplicate_value = allocator_->Allocate();
   ASSERT(duplicate_value.is_valid());
   __ mov(duplicate_value.reg(), value.reg());
   // The object register is also overwritten by the write barrier and
   // possibly aliased in the frame.
   frame_->Spill(object.reg());
   __ RecordWrite(object.reg(), JSValue::kValueOffset, duplicate_value.reg(),
                  scratch.reg());
+  duplicate_value.Unuse();
+#endif
+
   object.Unuse();
   scratch.Unuse();
-  duplicate_value.Unuse();
 
   // Leave.
   leave.Bind(&value);
   frame_->Push(&value);
 }
 
 
 void CodeGenerator::GenerateArguments(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
 
@@ skipping 249 matching lines @@
   __ lea(ebx, Operand(edx, JSFunctionResultCache::kEntrySize << 1));
   __ mov(FieldOperand(ecx, JSFunctionResultCache::kCacheSizeOffset), ebx);
 
   // Update the cache itself.
   // edx holds the index.
   __ bind(&update_cache);
   __ pop(ebx);  // restore the key
   __ mov(FieldOperand(ecx, JSFunctionResultCache::kFingerOffset), edx);
   // Store key.
   __ mov(CodeGenerator::FixedArrayElementOperand(ecx, edx), ebx);
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   __ RecordWrite(ecx, 0, ebx, edx);
+#endif
 
   // Store value.
   __ pop(ecx);  // restore the cache.
   __ mov(edx, FieldOperand(ecx, JSFunctionResultCache::kFingerOffset));
   __ add(Operand(edx), Immediate(Smi::FromInt(1)));
   __ mov(ebx, eax);
   __ mov(CodeGenerator::FixedArrayElementOperand(ecx, edx), ebx);
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   __ RecordWrite(ecx, 0, ebx, edx);
+#endif
 
   if (!dst_.is(eax)) {
     __ mov(dst_, eax);
   }
 }
 
 
 void CodeGenerator::GenerateGetFromCache(ZoneList<Expression*>* args) {
   ASSERT_EQ(2, args->length());
 
@@ skipping 137 matching lines @@
   // Bring addresses into index1 and index2.
   __ lea(index1.reg(), FixedArrayElementOperand(tmp1.reg(), index1.reg()));
   __ lea(index2.reg(), FixedArrayElementOperand(tmp1.reg(), index2.reg()));
 
   // Swap elements.
   __ mov(object.reg(), Operand(index1.reg(), 0));
   __ mov(tmp2.reg(),   Operand(index2.reg(), 0));
   __ mov(Operand(index2.reg(), 0), object.reg());
   __ mov(Operand(index1.reg(), 0), tmp2.reg());
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   Label done;
   __ InNewSpace(tmp1.reg(), tmp2.reg(), equal, &done);
   // Possible optimization: do a check that both values are Smis
   // (or them and test against Smi mask.)
 
   __ mov(tmp2.reg(), tmp1.reg());
   __ RecordWriteHelper(tmp2.reg(), index1.reg(), object.reg());
   __ RecordWriteHelper(tmp1.reg(), index2.reg(), object.reg());
   __ bind(&done);
+#endif
 
   deferred->BindExit();
   frame_->Push(Factory::undefined_value());
 }
 
 
 void CodeGenerator::GenerateCallFunction(ZoneList<Expression*>* args) {
   Comment cmnt(masm_, "[ GenerateCallFunction");
 
   ASSERT(args->length() >= 2);
@@ skipping 1917 matching lines @@
     // If the receiver and the value share a register allocate a new
     // register for the receiver.
     if (receiver.reg().is(value.reg())) {
       receiver = allocator()->Allocate();
       ASSERT(receiver.is_valid());
       __ mov(receiver.reg(), Operand(value.reg()));
     }
 
     // Update the write barrier. To save instructions in the inlined
     // version we do not filter smis.
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
     Label skip_write_barrier;
     __ InNewSpace(receiver.reg(), value.reg(), equal, &skip_write_barrier);
     int delta_to_record_write = masm_->SizeOfCodeGeneratedSince(&patch_site);
     __ lea(scratch.reg(), Operand(receiver.reg(), offset));
     __ RecordWriteHelper(receiver.reg(), scratch.reg(), value.reg());
     if (FLAG_debug_code) {
       __ mov(receiver.reg(), Immediate(BitCast<int32_t>(kZapValue)));
       __ mov(value.reg(), Immediate(BitCast<int32_t>(kZapValue)));
       __ mov(scratch.reg(), Immediate(BitCast<int32_t>(kZapValue)));
     }
     __ bind(&skip_write_barrier);
+#else
+    // Store some dummy value to avoid short encoding of test instruction.
+    int delta_to_record_write = 0x0001;
+#endif
     value.Unuse();
     scratch.Unuse();
     receiver.Unuse();
     done.Jump(&result);
 
     slow.Bind(&value, &receiver);
     frame()->Push(&receiver);
     frame()->Push(&value);
     result = frame()->CallStoreIC(name, is_contextual);
     // Encode the offset to the map check instruction and the offset
@@ skipping 113 matching lines @@
     // Get the receiver, key and value into registers.
     result = frame()->Pop();
     Result key = frame()->Pop();
     Result receiver = frame()->Pop();
 
     Result tmp = allocator_->Allocate();
     ASSERT(tmp.is_valid());
     Result tmp2 = allocator_->Allocate();
     ASSERT(tmp2.is_valid());
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
     // Determine whether the value is a constant before putting it in a
     // register.
     bool value_is_constant = result.is_constant();
+#endif
 
     // Make sure that value, key and receiver are in registers.
     result.ToRegister();
     key.ToRegister();
     receiver.ToRegister();
 
     DeferredReferenceSetKeyedValue* deferred =
         new DeferredReferenceSetKeyedValue(result.reg(),
                                            key.reg(),
                                            receiver.reg(),
@@ skipping 19 matching lines @@
     // the JSArray are smis. Use unsigned comparison to handle negative keys.
     __ cmp(key.reg(),
            FieldOperand(receiver.reg(), JSArray::kLengthOffset));
     deferred->Branch(above_equal);
 
     // Get the elements array from the receiver and check that it is not a
     // dictionary.
     __ mov(tmp.reg(),
            FieldOperand(receiver.reg(), JSArray::kElementsOffset));
 
+#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
     // Check whether it is possible to omit the write barrier. If the elements
     // array is in new space or the value written is a smi we can safely update
     // the elements array without write barrier.
     Label in_new_space;
     __ InNewSpace(tmp.reg(), tmp2.reg(), equal, &in_new_space);
     if (!value_is_constant) {
       __ test(result.reg(), Immediate(kSmiTagMask));
       deferred->Branch(not_zero);
     }
 
+
     __ bind(&in_new_space);
+#endif
     // Bind the deferred code patch site to be able to locate the fixed
     // array map comparison.  When debugging, we patch this comparison to
     // always fail so that we will hit the IC call in the deferred code
     // which will allow the debugger to break for fast case stores.
     __ bind(deferred->patch_site());
     __ cmp(FieldOperand(tmp.reg(), HeapObject::kMapOffset),
            Immediate(Factory::fixed_array_map()));
     deferred->Branch(not_equal);
 
     // Store the value.
@@ skipping 375 matching lines @@
   memcpy(chunk->GetStartAddress(), desc.buffer, desc.instr_size);
   CPU::FlushICache(chunk->GetStartAddress(), desc.instr_size);
   return FUNCTION_CAST<MemCopyFunction>(chunk->GetStartAddress());
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32