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" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 27 | #include "gc/accounting/card_table-inl.h" |
| 28 | #include "gc/heap.h" |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 29 | #include "iftable-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 30 | #include "monitor.h" |
| 31 | #include "object-inl.h" |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 32 | #include "object_array-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 33 | #include "object_utils.h" |
| 34 | #include "runtime.h" |
| 35 | #include "sirt_ref.h" |
| 36 | #include "throwable.h" |
| 37 | #include "well_known_classes.h" |
| 38 | |
| 39 | namespace art { |
| 40 | namespace mirror { |
| 41 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 42 | static Object* CopyObject(Thread* self, mirror::Object* dest, mirror::Object* src, size_t num_bytes) |
| 43 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 44 | // Copy instance data. We assume memcpy copies by words. |
| 45 | // TODO: expose and use move32. |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 46 | byte* src_bytes = reinterpret_cast<byte*>(src); |
| 47 | byte* dst_bytes = reinterpret_cast<byte*>(dest); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 48 | size_t offset = sizeof(Object); |
| 49 | memcpy(dst_bytes + offset, src_bytes + offset, num_bytes - offset); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 50 | gc::Heap* heap = Runtime::Current()->GetHeap(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 51 | // Perform write barriers on copied object references. |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 52 | Class* c = src->GetClass(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 53 | if (c->IsArrayClass()) { |
| 54 | if (!c->GetComponentType()->IsPrimitive()) { |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 55 | ObjectArray<Object>* array = dest->AsObjectArray<Object>(); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 56 | heap->WriteBarrierArray(dest, 0, array->GetLength()); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 57 | } |
| 58 | } else { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 59 | heap->WriteBarrierEveryFieldOf(dest); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 60 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 61 | if (c->IsFinalizable()) { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 62 | SirtRef<Object> sirt_dest(self, dest); |
| 63 | heap->AddFinalizerReference(self, dest); |
| 64 | return sirt_dest.get(); |
| 65 | } |
| 66 | return dest; |
| 67 | } |
| 68 | |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame^] | 69 | // An allocation pre-fence visitor that copies the object. |
| 70 | class CopyObjectVisitor { |
| 71 | public: |
| 72 | explicit CopyObjectVisitor(Thread* self, SirtRef<Object>* orig, size_t num_bytes) |
| 73 | : self_(self), orig_(orig), num_bytes_(num_bytes) { |
| 74 | } |
| 75 | |
| 76 | void operator()(Object* obj, size_t usable_size) const |
| 77 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 78 | UNUSED(usable_size); |
| 79 | CopyObject(self_, obj, orig_->get(), num_bytes_); |
| 80 | } |
| 81 | |
| 82 | private: |
| 83 | Thread* const self_; |
| 84 | SirtRef<Object>* const orig_; |
| 85 | const size_t num_bytes_; |
| 86 | DISALLOW_COPY_AND_ASSIGN(CopyObjectVisitor); |
| 87 | }; |
| 88 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 89 | Object* Object::Clone(Thread* self) { |
| 90 | CHECK(!IsClass()) << "Can't clone classes."; |
| 91 | // Object::SizeOf gets the right size even if we're an array. Using c->AllocObject() here would |
| 92 | // be wrong. |
| 93 | gc::Heap* heap = Runtime::Current()->GetHeap(); |
| 94 | size_t num_bytes = SizeOf(); |
| 95 | SirtRef<Object> this_object(self, this); |
| 96 | Object* copy; |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame^] | 97 | CopyObjectVisitor visitor(self, &this_object, num_bytes); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 98 | if (heap->IsMovableObject(this)) { |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame^] | 99 | copy = heap->AllocObject<true>(self, GetClass(), num_bytes, visitor); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 100 | } else { |
Hiroshi Yamauchi | 4cd662e | 2014-04-03 16:28:10 -0700 | [diff] [blame^] | 101 | copy = heap->AllocNonMovableObject<true>(self, GetClass(), num_bytes, visitor); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 102 | } |
Mathieu Chartier | 0732d59 | 2013-11-06 11:02:50 -0800 | [diff] [blame] | 103 | return copy; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 104 | } |
| 105 | |
Mathieu Chartier | 4e6a31e | 2013-10-31 10:35:05 -0700 | [diff] [blame] | 106 | int32_t Object::GenerateIdentityHashCode() { |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 107 | static AtomicInteger seed(987654321 + std::time(nullptr)); |
Mathieu Chartier | 4e6a31e | 2013-10-31 10:35:05 -0700 | [diff] [blame] | 108 | int32_t expected_value, new_value; |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 109 | do { |
Ian Rogers | b122a4b | 2013-11-19 18:00:50 -0800 | [diff] [blame] | 110 | expected_value = static_cast<uint32_t>(seed.Load()); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 111 | new_value = expected_value * 1103515245 + 12345; |
Mathieu Chartier | 4e6a31e | 2013-10-31 10:35:05 -0700 | [diff] [blame] | 112 | } while ((expected_value & LockWord::kHashMask) == 0 || |
Ian Rogers | b122a4b | 2013-11-19 18:00:50 -0800 | [diff] [blame] | 113 | !seed.CompareAndSwap(expected_value, new_value)); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 114 | return expected_value & LockWord::kHashMask; |
| 115 | } |
| 116 | |
| 117 | int32_t Object::IdentityHashCode() const { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 118 | mirror::Object* current_this = const_cast<mirror::Object*>(this); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 119 | while (true) { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 120 | LockWord lw = current_this->GetLockWord(); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 121 | switch (lw.GetState()) { |
| 122 | case LockWord::kUnlocked: { |
| 123 | // Try to compare and swap in a new hash, if we succeed we will return the hash on the next |
| 124 | // loop iteration. |
| 125 | LockWord hash_word(LockWord::FromHashCode(GenerateIdentityHashCode())); |
| 126 | DCHECK_EQ(hash_word.GetState(), LockWord::kHashCode); |
| 127 | if (const_cast<Object*>(this)->CasLockWord(lw, hash_word)) { |
| 128 | return hash_word.GetHashCode(); |
| 129 | } |
| 130 | break; |
| 131 | } |
| 132 | case LockWord::kThinLocked: { |
| 133 | // Inflate the thin lock to a monitor and stick the hash code inside of the monitor. |
| 134 | Thread* self = Thread::Current(); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 135 | SirtRef<mirror::Object> sirt_this(self, current_this); |
| 136 | Monitor::InflateThinLocked(self, sirt_this, lw, GenerateIdentityHashCode()); |
| 137 | // A GC may have occurred when we switched to kBlocked. |
| 138 | current_this = sirt_this.get(); |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 139 | break; |
| 140 | } |
| 141 | case LockWord::kFatLocked: { |
| 142 | // Already inflated, return the has stored in the monitor. |
| 143 | Monitor* monitor = lw.FatLockMonitor(); |
| 144 | DCHECK(monitor != nullptr); |
| 145 | return monitor->GetHashCode(); |
| 146 | } |
| 147 | case LockWord::kHashCode: { |
| 148 | return lw.GetHashCode(); |
| 149 | } |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 150 | default: { |
| 151 | LOG(FATAL) << "Invalid state during hashcode " << lw.GetState(); |
| 152 | break; |
| 153 | } |
Mathieu Chartier | ad2541a | 2013-10-25 10:05:23 -0700 | [diff] [blame] | 154 | } |
| 155 | } |
| 156 | LOG(FATAL) << "Unreachable"; |
| 157 | return 0; |
| 158 | } |
| 159 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 160 | void Object::CheckFieldAssignmentImpl(MemberOffset field_offset, Object* new_value) { |
| 161 | Class* c = GetClass(); |
Mathieu Chartier | 4e30541 | 2014-02-19 10:54:44 -0800 | [diff] [blame] | 162 | Runtime* runtime = Runtime::Current(); |
| 163 | if (runtime->GetClassLinker() == nullptr || !runtime->IsStarted() || |
| 164 | !runtime->GetHeap()->IsObjectValidationEnabled() || !c->IsResolved()) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 165 | return; |
| 166 | } |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 167 | for (Class* cur = c; cur != NULL; cur = cur->GetSuperClass()) { |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 168 | ObjectArray<ArtField>* fields = cur->GetIFields(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 169 | if (fields != NULL) { |
| 170 | size_t num_ref_ifields = cur->NumReferenceInstanceFields(); |
| 171 | for (size_t i = 0; i < num_ref_ifields; ++i) { |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 172 | ArtField* field = fields->Get(i); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 173 | if (field->GetOffset().Int32Value() == field_offset.Int32Value()) { |
| 174 | FieldHelper fh(field); |
| 175 | CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass())); |
| 176 | return; |
| 177 | } |
| 178 | } |
| 179 | } |
| 180 | } |
| 181 | if (c->IsArrayClass()) { |
| 182 | // Bounds and assign-ability done in the array setter. |
| 183 | return; |
| 184 | } |
| 185 | if (IsClass()) { |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 186 | ObjectArray<ArtField>* fields = AsClass()->GetSFields(); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 187 | if (fields != NULL) { |
| 188 | size_t num_ref_sfields = AsClass()->NumReferenceStaticFields(); |
| 189 | for (size_t i = 0; i < num_ref_sfields; ++i) { |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 190 | ArtField* field = fields->Get(i); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 191 | if (field->GetOffset().Int32Value() == field_offset.Int32Value()) { |
| 192 | FieldHelper fh(field); |
| 193 | CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass())); |
| 194 | return; |
| 195 | } |
| 196 | } |
| 197 | } |
| 198 | } |
| 199 | LOG(FATAL) << "Failed to find field for assignment to " << reinterpret_cast<void*>(this) |
| 200 | << " of type " << PrettyDescriptor(c) << " at offset " << field_offset; |
| 201 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 202 | |
| 203 | } // namespace mirror |
| 204 | } // namespace art |