blob: 40997f6ff7a66c522a2ec938e0b99f77d6612aab [file] [log] [blame]
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dex_cache-inl.h"
#include "art_method-inl.h"
#include "class_linker.h"
#include "gc/accounting/card_table-inl.h"
#include "gc/heap.h"
#include "linear_alloc.h"
#include "oat_file.h"
#include "object-inl.h"
#include "object.h"
#include "object_array-inl.h"
#include "reflective_value_visitor.h"
#include "runtime.h"
#include "runtime_globals.h"
#include "string.h"
#include "thread.h"
#include "utils/dex_cache_arrays_layout-inl.h"
#include "write_barrier.h"
namespace art {
namespace mirror {
void DexCache::InitializeDexCache(Thread* self,
ObjPtr<mirror::DexCache> dex_cache,
ObjPtr<mirror::String> location,
const DexFile* dex_file,
LinearAlloc* linear_alloc,
PointerSize image_pointer_size) {
DCHECK(dex_file != nullptr);
ScopedAssertNoThreadSuspension sants(__FUNCTION__);
DexCacheArraysLayout layout(image_pointer_size, dex_file);
uint8_t* raw_arrays = nullptr;
if (dex_file->NumStringIds() != 0u ||
dex_file->NumTypeIds() != 0u ||
dex_file->NumMethodIds() != 0u ||
dex_file->NumFieldIds() != 0u) {
static_assert(ArenaAllocator::kAlignment == 8, "Expecting arena alignment of 8.");
DCHECK(layout.Alignment() == 8u || layout.Alignment() == 16u);
// Zero-initialized.
raw_arrays = (layout.Alignment() == 16u)
? reinterpret_cast<uint8_t*>(linear_alloc->AllocAlign16(self, layout.Size()))
: reinterpret_cast<uint8_t*>(linear_alloc->Alloc(self, layout.Size()));
}
StringDexCacheType* strings = (dex_file->NumStringIds() == 0u) ? nullptr :
reinterpret_cast<StringDexCacheType*>(raw_arrays + layout.StringsOffset());
TypeDexCacheType* types = (dex_file->NumTypeIds() == 0u) ? nullptr :
reinterpret_cast<TypeDexCacheType*>(raw_arrays + layout.TypesOffset());
MethodDexCacheType* methods = (dex_file->NumMethodIds() == 0u) ? nullptr :
reinterpret_cast<MethodDexCacheType*>(raw_arrays + layout.MethodsOffset());
FieldDexCacheType* fields = (dex_file->NumFieldIds() == 0u) ? nullptr :
reinterpret_cast<FieldDexCacheType*>(raw_arrays + layout.FieldsOffset());
size_t num_strings = kDexCacheStringCacheSize;
if (dex_file->NumStringIds() < num_strings) {
num_strings = dex_file->NumStringIds();
}
size_t num_types = kDexCacheTypeCacheSize;
if (dex_file->NumTypeIds() < num_types) {
num_types = dex_file->NumTypeIds();
}
size_t num_fields = kDexCacheFieldCacheSize;
if (dex_file->NumFieldIds() < num_fields) {
num_fields = dex_file->NumFieldIds();
}
size_t num_methods = kDexCacheMethodCacheSize;
if (dex_file->NumMethodIds() < num_methods) {
num_methods = dex_file->NumMethodIds();
}
// Note that we allocate the method type dex caches regardless of this flag,
// and we make sure here that they're not used by the runtime. This is in the
// interest of simplicity and to avoid extensive compiler and layout class changes.
//
// If this needs to be mitigated in a production system running this code,
// DexCache::kDexCacheMethodTypeCacheSize can be set to zero.
MethodTypeDexCacheType* method_types = nullptr;
size_t num_method_types = 0;
if (dex_file->NumProtoIds() < kDexCacheMethodTypeCacheSize) {
num_method_types = dex_file->NumProtoIds();
} else {
num_method_types = kDexCacheMethodTypeCacheSize;
}
if (num_method_types > 0) {
method_types = reinterpret_cast<MethodTypeDexCacheType*>(
raw_arrays + layout.MethodTypesOffset());
}
GcRoot<mirror::CallSite>* call_sites = (dex_file->NumCallSiteIds() == 0)
? nullptr
: reinterpret_cast<GcRoot<CallSite>*>(raw_arrays + layout.CallSitesOffset());
DCHECK_ALIGNED(raw_arrays, alignof(StringDexCacheType)) <<
"Expected raw_arrays to align to StringDexCacheType.";
DCHECK_ALIGNED(layout.StringsOffset(), alignof(StringDexCacheType)) <<
"Expected StringsOffset() to align to StringDexCacheType.";
DCHECK_ALIGNED(strings, alignof(StringDexCacheType)) <<
"Expected strings to align to StringDexCacheType.";
static_assert(alignof(StringDexCacheType) == 8u,
"Expected StringDexCacheType to have align of 8.");
if (kIsDebugBuild) {
// Sanity check to make sure all the dex cache arrays are empty. b/28992179
for (size_t i = 0; i < num_strings; ++i) {
CHECK_EQ(strings[i].load(std::memory_order_relaxed).index, 0u);
CHECK(strings[i].load(std::memory_order_relaxed).object.IsNull());
}
for (size_t i = 0; i < num_types; ++i) {
CHECK_EQ(types[i].load(std::memory_order_relaxed).index, 0u);
CHECK(types[i].load(std::memory_order_relaxed).object.IsNull());
}
for (size_t i = 0; i < num_methods; ++i) {
CHECK_EQ(GetNativePairPtrSize(methods, i, image_pointer_size).index, 0u);
CHECK(GetNativePairPtrSize(methods, i, image_pointer_size).object == nullptr);
}
for (size_t i = 0; i < num_fields; ++i) {
CHECK_EQ(GetNativePairPtrSize(fields, i, image_pointer_size).index, 0u);
CHECK(GetNativePairPtrSize(fields, i, image_pointer_size).object == nullptr);
}
for (size_t i = 0; i < num_method_types; ++i) {
CHECK_EQ(method_types[i].load(std::memory_order_relaxed).index, 0u);
CHECK(method_types[i].load(std::memory_order_relaxed).object.IsNull());
}
for (size_t i = 0; i < dex_file->NumCallSiteIds(); ++i) {
CHECK(call_sites[i].IsNull());
}
}
if (strings != nullptr) {
mirror::StringDexCachePair::Initialize(strings);
}
if (types != nullptr) {
mirror::TypeDexCachePair::Initialize(types);
}
if (fields != nullptr) {
mirror::FieldDexCachePair::Initialize(fields, image_pointer_size);
}
if (methods != nullptr) {
mirror::MethodDexCachePair::Initialize(methods, image_pointer_size);
}
if (method_types != nullptr) {
mirror::MethodTypeDexCachePair::Initialize(method_types);
}
dex_cache->Init(dex_file,
location,
strings,
num_strings,
types,
num_types,
methods,
num_methods,
fields,
num_fields,
method_types,
num_method_types,
call_sites,
dex_file->NumCallSiteIds());
}
void DexCache::VisitReflectiveTargets(ReflectiveValueVisitor* visitor) {
bool wrote = false;
for (size_t i = 0; i < NumResolvedFields(); i++) {
auto pair(GetNativePairPtrSize(GetResolvedFields(), i, kRuntimePointerSize));
if (pair.index == FieldDexCachePair::InvalidIndexForSlot(i)) {
continue;
}
ArtField* new_val = visitor->VisitField(
pair.object, DexCacheSourceInfo(kSourceDexCacheResolvedField, pair.index, this));
if (UNLIKELY(new_val != pair.object)) {
if (new_val == nullptr) {
pair = FieldDexCachePair(nullptr, FieldDexCachePair::InvalidIndexForSlot(i));
} else {
pair.object = new_val;
}
SetNativePairPtrSize(GetResolvedFields(), i, pair, kRuntimePointerSize);
wrote = true;
}
}
for (size_t i = 0; i < NumResolvedMethods(); i++) {
auto pair(GetNativePairPtrSize(GetResolvedMethods(), i, kRuntimePointerSize));
if (pair.index == MethodDexCachePair::InvalidIndexForSlot(i)) {
continue;
}
ArtMethod* new_val = visitor->VisitMethod(
pair.object, DexCacheSourceInfo(kSourceDexCacheResolvedMethod, pair.index, this));
if (UNLIKELY(new_val != pair.object)) {
if (new_val == nullptr) {
pair = MethodDexCachePair(nullptr, MethodDexCachePair::InvalidIndexForSlot(i));
} else {
pair.object = new_val;
}
SetNativePairPtrSize(GetResolvedMethods(), i, pair, kRuntimePointerSize);
wrote = true;
}
}
if (wrote) {
WriteBarrier::ForEveryFieldWrite(this);
}
}
bool DexCache::AddPreResolvedStringsArray() {
DCHECK_EQ(NumPreResolvedStrings(), 0u);
Thread* const self = Thread::Current();
LinearAlloc* linear_alloc = Runtime::Current()->GetLinearAlloc();
const size_t num_strings = GetDexFile()->NumStringIds();
if (num_strings != 0) {
GcRoot<mirror::String>* strings =
linear_alloc->AllocArray<GcRoot<mirror::String>>(self, num_strings);
if (strings == nullptr) {
// Failed to allocate pre-resolved string array (probably due to address fragmentation), bail.
return false;
}
SetField32<false>(NumPreResolvedStringsOffset(), num_strings);
CHECK(strings != nullptr);
SetPreResolvedStrings(strings);
for (size_t i = 0; i < GetDexFile()->NumStringIds(); ++i) {
CHECK(GetPreResolvedStrings()[i].Read() == nullptr);
}
}
return true;
}
void DexCache::Init(const DexFile* dex_file,
ObjPtr<String> location,
StringDexCacheType* strings,
uint32_t num_strings,
TypeDexCacheType* resolved_types,
uint32_t num_resolved_types,
MethodDexCacheType* resolved_methods,
uint32_t num_resolved_methods,
FieldDexCacheType* resolved_fields,
uint32_t num_resolved_fields,
MethodTypeDexCacheType* resolved_method_types,
uint32_t num_resolved_method_types,
GcRoot<CallSite>* resolved_call_sites,
uint32_t num_resolved_call_sites) {
CHECK(dex_file != nullptr);
CHECK(location != nullptr);
CHECK_EQ(num_strings != 0u, strings != nullptr);
CHECK_EQ(num_resolved_types != 0u, resolved_types != nullptr);
CHECK_EQ(num_resolved_methods != 0u, resolved_methods != nullptr);
CHECK_EQ(num_resolved_fields != 0u, resolved_fields != nullptr);
CHECK_EQ(num_resolved_method_types != 0u, resolved_method_types != nullptr);
CHECK_EQ(num_resolved_call_sites != 0u, resolved_call_sites != nullptr);
SetDexFile(dex_file);
SetLocation(location);
SetStrings(strings);
SetResolvedTypes(resolved_types);
SetResolvedMethods(resolved_methods);
SetResolvedFields(resolved_fields);
SetResolvedMethodTypes(resolved_method_types);
SetResolvedCallSites(resolved_call_sites);
SetField32<false>(NumStringsOffset(), num_strings);
SetField32<false>(NumResolvedTypesOffset(), num_resolved_types);
SetField32<false>(NumResolvedMethodsOffset(), num_resolved_methods);
SetField32<false>(NumResolvedFieldsOffset(), num_resolved_fields);
SetField32<false>(NumResolvedMethodTypesOffset(), num_resolved_method_types);
SetField32<false>(NumResolvedCallSitesOffset(), num_resolved_call_sites);
}
void DexCache::SetLocation(ObjPtr<mirror::String> location) {
SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(DexCache, location_), location);
}
void DexCache::SetClassLoader(ObjPtr<ClassLoader> class_loader) {
SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(DexCache, class_loader_), class_loader);
}
#if !defined(__aarch64__) && !defined(__x86_64__)
static pthread_mutex_t dex_cache_slow_atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
DexCache::ConversionPair64 DexCache::AtomicLoadRelaxed16B(std::atomic<ConversionPair64>* target) {
pthread_mutex_lock(&dex_cache_slow_atomic_mutex);
DexCache::ConversionPair64 value = *reinterpret_cast<ConversionPair64*>(target);
pthread_mutex_unlock(&dex_cache_slow_atomic_mutex);
return value;
}
void DexCache::AtomicStoreRelease16B(std::atomic<ConversionPair64>* target,
ConversionPair64 value) {
pthread_mutex_lock(&dex_cache_slow_atomic_mutex);
*reinterpret_cast<ConversionPair64*>(target) = value;
pthread_mutex_unlock(&dex_cache_slow_atomic_mutex);
}
#endif
} // namespace mirror
} // namespace art