Deprecate several unchecked accessors.

src/objects-inl.h

 // Copyright 2012 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 2073 matching lines @@
 void FixedArray::set_the_hole(int index) {
   ASSERT(map() != HEAP->fixed_cow_array_map());
   ASSERT(index >= 0 && index < this->length());
   ASSERT(!HEAP->InNewSpace(HEAP->the_hole_value()));
   WRITE_FIELD(this,
               kHeaderSize + index * kPointerSize,
               GetHeap()->the_hole_value());
 }
 
 
-void FixedArray::set_unchecked(int index, Smi* value) {
-  ASSERT(reinterpret_cast<Object*>(value)->IsSmi());
-  int offset = kHeaderSize + index * kPointerSize;
-  WRITE_FIELD(this, offset, value);
-}
-
-
-void FixedArray::set_unchecked(Heap* heap,
-                               int index,
-                               Object* value,
-                               WriteBarrierMode mode) {
-  int offset = kHeaderSize + index * kPointerSize;
-  WRITE_FIELD(this, offset, value);
-  CONDITIONAL_WRITE_BARRIER(heap, this, offset, value, mode);
-}
-
-
-void FixedArray::set_null_unchecked(Heap* heap, int index) {
-  ASSERT(index >= 0 && index < this->length());
-  ASSERT(!heap->InNewSpace(heap->null_value()));
-  WRITE_FIELD(this, kHeaderSize + index * kPointerSize, heap->null_value());
-}
-
-
 double* FixedDoubleArray::data_start() {
   return reinterpret_cast<double*>(FIELD_ADDR(this, kHeaderSize));
 }
 
 
 Object** FixedArray::data_start() {
   return HeapObject::RawField(this, kHeaderSize);
 }
 
 
@@ skipping 1442 matching lines @@
 void Map::set_dictionary_map(bool value) {
   set_bit_field3(DictionaryMap::update(bit_field3(), value));
 }
 
 
 bool Map::is_dictionary_map() {
   return DictionaryMap::decode(bit_field3());
 }
 
 
-JSFunction* Map::unchecked_constructor() {
-  return reinterpret_cast<JSFunction*>(READ_FIELD(this, kConstructorOffset));
-}
-
-
 Code::Flags Code::flags() {
   return static_cast<Flags>(READ_INT_FIELD(this, kFlagsOffset));
 }
 
 
 inline bool Map::CanTrackAllocationSite() {
   return instance_type() == JS_ARRAY_TYPE;
 }
 
 
@@ skipping 1142 matching lines @@
   set_start_position_and_type((start_position << kStartPositionShift)
     | (start_position_and_type() & ~kStartPositionMask));
 }
 
 
 Code* SharedFunctionInfo::code() {
   return Code::cast(READ_FIELD(this, kCodeOffset));
 }
 
 
-Code* SharedFunctionInfo::unchecked_code() {
-  return reinterpret_cast<Code*>(READ_FIELD(this, kCodeOffset));
-}
-
-
 void SharedFunctionInfo::set_code(Code* value, WriteBarrierMode mode) {
   WRITE_FIELD(this, kCodeOffset, value);
   CONDITIONAL_WRITE_BARRIER(value->GetHeap(), this, kCodeOffset, value, mode);
 }
 
 
 void SharedFunctionInfo::ReplaceCode(Code* value) {
   // If the GC metadata field is already used then the function was
   // enqueued as a code flushing candidate and we remove it now.
   if (code()->gc_metadata() != NULL) {
@@ skipping 516 matching lines @@
 byte* Code::instruction_end()  {
   return instruction_start() + instruction_size();
 }
 
 
 int Code::body_size() {
   return RoundUp(instruction_size(), kObjectAlignment);
 }
 
 
-FixedArray* Code::unchecked_deoptimization_data() {
-  return reinterpret_cast<FixedArray*>(
-      READ_FIELD(this, kDeoptimizationDataOffset));
-}
-
-
 ByteArray* Code::unchecked_relocation_info() {
   return reinterpret_cast<ByteArray*>(READ_FIELD(this, kRelocationInfoOffset));
 }
 
 
 byte* Code::relocation_start() {
   return unchecked_relocation_info()->GetDataStartAddress();
 }
 
 
@@ skipping 55 matching lines @@
 
 
 JSRegExp::Type JSRegExp::TypeTag() {
   Object* data = this->data();
   if (data->IsUndefined()) return JSRegExp::NOT_COMPILED;
   Smi* smi = Smi::cast(FixedArray::cast(data)->get(kTagIndex));
   return static_cast<JSRegExp::Type>(smi->value());
 }
 
 
-JSRegExp::Type JSRegExp::TypeTagUnchecked() {
-  Smi* smi = Smi::cast(DataAtUnchecked(kTagIndex));
-  return static_cast<JSRegExp::Type>(smi->value());
-}
-
-
 int JSRegExp::CaptureCount() {
   switch (TypeTag()) {
     case ATOM:
       return 0;
     case IRREGEXP:
       return Smi::cast(DataAt(kIrregexpCaptureCountIndex))->value();
     default:
       UNREACHABLE();
       return -1;
   }
@@ skipping 15 matching lines @@
   return pattern;
 }
 
 
 Object* JSRegExp::DataAt(int index) {
   ASSERT(TypeTag() != NOT_COMPILED);
   return FixedArray::cast(data())->get(index);
 }
 
 
-Object* JSRegExp::DataAtUnchecked(int index) {
-  FixedArray* fa = reinterpret_cast<FixedArray*>(data());
-  int offset = FixedArray::kHeaderSize + index * kPointerSize;
-  return READ_FIELD(fa, offset);
-}
-
-
 void JSRegExp::SetDataAt(int index, Object* value) {
   ASSERT(TypeTag() != NOT_COMPILED);
   ASSERT(index >= kDataIndex);  // Only implementation data can be set this way.
   FixedArray::cast(data())->set(index, value);
 }
 
 
-void JSRegExp::SetDataAtUnchecked(int index, Object* value, Heap* heap) {
-  ASSERT(index >= kDataIndex);  // Only implementation data can be set this way.
-  FixedArray* fa = reinterpret_cast<FixedArray*>(data());
-  if (value->IsSmi()) {
-    fa->set_unchecked(index, Smi::cast(value));
-  } else {
-    // We only do this during GC, so we don't need to notify the write barrier.
-    fa->set_unchecked(heap, index, value, SKIP_WRITE_BARRIER);
-  }
-}
-
-
 ElementsKind JSObject::GetElementsKind() {
   ElementsKind kind = map()->elements_kind();
 #if DEBUG
   FixedArrayBase* fixed_array =
       reinterpret_cast<FixedArrayBase*>(READ_FIELD(this, kElementsOffset));
   Map* map = fixed_array->map();
   ASSERT((IsFastSmiOrObjectElementsKind(kind) &&
           (map == GetHeap()->fixed_array_map() ||
            map == GetHeap()->fixed_cow_array_map())) ||
          (IsFastDoubleElementsKind(kind) &&
@@ skipping 800 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_