Remove DexCache arrays from app oat .bss.
Their presence in the .bss was no longer necessary and
it doesn't really matter for memory usage whether they
are in the .bss or in the LinearAlloc. This removes
a lot of unnecessary code.
Test: m test-art-host
Test: testrunner.py --host
Change-Id: I63ccd4412fcb267341b8b012b7e3b09903f86625
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index 6fbb2bd..58b6137 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -1943,20 +1943,15 @@
DCHECK_EQ(bss_size_, 0u);
if (HasBootImage()) {
DCHECK(bss_string_entries_.empty());
- if (bss_method_entries_.empty() && bss_type_entries_.empty()) {
- // Nothing to put to the .bss section.
- return;
- }
+ }
+ if (bss_method_entries_.empty() &&
+ bss_type_entries_.empty() &&
+ bss_string_entries_.empty()) {
+ // Nothing to put to the .bss section.
+ return;
}
- // Allocate space for app dex cache arrays in the .bss section.
PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set);
- if (!HasBootImage()) {
- for (const DexFile* dex_file : *dex_files_) {
- DexCacheArraysLayout layout(pointer_size, dex_file);
- bss_size_ += layout.Size();
- }
- }
bss_methods_offset_ = bss_size_;
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index d22482f..4712c93 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -1189,219 +1189,41 @@
}
};
-// Copies data from one array to another array at the same position
-// if pred returns false. If there is a page of continuous data in
-// the src array for which pred consistently returns true then
-// corresponding page in the dst array will not be touched.
-// This should reduce number of allocated physical pages.
-template <class T, class NullPred>
-static void CopyNonNull(const T* src, size_t count, T* dst, const NullPred& pred) {
- for (size_t i = 0; i < count; ++i) {
- if (!pred(src[i])) {
- dst[i] = src[i];
- }
- }
-}
-
-template <typename T>
-static void CopyDexCachePairs(const std::atomic<mirror::DexCachePair<T>>* src,
- size_t count,
- std::atomic<mirror::DexCachePair<T>>* dst) {
- DCHECK_NE(count, 0u);
- DCHECK(!src[0].load(std::memory_order_relaxed).object.IsNull() ||
- src[0].load(std::memory_order_relaxed).index != 0u);
- for (size_t i = 0; i < count; ++i) {
- DCHECK_EQ(dst[i].load(std::memory_order_relaxed).index, 0u);
- DCHECK(dst[i].load(std::memory_order_relaxed).object.IsNull());
- mirror::DexCachePair<T> source = src[i].load(std::memory_order_relaxed);
- if (source.index != 0u || !source.object.IsNull()) {
- dst[i].store(source, std::memory_order_relaxed);
- }
- }
-}
-
-template <typename T>
-static void CopyNativeDexCachePairs(std::atomic<mirror::NativeDexCachePair<T>>* src,
- size_t count,
- std::atomic<mirror::NativeDexCachePair<T>>* dst,
- PointerSize pointer_size) {
- DCHECK_NE(count, 0u);
- DCHECK(mirror::DexCache::GetNativePairPtrSize(src, 0, pointer_size).object != nullptr ||
- mirror::DexCache::GetNativePairPtrSize(src, 0, pointer_size).index != 0u);
- for (size_t i = 0; i < count; ++i) {
- DCHECK_EQ(mirror::DexCache::GetNativePairPtrSize(dst, i, pointer_size).index, 0u);
- DCHECK(mirror::DexCache::GetNativePairPtrSize(dst, i, pointer_size).object == nullptr);
- mirror::NativeDexCachePair<T> source =
- mirror::DexCache::GetNativePairPtrSize(src, i, pointer_size);
- if (source.index != 0u || source.object != nullptr) {
- mirror::DexCache::SetNativePairPtrSize(dst, i, source, pointer_size);
- }
- }
-}
-
// new_class_set is the set of classes that were read from the class table section in the image.
// If there was no class table section, it is null.
// Note: using a class here to avoid having to make ClassLinker internals public.
class AppImageClassLoadersAndDexCachesHelper {
public:
- static bool Update(
+ static void Update(
ClassLinker* class_linker,
gc::space::ImageSpace* space,
Handle<mirror::ClassLoader> class_loader,
Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
- ClassTable::ClassSet* new_class_set,
- bool* out_forward_dex_cache_array,
- std::string* out_error_msg)
+ ClassTable::ClassSet* new_class_set)
REQUIRES(!Locks::dex_lock_)
REQUIRES_SHARED(Locks::mutator_lock_);
};
-bool AppImageClassLoadersAndDexCachesHelper::Update(
+void AppImageClassLoadersAndDexCachesHelper::Update(
ClassLinker* class_linker,
gc::space::ImageSpace* space,
Handle<mirror::ClassLoader> class_loader,
Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
- ClassTable::ClassSet* new_class_set,
- bool* out_forward_dex_cache_array,
- std::string* out_error_msg)
+ ClassTable::ClassSet* new_class_set)
REQUIRES(!Locks::dex_lock_)
REQUIRES_SHARED(Locks::mutator_lock_) {
- DCHECK(out_forward_dex_cache_array != nullptr);
- DCHECK(out_error_msg != nullptr);
- PointerSize image_pointer_size = class_linker->GetImagePointerSize();
Thread* const self = Thread::Current();
gc::Heap* const heap = Runtime::Current()->GetHeap();
const ImageHeader& header = space->GetImageHeader();
{
- // Add image classes into the class table for the class loader, and fixup the dex caches and
- // class loader fields.
+ // Register dex caches with the class loader.
WriterMutexLock mu(self, *Locks::classlinker_classes_lock_);
- // Dex cache array fixup is all or nothing, we must reject app images that have mixed since we
- // rely on clobering the dex cache arrays in the image to forward to bss.
- size_t num_dex_caches_with_bss_arrays = 0;
const size_t num_dex_caches = dex_caches->GetLength();
for (size_t i = 0; i < num_dex_caches; i++) {
- ObjPtr<mirror::DexCache> const dex_cache = dex_caches->Get(i);
- const DexFile* const dex_file = dex_cache->GetDexFile();
- const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
- if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
- ++num_dex_caches_with_bss_arrays;
- }
- }
- *out_forward_dex_cache_array = num_dex_caches_with_bss_arrays != 0;
- if (*out_forward_dex_cache_array) {
- if (num_dex_caches_with_bss_arrays != num_dex_caches) {
- // Reject application image since we cannot forward only some of the dex cache arrays.
- // TODO: We could get around this by having a dedicated forwarding slot. It should be an
- // uncommon case.
- *out_error_msg = StringPrintf("Dex caches in bss does not match total: %zu vs %zu",
- num_dex_caches_with_bss_arrays,
- num_dex_caches);
- return false;
- }
- }
-
- // Only add the classes to the class loader after the points where we can return false.
- for (size_t i = 0; i < num_dex_caches; i++) {
ObjPtr<mirror::DexCache> dex_cache = dex_caches->Get(i);
const DexFile* const dex_file = dex_cache->GetDexFile();
- const OatFile::OatDexFile* oat_dex_file = dex_file->GetOatDexFile();
- if (oat_dex_file != nullptr && oat_dex_file->GetDexCacheArrays() != nullptr) {
- // If the oat file expects the dex cache arrays to be in the BSS, then allocate there and
- // copy over the arrays.
- DCHECK(dex_file != nullptr);
- size_t num_strings = mirror::DexCache::kDexCacheStringCacheSize;
- if (dex_file->NumStringIds() < num_strings) {
- num_strings = dex_file->NumStringIds();
- }
- size_t num_types = mirror::DexCache::kDexCacheTypeCacheSize;
- if (dex_file->NumTypeIds() < num_types) {
- num_types = dex_file->NumTypeIds();
- }
- size_t num_methods = mirror::DexCache::kDexCacheMethodCacheSize;
- if (dex_file->NumMethodIds() < num_methods) {
- num_methods = dex_file->NumMethodIds();
- }
- size_t num_fields = mirror::DexCache::kDexCacheFieldCacheSize;
- if (dex_file->NumFieldIds() < num_fields) {
- num_fields = dex_file->NumFieldIds();
- }
- size_t num_method_types = mirror::DexCache::kDexCacheMethodTypeCacheSize;
- if (dex_file->NumProtoIds() < num_method_types) {
- num_method_types = dex_file->NumProtoIds();
- }
- const size_t num_call_sites = dex_file->NumCallSiteIds();
- CHECK_EQ(num_strings, dex_cache->NumStrings());
- CHECK_EQ(num_types, dex_cache->NumResolvedTypes());
- CHECK_EQ(num_methods, dex_cache->NumResolvedMethods());
- CHECK_EQ(num_fields, dex_cache->NumResolvedFields());
- CHECK_EQ(num_method_types, dex_cache->NumResolvedMethodTypes());
- CHECK_EQ(num_call_sites, dex_cache->NumResolvedCallSites());
- DexCacheArraysLayout layout(image_pointer_size, dex_file);
- uint8_t* const raw_arrays = oat_dex_file->GetDexCacheArrays();
- if (num_strings != 0u) {
- mirror::StringDexCacheType* const image_resolved_strings = dex_cache->GetStrings();
- mirror::StringDexCacheType* const strings =
- reinterpret_cast<mirror::StringDexCacheType*>(raw_arrays + layout.StringsOffset());
- CopyDexCachePairs(image_resolved_strings, num_strings, strings);
- dex_cache->SetStrings(strings);
- }
- if (num_types != 0u) {
- mirror::TypeDexCacheType* const image_resolved_types = dex_cache->GetResolvedTypes();
- mirror::TypeDexCacheType* const types =
- reinterpret_cast<mirror::TypeDexCacheType*>(raw_arrays + layout.TypesOffset());
- CopyDexCachePairs(image_resolved_types, num_types, types);
- dex_cache->SetResolvedTypes(types);
- }
- if (num_methods != 0u) {
- mirror::MethodDexCacheType* const image_resolved_methods =
- dex_cache->GetResolvedMethods();
- mirror::MethodDexCacheType* const methods =
- reinterpret_cast<mirror::MethodDexCacheType*>(raw_arrays + layout.MethodsOffset());
- CopyNativeDexCachePairs(image_resolved_methods, num_methods, methods, image_pointer_size);
- dex_cache->SetResolvedMethods(methods);
- }
- if (num_fields != 0u) {
- mirror::FieldDexCacheType* const image_resolved_fields = dex_cache->GetResolvedFields();
- mirror::FieldDexCacheType* const fields =
- reinterpret_cast<mirror::FieldDexCacheType*>(raw_arrays + layout.FieldsOffset());
- CopyNativeDexCachePairs(image_resolved_fields, num_fields, fields, image_pointer_size);
- dex_cache->SetResolvedFields(fields);
- }
- if (num_method_types != 0u) {
- // NOTE: We currently (Sep 2016) do not resolve any method types at
- // compile time, but plan to in the future. This code exists for the
- // sake of completeness.
- mirror::MethodTypeDexCacheType* const image_resolved_method_types =
- dex_cache->GetResolvedMethodTypes();
- mirror::MethodTypeDexCacheType* const method_types =
- reinterpret_cast<mirror::MethodTypeDexCacheType*>(
- raw_arrays + layout.MethodTypesOffset());
- CopyDexCachePairs(image_resolved_method_types, num_method_types, method_types);
- dex_cache->SetResolvedMethodTypes(method_types);
- }
- if (num_call_sites != 0u) {
- GcRoot<mirror::CallSite>* const image_resolved_call_sites =
- dex_cache->GetResolvedCallSites();
- GcRoot<mirror::CallSite>* const call_sites =
- reinterpret_cast<GcRoot<mirror::CallSite>*>(raw_arrays + layout.CallSitesOffset());
- for (size_t j = 0; kIsDebugBuild && j < num_call_sites; ++j) {
- DCHECK(call_sites[j].IsNull());
- }
- CopyNonNull(image_resolved_call_sites,
- num_call_sites,
- call_sites,
- [](const GcRoot<mirror::CallSite>& elem) {
- return elem.IsNull();
- });
- dex_cache->SetResolvedCallSites(call_sites);
- }
- }
{
WriterMutexLock mu2(self, *Locks::dex_lock_);
- // Make sure to do this after we update the arrays since we store the resolved types array
- // in DexCacheData in RegisterDexFileLocked. We need the array pointer to be the one in the
- // BSS.
CHECK(!class_linker->FindDexCacheDataLocked(*dex_file).IsValid());
class_linker->RegisterDexFileLocked(*dex_file, dex_cache, class_loader.Get());
}
@@ -1468,7 +1290,6 @@
VerifyDeclaringClassVisitor visitor;
header.VisitPackedArtMethods(&visitor, space->Begin(), kRuntimePointerSize);
}
- return true;
}
// Update the class loader. Should only be used on classes in the image space.
@@ -1947,7 +1768,7 @@
// If we have a class table section, read it and use it for verification in
// UpdateAppImageClassLoadersAndDexCaches.
ClassTable::ClassSet temp_set;
- const ImageSection& class_table_section = header.GetImageSection(ImageHeader::kSectionClassTable);
+ const ImageSection& class_table_section = header.GetClassTableSection();
const bool added_class_table = class_table_section.Size() > 0u;
if (added_class_table) {
const uint64_t start_time2 = NanoTime();
@@ -1958,37 +1779,17 @@
VLOG(image) << "Adding class table classes took " << PrettyDuration(NanoTime() - start_time2);
}
if (app_image) {
- bool forward_dex_cache_arrays = false;
- if (!AppImageClassLoadersAndDexCachesHelper::Update(this,
- space,
- class_loader,
- dex_caches,
- &temp_set,
- /*out*/&forward_dex_cache_arrays,
- /*out*/error_msg)) {
- return false;
- }
+ AppImageClassLoadersAndDexCachesHelper::Update(this,
+ space,
+ class_loader,
+ dex_caches,
+ &temp_set);
// Update class loader and resolved strings. If added_class_table is false, the resolved
// strings were forwarded UpdateAppImageClassLoadersAndDexCaches.
UpdateClassLoaderVisitor visitor(space, class_loader.Get());
for (const ClassTable::TableSlot& root : temp_set) {
visitor(root.Read());
}
- // forward_dex_cache_arrays is true iff we copied all of the dex cache arrays into the .bss.
- // In this case, madvise away the dex cache arrays section of the image to reduce RAM usage and
- // mark as PROT_NONE to catch any invalid accesses.
- if (forward_dex_cache_arrays) {
- const ImageSection& dex_cache_section = header.GetDexCacheArraysSection();
- uint8_t* section_begin = AlignUp(space->Begin() + dex_cache_section.Offset(), kPageSize);
- uint8_t* section_end = AlignDown(space->Begin() + dex_cache_section.End(), kPageSize);
- if (section_begin < section_end) {
- madvise(section_begin, section_end - section_begin, MADV_DONTNEED);
- mprotect(section_begin, section_end - section_begin, PROT_NONE);
- VLOG(image) << "Released and protected dex cache array image section from "
- << reinterpret_cast<const void*>(section_begin) << "-"
- << reinterpret_cast<const void*>(section_end);
- }
- }
}
if (!oat_file->GetBssGcRoots().empty()) {
// Insert oat file to class table for visiting .bss GC roots.
diff --git a/runtime/mirror/dex_cache.cc b/runtime/mirror/dex_cache.cc
index f6f20ba..2f63dff 100644
--- a/runtime/mirror/dex_cache.cc
+++ b/runtime/mirror/dex_cache.cc
@@ -46,13 +46,10 @@
DexCacheArraysLayout layout(image_pointer_size, dex_file);
uint8_t* raw_arrays = nullptr;
- const OatDexFile* const oat_dex = dex_file->GetOatDexFile();
- if (oat_dex != nullptr && oat_dex->GetDexCacheArrays() != nullptr) {
- raw_arrays = oat_dex->GetDexCacheArrays();
- } else if (dex_file->NumStringIds() != 0u ||
- dex_file->NumTypeIds() != 0u ||
- dex_file->NumMethodIds() != 0u ||
- dex_file->NumFieldIds() != 0u) {
+ 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.
diff --git a/runtime/oat.h b/runtime/oat.h
index 1d79ed6..ab7c42e 100644
--- a/runtime/oat.h
+++ b/runtime/oat.h
@@ -32,8 +32,8 @@
class PACKED(4) OatHeader {
public:
static constexpr uint8_t kOatMagic[] = { 'o', 'a', 't', '\n' };
- // Last oat version changed reason: Add dex section layout info to header.
- static constexpr uint8_t kOatVersion[] = { '1', '3', '2', '\0' };
+ // Last oat version changed reason: Remove DexCache arrays from .bss.
+ static constexpr uint8_t kOatVersion[] = { '1', '3', '3', '\0' };
static constexpr const char* kImageLocationKey = "image-location";
static constexpr const char* kDex2OatCmdLineKey = "dex2oat-cmdline";
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index d9cfa53..200681e 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -55,7 +55,6 @@
#include "type_lookup_table.h"
#include "utf-inl.h"
#include "utils.h"
-#include "utils/dex_cache_arrays_layout-inl.h"
#include "vdex_file.h"
namespace art {
@@ -279,36 +278,6 @@
return true;
}
-static bool FindDexFileMapItem(const uint8_t* dex_begin,
- const uint8_t* dex_end,
- DexFile::MapItemType map_item_type,
- const DexFile::MapItem** result_item) {
- *result_item = nullptr;
-
- const DexFile::Header* header =
- BoundsCheckedCast<const DexFile::Header*>(dex_begin, dex_begin, dex_end);
- if (nullptr == header) return false;
-
- if (!DexFile::IsMagicValid(header->magic_)) return true; // Not a dex file, not an error.
-
- const DexFile::MapList* map_list =
- BoundsCheckedCast<const DexFile::MapList*>(dex_begin + header->map_off_, dex_begin, dex_end);
- if (nullptr == map_list) return false;
-
- const DexFile::MapItem* map_item = map_list->list_;
- size_t count = map_list->size_;
- while (count--) {
- if (map_item->type_ == static_cast<uint16_t>(map_item_type)) {
- *result_item = map_item;
- break;
- }
- map_item = BoundsCheckedCast<const DexFile::MapItem*>(map_item + 1, dex_begin, dex_end);
- if (nullptr == map_item) return false;
- }
-
- return true;
-}
-
bool OatFileBase::Setup(const char* abs_dex_location, std::string* error_msg) {
if (!GetOatHeader().IsValid()) {
std::string cause = GetOatHeader().GetValidationErrorMessage();
@@ -361,7 +330,7 @@
(bss_roots_ != nullptr && (bss_roots_ < bss_begin_ || bss_roots_ > bss_end_)) ||
(bss_methods_ != nullptr && bss_roots_ != nullptr && bss_methods_ > bss_roots_)) {
*error_msg = StringPrintf("In oat file '%s' found bss symbol(s) outside .bss or unordered: "
- "begin = %p, methods_ = %p, roots = %p, end = %p",
+ "begin = %p, methods = %p, roots = %p, end = %p",
GetLocation().c_str(),
bss_begin_,
bss_methods_,
@@ -370,11 +339,15 @@
return false;
}
- uint8_t* after_arrays = (bss_methods_ != nullptr) ? bss_methods_ : bss_roots_; // May be null.
- uint8_t* dex_cache_arrays = (bss_begin_ == after_arrays) ? nullptr : bss_begin_;
- uint8_t* dex_cache_arrays_end =
- (bss_begin_ == after_arrays) ? nullptr : (after_arrays != nullptr) ? after_arrays : bss_end_;
- DCHECK_EQ(dex_cache_arrays != nullptr, dex_cache_arrays_end != nullptr);
+ if (bss_methods_ != nullptr && bss_methods_ != bss_begin_) {
+ *error_msg = StringPrintf("In oat file '%s' found unexpected .bss gap before 'oatbssmethods': "
+ "begin = %p, methods = %p",
+ GetLocation().c_str(),
+ bss_begin_,
+ bss_methods_);
+ return false;
+ }
+
uint32_t dex_file_count = GetOatHeader().GetDexFileCount();
oat_dex_files_storage_.reserve(dex_file_count);
for (size_t i = 0; i < dex_file_count; i++) {
@@ -609,37 +582,6 @@
reinterpret_cast<const DexFile::Header*>(dex_file_pointer)->method_ids_size_);
}
- uint8_t* current_dex_cache_arrays = nullptr;
- if (dex_cache_arrays != nullptr) {
- // All DexCache types except for CallSite have their instance counts in the
- // DexFile header. For CallSites, we need to read the info from the MapList.
- const DexFile::MapItem* call_sites_item = nullptr;
- if (!FindDexFileMapItem(DexBegin(),
- DexEnd(),
- DexFile::MapItemType::kDexTypeCallSiteIdItem,
- &call_sites_item)) {
- *error_msg = StringPrintf("In oat file '%s' could not read data from truncated DexFile map",
- GetLocation().c_str());
- return false;
- }
- size_t num_call_sites = call_sites_item == nullptr ? 0 : call_sites_item->size_;
- DexCacheArraysLayout layout(pointer_size, *header, num_call_sites);
- if (layout.Size() != 0u) {
- if (static_cast<size_t>(dex_cache_arrays_end - dex_cache_arrays) < layout.Size()) {
- *error_msg = StringPrintf("In oat file '%s' found OatDexFile #%zu for '%s' with "
- "truncated dex cache arrays, %zu < %zu.",
- GetLocation().c_str(),
- i,
- dex_file_location.c_str(),
- static_cast<size_t>(dex_cache_arrays_end - dex_cache_arrays),
- layout.Size());
- return false;
- }
- current_dex_cache_arrays = dex_cache_arrays;
- dex_cache_arrays += layout.Size();
- }
- }
-
std::string canonical_location = DexFile::GetDexCanonicalLocation(dex_file_location.c_str());
// Create the OatDexFile and add it to the owning container.
@@ -651,7 +593,6 @@
lookup_table_data,
method_bss_mapping,
class_offsets_pointer,
- current_dex_cache_arrays,
dex_layout_sections);
oat_dex_files_storage_.push_back(oat_dex_file);
@@ -664,14 +605,6 @@
}
}
- if (dex_cache_arrays != dex_cache_arrays_end) {
- // We expect the bss section to be either empty (dex_cache_arrays and bss_end_
- // both null) or contain just the dex cache arrays and optionally some GC roots.
- *error_msg = StringPrintf("In oat file '%s' found unexpected bss size bigger by %zu bytes.",
- GetLocation().c_str(),
- static_cast<size_t>(bss_end_ - dex_cache_arrays));
- return false;
- }
return true;
}
@@ -1379,7 +1312,6 @@
const uint8_t* lookup_table_data,
const MethodBssMapping* method_bss_mapping_data,
const uint32_t* oat_class_offsets_pointer,
- uint8_t* dex_cache_arrays,
const DexLayoutSections* dex_layout_sections)
: oat_file_(oat_file),
dex_file_location_(dex_file_location),
@@ -1389,7 +1321,6 @@
lookup_table_data_(lookup_table_data),
method_bss_mapping_(method_bss_mapping_data),
oat_class_offsets_pointer_(oat_class_offsets_pointer),
- dex_cache_arrays_(dex_cache_arrays),
dex_layout_sections_(dex_layout_sections) {
// Initialize TypeLookupTable.
if (lookup_table_data_ != nullptr) {
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index 9a7fe51..e13126b 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -422,10 +422,6 @@
// Returns the offset to the OatClass information. Most callers should use GetOatClass.
uint32_t GetOatClassOffset(uint16_t class_def_index) const;
- uint8_t* GetDexCacheArrays() const {
- return dex_cache_arrays_;
- }
-
const uint8_t* GetLookupTableData() const {
return lookup_table_data_;
}
@@ -470,7 +466,6 @@
const uint8_t* lookup_table_data,
const MethodBssMapping* method_bss_mapping,
const uint32_t* oat_class_offsets_pointer,
- uint8_t* dex_cache_arrays,
const DexLayoutSections* dex_layout_sections);
static void AssertAotCompiler();
@@ -483,7 +478,6 @@
const uint8_t* const lookup_table_data_ = nullptr;
const MethodBssMapping* const method_bss_mapping_ = nullptr;
const uint32_t* const oat_class_offsets_pointer_ = 0u;
- uint8_t* const dex_cache_arrays_ = nullptr;
mutable std::unique_ptr<TypeLookupTable> lookup_table_;
const DexLayoutSections* const dex_layout_sections_ = nullptr;