Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 17 | #include <ctime> |
| 18 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 19 | #include "object.h" |
| 20 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 21 | #include "art_field.h" |
| 22 | #include "art_field-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 23 | #include "array-inl.h" |
| 24 | #include "class.h" |
| 25 | #include "class-inl.h" |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 26 | #include "class_linker-inl.h" |
Elliott Hughes | 956af0f | 2014-12-11 14:34:28 -0800 | [diff] [blame] | 27 | #include "dex_file-inl.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 28 | #include "gc/accounting/card_table-inl.h" |
| 29 | #include "gc/heap.h" |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 30 | #include "iftable-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 31 | #include "monitor.h" |
| 32 | #include "object-inl.h" |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 33 | #include "object_array-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 34 | #include "runtime.h" |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 35 | #include "handle_scope-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 36 | #include "throwable.h" |
| 37 | #include "well_known_classes.h" |
| 38 | |
| 39 | namespace art { |
| 40 | namespace mirror { |
| 41 | |
tony.ys_liu | 7380c31 | 2015-01-16 19:16:45 +0800 | [diff] [blame] | 42 | Atomic<uint32_t> Object::hash_code_seed(987654321U + std::time(nullptr)); |
| 43 | |
Hiroshi Yamauchi | 7971928 | 2014-04-10 12:46:22 -0700 | [diff] [blame] | 44 | class CopyReferenceFieldsWithReadBarrierVisitor { |
| 45 | public: |
| 46 | explicit CopyReferenceFieldsWithReadBarrierVisitor(Object* dest_obj) |
| 47 | : dest_obj_(dest_obj) {} |
| 48 | |
| 49 | void operator()(Object* obj, MemberOffset offset, bool /* is_static */) const |
| 50 | ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 51 | // GetFieldObject() contains a RB. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 52 | Object* ref = obj->GetFieldObject<Object>(offset); |
Hiroshi Yamauchi | 7971928 | 2014-04-10 12:46:22 -0700 | [diff] [blame] | 53 | // No WB here as a large object space does not have a card table |
| 54 | // coverage. Instead, cards will be marked separately. |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 55 | dest_obj_->SetFieldObjectWithoutWriteBarrier<false, false>(offset, ref); |
Hiroshi Yamauchi | 7971928 | 2014-04-10 12:46:22 -0700 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | void operator()(mirror::Class* klass, mirror::Reference* ref) const |
| 59 | ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 60 | // Copy java.lang.ref.Reference.referent which isn't visited in |
| 61 | // Object::VisitReferences(). |
Fred Shih | 4ee7a66 | 2014-07-11 09:59:27 -0700 | [diff] [blame] | 62 | DCHECK(klass->IsTypeOfReferenceClass()); |
Hiroshi Yamauchi | 7971928 | 2014-04-10 12:46:22 -0700 | [diff] [blame] | 63 | this->operator()(ref, mirror::Reference::ReferentOffset(), false); |
| 64 | } |
| 65 | |
| 66 | private: |
| 67 | Object* const dest_obj_; |
| 68 | }; |
| 69 | |
Hiroshi Yamauchi | 0fbd6e6 | 2014-07-17 16:16:31 -0700 | [diff] [blame] | 70 | Object* Object::CopyObject(Thread* self, mirror::Object* dest, mirror::Object* src, |
| 71 | size_t num_bytes) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 72 | // Copy instance data. We assume memcpy copies by words. |
| 73 | // TODO: expose and use move32. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 74 | uint8_t* src_bytes = reinterpret_cast<uint8_t*>(src); |
| 75 | uint8_t* dst_bytes = reinterpret_cast<uint8_t*>(dest); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 76 | size_t offset = sizeof(Object); |
| 77 | memcpy(dst_bytes + offset, src_bytes + offset, num_bytes - offset); |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 78 | if (kUseReadBarrier) { |
Hiroshi Yamauchi | 7971928 | 2014-04-10 12:46:22 -0700 | [diff] [blame] | 79 | // We need a RB here. After the memcpy that covers the whole |
| 80 | // object above, copy references fields one by one again with a |
| 81 | // RB. TODO: Optimize this later? |
| 82 | CopyReferenceFieldsWithReadBarrierVisitor visitor(dest); |
| 83 | src->VisitReferences<true>(visitor, visitor); |
| 84 | } |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 85 | gc::Heap* heap = Runtime::Current()->GetHeap(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 86 | // Perform write barriers on copied object references. |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 87 | Class* c = src->GetClass(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 88 | if (c->IsArrayClass()) { |
| 89 | if (!c->GetComponentType()->IsPrimitive()) { |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 90 | ObjectArray<Object>* array = dest->AsObjectArray<Object>(); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 91 | heap->WriteBarrierArray(dest, 0, array->GetLength()); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 92 | } |
| 93 | } else { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 94 | heap->WriteBarrierEveryFieldOf(dest); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 95 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 96 | if (c->IsFinalizable()) { |
Mathieu Chartier | 8668c3c | 2014-04-24 16:48:11 -0700 | [diff] [blame] | 97 | heap->AddFinalizerReference(self, &dest); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 98 | } |
| 99 | return dest; |
| 100 | } |
| 101 | |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 102 | // An allocation pre-fence visitor that copies the object. |
| 103 | class CopyObjectVisitor { |
| 104 | public: |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 105 | explicit CopyObjectVisitor(Thread* self, Handle<Object>* orig, size_t num_bytes) |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 106 | : self_(self), orig_(orig), num_bytes_(num_bytes) { |
| 107 | } |
| 108 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 109 | void operator()(Object* obj, size_t usable_size ATTRIBUTE_UNUSED) const |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 110 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
Hiroshi Yamauchi | 0fbd6e6 | 2014-07-17 16:16:31 -0700 | [diff] [blame] | 111 | Object::CopyObject(self_, obj, orig_->Get(), num_bytes_); |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 112 | } |
| 113 | |
| 114 | private: |
| 115 | Thread* const self_; |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 116 | Handle<Object>* const orig_; |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 117 | const size_t num_bytes_; |
| 118 | DISALLOW_COPY_AND_ASSIGN(CopyObjectVisitor); |
| 119 | }; |
| 120 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 121 | Object* Object::Clone(Thread* self) { |
| 122 | CHECK(!IsClass()) << "Can't clone classes."; |
| 123 | // Object::SizeOf gets the right size even if we're an array. Using c->AllocObject() here would |
| 124 | // be wrong. |
| 125 | gc::Heap* heap = Runtime::Current()->GetHeap(); |
| 126 | size_t num_bytes = SizeOf(); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 127 | StackHandleScope<1> hs(self); |
| 128 | Handle<Object> this_object(hs.NewHandle(this)); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 129 | Object* copy; |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 130 | CopyObjectVisitor visitor(self, &this_object, num_bytes); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 131 | if (heap->IsMovableObject(this)) { |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 132 | copy = heap->AllocObject<true>(self, GetClass(), num_bytes, visitor); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 133 | } else { |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame] | 134 | copy = heap->AllocNonMovableObject<true>(self, GetClass(), num_bytes, visitor); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 135 | } |
Mathieu Chartier | 0732d59 | 2013-11-06 11:02:50 -0800 | [diff] [blame] | 136 | return copy; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 137 | } |
| 138 | |
Ian Rogers | bbcd30b | 2014-10-30 15:25:36 -0700 | [diff] [blame] | 139 | uint32_t Object::GenerateIdentityHashCode() { |
Ian Rogers | bbcd30b | 2014-10-30 15:25:36 -0700 | [diff] [blame] | 140 | uint32_t expected_value, new_value; |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 141 | do { |
tony.ys_liu | 7380c31 | 2015-01-16 19:16:45 +0800 | [diff] [blame] | 142 | expected_value = hash_code_seed.LoadRelaxed(); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 143 | new_value = expected_value * 1103515245 + 12345; |
tony.ys_liu | 7380c31 | 2015-01-16 19:16:45 +0800 | [diff] [blame] | 144 | } while (!hash_code_seed.CompareExchangeWeakRelaxed(expected_value, new_value) || |
| 145 | (expected_value & LockWord::kHashMask) == 0); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 146 | return expected_value & LockWord::kHashMask; |
| 147 | } |
| 148 | |
tony.ys_liu | 7380c31 | 2015-01-16 19:16:45 +0800 | [diff] [blame] | 149 | void Object::SetHashCodeSeed(uint32_t new_seed) { |
| 150 | hash_code_seed.StoreRelaxed(new_seed); |
| 151 | } |
| 152 | |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 153 | int32_t Object::IdentityHashCode() const { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 154 | mirror::Object* current_this = const_cast<mirror::Object*>(this); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 155 | while (true) { |
Mathieu Chartier | 4d7f61d | 2014-04-17 14:43:39 -0700 | [diff] [blame] | 156 | LockWord lw = current_this->GetLockWord(false); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 157 | switch (lw.GetState()) { |
| 158 | case LockWord::kUnlocked: { |
| 159 | // Try to compare and swap in a new hash, if we succeed we will return the hash on the next |
| 160 | // loop iteration. |
Hiroshi Yamauchi | e15ea08 | 2015-02-09 17:11:42 -0800 | [diff] [blame] | 161 | LockWord hash_word = LockWord::FromHashCode(GenerateIdentityHashCode(), |
| 162 | lw.ReadBarrierState()); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 163 | DCHECK_EQ(hash_word.GetState(), LockWord::kHashCode); |
Hans Boehm | d843443 | 2014-07-11 09:56:07 -0700 | [diff] [blame] | 164 | if (const_cast<Object*>(this)->CasLockWordWeakRelaxed(lw, hash_word)) { |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 165 | return hash_word.GetHashCode(); |
| 166 | } |
| 167 | break; |
| 168 | } |
| 169 | case LockWord::kThinLocked: { |
Ian Rogers | 43c69cc | 2014-08-15 11:09:28 -0700 | [diff] [blame] | 170 | // Inflate the thin lock to a monitor and stick the hash code inside of the monitor. May |
| 171 | // fail spuriously. |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 172 | Thread* self = Thread::Current(); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 173 | StackHandleScope<1> hs(self); |
| 174 | Handle<mirror::Object> h_this(hs.NewHandle(current_this)); |
| 175 | Monitor::InflateThinLocked(self, h_this, lw, GenerateIdentityHashCode()); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 176 | // A GC may have occurred when we switched to kBlocked. |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 177 | current_this = h_this.Get(); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 178 | break; |
| 179 | } |
| 180 | case LockWord::kFatLocked: { |
| 181 | // Already inflated, return the has stored in the monitor. |
| 182 | Monitor* monitor = lw.FatLockMonitor(); |
| 183 | DCHECK(monitor != nullptr); |
| 184 | return monitor->GetHashCode(); |
| 185 | } |
| 186 | case LockWord::kHashCode: { |
| 187 | return lw.GetHashCode(); |
| 188 | } |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 189 | default: { |
| 190 | LOG(FATAL) << "Invalid state during hashcode " << lw.GetState(); |
| 191 | break; |
| 192 | } |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 193 | } |
| 194 | } |
Ian Rogers | 0714083 | 2014-09-30 15:43:59 -0700 | [diff] [blame] | 195 | UNREACHABLE(); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 196 | } |
| 197 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 198 | void Object::CheckFieldAssignmentImpl(MemberOffset field_offset, Object* new_value) { |
| 199 | Class* c = GetClass(); |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 200 | Runtime* runtime = Runtime::Current(); |
| 201 | if (runtime->GetClassLinker() == nullptr || !runtime->IsStarted() || |
| 202 | !runtime->GetHeap()->IsObjectValidationEnabled() || !c->IsResolved()) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 203 | return; |
| 204 | } |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 205 | for (Class* cur = c; cur != nullptr; cur = cur->GetSuperClass()) { |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 206 | ArtField* fields = cur->GetIFields(); |
| 207 | for (size_t i = 0, count = cur->NumInstanceFields(); i < count; ++i) { |
| 208 | StackHandleScope<1> hs(Thread::Current()); |
| 209 | Handle<Object> h_object(hs.NewHandle(new_value)); |
| 210 | ArtField* field = &fields[i]; |
| 211 | if (field->GetOffset().Int32Value() == field_offset.Int32Value()) { |
| 212 | CHECK_NE(field->GetTypeAsPrimitiveType(), Primitive::kPrimNot); |
| 213 | // TODO: resolve the field type for moving GC. |
| 214 | mirror::Class* field_type = field->GetType<!kMovingCollector>(); |
| 215 | if (field_type != nullptr) { |
| 216 | CHECK(field_type->IsAssignableFrom(new_value->GetClass())); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 217 | } |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 218 | return; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 219 | } |
| 220 | } |
| 221 | } |
| 222 | if (c->IsArrayClass()) { |
| 223 | // Bounds and assign-ability done in the array setter. |
| 224 | return; |
| 225 | } |
| 226 | if (IsClass()) { |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 227 | ArtField* fields = AsClass()->GetSFields(); |
| 228 | for (size_t i = 0, count = AsClass()->NumStaticFields(); i < count; ++i) { |
| 229 | ArtField* field = &fields[i]; |
| 230 | if (field->GetOffset().Int32Value() == field_offset.Int32Value()) { |
| 231 | CHECK_NE(field->GetTypeAsPrimitiveType(), Primitive::kPrimNot); |
| 232 | // TODO: resolve the field type for moving GC. |
| 233 | mirror::Class* field_type = field->GetType<!kMovingCollector>(); |
| 234 | if (field_type != nullptr) { |
| 235 | CHECK(field_type->IsAssignableFrom(new_value->GetClass())); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 236 | } |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 237 | return; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 238 | } |
| 239 | } |
| 240 | } |
| 241 | LOG(FATAL) << "Failed to find field for assignment to " << reinterpret_cast<void*>(this) |
| 242 | << " of type " << PrettyDescriptor(c) << " at offset " << field_offset; |
Ian Rogers | 08f1f50 | 2014-12-02 15:04:37 -0800 | [diff] [blame] | 243 | UNREACHABLE(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 244 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 245 | |
Hiroshi Yamauchi | eb2baaf | 2015-05-13 21:14:22 -0700 | [diff] [blame] | 246 | ArtField* Object::FindFieldByOffset(MemberOffset offset) { |
| 247 | return IsClass() ? ArtField::FindStaticFieldWithOffset(AsClass(), offset.Uint32Value()) |
| 248 | : ArtField::FindInstanceFieldWithOffset(GetClass(), offset.Uint32Value()); |
| 249 | } |
| 250 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 251 | } // namespace mirror |
| 252 | } // namespace art |