1 /* 2 * Copyright (C) 2012 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 17 #include "entrypoints/quick/quick_alloc_entrypoints.h" 18 19 #include "art_method-inl.h" 20 #include "base/enums.h" 21 #include "callee_save_frame.h" 22 #include "dex_file_types.h" 23 #include "entrypoints/entrypoint_utils-inl.h" 24 #include "mirror/class-inl.h" 25 #include "mirror/object_array-inl.h" 26 #include "mirror/object-inl.h" 27 28 namespace art { 29 30 static constexpr bool kUseTlabFastPath = true; 31 32 template <bool kInitialized, 33 bool kFinalize, 34 bool kInstrumented, 35 gc::AllocatorType allocator_type> 36 static ALWAYS_INLINE inline mirror::Object* artAllocObjectFromCode( 37 mirror::Class* klass, 38 Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) { 39 ScopedQuickEntrypointChecks sqec(self); 40 DCHECK(klass != nullptr); 41 if (kUseTlabFastPath && !kInstrumented && allocator_type == gc::kAllocatorTypeTLAB) { 42 if (kInitialized || klass->IsInitialized()) { 43 if (!kFinalize || !klass->IsFinalizable()) { 44 size_t byte_count = klass->GetObjectSize(); 45 byte_count = RoundUp(byte_count, gc::space::BumpPointerSpace::kAlignment); 46 mirror::Object* obj; 47 if (LIKELY(byte_count < self->TlabSize())) { 48 obj = self->AllocTlab(byte_count); 49 DCHECK(obj != nullptr) << "AllocTlab can't fail"; 50 obj->SetClass(klass); 51 if (kUseBakerReadBarrier) { 52 obj->AssertReadBarrierState(); 53 } 54 QuasiAtomic::ThreadFenceForConstructor(); 55 return obj; 56 } 57 } 58 } 59 } 60 if (kInitialized) { 61 return AllocObjectFromCodeInitialized<kInstrumented>(klass, self, allocator_type); 62 } else if (!kFinalize) { 63 return AllocObjectFromCodeResolved<kInstrumented>(klass, self, allocator_type); 64 } else { 65 return AllocObjectFromCode<kInstrumented>(klass, self, allocator_type); 66 } 67 } 68 69 #define GENERATE_ENTRYPOINTS_FOR_ALLOCATOR_INST(suffix, suffix2, instrumented_bool, allocator_type) \ 70 extern "C" mirror::Object* artAllocObjectFromCodeWithChecks##suffix##suffix2( \ 71 mirror::Class* klass, Thread* self) \ 72 REQUIRES_SHARED(Locks::mutator_lock_) { \ 73 return artAllocObjectFromCode<false, true, instrumented_bool, allocator_type>(klass, self); \ 74 } \ 75 extern "C" mirror::Object* artAllocObjectFromCodeResolved##suffix##suffix2( \ 76 mirror::Class* klass, Thread* self) \ 77 REQUIRES_SHARED(Locks::mutator_lock_) { \ 78 return artAllocObjectFromCode<false, false, instrumented_bool, allocator_type>(klass, self); \ 79 } \ 80 extern "C" mirror::Object* artAllocObjectFromCodeInitialized##suffix##suffix2( \ 81 mirror::Class* klass, Thread* self) \ 82 REQUIRES_SHARED(Locks::mutator_lock_) { \ 83 return artAllocObjectFromCode<true, false, instrumented_bool, allocator_type>(klass, self); \ 84 } \ 85 extern "C" mirror::Array* artAllocArrayFromCodeResolved##suffix##suffix2( \ 86 mirror::Class* klass, int32_t component_count, Thread* self) \ 87 REQUIRES_SHARED(Locks::mutator_lock_) { \ 88 ScopedQuickEntrypointChecks sqec(self); \ 89 return AllocArrayFromCodeResolved<instrumented_bool>(klass, component_count, self, \ 90 allocator_type); \ 91 } \ 92 extern "C" mirror::String* artAllocStringFromBytesFromCode##suffix##suffix2( \ 93 mirror::ByteArray* byte_array, int32_t high, int32_t offset, int32_t byte_count, \ 94 Thread* self) \ 95 REQUIRES_SHARED(Locks::mutator_lock_) { \ 96 ScopedQuickEntrypointChecks sqec(self); \ 97 StackHandleScope<1> hs(self); \ 98 Handle<mirror::ByteArray> handle_array(hs.NewHandle(byte_array)); \ 99 return mirror::String::AllocFromByteArray<instrumented_bool>(self, byte_count, handle_array, \ 100 offset, high, allocator_type); \ 101 } \ 102 extern "C" mirror::String* artAllocStringFromCharsFromCode##suffix##suffix2( \ 103 int32_t offset, int32_t char_count, mirror::CharArray* char_array, Thread* self) \ 104 REQUIRES_SHARED(Locks::mutator_lock_) { \ 105 StackHandleScope<1> hs(self); \ 106 Handle<mirror::CharArray> handle_array(hs.NewHandle(char_array)); \ 107 return mirror::String::AllocFromCharArray<instrumented_bool>(self, char_count, handle_array, \ 108 offset, allocator_type); \ 109 } \ 110 extern "C" mirror::String* artAllocStringFromStringFromCode##suffix##suffix2( /* NOLINT */ \ 111 mirror::String* string, Thread* self) \ 112 REQUIRES_SHARED(Locks::mutator_lock_) { \ 113 StackHandleScope<1> hs(self); \ 114 Handle<mirror::String> handle_string(hs.NewHandle(string)); \ 115 return mirror::String::AllocFromString<instrumented_bool>(self, handle_string->GetLength(), \ 116 handle_string, 0, allocator_type); \ 117 } 118 119 #define GENERATE_ENTRYPOINTS_FOR_ALLOCATOR(suffix, allocator_type) \ 120 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR_INST(suffix, Instrumented, true, allocator_type) \ 121 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR_INST(suffix, , false, allocator_type) 122 123 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR(DlMalloc, gc::kAllocatorTypeDlMalloc) 124 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR(RosAlloc, gc::kAllocatorTypeRosAlloc) 125 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR(BumpPointer, gc::kAllocatorTypeBumpPointer) 126 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR(TLAB, gc::kAllocatorTypeTLAB) 127 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR(Region, gc::kAllocatorTypeRegion) 128 GENERATE_ENTRYPOINTS_FOR_ALLOCATOR(RegionTLAB, gc::kAllocatorTypeRegionTLAB) 129 130 #define GENERATE_ENTRYPOINTS(suffix) \ 131 extern "C" void* art_quick_alloc_array_resolved##suffix(mirror::Class* klass, int32_t); \ 132 extern "C" void* art_quick_alloc_array_resolved8##suffix(mirror::Class* klass, int32_t); \ 133 extern "C" void* art_quick_alloc_array_resolved16##suffix(mirror::Class* klass, int32_t); \ 134 extern "C" void* art_quick_alloc_array_resolved32##suffix(mirror::Class* klass, int32_t); \ 135 extern "C" void* art_quick_alloc_array_resolved64##suffix(mirror::Class* klass, int32_t); \ 136 extern "C" void* art_quick_alloc_object_resolved##suffix(mirror::Class* klass); \ 137 extern "C" void* art_quick_alloc_object_initialized##suffix(mirror::Class* klass); \ 138 extern "C" void* art_quick_alloc_object_with_checks##suffix(mirror::Class* klass); \ 139 extern "C" void* art_quick_alloc_string_from_bytes##suffix(void*, int32_t, int32_t, int32_t); \ 140 extern "C" void* art_quick_alloc_string_from_chars##suffix(int32_t, int32_t, void*); \ 141 extern "C" void* art_quick_alloc_string_from_string##suffix(void*); \ 142 extern "C" void* art_quick_alloc_array_resolved##suffix##_instrumented(mirror::Class* klass, int32_t); \ 143 extern "C" void* art_quick_alloc_array_resolved8##suffix##_instrumented(mirror::Class* klass, int32_t); \ 144 extern "C" void* art_quick_alloc_array_resolved16##suffix##_instrumented(mirror::Class* klass, int32_t); \ 145 extern "C" void* art_quick_alloc_array_resolved32##suffix##_instrumented(mirror::Class* klass, int32_t); \ 146 extern "C" void* art_quick_alloc_array_resolved64##suffix##_instrumented(mirror::Class* klass, int32_t); \ 147 extern "C" void* art_quick_alloc_object_resolved##suffix##_instrumented(mirror::Class* klass); \ 148 extern "C" void* art_quick_alloc_object_initialized##suffix##_instrumented(mirror::Class* klass); \ 149 extern "C" void* art_quick_alloc_object_with_checks##suffix##_instrumented(mirror::Class* klass); \ 150 extern "C" void* art_quick_alloc_string_from_bytes##suffix##_instrumented(void*, int32_t, int32_t, int32_t); \ 151 extern "C" void* art_quick_alloc_string_from_chars##suffix##_instrumented(int32_t, int32_t, void*); \ 152 extern "C" void* art_quick_alloc_string_from_string##suffix##_instrumented(void*); \ 153 void SetQuickAllocEntryPoints##suffix(QuickEntryPoints* qpoints, bool instrumented) { \ 154 if (instrumented) { \ 155 qpoints->pAllocArrayResolved = art_quick_alloc_array_resolved##suffix##_instrumented; \ 156 qpoints->pAllocArrayResolved8 = art_quick_alloc_array_resolved8##suffix##_instrumented; \ 157 qpoints->pAllocArrayResolved16 = art_quick_alloc_array_resolved16##suffix##_instrumented; \ 158 qpoints->pAllocArrayResolved32 = art_quick_alloc_array_resolved32##suffix##_instrumented; \ 159 qpoints->pAllocArrayResolved64 = art_quick_alloc_array_resolved64##suffix##_instrumented; \ 160 qpoints->pAllocObjectResolved = art_quick_alloc_object_resolved##suffix##_instrumented; \ 161 qpoints->pAllocObjectInitialized = art_quick_alloc_object_initialized##suffix##_instrumented; \ 162 qpoints->pAllocObjectWithChecks = art_quick_alloc_object_with_checks##suffix##_instrumented; \ 163 qpoints->pAllocStringFromBytes = art_quick_alloc_string_from_bytes##suffix##_instrumented; \ 164 qpoints->pAllocStringFromChars = art_quick_alloc_string_from_chars##suffix##_instrumented; \ 165 qpoints->pAllocStringFromString = art_quick_alloc_string_from_string##suffix##_instrumented; \ 166 } else { \ 167 qpoints->pAllocArrayResolved = art_quick_alloc_array_resolved##suffix; \ 168 qpoints->pAllocArrayResolved8 = art_quick_alloc_array_resolved8##suffix; \ 169 qpoints->pAllocArrayResolved16 = art_quick_alloc_array_resolved16##suffix; \ 170 qpoints->pAllocArrayResolved32 = art_quick_alloc_array_resolved32##suffix; \ 171 qpoints->pAllocArrayResolved64 = art_quick_alloc_array_resolved64##suffix; \ 172 qpoints->pAllocObjectResolved = art_quick_alloc_object_resolved##suffix; \ 173 qpoints->pAllocObjectInitialized = art_quick_alloc_object_initialized##suffix; \ 174 qpoints->pAllocObjectWithChecks = art_quick_alloc_object_with_checks##suffix; \ 175 qpoints->pAllocStringFromBytes = art_quick_alloc_string_from_bytes##suffix; \ 176 qpoints->pAllocStringFromChars = art_quick_alloc_string_from_chars##suffix; \ 177 qpoints->pAllocStringFromString = art_quick_alloc_string_from_string##suffix; \ 178 } \ 179 } 180 181 // Generate the entrypoint functions. 182 #if !defined(__APPLE__) || !defined(__LP64__) 183 GENERATE_ENTRYPOINTS(_dlmalloc) 184 GENERATE_ENTRYPOINTS(_rosalloc) 185 GENERATE_ENTRYPOINTS(_bump_pointer) 186 GENERATE_ENTRYPOINTS(_tlab) 187 GENERATE_ENTRYPOINTS(_region) 188 GENERATE_ENTRYPOINTS(_region_tlab) 189 #endif 190 191 static bool entry_points_instrumented = false; 192 static gc::AllocatorType entry_points_allocator = gc::kAllocatorTypeDlMalloc; 193 194 void SetQuickAllocEntryPointsAllocator(gc::AllocatorType allocator) { 195 entry_points_allocator = allocator; 196 } 197 198 void SetQuickAllocEntryPointsInstrumented(bool instrumented) { 199 entry_points_instrumented = instrumented; 200 } 201 202 void ResetQuickAllocEntryPoints(QuickEntryPoints* qpoints, bool is_marking) { 203 #if !defined(__APPLE__) || !defined(__LP64__) 204 switch (entry_points_allocator) { 205 case gc::kAllocatorTypeDlMalloc: { 206 SetQuickAllocEntryPoints_dlmalloc(qpoints, entry_points_instrumented); 207 return; 208 } 209 case gc::kAllocatorTypeRosAlloc: { 210 SetQuickAllocEntryPoints_rosalloc(qpoints, entry_points_instrumented); 211 return; 212 } 213 case gc::kAllocatorTypeBumpPointer: { 214 CHECK(kMovingCollector); 215 SetQuickAllocEntryPoints_bump_pointer(qpoints, entry_points_instrumented); 216 return; 217 } 218 case gc::kAllocatorTypeTLAB: { 219 CHECK(kMovingCollector); 220 SetQuickAllocEntryPoints_tlab(qpoints, entry_points_instrumented); 221 return; 222 } 223 case gc::kAllocatorTypeRegion: { 224 CHECK(kMovingCollector); 225 SetQuickAllocEntryPoints_region(qpoints, entry_points_instrumented); 226 return; 227 } 228 case gc::kAllocatorTypeRegionTLAB: { 229 CHECK(kMovingCollector); 230 if (is_marking) { 231 SetQuickAllocEntryPoints_region_tlab(qpoints, entry_points_instrumented); 232 } else { 233 // Not marking means we need no read barriers and can just use the normal TLAB case. 234 SetQuickAllocEntryPoints_tlab(qpoints, entry_points_instrumented); 235 } 236 return; 237 } 238 default: 239 break; 240 } 241 #else 242 UNUSED(qpoints); 243 UNUSED(is_marking); 244 #endif 245 UNIMPLEMENTED(FATAL); 246 UNREACHABLE(); 247 } 248 249 } // namespace art 250