ART: Move dex structs into own header
Separating out the structs from DexFile allows them to be forward-
declared, which reduces the need to include the dex_file header.
Bug: 119869270
Test: m
Change-Id: I32dde5a632884bca7435cd584b4a81883de2e7b4
diff --git a/runtime/art_field-inl.h b/runtime/art_field-inl.h
index 53e4c11..fb41418 100644
--- a/runtime/art_field-inl.h
+++ b/runtime/art_field-inl.h
@@ -291,7 +291,7 @@
return field_index == 0 ? "[Ljava/lang/Class;" : "[[Ljava/lang/Class;";
}
const DexFile* dex_file = GetDexFile();
- const DexFile::FieldId& field_id = dex_file->GetFieldId(field_index);
+ const dex::FieldId& field_id = dex_file->GetFieldId(field_index);
return dex_file->GetFieldTypeDescriptor(field_id);
}
@@ -342,7 +342,7 @@
inline ObjPtr<mirror::String> ArtField::ResolveNameString() {
uint32_t dex_field_index = GetDexFieldIndex();
CHECK_NE(dex_field_index, dex::kDexNoIndex);
- const DexFile::FieldId& field_id = GetDexFile()->GetFieldId(dex_field_index);
+ const dex::FieldId& field_id = GetDexFile()->GetFieldId(dex_field_index);
return Runtime::Current()->GetClassLinker()->ResolveString(field_id.name_idx_, this);
}
diff --git a/runtime/art_method-inl.h b/runtime/art_method-inl.h
index fda269c..02196ba 100644
--- a/runtime/art_method-inl.h
+++ b/runtime/art_method-inl.h
@@ -224,11 +224,11 @@
inline ObjPtr<mirror::String> ArtMethod::ResolveNameString() {
DCHECK(!IsProxyMethod());
- const DexFile::MethodId& method_id = GetDexFile()->GetMethodId(GetDexMethodIndex());
+ const dex::MethodId& method_id = GetDexFile()->GetMethodId(GetDexMethodIndex());
return Runtime::Current()->GetClassLinker()->ResolveString(method_id.name_idx_, this);
}
-inline const DexFile::CodeItem* ArtMethod::GetCodeItem() {
+inline const dex::CodeItem* ArtMethod::GetCodeItem() {
return GetDexFile()->GetCodeItem(GetCodeItemOffset());
}
@@ -245,16 +245,16 @@
return annotations::GetLineNumFromPC(GetDexFile(), this, dex_pc);
}
-inline const DexFile::ProtoId& ArtMethod::GetPrototype() {
+inline const dex::ProtoId& ArtMethod::GetPrototype() {
DCHECK(!IsProxyMethod());
const DexFile* dex_file = GetDexFile();
return dex_file->GetMethodPrototype(dex_file->GetMethodId(GetDexMethodIndex()));
}
-inline const DexFile::TypeList* ArtMethod::GetParameterTypeList() {
+inline const dex::TypeList* ArtMethod::GetParameterTypeList() {
DCHECK(!IsProxyMethod());
const DexFile* dex_file = GetDexFile();
- const DexFile::ProtoId& proto = dex_file->GetMethodPrototype(
+ const dex::ProtoId& proto = dex_file->GetMethodPrototype(
dex_file->GetMethodId(GetDexMethodIndex()));
return dex_file->GetProtoParameters(proto);
}
@@ -273,7 +273,7 @@
}
}
-inline const DexFile::ClassDef& ArtMethod::GetClassDef() {
+inline const dex::ClassDef& ArtMethod::GetClassDef() {
DCHECK(!IsProxyMethod());
return GetDexFile()->GetClassDef(GetClassDefIndex());
}
@@ -344,8 +344,8 @@
inline dex::TypeIndex ArtMethod::GetReturnTypeIndex() {
DCHECK(!IsProxyMethod());
const DexFile* dex_file = GetDexFile();
- const DexFile::MethodId& method_id = dex_file->GetMethodId(GetDexMethodIndex());
- const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
+ const dex::MethodId& method_id = dex_file->GetMethodId(GetDexMethodIndex());
+ const dex::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
return proto_id.return_type_idx_;
}
diff --git a/runtime/art_method.cc b/runtime/art_method.cc
index 5f5361a..dd5b0d5 100644
--- a/runtime/art_method.cc
+++ b/runtime/art_method.cc
@@ -133,7 +133,7 @@
DCHECK(IsObsolete());
const DexFile* dex_file = GetDexFile();
const dex::TypeIndex declaring_class_type = dex_file->GetMethodId(GetDexMethodIndex()).class_idx_;
- const DexFile::ClassDef* class_def = dex_file->FindClassDef(declaring_class_type);
+ const dex::ClassDef* class_def = dex_file->FindClassDef(declaring_class_type);
CHECK(class_def != nullptr);
return dex_file->GetIndexForClassDef(*class_def);
}
@@ -182,13 +182,13 @@
bool ArtMethod::HasSameNameAndSignature(ArtMethod* other) {
ScopedAssertNoThreadSuspension ants("HasSameNameAndSignature");
const DexFile* dex_file = GetDexFile();
- const DexFile::MethodId& mid = dex_file->GetMethodId(GetDexMethodIndex());
+ const dex::MethodId& mid = dex_file->GetMethodId(GetDexMethodIndex());
if (GetDexCache() == other->GetDexCache()) {
- const DexFile::MethodId& mid2 = dex_file->GetMethodId(other->GetDexMethodIndex());
+ const dex::MethodId& mid2 = dex_file->GetMethodId(other->GetDexMethodIndex());
return mid.name_idx_ == mid2.name_idx_ && mid.proto_idx_ == mid2.proto_idx_;
}
const DexFile* dex_file2 = other->GetDexFile();
- const DexFile::MethodId& mid2 = dex_file2->GetMethodId(other->GetDexMethodIndex());
+ const dex::MethodId& mid2 = dex_file2->GetMethodId(other->GetDexMethodIndex());
if (!DexFileStringEquals(dex_file, mid.name_idx_, dex_file2, mid2.name_idx_)) {
return false; // Name mismatch.
}
@@ -235,17 +235,17 @@
uint32_t name_and_signature_idx) {
const DexFile* dexfile = GetDexFile();
const uint32_t dex_method_idx = GetDexMethodIndex();
- const DexFile::MethodId& mid = dexfile->GetMethodId(dex_method_idx);
- const DexFile::MethodId& name_and_sig_mid = other_dexfile.GetMethodId(name_and_signature_idx);
+ const dex::MethodId& mid = dexfile->GetMethodId(dex_method_idx);
+ const dex::MethodId& name_and_sig_mid = other_dexfile.GetMethodId(name_and_signature_idx);
DCHECK_STREQ(dexfile->GetMethodName(mid), other_dexfile.GetMethodName(name_and_sig_mid));
DCHECK_EQ(dexfile->GetMethodSignature(mid), other_dexfile.GetMethodSignature(name_and_sig_mid));
if (dexfile == &other_dexfile) {
return dex_method_idx;
}
const char* mid_declaring_class_descriptor = dexfile->StringByTypeIdx(mid.class_idx_);
- const DexFile::TypeId* other_type_id = other_dexfile.FindTypeId(mid_declaring_class_descriptor);
+ const dex::TypeId* other_type_id = other_dexfile.FindTypeId(mid_declaring_class_descriptor);
if (other_type_id != nullptr) {
- const DexFile::MethodId* other_mid = other_dexfile.FindMethodId(
+ const dex::MethodId* other_mid = other_dexfile.FindMethodId(
*other_type_id, other_dexfile.GetStringId(name_and_sig_mid.name_idx_),
other_dexfile.GetProtoId(name_and_sig_mid.proto_idx_));
if (other_mid != nullptr) {
@@ -447,11 +447,11 @@
// recreate the class_def_index from the descriptor.
std::string descriptor_storage;
- const DexFile::TypeId* declaring_class_type_id =
+ const dex::TypeId* declaring_class_type_id =
dex_file->FindTypeId(method->GetDeclaringClass()->GetDescriptor(&descriptor_storage));
CHECK(declaring_class_type_id != nullptr);
dex::TypeIndex declaring_class_type_index = dex_file->GetIndexForTypeId(*declaring_class_type_id);
- const DexFile::ClassDef* declaring_class_type_def =
+ const dex::ClassDef* declaring_class_type_def =
dex_file->FindClassDef(declaring_class_type_index);
CHECK(declaring_class_type_def != nullptr);
uint16_t declaring_class_def_index = dex_file->GetIndexForClassDef(*declaring_class_type_def);
@@ -522,7 +522,7 @@
auto* dex_file = dex_cache->GetDexFile();
const auto& method_id = dex_file->GetMethodId(GetDexMethodIndex());
const auto& proto_id = dex_file->GetMethodPrototype(method_id);
- const DexFile::TypeList* proto_params = dex_file->GetProtoParameters(proto_id);
+ const dex::TypeList* proto_params = dex_file->GetProtoParameters(proto_id);
auto count = proto_params != nullptr ? proto_params->Size() : 0u;
auto param_len = params != nullptr ? params->GetLength() : 0u;
if (param_len != count) {
diff --git a/runtime/art_method.h b/runtime/art_method.h
index cc214f7..6b598da 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -29,7 +29,7 @@
#include "base/macros.h"
#include "base/runtime_debug.h"
#include "dex/code_item_accessors.h"
-#include "dex/dex_file.h"
+#include "dex/dex_file_structs.h"
#include "dex/dex_instruction_iterator.h"
#include "dex/modifiers.h"
#include "dex/primitive.h"
@@ -40,6 +40,7 @@
namespace art {
+class DexFile;
template<class T> class Handle;
class ImtConflictTable;
enum InvokeType : uint32_t;
@@ -586,21 +587,21 @@
ObjPtr<mirror::String> ResolveNameString() REQUIRES_SHARED(Locks::mutator_lock_);
- const DexFile::CodeItem* GetCodeItem() REQUIRES_SHARED(Locks::mutator_lock_);
+ const dex::CodeItem* GetCodeItem() REQUIRES_SHARED(Locks::mutator_lock_);
bool IsResolvedTypeIdx(dex::TypeIndex type_idx) REQUIRES_SHARED(Locks::mutator_lock_);
int32_t GetLineNumFromDexPC(uint32_t dex_pc) REQUIRES_SHARED(Locks::mutator_lock_);
- const DexFile::ProtoId& GetPrototype() REQUIRES_SHARED(Locks::mutator_lock_);
+ const dex::ProtoId& GetPrototype() REQUIRES_SHARED(Locks::mutator_lock_);
- const DexFile::TypeList* GetParameterTypeList() REQUIRES_SHARED(Locks::mutator_lock_);
+ const dex::TypeList* GetParameterTypeList() REQUIRES_SHARED(Locks::mutator_lock_);
const char* GetDeclaringClassSourceFile() REQUIRES_SHARED(Locks::mutator_lock_);
uint16_t GetClassDefIndex() REQUIRES_SHARED(Locks::mutator_lock_);
- const DexFile::ClassDef& GetClassDef() REQUIRES_SHARED(Locks::mutator_lock_);
+ const dex::ClassDef& GetClassDef() REQUIRES_SHARED(Locks::mutator_lock_);
ALWAYS_INLINE size_t GetNumberOfParameters() REQUIRES_SHARED(Locks::mutator_lock_);
diff --git a/runtime/class_linker-inl.h b/runtime/class_linker-inl.h
index 43f3ed3..978b1ab 100644
--- a/runtime/class_linker-inl.h
+++ b/runtime/class_linker-inl.h
@@ -23,6 +23,8 @@
#include "art_method-inl.h"
#include "base/mutex.h"
#include "class_linker.h"
+#include "dex/dex_file.h"
+#include "dex/dex_file_structs.h"
#include "gc_root-inl.h"
#include "handle_scope-inl.h"
#include "mirror/class_loader.h"
@@ -271,7 +273,7 @@
dex_cache,
type,
[this, dex_cache, method_idx, class_loader]() REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::MethodId& method_id = dex_cache->GetDexFile()->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_cache->GetDexFile()->GetMethodId(method_idx);
ObjPtr<mirror::Class> klass =
LookupResolvedType(method_id.class_idx_, dex_cache, class_loader);
DCHECK(klass != nullptr);
@@ -286,7 +288,7 @@
ArtMethod* resolved = dex_cache->GetResolvedMethod(method_idx, pointer_size);
if (resolved == nullptr) {
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file.GetMethodId(method_idx);
ObjPtr<mirror::Class> klass = LookupResolvedType(method_id.class_idx_, dex_cache, class_loader);
if (klass != nullptr) {
resolved = FindResolvedMethod(klass, dex_cache, class_loader, method_idx);
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 3b92e2c..c22a5cb 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -2628,13 +2628,13 @@
return klass;
}
-using ClassPathEntry = std::pair<const DexFile*, const DexFile::ClassDef*>;
+using ClassPathEntry = std::pair<const DexFile*, const dex::ClassDef*>;
// Search a collection of DexFiles for a descriptor
ClassPathEntry FindInClassPath(const char* descriptor,
size_t hash, const std::vector<const DexFile*>& class_path) {
for (const DexFile* dex_file : class_path) {
- const DexFile::ClassDef* dex_class_def = OatDexFile::FindClassDef(*dex_file, descriptor, hash);
+ const dex::ClassDef* dex_class_def = OatDexFile::FindClassDef(*dex_file, descriptor, hash);
if (dex_class_def != nullptr) {
return ClassPathEntry(dex_file, dex_class_def);
}
@@ -2784,8 +2784,7 @@
ObjPtr<mirror::Class> ret;
auto define_class = [&](const DexFile* cp_dex_file) REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::ClassDef* dex_class_def =
- OatDexFile::FindClassDef(*cp_dex_file, descriptor, hash);
+ const dex::ClassDef* dex_class_def = OatDexFile::FindClassDef(*cp_dex_file, descriptor, hash);
if (dex_class_def != nullptr) {
ObjPtr<mirror::Class> klass = DefineClass(soa.Self(),
descriptor,
@@ -2985,7 +2984,7 @@
size_t hash,
Handle<mirror::ClassLoader> class_loader,
const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def) {
+ const dex::ClassDef& dex_class_def) {
StackHandleScope<3> hs(self);
auto klass = hs.NewHandle<mirror::Class>(nullptr);
@@ -3032,7 +3031,7 @@
// Get the real dex file. This will return the input if there aren't any callbacks or they do
// nothing.
DexFile const* new_dex_file = nullptr;
- DexFile::ClassDef const* new_class_def = nullptr;
+ dex::ClassDef const* new_class_def = nullptr;
// TODO We should ideally figure out some way to move this after we get a lock on the klass so it
// will only be called once.
Runtime::Current()->GetRuntimeCallbacks()->ClassPreDefine(descriptor,
@@ -3153,7 +3152,7 @@
}
uint32_t ClassLinker::SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def) {
+ const dex::ClassDef& dex_class_def) {
size_t num_ref = 0;
size_t num_8 = 0;
size_t num_16 = 0;
@@ -3171,7 +3170,7 @@
continue;
}
last_field_idx = field_idx;
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file.GetFieldId(field_idx);
const char* descriptor = dex_file.GetFieldTypeDescriptor(field_id);
char c = descriptor[0];
switch (c) {
@@ -3400,7 +3399,7 @@
}
void ClassLinker::SetupClass(const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def,
+ const dex::ClassDef& dex_class_def,
Handle<mirror::Class> klass,
ObjPtr<mirror::ClassLoader> class_loader) {
CHECK(klass != nullptr);
@@ -3481,7 +3480,7 @@
void ClassLinker::LoadClass(Thread* self,
const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def,
+ const dex::ClassDef& dex_class_def,
Handle<mirror::Class> klass) {
ClassAccessor accessor(dex_file,
dex_class_def,
@@ -3606,7 +3605,7 @@
Handle<mirror::Class> klass,
ArtMethod* dst) {
const uint32_t dex_method_idx = method.GetIndex();
- const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
+ const dex::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
const char* method_name = dex_file.StringDataByIdx(method_id.name_idx_);
ScopedAssertNoThreadSuspension ants("LoadMethod");
@@ -4987,7 +4986,7 @@
}
// Check if there are encoded static values needing initialization.
if (klass->NumStaticFields() != 0) {
- const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
+ const dex::ClassDef* dex_class_def = klass->GetClassDef();
DCHECK(dex_class_def != nullptr);
if (dex_class_def->static_values_off_ != 0) {
return false;
@@ -5204,7 +5203,7 @@
const size_t num_static_fields = klass->NumStaticFields();
if (num_static_fields > 0) {
- const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
+ const dex::ClassDef* dex_class_def = klass->GetClassDef();
CHECK(dex_class_def != nullptr);
StackHandleScope<3> hs(self);
Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader()));
@@ -5413,8 +5412,8 @@
DCHECK(Thread::Current()->IsExceptionPending());
DCHECK(!m->IsProxyMethod());
const DexFile* dex_file = m->GetDexFile();
- const DexFile::MethodId& method_id = dex_file->GetMethodId(m->GetDexMethodIndex());
- const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
+ const dex::MethodId& method_id = dex_file->GetMethodId(m->GetDexMethodIndex());
+ const dex::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
dex::TypeIndex return_type_idx = proto_id.return_type_idx_;
std::string return_type = dex_file->PrettyType(return_type_idx);
std::string class_loader = mirror::Object::PrettyTypeOf(m->GetDeclaringClass()->GetClassLoader());
@@ -5492,8 +5491,8 @@
return false;
}
}
- const DexFile::TypeList* types1 = method1->GetParameterTypeList();
- const DexFile::TypeList* types2 = method2->GetParameterTypeList();
+ const dex::TypeList* types1 = method1->GetParameterTypeList();
+ const dex::TypeList* types2 = method2->GetParameterTypeList();
if (types1 == nullptr) {
if (types2 != nullptr && types2->Size() != 0) {
ThrowSignatureMismatch(klass, super_klass, method1,
@@ -5852,7 +5851,7 @@
bool ClassLinker::LoadSuperAndInterfaces(Handle<mirror::Class> klass, const DexFile& dex_file) {
CHECK_EQ(ClassStatus::kIdx, klass->GetStatus());
- const DexFile::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
+ const dex::ClassDef& class_def = dex_file.GetClassDef(klass->GetDexClassDefIndex());
dex::TypeIndex super_class_idx = class_def.superclass_idx_;
if (super_class_idx.IsValid()) {
// Check that a class does not inherit from itself directly.
@@ -5883,7 +5882,7 @@
CHECK(super_class->IsResolved());
klass->SetSuperClass(super_class);
}
- const DexFile::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
+ const dex::TypeList* interfaces = dex_file.GetInterfacesList(class_def);
if (interfaces != nullptr) {
for (size_t i = 0; i < interfaces->Size(); i++) {
dex::TypeIndex idx = interfaces->GetTypeItem(i).type_idx_;
@@ -6027,7 +6026,7 @@
REQUIRES_SHARED(Locks::mutator_lock_) {
DCHECK(!other->IsProxyMethod()) << other->PrettyMethod();
const DexFile* other_dex_file = other->GetDexFile();
- const DexFile::MethodId& other_mid = other_dex_file->GetMethodId(other->GetDexMethodIndex());
+ const dex::MethodId& other_mid = other_dex_file->GetMethodId(other->GetDexMethodIndex());
if (dex_file_ == other_dex_file) {
return mid_->name_idx_ == other_mid.name_idx_ && mid_->proto_idx_ == other_mid.proto_idx_;
}
@@ -6045,7 +6044,7 @@
// Dex file for the method to compare against.
const DexFile* const dex_file_;
// MethodId for the method to compare against.
- const DexFile::MethodId* const mid_;
+ const dex::MethodId* const mid_;
// Lazily computed name from the dex file's strings.
const char* name_;
// Lazily computed name length.
@@ -8336,7 +8335,7 @@
return resolved;
}
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file.GetMethodId(method_idx);
ObjPtr<mirror::Class> klass = nullptr;
if (valid_dex_cache_method) {
// We have a valid method from the DexCache but we need to perform ICCE and IAE checks.
@@ -8417,7 +8416,7 @@
return resolved;
}
// Fail, get the declaring class.
- const DexFile::MethodId& method_id = dex_cache->GetDexFile()->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_cache->GetDexFile()->GetMethodId(method_idx);
ObjPtr<mirror::Class> klass = ResolveType(method_id.class_idx_, dex_cache, class_loader);
if (klass == nullptr) {
Thread::Current()->AssertPendingException();
@@ -8443,7 +8442,7 @@
ObjPtr<mirror::ClassLoader> class_loader,
bool is_static) {
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file.GetFieldId(field_idx);
ObjPtr<mirror::Class> klass = dex_cache->GetResolvedType(field_id.class_idx_);
if (klass == nullptr) {
klass = LookupResolvedType(field_id.class_idx_, dex_cache, class_loader);
@@ -8468,7 +8467,7 @@
return resolved;
}
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file.GetFieldId(field_idx);
ObjPtr<mirror::Class> klass = ResolveType(field_id.class_idx_, dex_cache, class_loader);
if (klass == nullptr) {
DCHECK(Thread::Current()->IsExceptionPending());
@@ -8494,7 +8493,7 @@
return resolved;
}
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file.GetFieldId(field_idx);
ObjPtr<mirror::Class> klass = ResolveType(field_id.class_idx_, dex_cache, class_loader);
if (klass == nullptr) {
DCHECK(Thread::Current()->IsExceptionPending());
@@ -8523,7 +8522,7 @@
: klass->FindInstanceField(dex_cache, field_idx);
if (resolved == nullptr) {
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file.GetFieldId(field_idx);
const char* name = dex_file.GetFieldName(field_id);
const char* type = dex_file.GetFieldTypeDescriptor(field_id);
resolved = is_static ? mirror::Class::FindStaticField(self, klass, name, type)
@@ -8551,7 +8550,7 @@
ArtField* resolved = nullptr;
Thread* self = Thread::Current();
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file.GetFieldId(field_idx);
const char* name = dex_file.GetFieldName(field_id);
const char* type = dex_file.GetFieldTypeDescriptor(field_id);
@@ -8588,7 +8587,7 @@
// First resolve the return type.
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::ProtoId& proto_id = dex_file.GetProtoId(proto_idx);
+ const dex::ProtoId& proto_id = dex_file.GetProtoId(proto_idx);
Handle<mirror::Class> return_type(hs.NewHandle(
ResolveType(proto_id.return_type_idx_, dex_cache, class_loader)));
if (return_type == nullptr) {
@@ -8644,7 +8643,7 @@
mirror::MethodHandle* ClassLinker::ResolveMethodHandleForField(
Thread* self,
- const DexFile::MethodHandleItem& method_handle,
+ const dex::MethodHandleItem& method_handle,
ArtMethod* referrer) {
DexFile::MethodHandleType handle_type =
static_cast<DexFile::MethodHandleType>(method_handle.method_handle_type_);
@@ -8772,7 +8771,7 @@
mirror::MethodHandle* ClassLinker::ResolveMethodHandleForMethod(
Thread* self,
- const DexFile::MethodHandleItem& method_handle,
+ const dex::MethodHandleItem& method_handle,
ArtMethod* referrer) {
DexFile::MethodHandleType handle_type =
static_cast<DexFile::MethodHandleType>(method_handle.method_handle_type_);
@@ -8895,7 +8894,7 @@
}
const DexFile* dex_file = referrer->GetDexFile();
- const DexFile::MethodId& method_id = dex_file->GetMethodId(method_handle.field_or_method_idx_);
+ const dex::MethodId& method_id = dex_file->GetMethodId(method_handle.field_or_method_idx_);
int32_t index = 0;
if (receiver_count != 0) {
// Insert receiver. Use the class identified in the method handle rather than the declaring
@@ -8907,7 +8906,7 @@
method_params->Set(index++, receiver_class);
}
- const DexFile::ProtoId& proto_id = dex_file->GetProtoId(method_id.proto_idx_);
+ const dex::ProtoId& proto_id = dex_file->GetProtoId(method_id.proto_idx_);
DexFileParameterIterator it(*dex_file, proto_id);
while (it.HasNext()) {
DCHECK_LT(index, num_params);
@@ -8951,7 +8950,7 @@
ArtMethod* referrer)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile* const dex_file = referrer->GetDexFile();
- const DexFile::MethodHandleItem& method_handle = dex_file->GetMethodHandle(method_handle_idx);
+ const dex::MethodHandleItem& method_handle = dex_file->GetMethodHandle(method_handle_idx);
switch (static_cast<DexFile::MethodHandleType>(method_handle.method_handle_type_)) {
case DexFile::MethodHandleType::kStaticPut:
case DexFile::MethodHandleType::kStaticGet:
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index d0a7c9b..fa5df44 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -29,7 +29,6 @@
#include "base/macros.h"
#include "dex/class_accessor.h"
#include "dex/dex_cache_resolved_classes.h"
-#include "dex/dex_file.h"
#include "dex/dex_file_types.h"
#include "gc_root.h"
#include "handle.h"
@@ -39,6 +38,10 @@
namespace art {
+namespace dex {
+struct ClassDef;
+} // namespace dex
+
namespace gc {
namespace space {
class ImageSpace;
@@ -73,6 +76,7 @@
class ClassHierarchyAnalysis;
enum class ClassRoot : uint32_t;
class ClassTable;
+class DexFile;
template<class T> class Handle;
class ImtConflictTable;
template<typename T> class LengthPrefixedArray;
@@ -185,7 +189,7 @@
size_t hash,
Handle<mirror::ClassLoader> class_loader,
const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def)
+ const dex::ClassDef& dex_class_def)
REQUIRES_SHARED(Locks::mutator_lock_)
REQUIRES(!Locks::dex_lock_);
@@ -844,19 +848,19 @@
// Precomputes size needed for Class, in the case of a non-temporary class this size must be
// sufficient to hold all static fields.
uint32_t SizeOfClassWithoutEmbeddedTables(const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def);
+ const dex::ClassDef& dex_class_def);
// Setup the classloader, class def index, type idx so that we can insert this class in the class
// table.
void SetupClass(const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def,
+ const dex::ClassDef& dex_class_def,
Handle<mirror::Class> klass,
ObjPtr<mirror::ClassLoader> class_loader)
REQUIRES_SHARED(Locks::mutator_lock_);
void LoadClass(Thread* self,
const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def,
+ const dex::ClassDef& dex_class_def,
Handle<mirror::Class> klass)
REQUIRES_SHARED(Locks::mutator_lock_);
@@ -1028,12 +1032,12 @@
REQUIRES_SHARED(Locks::mutator_lock_);
mirror::MethodHandle* ResolveMethodHandleForField(Thread* self,
- const DexFile::MethodHandleItem& method_handle,
+ const dex::MethodHandleItem& method_handle,
ArtMethod* referrer)
REQUIRES_SHARED(Locks::mutator_lock_);
mirror::MethodHandle* ResolveMethodHandleForMethod(Thread* self,
- const DexFile::MethodHandleItem& method_handle,
+ const dex::MethodHandleItem& method_handle,
ArtMethod* referrer)
REQUIRES_SHARED(Locks::mutator_lock_);
@@ -1403,9 +1407,9 @@
Handle<mirror::Class> klass ATTRIBUTE_UNUSED,
Handle<mirror::ClassLoader> class_loader ATTRIBUTE_UNUSED,
const DexFile& initial_dex_file ATTRIBUTE_UNUSED,
- const DexFile::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
+ const dex::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
/*out*/DexFile const** final_dex_file ATTRIBUTE_UNUSED,
- /*out*/DexFile::ClassDef const** final_class_def ATTRIBUTE_UNUSED)
+ /*out*/dex::ClassDef const** final_class_def ATTRIBUTE_UNUSED)
REQUIRES_SHARED(Locks::mutator_lock_) {}
// A class has been loaded.
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index 061c788..f3aefc2 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -429,13 +429,13 @@
REQUIRES_SHARED(Locks::mutator_lock_) {
// Verify all the classes defined in this file
for (size_t i = 0; i < dex.NumClassDefs(); i++) {
- const DexFile::ClassDef& class_def = dex.GetClassDef(i);
+ const dex::ClassDef& class_def = dex.GetClassDef(i);
const char* descriptor = dex.GetClassDescriptor(class_def);
AssertDexFileClass(class_loader, descriptor);
}
// Verify all the types referenced by this file
for (size_t i = 0; i < dex.NumTypeIds(); i++) {
- const DexFile::TypeId& type_id = dex.GetTypeId(dex::TypeIndex(i));
+ const dex::TypeId& type_id = dex.GetTypeId(dex::TypeIndex(i));
const char* descriptor = dex.GetTypeDescriptor(type_id);
AssertDexFileClass(class_loader, descriptor);
}
@@ -997,7 +997,7 @@
Handle<mirror::DexCache> dex_cache = hs.NewHandle(all_fields_klass->GetDexCache());
const DexFile& dex_file = *dex_cache->GetDexFile();
// Get the index of the array class we want to test.
- const DexFile::TypeId* array_id = dex_file.FindTypeId("[Ljava/lang/Object;");
+ const dex::TypeId* array_id = dex_file.FindTypeId("[Ljava/lang/Object;");
ASSERT_TRUE(array_id != nullptr);
dex::TypeIndex array_idx = dex_file.GetIndexForTypeId(*array_id);
// Check that the array class wasn't resolved yet.
@@ -1323,7 +1323,7 @@
klass->FindClassMethod("getS0", "()Ljava/lang/Object;", kRuntimePointerSize);
ASSERT_TRUE(getS0 != nullptr);
ASSERT_TRUE(getS0->IsStatic());
- const DexFile::TypeId* type_id = dex_file->FindTypeId("LStaticsFromCode;");
+ const dex::TypeId* type_id = dex_file->FindTypeId("LStaticsFromCode;");
ASSERT_TRUE(type_id != nullptr);
dex::TypeIndex type_idx = dex_file->GetIndexForTypeId(*type_id);
ObjPtr<mirror::Class> uninit = ResolveVerifyAndClinit(type_idx,
@@ -1564,7 +1564,7 @@
Handle<mirror::DexCache> dex_cache = hs.NewHandle(
class_linker_->FindDexCache(soa.Self(), dex_file));
- const DexFile::MethodId& method1_id = dex_file.GetMethodId(method1->GetDexMethodIndex());
+ const dex::MethodId& method1_id = dex_file.GetMethodId(method1->GetDexMethodIndex());
// This is the MethodType corresponding to the prototype of
// String MethodTypes# method1(String).
@@ -1596,7 +1596,7 @@
kRuntimePointerSize);
ASSERT_TRUE(method2 != nullptr);
ASSERT_FALSE(method2->IsDirect());
- const DexFile::MethodId& method2_id = dex_file.GetMethodId(method2->GetDexMethodIndex());
+ const dex::MethodId& method2_id = dex_file.GetMethodId(method2->GetDexMethodIndex());
Handle<mirror::MethodType> method2_type = hs.NewHandle(
class_linker_->ResolveMethodType(soa.Self(), method2_id.proto_idx_, dex_cache, class_loader));
ASSERT_OBJ_PTR_NE(method1_type.Get(), method2_type.Get());
diff --git a/runtime/common_dex_operations.h b/runtime/common_dex_operations.h
index 5c5431d..1c95622 100644
--- a/runtime/common_dex_operations.h
+++ b/runtime/common_dex_operations.h
@@ -24,6 +24,7 @@
#include "base/macros.h"
#include "class_linker.h"
#include "dex/code_item_accessors.h"
+#include "dex/dex_file_structs.h"
#include "dex/primitive.h"
#include "handle_scope-inl.h"
#include "instrumentation.h"
@@ -42,7 +43,7 @@
namespace interpreter {
void ArtInterpreterToInterpreterBridge(Thread* self,
- const DexFile::CodeItem* code_item,
+ const dex::CodeItem* code_item,
ShadowFrame* shadow_frame,
JValue* result)
REQUIRES_SHARED(Locks::mutator_lock_);
diff --git a/runtime/debugger.cc b/runtime/debugger.cc
index 80140b3..adf01c3 100644
--- a/runtime/debugger.cc
+++ b/runtime/debugger.cc
@@ -3927,7 +3927,7 @@
StackHandleScope<2> hs(soa.Self());
HandleWrapper<mirror::Object> h_obj(hs.NewHandleWrapper(&receiver));
HandleWrapper<mirror::Class> h_klass(hs.NewHandleWrapper(&c));
- const DexFile::TypeList* types = m->GetParameterTypeList();
+ const dex::TypeList* types = m->GetParameterTypeList();
for (size_t i = 0; i < arg_count; ++i) {
if (shorty[i + 1] != JdwpTagToShortyChar(arg_types[i])) {
return JDWP::ERR_ILLEGAL_ARGUMENT;
diff --git a/runtime/dex/dex_file_annotations.cc b/runtime/dex/dex_file_annotations.cc
index 9127a27..e75baf8 100644
--- a/runtime/dex/dex_file_annotations.cc
+++ b/runtime/dex/dex_file_annotations.cc
@@ -44,6 +44,15 @@
using android::base::StringPrintf;
+using dex::AnnotationItem;
+using dex::AnnotationSetItem;
+using dex::AnnotationSetRefItem;
+using dex::AnnotationSetRefList;
+using dex::AnnotationsDirectoryItem;
+using dex::FieldAnnotationsItem;
+using dex::MethodAnnotationsItem;
+using dex::ParameterAnnotationsItem;
+
struct DexFile::AnnotationValue {
JValue value_;
uint8_t type_;
@@ -75,7 +84,7 @@
return dex_file_;
}
- const DexFile::ClassDef* GetClassDef() const REQUIRES_SHARED(Locks::mutator_lock_) {
+ const dex::ClassDef* GetClassDef() const REQUIRES_SHARED(Locks::mutator_lock_) {
return class_def_;
}
@@ -107,7 +116,7 @@
ClassData(Handle<mirror::Class> klass,
ArtMethod* method,
const DexFile& dex_file,
- const DexFile::ClassDef* class_def) REQUIRES_SHARED(Locks::mutator_lock_)
+ const dex::ClassDef* class_def) REQUIRES_SHARED(Locks::mutator_lock_)
: real_klass_(klass),
method_(method),
dex_file_(dex_file),
@@ -118,7 +127,7 @@
Handle<mirror::Class> real_klass_;
ArtMethod* method_;
const DexFile& dex_file_;
- const DexFile::ClassDef* class_def_;
+ const dex::ClassDef* class_def_;
DISALLOW_COPY_AND_ASSIGN(ClassData);
};
@@ -137,21 +146,20 @@
return actual == expected;
}
-const DexFile::AnnotationSetItem* FindAnnotationSetForField(ArtField* field)
+const AnnotationSetItem* FindAnnotationSetForField(ArtField* field)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile* dex_file = field->GetDexFile();
ObjPtr<mirror::Class> klass = field->GetDeclaringClass();
- const DexFile::ClassDef* class_def = klass->GetClassDef();
+ const dex::ClassDef* class_def = klass->GetClassDef();
if (class_def == nullptr) {
DCHECK(klass->IsProxyClass());
return nullptr;
}
- const DexFile::AnnotationsDirectoryItem* annotations_dir =
- dex_file->GetAnnotationsDirectory(*class_def);
+ const AnnotationsDirectoryItem* annotations_dir = dex_file->GetAnnotationsDirectory(*class_def);
if (annotations_dir == nullptr) {
return nullptr;
}
- const DexFile::FieldAnnotationsItem* field_annotations =
+ const FieldAnnotationsItem* field_annotations =
dex_file->GetFieldAnnotations(annotations_dir);
if (field_annotations == nullptr) {
return nullptr;
@@ -166,14 +174,14 @@
return nullptr;
}
-const DexFile::AnnotationItem* SearchAnnotationSet(const DexFile& dex_file,
- const DexFile::AnnotationSetItem* annotation_set,
- const char* descriptor,
- uint32_t visibility)
+const AnnotationItem* SearchAnnotationSet(const DexFile& dex_file,
+ const AnnotationSetItem* annotation_set,
+ const char* descriptor,
+ uint32_t visibility)
REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::AnnotationItem* result = nullptr;
+ const AnnotationItem* result = nullptr;
for (uint32_t i = 0; i < annotation_set->size_; ++i) {
- const DexFile::AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
+ const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
if (!IsVisibilityCompatible(annotation_item->visibility_, visibility)) {
continue;
}
@@ -268,16 +276,14 @@
return nullptr;
}
-const DexFile::AnnotationSetItem* FindAnnotationSetForMethod(const DexFile& dex_file,
- const DexFile::ClassDef& class_def,
- uint32_t method_index) {
- const DexFile::AnnotationsDirectoryItem* annotations_dir =
- dex_file.GetAnnotationsDirectory(class_def);
+const AnnotationSetItem* FindAnnotationSetForMethod(const DexFile& dex_file,
+ const dex::ClassDef& class_def,
+ uint32_t method_index) {
+ const AnnotationsDirectoryItem* annotations_dir = dex_file.GetAnnotationsDirectory(class_def);
if (annotations_dir == nullptr) {
return nullptr;
}
- const DexFile::MethodAnnotationsItem* method_annotations =
- dex_file.GetMethodAnnotations(annotations_dir);
+ const MethodAnnotationsItem* method_annotations = dex_file.GetMethodAnnotations(annotations_dir);
if (method_annotations == nullptr) {
return nullptr;
}
@@ -290,7 +296,7 @@
return nullptr;
}
-inline const DexFile::AnnotationSetItem* FindAnnotationSetForMethod(ArtMethod* method)
+inline const AnnotationSetItem* FindAnnotationSetForMethod(ArtMethod* method)
REQUIRES_SHARED(Locks::mutator_lock_) {
if (method->IsProxyMethod()) {
return nullptr;
@@ -300,15 +306,15 @@
method->GetDexMethodIndex());
}
-const DexFile::ParameterAnnotationsItem* FindAnnotationsItemForMethod(ArtMethod* method)
+const ParameterAnnotationsItem* FindAnnotationsItemForMethod(ArtMethod* method)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile* dex_file = method->GetDexFile();
- const DexFile::AnnotationsDirectoryItem* annotations_dir =
+ const AnnotationsDirectoryItem* annotations_dir =
dex_file->GetAnnotationsDirectory(method->GetClassDef());
if (annotations_dir == nullptr) {
return nullptr;
}
- const DexFile::ParameterAnnotationsItem* parameter_annotations =
+ const ParameterAnnotationsItem* parameter_annotations =
dex_file->GetParameterAnnotations(annotations_dir);
if (parameter_annotations == nullptr) {
return nullptr;
@@ -323,16 +329,15 @@
return nullptr;
}
-const DexFile::AnnotationSetItem* FindAnnotationSetForClass(const ClassData& klass)
+const AnnotationSetItem* FindAnnotationSetForClass(const ClassData& klass)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile& dex_file = klass.GetDexFile();
- const DexFile::ClassDef* class_def = klass.GetClassDef();
+ const dex::ClassDef* class_def = klass.GetClassDef();
if (class_def == nullptr) {
DCHECK(klass.GetRealClass()->IsProxyClass());
return nullptr;
}
- const DexFile::AnnotationsDirectoryItem* annotations_dir =
- dex_file.GetAnnotationsDirectory(*class_def);
+ const AnnotationsDirectoryItem* annotations_dir = dex_file.GetAnnotationsDirectory(*class_def);
if (annotations_dir == nullptr) {
return nullptr;
}
@@ -768,15 +773,14 @@
return new_member.Get();
}
-const DexFile::AnnotationItem* GetAnnotationItemFromAnnotationSet(
- const ClassData& klass,
- const DexFile::AnnotationSetItem* annotation_set,
- uint32_t visibility,
- Handle<mirror::Class> annotation_class)
+const AnnotationItem* GetAnnotationItemFromAnnotationSet(const ClassData& klass,
+ const AnnotationSetItem* annotation_set,
+ uint32_t visibility,
+ Handle<mirror::Class> annotation_class)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile& dex_file = klass.GetDexFile();
for (uint32_t i = 0; i < annotation_set->size_; ++i) {
- const DexFile::AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
+ const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
if (!IsVisibilityCompatible(annotation_item->visibility_, visibility)) {
continue;
}
@@ -805,13 +809,12 @@
return nullptr;
}
-ObjPtr<mirror::Object> GetAnnotationObjectFromAnnotationSet(
- const ClassData& klass,
- const DexFile::AnnotationSetItem* annotation_set,
- uint32_t visibility,
- Handle<mirror::Class> annotation_class)
+ObjPtr<mirror::Object> GetAnnotationObjectFromAnnotationSet(const ClassData& klass,
+ const AnnotationSetItem* annotation_set,
+ uint32_t visibility,
+ Handle<mirror::Class> annotation_class)
REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
+ const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
klass, annotation_set, visibility, annotation_class);
if (annotation_item == nullptr) {
return nullptr;
@@ -821,7 +824,7 @@
}
ObjPtr<mirror::Object> GetAnnotationValue(const ClassData& klass,
- const DexFile::AnnotationItem* annotation_item,
+ const AnnotationItem* annotation_item,
const char* annotation_name,
Handle<mirror::Class> array_class,
uint32_t expected_type)
@@ -855,11 +858,11 @@
static ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureValue(
const ClassData& klass,
- const DexFile::AnnotationSetItem* annotation_set)
+ const AnnotationSetItem* annotation_set)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile& dex_file = klass.GetDexFile();
StackHandleScope<1> hs(Thread::Current());
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(dex_file, annotation_set, "Ldalvik/annotation/Signature;",
DexFile::kDexVisibilitySystem);
if (annotation_item == nullptr) {
@@ -877,12 +880,11 @@
return obj->AsObjectArray<mirror::String>();
}
-ObjPtr<mirror::ObjectArray<mirror::Class>> GetThrowsValue(
- const ClassData& klass,
- const DexFile::AnnotationSetItem* annotation_set)
+ObjPtr<mirror::ObjectArray<mirror::Class>> GetThrowsValue(const ClassData& klass,
+ const AnnotationSetItem* annotation_set)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile& dex_file = klass.GetDexFile();
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(dex_file, annotation_set, "Ldalvik/annotation/Throws;",
DexFile::kDexVisibilitySystem);
if (annotation_item == nullptr) {
@@ -903,7 +905,7 @@
ObjPtr<mirror::ObjectArray<mirror::Object>> ProcessAnnotationSet(
const ClassData& klass,
- const DexFile::AnnotationSetItem* annotation_set,
+ const AnnotationSetItem* annotation_set,
uint32_t visibility)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile& dex_file = klass.GetDexFile();
@@ -925,7 +927,7 @@
uint32_t dest_index = 0;
for (uint32_t i = 0; i < size; ++i) {
- const DexFile::AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
+ const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
// Note that we do not use IsVisibilityCompatible here because older code
// was correct for this case.
if (annotation_item->visibility_ != visibility) {
@@ -961,7 +963,7 @@
ObjPtr<mirror::ObjectArray<mirror::Object>> ProcessAnnotationSetRefList(
const ClassData& klass,
- const DexFile::AnnotationSetRefList* set_ref_list,
+ const AnnotationSetRefList* set_ref_list,
uint32_t size)
REQUIRES_SHARED(Locks::mutator_lock_) {
const DexFile& dex_file = klass.GetDexFile();
@@ -982,8 +984,8 @@
return nullptr;
}
for (uint32_t index = 0; index < size; ++index) {
- const DexFile::AnnotationSetRefItem* set_ref_item = &set_ref_list->list_[index];
- const DexFile::AnnotationSetItem* set_item = dex_file.GetSetRefItemItem(set_ref_item);
+ const AnnotationSetRefItem* set_ref_item = &set_ref_list->list_[index];
+ const AnnotationSetItem* set_item = dex_file.GetSetRefItemItem(set_ref_item);
ObjPtr<mirror::Object> annotation_set = ProcessAnnotationSet(klass,
set_item,
DexFile::kDexVisibilityRuntime);
@@ -1000,7 +1002,7 @@
ObjPtr<mirror::Object> GetAnnotationForField(ArtField* field,
Handle<mirror::Class> annotation_class) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
if (annotation_set == nullptr) {
return nullptr;
}
@@ -1013,14 +1015,14 @@
}
ObjPtr<mirror::ObjectArray<mirror::Object>> GetAnnotationsForField(ArtField* field) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
StackHandleScope<1> hs(Thread::Current());
const ClassData field_class(hs, field);
return ProcessAnnotationSet(field_class, annotation_set, DexFile::kDexVisibilityRuntime);
}
ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureAnnotationForField(ArtField* field) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
if (annotation_set == nullptr) {
return nullptr;
}
@@ -1030,13 +1032,13 @@
}
bool IsFieldAnnotationPresent(ArtField* field, Handle<mirror::Class> annotation_class) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
if (annotation_set == nullptr) {
return false;
}
StackHandleScope<1> hs(Thread::Current());
const ClassData field_class(hs, field);
- const DexFile::AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
+ const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
field_class, annotation_set, DexFile::kDexVisibilityRuntime, annotation_class);
return annotation_item != nullptr;
}
@@ -1044,17 +1046,17 @@
ObjPtr<mirror::Object> GetAnnotationDefaultValue(ArtMethod* method) {
const ClassData klass(method);
const DexFile* dex_file = &klass.GetDexFile();
- const DexFile::AnnotationsDirectoryItem* annotations_dir =
+ const AnnotationsDirectoryItem* annotations_dir =
dex_file->GetAnnotationsDirectory(*klass.GetClassDef());
if (annotations_dir == nullptr) {
return nullptr;
}
- const DexFile::AnnotationSetItem* annotation_set =
+ const AnnotationSetItem* annotation_set =
dex_file->GetClassAnnotationSet(annotations_dir);
if (annotation_set == nullptr) {
return nullptr;
}
- const DexFile::AnnotationItem* annotation_item = SearchAnnotationSet(*dex_file, annotation_set,
+ const AnnotationItem* annotation_item = SearchAnnotationSet(*dex_file, annotation_set,
"Ldalvik/annotation/AnnotationDefault;", DexFile::kDexVisibilitySystem);
if (annotation_item == nullptr) {
return nullptr;
@@ -1087,7 +1089,7 @@
ObjPtr<mirror::Object> GetAnnotationForMethod(ArtMethod* method,
Handle<mirror::Class> annotation_class) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
if (annotation_set == nullptr) {
return nullptr;
}
@@ -1096,14 +1098,14 @@
}
ObjPtr<mirror::ObjectArray<mirror::Object>> GetAnnotationsForMethod(ArtMethod* method) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
return ProcessAnnotationSet(ClassData(method),
annotation_set,
DexFile::kDexVisibilityRuntime);
}
ObjPtr<mirror::ObjectArray<mirror::Class>> GetExceptionTypesForMethod(ArtMethod* method) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
if (annotation_set == nullptr) {
return nullptr;
}
@@ -1112,12 +1114,12 @@
ObjPtr<mirror::ObjectArray<mirror::Object>> GetParameterAnnotations(ArtMethod* method) {
const DexFile* dex_file = method->GetDexFile();
- const DexFile::ParameterAnnotationsItem* parameter_annotations =
+ const ParameterAnnotationsItem* parameter_annotations =
FindAnnotationsItemForMethod(method);
if (parameter_annotations == nullptr) {
return nullptr;
}
- const DexFile::AnnotationSetRefList* set_ref_list =
+ const AnnotationSetRefList* set_ref_list =
dex_file->GetParameterAnnotationSetRefList(parameter_annotations);
if (set_ref_list == nullptr) {
return nullptr;
@@ -1128,12 +1130,12 @@
uint32_t GetNumberOfAnnotatedMethodParameters(ArtMethod* method) {
const DexFile* dex_file = method->GetDexFile();
- const DexFile::ParameterAnnotationsItem* parameter_annotations =
+ const ParameterAnnotationsItem* parameter_annotations =
FindAnnotationsItemForMethod(method);
if (parameter_annotations == nullptr) {
return 0u;
}
- const DexFile::AnnotationSetRefList* set_ref_list =
+ const AnnotationSetRefList* set_ref_list =
dex_file->GetParameterAnnotationSetRefList(parameter_annotations);
if (set_ref_list == nullptr) {
return 0u;
@@ -1145,12 +1147,11 @@
uint32_t parameter_idx,
Handle<mirror::Class> annotation_class) {
const DexFile* dex_file = method->GetDexFile();
- const DexFile::ParameterAnnotationsItem* parameter_annotations =
- FindAnnotationsItemForMethod(method);
+ const ParameterAnnotationsItem* parameter_annotations = FindAnnotationsItemForMethod(method);
if (parameter_annotations == nullptr) {
return nullptr;
}
- const DexFile::AnnotationSetRefList* set_ref_list =
+ const AnnotationSetRefList* set_ref_list =
dex_file->GetParameterAnnotationSetRefList(parameter_annotations);
if (set_ref_list == nullptr) {
return nullptr;
@@ -1158,8 +1159,8 @@
if (parameter_idx >= set_ref_list->size_) {
return nullptr;
}
- const DexFile::AnnotationSetRefItem* annotation_set_ref = &set_ref_list->list_[parameter_idx];
- const DexFile::AnnotationSetItem* annotation_set =
+ const AnnotationSetRefItem* annotation_set_ref = &set_ref_list->list_[parameter_idx];
+ const AnnotationSetItem* annotation_set =
dex_file->GetSetRefItemItem(annotation_set_ref);
if (annotation_set == nullptr) {
return nullptr;
@@ -1174,14 +1175,14 @@
ArtMethod* method,
/*out*/ MutableHandle<mirror::ObjectArray<mirror::String>>* names,
/*out*/ MutableHandle<mirror::IntArray>* access_flags) {
- const DexFile::AnnotationSetItem* annotation_set =
+ const AnnotationSetItem* annotation_set =
FindAnnotationSetForMethod(method);
if (annotation_set == nullptr) {
return false;
}
const DexFile* dex_file = method->GetDexFile();
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(*dex_file,
annotation_set,
"Ldalvik/annotation/MethodParameters;",
@@ -1228,7 +1229,7 @@
}
ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureAnnotationForMethod(ArtMethod* method) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
if (annotation_set == nullptr) {
return nullptr;
}
@@ -1238,11 +1239,11 @@
bool IsMethodAnnotationPresent(ArtMethod* method,
Handle<mirror::Class> annotation_class,
uint32_t visibility /* = DexFile::kDexVisibilityRuntime */) {
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
if (annotation_set == nullptr) {
return false;
}
- const DexFile::AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
+ const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
ClassData(method), annotation_set, visibility, annotation_class);
return annotation_item != nullptr;
}
@@ -1263,11 +1264,11 @@
// Check whether a method from the `dex_file` with the given `annotation_set`
// is annotated with `annotation_descriptor` with build visibility.
static bool IsMethodBuildAnnotationPresent(const DexFile& dex_file,
- const DexFile::AnnotationSetItem& annotation_set,
+ const AnnotationSetItem& annotation_set,
const char* annotation_descriptor,
jclass annotation_class) {
for (uint32_t i = 0; i < annotation_set.size_; ++i) {
- const DexFile::AnnotationItem* annotation_item = dex_file.GetAnnotationItem(&annotation_set, i);
+ const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(&annotation_set, i);
if (!IsVisibilityCompatible(annotation_item->visibility_, DexFile::kDexVisibilityBuild)) {
continue;
}
@@ -1283,9 +1284,9 @@
}
uint32_t GetNativeMethodAnnotationAccessFlags(const DexFile& dex_file,
- const DexFile::ClassDef& class_def,
+ const dex::ClassDef& class_def,
uint32_t method_index) {
- const DexFile::AnnotationSetItem* annotation_set =
+ const dex::AnnotationSetItem* annotation_set =
FindAnnotationSetForMethod(dex_file, class_def, method_index);
if (annotation_set == nullptr) {
return 0u;
@@ -1312,7 +1313,7 @@
ObjPtr<mirror::Object> GetAnnotationForClass(Handle<mirror::Class> klass,
Handle<mirror::Class> annotation_class) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return nullptr;
}
@@ -1324,17 +1325,17 @@
ObjPtr<mirror::ObjectArray<mirror::Object>> GetAnnotationsForClass(Handle<mirror::Class> klass) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
return ProcessAnnotationSet(data, annotation_set, DexFile::kDexVisibilityRuntime);
}
ObjPtr<mirror::ObjectArray<mirror::Class>> GetDeclaredClasses(Handle<mirror::Class> klass) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return nullptr;
}
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/MemberClasses;",
DexFile::kDexVisibilitySystem);
if (annotation_item == nullptr) {
@@ -1355,11 +1356,11 @@
ObjPtr<mirror::Class> GetDeclaringClass(Handle<mirror::Class> klass) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return nullptr;
}
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/EnclosingClass;",
DexFile::kDexVisibilitySystem);
if (annotation_item == nullptr) {
@@ -1382,11 +1383,11 @@
return declaring_class;
}
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return nullptr;
}
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(data.GetDexFile(),
annotation_set,
"Ldalvik/annotation/EnclosingMethod;",
@@ -1423,11 +1424,11 @@
ObjPtr<mirror::Object> GetEnclosingMethod(Handle<mirror::Class> klass) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return nullptr;
}
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(data.GetDexFile(),
annotation_set,
"Ldalvik/annotation/EnclosingMethod;",
@@ -1441,11 +1442,11 @@
bool GetInnerClass(Handle<mirror::Class> klass, /*out*/ ObjPtr<mirror::String>* name) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return false;
}
- const DexFile::AnnotationItem* annotation_item = SearchAnnotationSet(
+ const AnnotationItem* annotation_item = SearchAnnotationSet(
data.GetDexFile(),
annotation_set,
"Ldalvik/annotation/InnerClass;",
@@ -1476,11 +1477,11 @@
bool GetInnerClassFlags(Handle<mirror::Class> klass, uint32_t* flags) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return false;
}
- const DexFile::AnnotationItem* annotation_item =
+ const AnnotationItem* annotation_item =
SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/InnerClass;",
DexFile::kDexVisibilitySystem);
if (annotation_item == nullptr) {
@@ -1509,7 +1510,7 @@
ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureAnnotationForClass(
Handle<mirror::Class> klass) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return nullptr;
}
@@ -1526,12 +1527,12 @@
}
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return nullptr;
}
- const DexFile::AnnotationItem* annotation_item = SearchAnnotationSet(
+ const AnnotationItem* annotation_item = SearchAnnotationSet(
data.GetDexFile(),
annotation_set,
"Ldalvik/annotation/SourceDebugExtension;",
@@ -1562,11 +1563,11 @@
bool IsClassAnnotationPresent(Handle<mirror::Class> klass, Handle<mirror::Class> annotation_class) {
ClassData data(klass);
- const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
+ const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
if (annotation_set == nullptr) {
return false;
}
- const DexFile::AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
+ const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
data, annotation_set, DexFile::kDexVisibilityRuntime, annotation_class);
return annotation_item != nullptr;
}
diff --git a/runtime/dex/dex_file_annotations.h b/runtime/dex/dex_file_annotations.h
index bde7891..3625cee 100644
--- a/runtime/dex/dex_file_annotations.h
+++ b/runtime/dex/dex_file_annotations.h
@@ -18,7 +18,6 @@
#define ART_RUNTIME_DEX_DEX_FILE_ANNOTATIONS_H_
#include "dex/dex_file.h"
-
#include "handle.h"
#include "mirror/dex_cache.h"
#include "mirror/object_array.h"
@@ -84,7 +83,7 @@
// @dalvik.annotation.optimization.CriticalNative with build visibility.
// If yes, return the associated access flags, i.e. kAccFastNative or kAccCriticalNative.
uint32_t GetNativeMethodAnnotationAccessFlags(const DexFile& dex_file,
- const DexFile::ClassDef& class_def,
+ const dex::ClassDef& class_def,
uint32_t method_index);
// Class annotations.
@@ -124,7 +123,7 @@
RuntimeEncodedStaticFieldValueIterator(Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
ClassLinker* linker,
- const DexFile::ClassDef& class_def)
+ const dex::ClassDef& class_def)
REQUIRES_SHARED(Locks::mutator_lock_)
: EncodedStaticFieldValueIterator(*dex_cache->GetDexFile(), class_def),
dex_cache_(dex_cache),
diff --git a/runtime/dex_to_dex_decompiler.cc b/runtime/dex_to_dex_decompiler.cc
index aff9b47..d078d6f 100644
--- a/runtime/dex_to_dex_decompiler.cc
+++ b/runtime/dex_to_dex_decompiler.cc
@@ -32,7 +32,7 @@
class DexDecompiler {
public:
DexDecompiler(const DexFile& dex_file,
- const DexFile::CodeItem& code_item,
+ const dex::CodeItem& code_item,
const ArrayRef<const uint8_t>& quickened_info,
bool decompile_return_instruction)
: code_item_accessor_(dex_file, &code_item),
@@ -194,7 +194,7 @@
}
bool ArtDecompileDEX(const DexFile& dex_file,
- const DexFile::CodeItem& code_item,
+ const dex::CodeItem& code_item,
const ArrayRef<const uint8_t>& quickened_info,
bool decompile_return_instruction) {
if (quickened_info.size() == 0 && !decompile_return_instruction) {
diff --git a/runtime/dex_to_dex_decompiler.h b/runtime/dex_to_dex_decompiler.h
index 93711d1..4b6b0f7 100644
--- a/runtime/dex_to_dex_decompiler.h
+++ b/runtime/dex_to_dex_decompiler.h
@@ -18,9 +18,15 @@
#define ART_RUNTIME_DEX_TO_DEX_DECOMPILER_H_
#include "base/array_ref.h"
-#include "dex/dex_file.h"
namespace art {
+
+class DexFile;
+
+namespace dex {
+struct CodeItem;
+} // namespace dex
+
namespace optimizer {
// "Decompile", that is unquicken, the code item provided, given the
@@ -30,7 +36,7 @@
// consistent with DexToDexCompiler, but we should really change it to
// DexFile::CodeItem*.
bool ArtDecompileDEX(const DexFile& dex_file,
- const DexFile::CodeItem& code_item,
+ const dex::CodeItem& code_item,
const ArrayRef<const uint8_t>& quickened_data,
bool decompile_return_instruction);
diff --git a/runtime/hidden_api.cc b/runtime/hidden_api.cc
index e0939dd..c146daa 100644
--- a/runtime/hidden_api.cc
+++ b/runtime/hidden_api.cc
@@ -98,7 +98,7 @@
MemberSignature::MemberSignature(const ClassAccessor::Field& field) {
const DexFile& dex_file = field.GetDexFile();
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field.GetIndex());
+ const dex::FieldId& field_id = dex_file.GetFieldId(field.GetIndex());
class_name_ = dex_file.GetFieldDeclaringClassDescriptor(field_id);
member_name_ = dex_file.GetFieldName(field_id);
type_signature_ = dex_file.GetFieldTypeDescriptor(field_id);
@@ -107,7 +107,7 @@
MemberSignature::MemberSignature(const ClassAccessor::Method& method) {
const DexFile& dex_file = method.GetDexFile();
- const DexFile::MethodId& method_id = dex_file.GetMethodId(method.GetIndex());
+ const dex::MethodId& method_id = dex_file.GetMethodId(method.GetIndex());
class_name_ = dex_file.GetMethodDeclaringClassDescriptor(method_id);
member_name_ = dex_file.GetMethodName(method_id);
type_signature_ = dex_file.GetMethodSignature(method_id).ToString();
@@ -282,14 +282,14 @@
}
static void VisitMembers(const DexFile& dex_file,
- const DexFile::ClassDef& class_def,
+ const dex::ClassDef& class_def,
const std::function<void(const ClassAccessor::Field&)>& fn_visit) {
ClassAccessor accessor(dex_file, class_def, /* parse_hiddenapi_class_data= */ true);
accessor.VisitFields(fn_visit, fn_visit);
}
static void VisitMembers(const DexFile& dex_file,
- const DexFile::ClassDef& class_def,
+ const dex::ClassDef& class_def,
const std::function<void(const ClassAccessor::Method&)>& fn_visit) {
ClassAccessor accessor(dex_file, class_def, /* parse_hiddenapi_class_data= */ true);
accessor.VisitMethods(fn_visit, fn_visit);
@@ -317,7 +317,7 @@
if (LIKELY(original_dex == nullptr)) {
// Class is not redefined. Find the class def, iterate over its members and
// find the entry corresponding to this `member`.
- const DexFile::ClassDef* class_def = declaring_class->GetClassDef();
+ const dex::ClassDef* class_def = declaring_class->GetClassDef();
if (class_def == nullptr) {
flags = kNoDexFlags;
} else {
@@ -338,7 +338,7 @@
// to access a hidden member of a JVMTI-redefined class.
uint16_t class_def_idx = ext->GetPreRedefineClassDefIndex();
DCHECK_NE(class_def_idx, DexFile::kDexNoIndex16);
- const DexFile::ClassDef& original_class_def = original_dex->GetClassDef(class_def_idx);
+ const dex::ClassDef& original_class_def = original_dex->GetClassDef(class_def_idx);
MemberSignature member_signature(member);
auto fn_visit = [&](const AccessorType& dex_member) {
MemberSignature cur_signature(dex_member);
diff --git a/runtime/imtable-inl.h b/runtime/imtable-inl.h
index 93346f6..21e3eb1 100644
--- a/runtime/imtable-inl.h
+++ b/runtime/imtable-inl.h
@@ -46,7 +46,7 @@
}
const DexFile* dex_file = method->GetDexFile();
- const DexFile::MethodId& method_id = dex_file->GetMethodId(method->GetDexMethodIndex());
+ const dex::MethodId& method_id = dex_file->GetMethodId(method->GetDexMethodIndex());
// Class descriptor for the class component.
*class_hash = ComputeModifiedUtf8Hash(dex_file->GetMethodDeclaringClassDescriptor(method_id));
@@ -54,7 +54,7 @@
// Method name for the method component.
*name_hash = ComputeModifiedUtf8Hash(dex_file->GetMethodName(method_id));
- const DexFile::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
+ const dex::ProtoId& proto_id = dex_file->GetMethodPrototype(method_id);
// Read the proto for the signature component.
uint32_t tmp = ComputeModifiedUtf8Hash(
@@ -63,10 +63,10 @@
// Mix in the argument types.
// Note: we could consider just using the shorty. This would be faster, at the price of
// potential collisions.
- const DexFile::TypeList* param_types = dex_file->GetProtoParameters(proto_id);
+ const dex::TypeList* param_types = dex_file->GetProtoParameters(proto_id);
if (param_types != nullptr) {
for (size_t i = 0; i != param_types->Size(); ++i) {
- const DexFile::TypeItem& type = param_types->GetTypeItem(i);
+ const dex::TypeItem& type = param_types->GetTypeItem(i);
tmp = 31 * tmp + ComputeModifiedUtf8Hash(
dex_file->GetTypeDescriptor(dex_file->GetTypeId(type.type_idx_)));
}
diff --git a/runtime/interpreter/interpreter_common.cc b/runtime/interpreter/interpreter_common.cc
index e52a1c9..7a40ab4 100644
--- a/runtime/interpreter/interpreter_common.cc
+++ b/runtime/interpreter/interpreter_common.cc
@@ -1168,7 +1168,7 @@
const DexFile* dex_file,
uint32_t call_site_idx)
REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::CallSiteIdItem& csi = dex_file->GetCallSiteId(call_site_idx);
+ const dex::CallSiteIdItem& csi = dex_file->GetCallSiteId(call_site_idx);
CallSiteArrayValueIterator it(*dex_file, csi);
DCHECK_GE(it.Size(), 1u);
@@ -1223,7 +1223,7 @@
static constexpr size_t kMandatoryArgumentsCount = 3;
ArtMethod* referrer = shadow_frame.GetMethod();
const DexFile* dex_file = referrer->GetDexFile();
- const DexFile::CallSiteIdItem& csi = dex_file->GetCallSiteId(call_site_idx);
+ const dex::CallSiteIdItem& csi = dex_file->GetCallSiteId(call_site_idx);
CallSiteArrayValueIterator it(*dex_file, csi);
if (it.Size() < kMandatoryArgumentsCount) {
ThrowBootstrapMethodError("Truncated bootstrap arguments (%zu < %zu)",
@@ -1637,7 +1637,7 @@
// We need to do runtime check on reference assignment. We need to load the shorty
// to get the exact type of each reference argument.
- const DexFile::TypeList* params = method->GetParameterTypeList();
+ const dex::TypeList* params = method->GetParameterTypeList();
uint32_t shorty_len = 0;
const char* shorty = method->GetShorty(&shorty_len);
diff --git a/runtime/interpreter/interpreter_common.h b/runtime/interpreter/interpreter_common.h
index d1896e6..6366035 100644
--- a/runtime/interpreter/interpreter_common.h
+++ b/runtime/interpreter/interpreter_common.h
@@ -621,7 +621,7 @@
static inline bool IsStringInit(const DexFile* dex_file, uint32_t method_idx)
REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::MethodId& method_id = dex_file->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file->GetMethodId(method_idx);
const char* class_name = dex_file->StringByTypeIdx(method_id.class_idx_);
const char* method_name = dex_file->GetMethodName(method_id);
// Instead of calling ResolveMethod() which has suspend point and can trigger
diff --git a/runtime/mirror/class-inl.h b/runtime/mirror/class-inl.h
index 679ca43..bdad412 100644
--- a/runtime/mirror/class-inl.h
+++ b/runtime/mirror/class-inl.h
@@ -825,7 +825,7 @@
return ProxyDescriptorEquals(match);
} else {
const DexFile& dex_file = GetDexFile();
- const DexFile::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
+ const dex::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
return strcmp(dex_file.GetTypeDescriptor(type_id), match) == 0;
}
}
@@ -899,7 +899,7 @@
ObjectArray<Class>* interfaces = GetProxyInterfaces();
return interfaces != nullptr ? interfaces->GetLength() : 0;
} else {
- const DexFile::TypeList* interfaces = GetInterfaceTypeList();
+ const dex::TypeList* interfaces = GetInterfaceTypeList();
if (interfaces == nullptr) {
return 0;
} else {
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index c5ed1bf..515394a 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -493,7 +493,7 @@
PointerSize pointer_size) {
// We always search by name and signature, ignoring the type index in the MethodId.
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
+ const dex::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
StringPiece name = dex_file.StringDataByIdx(method_id.name_idx_);
const Signature signature = dex_file.GetMethodSignature(method_id);
return FindInterfaceMethod(name, signature, pointer_size);
@@ -620,7 +620,7 @@
}
// If not found, we need to search by name and signature.
const DexFile& dex_file = *dex_cache->GetDexFile();
- const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
+ const dex::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
const Signature signature = dex_file.GetMethodSignature(method_id);
StringPiece name; // Delay strlen() until actually needed.
// If we do not have a dex_cache match, try to find the declared method in this class now.
@@ -651,7 +651,7 @@
// Matching dex_cache. We cannot compare the `dex_method_idx` anymore because
// the type index differs, so compare the name index and proto index.
for (ArtMethod& method : declared_methods) {
- const DexFile::MethodId& cmp_method_id = dex_file.GetMethodId(method.GetDexMethodIndex());
+ const dex::MethodId& cmp_method_id = dex_file.GetMethodId(method.GetDexMethodIndex());
if (cmp_method_id.name_idx_ == method_id.name_idx_ &&
cmp_method_id.proto_idx_ == method_id.proto_idx_) {
candidate_method = &method;
@@ -1005,7 +1005,7 @@
return storage->c_str();
} else {
const DexFile& dex_file = GetDexFile();
- const DexFile::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
+ const dex::TypeId& type_id = dex_file.GetTypeId(GetClassDef()->class_idx_);
return dex_file.GetTypeDescriptor(type_id);
}
}
@@ -1018,7 +1018,7 @@
return storage->c_str();
}
-const DexFile::ClassDef* Class::GetClassDef() {
+const dex::ClassDef* Class::GetClassDef() {
uint16_t class_def_idx = GetDexClassDefIndex();
if (class_def_idx == DexFile::kDexNoIndex16) {
return nullptr;
@@ -1086,7 +1086,7 @@
const char* Class::GetSourceFile() {
const DexFile& dex_file = GetDexFile();
- const DexFile::ClassDef* dex_class_def = GetClassDef();
+ const dex::ClassDef* dex_class_def = GetClassDef();
if (dex_class_def == nullptr) {
// Generated classes have no class def.
return nullptr;
@@ -1103,8 +1103,8 @@
return "generated class";
}
-const DexFile::TypeList* Class::GetInterfaceTypeList() {
- const DexFile::ClassDef* class_def = GetClassDef();
+const dex::TypeList* Class::GetInterfaceTypeList() {
+ const dex::ClassDef* class_def = GetClassDef();
if (class_def == nullptr) {
return nullptr;
}
@@ -1247,7 +1247,7 @@
dex::TypeIndex Class::FindTypeIndexInOtherDexFile(const DexFile& dex_file) {
std::string temp;
- const DexFile::TypeId* type_id = dex_file.FindTypeId(GetDescriptor(&temp));
+ const dex::TypeId* type_id = dex_file.FindTypeId(GetDescriptor(&temp));
return (type_id == nullptr) ? dex::TypeIndex() : dex_file.GetIndexForTypeId(*type_id);
}
diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h
index d5aa514..8e392bc 100644
--- a/runtime/mirror/class.h
+++ b/runtime/mirror/class.h
@@ -24,7 +24,7 @@
#include "base/stride_iterator.h"
#include "class_flags.h"
#include "class_status.h"
-#include "dex/dex_file.h"
+#include "dex/dex_file_structs.h"
#include "dex/dex_file_types.h"
#include "dex/modifiers.h"
#include "dex/primitive.h"
@@ -40,6 +40,7 @@
class ArtField;
class ArtMethod;
struct ClassOffsets;
+class DexFile;
template<class T> class Handle;
enum InvokeType : uint32_t;
template<typename T> class LengthPrefixedArray;
@@ -1133,7 +1134,7 @@
bool DescriptorEquals(const char* match) REQUIRES_SHARED(Locks::mutator_lock_);
- const DexFile::ClassDef* GetClassDef() REQUIRES_SHARED(Locks::mutator_lock_);
+ const dex::ClassDef* GetClassDef() REQUIRES_SHARED(Locks::mutator_lock_);
ALWAYS_INLINE uint32_t NumDirectInterfaces() REQUIRES_SHARED(Locks::mutator_lock_);
@@ -1156,7 +1157,7 @@
const DexFile& GetDexFile() REQUIRES_SHARED(Locks::mutator_lock_);
- const DexFile::TypeList* GetInterfaceTypeList() REQUIRES_SHARED(Locks::mutator_lock_);
+ const dex::TypeList* GetInterfaceTypeList() REQUIRES_SHARED(Locks::mutator_lock_);
// Asserts we are initialized or initializing in the given thread.
void AssertInitializedOrInitializingInThread(Thread* self)
diff --git a/runtime/mirror/dex_cache_test.cc b/runtime/mirror/dex_cache_test.cc
index 36c5ae2..f7c1c02 100644
--- a/runtime/mirror/dex_cache_test.cc
+++ b/runtime/mirror/dex_cache_test.cc
@@ -146,8 +146,8 @@
Handle<mirror::DexCache> dex_cache = hs.NewHandle(
class_linker_->FindDexCache(Thread::Current(), dex_file));
- const DexFile::MethodId& method1_id = dex_file.GetMethodId(method1->GetDexMethodIndex());
- const DexFile::MethodId& method2_id = dex_file.GetMethodId(method2->GetDexMethodIndex());
+ const dex::MethodId& method1_id = dex_file.GetMethodId(method1->GetDexMethodIndex());
+ const dex::MethodId& method2_id = dex_file.GetMethodId(method2->GetDexMethodIndex());
Handle<mirror::MethodType> method1_type = hs.NewHandle(
class_linker_->ResolveMethodType(soa.Self(),
method1_id.proto_idx_,
diff --git a/runtime/mirror/object_test.cc b/runtime/mirror/object_test.cc
index d8c7b1d..f4b8ba5 100644
--- a/runtime/mirror/object_test.cc
+++ b/runtime/mirror/object_test.cc
@@ -364,16 +364,16 @@
Handle<Class> klass =
hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", loader));
ArtMethod* clinit = klass->FindClassInitializer(kRuntimePointerSize);
- const DexFile::TypeId* klass_type_id = dex_file->FindTypeId("LStaticsFromCode;");
+ const dex::TypeId* klass_type_id = dex_file->FindTypeId("LStaticsFromCode;");
ASSERT_TRUE(klass_type_id != nullptr);
- const DexFile::TypeId* type_type_id = dex_file->FindTypeId("Ljava/lang/Object;");
+ const dex::TypeId* type_type_id = dex_file->FindTypeId("Ljava/lang/Object;");
ASSERT_TRUE(type_type_id != nullptr);
- const DexFile::StringId* name_str_id = dex_file->FindStringId("s0");
+ const dex::StringId* name_str_id = dex_file->FindStringId("s0");
ASSERT_TRUE(name_str_id != nullptr);
- const DexFile::FieldId* field_id = dex_file->FindFieldId(
+ const dex::FieldId* field_id = dex_file->FindFieldId(
*klass_type_id, *name_str_id, *type_type_id);
ASSERT_TRUE(field_id != nullptr);
uint32_t field_idx = dex_file->GetIndexForFieldId(*field_id);
diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc
index 1da91b0..52482b7 100644
--- a/runtime/native/dalvik_system_DexFile.cc
+++ b/runtime/native/dalvik_system_DexFile.cc
@@ -383,7 +383,7 @@
const std::string descriptor(DotToDescriptor(class_name.c_str()));
const size_t hash(ComputeModifiedUtf8Hash(descriptor.c_str()));
for (auto& dex_file : dex_files) {
- const DexFile::ClassDef* dex_class_def =
+ const dex::ClassDef* dex_class_def =
OatDexFile::FindClassDef(*dex_file, descriptor.c_str(), hash);
if (dex_class_def != nullptr) {
ScopedObjectAccess soa(env);
@@ -440,7 +440,7 @@
std::set<const char*, CharPointerComparator> descriptors;
for (auto& dex_file : dex_files) {
for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) {
- const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
+ const dex::ClassDef& class_def = dex_file->GetClassDef(i);
const char* descriptor = dex_file->GetClassDescriptor(class_def);
descriptors.insert(descriptor);
}
diff --git a/runtime/native/dalvik_system_VMRuntime.cc b/runtime/native/dalvik_system_VMRuntime.cc
index 892d4cc..d705d5f 100644
--- a/runtime/native/dalvik_system_VMRuntime.cc
+++ b/runtime/native/dalvik_system_VMRuntime.cc
@@ -413,7 +413,7 @@
return; // The entry already contains some ArtField.
}
const DexFile* dex_file = dex_cache->GetDexFile();
- const DexFile::FieldId& field_id = dex_file->GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file->GetFieldId(field_idx);
ObjPtr<mirror::Class> klass = Runtime::Current()->GetClassLinker()->LookupResolvedType(
field_id.class_idx_, dex_cache, /* class_loader= */ nullptr);
if (klass == nullptr) {
@@ -439,7 +439,7 @@
return; // The entry already contains some ArtMethod.
}
const DexFile* dex_file = dex_cache->GetDexFile();
- const DexFile::MethodId& method_id = dex_file->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file->GetMethodId(method_idx);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
ObjPtr<mirror::Class> klass = class_linker->LookupResolvedType(
diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc
index 612a4b3..d022c3b 100644
--- a/runtime/native/java_lang_Class.cc
+++ b/runtime/native/java_lang_Class.cc
@@ -220,7 +220,7 @@
return soa.AddLocalReference<jobjectArray>(klass->GetProxyInterfaces()->Clone(soa.Self()));
}
- const DexFile::TypeList* iface_list = klass->GetInterfaceTypeList();
+ const dex::TypeList* iface_list = klass->GetInterfaceTypeList();
if (iface_list == nullptr) {
return nullptr;
}
diff --git a/runtime/native/java_lang_reflect_Executable.cc b/runtime/native/java_lang_reflect_Executable.cc
index ada0a64..2ce56b5 100644
--- a/runtime/native/java_lang_reflect_Executable.cc
+++ b/runtime/native/java_lang_reflect_Executable.cc
@@ -275,8 +275,8 @@
this_method = this_method->GetInterfaceMethodIfProxy(kRuntimePointerSize);
other_method = other_method->GetInterfaceMethodIfProxy(kRuntimePointerSize);
- const DexFile::TypeList* this_list = this_method->GetParameterTypeList();
- const DexFile::TypeList* other_list = other_method->GetParameterTypeList();
+ const dex::TypeList* this_list = this_method->GetParameterTypeList();
+ const dex::TypeList* other_list = other_method->GetParameterTypeList();
if (this_list == other_list) {
return 0;
@@ -298,9 +298,9 @@
}
for (int32_t i = 0; i < this_size; ++i) {
- const DexFile::TypeId& lhs = this_method->GetDexFile()->GetTypeId(
+ const dex::TypeId& lhs = this_method->GetDexFile()->GetTypeId(
this_list->GetTypeItem(i).type_idx_);
- const DexFile::TypeId& rhs = other_method->GetDexFile()->GetTypeId(
+ const dex::TypeId& rhs = other_method->GetDexFile()->GetTypeId(
other_list->GetTypeItem(i).type_idx_);
uint32_t lhs_len, rhs_len;
@@ -343,7 +343,7 @@
ArtMethod* method = ArtMethod::FromReflectedMethod(soa, javaMethod);
method = method->GetInterfaceMethodIfProxy(kRuntimePointerSize);
- const DexFile::TypeList* params = method->GetParameterTypeList();
+ const dex::TypeList* params = method->GetParameterTypeList();
if (params == nullptr) {
return nullptr;
}
@@ -378,7 +378,7 @@
ArtMethod* method = ArtMethod::FromReflectedMethod(soa, javaMethod);
method = method->GetInterfaceMethodIfProxy(kRuntimePointerSize);
- const DexFile::TypeList* params = method->GetParameterTypeList();
+ const dex::TypeList* params = method->GetParameterTypeList();
return (params == nullptr) ? 0 : params->Size();
}
diff --git a/runtime/oat_file.cc b/runtime/oat_file.cc
index de4826f..f4a8c50 100644
--- a/runtime/oat_file.cc
+++ b/runtime/oat_file.cc
@@ -48,7 +48,9 @@
#include "base/unix_file/fd_file.h"
#include "base/utils.h"
#include "dex/art_dex_file_loader.h"
+#include "dex/dex_file.h"
#include "dex/dex_file_loader.h"
+#include "dex/dex_file_structs.h"
#include "dex/dex_file_types.h"
#include "dex/standard_dex_file.h"
#include "dex/type_lookup_table.h"
@@ -1831,13 +1833,13 @@
reinterpret_cast<const OatMethodOffsets*>(methods_pointer));
}
-const DexFile::ClassDef* OatDexFile::FindClassDef(const DexFile& dex_file,
- const char* descriptor,
- size_t hash) {
+const dex::ClassDef* OatDexFile::FindClassDef(const DexFile& dex_file,
+ const char* descriptor,
+ size_t hash) {
const OatDexFile* oat_dex_file = dex_file.GetOatDexFile();
DCHECK_EQ(ComputeModifiedUtf8Hash(descriptor), hash);
bool used_lookup_table = false;
- const DexFile::ClassDef* lookup_table_classdef = nullptr;
+ const dex::ClassDef* lookup_table_classdef = nullptr;
if (LIKELY((oat_dex_file != nullptr) && oat_dex_file->GetTypeLookupTable().Valid())) {
used_lookup_table = true;
const uint32_t class_def_idx = oat_dex_file->GetTypeLookupTable().Lookup(descriptor, hash);
@@ -1854,10 +1856,10 @@
DCHECK(!used_lookup_table);
return nullptr;
}
- const DexFile::TypeId* type_id = dex_file.FindTypeId(descriptor);
+ const dex::TypeId* type_id = dex_file.FindTypeId(descriptor);
if (type_id != nullptr) {
dex::TypeIndex type_idx = dex_file.GetIndexForTypeId(*type_id);
- const DexFile::ClassDef* found_class_def = dex_file.FindClassDef(type_idx);
+ const dex::ClassDef* found_class_def = dex_file.FindClassDef(type_idx);
if (kIsDebugBuild && used_lookup_table) {
DCHECK_EQ(found_class_def, lookup_table_classdef);
}
diff --git a/runtime/oat_file.h b/runtime/oat_file.h
index ab6e62d..3e9c01f 100644
--- a/runtime/oat_file.h
+++ b/runtime/oat_file.h
@@ -29,7 +29,6 @@
#include "base/tracking_safe_map.h"
#include "class_status.h"
#include "compiler_filter.h"
-#include "dex/dex_file.h"
#include "dex/dex_file_layout.h"
#include "dex/type_lookup_table.h"
#include "dex/utf.h"
@@ -40,6 +39,7 @@
namespace art {
class BitVector;
+class DexFile;
class ElfFile;
class DexLayoutSections;
template <class MirrorType> class GcRoot;
@@ -50,6 +50,10 @@
class OatQuickMethodHeader;
class VdexFile;
+namespace dex {
+struct ClassDef;
+} // namespace dex
+
namespace gc {
namespace collector {
class DummyOatFile;
@@ -500,9 +504,9 @@
// Looks up a class definition by its class descriptor. Hash must be
// ComputeModifiedUtf8Hash(descriptor).
- static const DexFile::ClassDef* FindClassDef(const DexFile& dex_file,
- const char* descriptor,
- size_t hash);
+ static const dex::ClassDef* FindClassDef(const DexFile& dex_file,
+ const char* descriptor,
+ size_t hash);
// Madvise the dex file based on the state we are moving to.
static void MadviseDexFile(const DexFile& dex_file, MadviseState state);
diff --git a/runtime/oat_file_manager.cc b/runtime/oat_file_manager.cc
index 9552ca3..5aa1ea2 100644
--- a/runtime/oat_file_manager.cc
+++ b/runtime/oat_file_manager.cc
@@ -186,7 +186,7 @@
static BitVector GenerateTypeIndexes(const DexFile* dex_file) {
BitVector type_indexes(/*start_bits=*/0, /*expandable=*/true, Allocator::GetMallocAllocator());
for (uint16_t i = 0; i < dex_file->NumClassDefs(); ++i) {
- const DexFile::ClassDef& class_def = dex_file->GetClassDef(i);
+ const dex::ClassDef& class_def = dex_file->GetClassDef(i);
uint16_t type_idx = class_def.class_idx_.index_;
type_indexes.SetBit(type_idx);
}
diff --git a/runtime/reflection.cc b/runtime/reflection.cc
index 8011836..dfd7e64 100644
--- a/runtime/reflection.cc
+++ b/runtime/reflection.cc
@@ -226,7 +226,7 @@
ArtMethod* m,
Thread* self)
REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::TypeList* classes = m->GetParameterTypeList();
+ const dex::TypeList* classes = m->GetParameterTypeList();
// Set receiver if non-null (method is not static)
if (receiver != nullptr) {
Append(receiver);
@@ -367,7 +367,7 @@
void CheckMethodArguments(JavaVMExt* vm, ArtMethod* m, uint32_t* args)
REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::TypeList* params = m->GetParameterTypeList();
+ const dex::TypeList* params = m->GetParameterTypeList();
if (params == nullptr) {
return; // No arguments so nothing to check.
}
@@ -461,7 +461,7 @@
bool CheckArgsForInvokeMethod(ArtMethod* np_method,
ObjPtr<mirror::ObjectArray<mirror::Object>> objects)
REQUIRES_SHARED(Locks::mutator_lock_) {
- const DexFile::TypeList* classes = np_method->GetParameterTypeList();
+ const dex::TypeList* classes = np_method->GetParameterTypeList();
uint32_t classes_size = (classes == nullptr) ? 0 : classes->Size();
uint32_t arg_count = (objects == nullptr) ? 0 : objects->GetLength();
if (UNLIKELY(arg_count != classes_size)) {
diff --git a/runtime/runtime_callbacks.cc b/runtime/runtime_callbacks.cc
index bf74816..da13eb8 100644
--- a/runtime/runtime_callbacks.cc
+++ b/runtime/runtime_callbacks.cc
@@ -205,14 +205,14 @@
Handle<mirror::Class> temp_class,
Handle<mirror::ClassLoader> loader,
const DexFile& initial_dex_file,
- const DexFile::ClassDef& initial_class_def,
+ const dex::ClassDef& initial_class_def,
/*out*/DexFile const** final_dex_file,
- /*out*/DexFile::ClassDef const** final_class_def) {
+ /*out*/dex::ClassDef const** final_class_def) {
DexFile const* current_dex_file = &initial_dex_file;
- DexFile::ClassDef const* current_class_def = &initial_class_def;
+ dex::ClassDef const* current_class_def = &initial_class_def;
for (ClassLoadCallback* cb : class_callbacks_) {
DexFile const* new_dex_file = nullptr;
- DexFile::ClassDef const* new_class_def = nullptr;
+ dex::ClassDef const* new_class_def = nullptr;
cb->ClassPreDefine(descriptor,
temp_class,
loader,
diff --git a/runtime/runtime_callbacks.h b/runtime/runtime_callbacks.h
index 32ee3aa..41d552a 100644
--- a/runtime/runtime_callbacks.h
+++ b/runtime/runtime_callbacks.h
@@ -22,11 +22,14 @@
#include "base/array_ref.h"
#include "base/locks.h"
#include "base/macros.h"
-#include "dex/dex_file.h"
#include "handle.h"
namespace art {
+namespace dex {
+struct ClassDef;
+} // namespace dex
+
namespace mirror {
class Class;
class ClassLoader;
@@ -35,6 +38,7 @@
class ArtMethod;
class ClassLoadCallback;
+class DexFile;
class Thread;
class MethodCallback;
class Monitor;
@@ -183,9 +187,9 @@
Handle<mirror::Class> temp_class,
Handle<mirror::ClassLoader> loader,
const DexFile& initial_dex_file,
- const DexFile::ClassDef& initial_class_def,
+ const dex::ClassDef& initial_class_def,
/*out*/DexFile const** final_dex_file,
- /*out*/DexFile::ClassDef const** final_class_def)
+ /*out*/dex::ClassDef const** final_class_def)
REQUIRES_SHARED(Locks::mutator_lock_);
void AddMethodCallback(MethodCallback* cb) REQUIRES(Locks::mutator_lock_);
diff --git a/runtime/runtime_callbacks_test.cc b/runtime/runtime_callbacks_test.cc
index d08be72..df06a9f 100644
--- a/runtime/runtime_callbacks_test.cc
+++ b/runtime/runtime_callbacks_test.cc
@@ -257,9 +257,9 @@
Handle<mirror::Class> klass ATTRIBUTE_UNUSED,
Handle<mirror::ClassLoader> class_loader ATTRIBUTE_UNUSED,
const DexFile& initial_dex_file,
- const DexFile::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
+ const dex::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
/*out*/DexFile const** final_dex_file ATTRIBUTE_UNUSED,
- /*out*/DexFile::ClassDef const** final_class_def ATTRIBUTE_UNUSED) override
+ /*out*/dex::ClassDef const** final_class_def ATTRIBUTE_UNUSED) override
REQUIRES_SHARED(Locks::mutator_lock_) {
const std::string& location = initial_dex_file.GetLocation();
std::string event =
diff --git a/runtime/transaction_test.cc b/runtime/transaction_test.cc
index 3d9afa0..69ded3d 100644
--- a/runtime/transaction_test.cc
+++ b/runtime/transaction_test.cc
@@ -489,7 +489,7 @@
// Go search the dex file to find the string id of our string.
static const char* kResolvedString = "ResolvedString";
- const DexFile::StringId* string_id = dex_file->FindStringId(kResolvedString);
+ const dex::StringId* string_id = dex_file->FindStringId(kResolvedString);
ASSERT_TRUE(string_id != nullptr);
dex::StringIndex string_idx = dex_file->GetIndexForStringId(*string_id);
ASSERT_TRUE(string_idx.IsValid());
diff --git a/runtime/vdex_file.cc b/runtime/vdex_file.cc
index f24711a..72c42b9 100644
--- a/runtime/vdex_file.cc
+++ b/runtime/vdex_file.cc
@@ -281,12 +281,12 @@
return;
}
// Make sure to not unquicken the same code item multiple times.
- std::unordered_set<const DexFile::CodeItem*> unquickened_code_item;
+ std::unordered_set<const dex::CodeItem*> unquickened_code_item;
CompactOffsetTable::Accessor accessor(GetQuickenInfoOffsetTable(source_dex_begin,
quickening_info));
for (ClassAccessor class_accessor : target_dex_file.GetClasses()) {
for (const ClassAccessor::Method& method : class_accessor.GetMethods()) {
- const DexFile::CodeItem* code_item = method.GetCodeItem();
+ const dex::CodeItem* code_item = method.GetCodeItem();
if (code_item != nullptr && unquickened_code_item.emplace(code_item).second) {
const uint32_t offset = accessor.GetOffset(method.GetIndex());
// Offset being 0 means not quickened.
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 0b33a0b..1679821 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -158,7 +158,7 @@
bool early_failure = false;
std::string failure_message;
const DexFile& dex_file = klass->GetDexFile();
- const DexFile::ClassDef* class_def = klass->GetClassDef();
+ const dex::ClassDef* class_def = klass->GetClassDef();
ObjPtr<mirror::Class> super = klass->GetSuperClass();
std::string temp;
if (super == nullptr && strcmp("Ljava/lang/Object;", klass->GetDescriptor(&temp)) != 0) {
@@ -210,7 +210,7 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def,
+ const dex::ClassDef& class_def,
CompilerCallbacks* callbacks,
bool allow_soft_failures,
HardFailLogMode log_level,
@@ -319,8 +319,8 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def,
- const DexFile::CodeItem* code_item,
+ const dex::ClassDef& class_def,
+ const dex::CodeItem* code_item,
ArtMethod* method,
uint32_t method_access_flags,
CompilerCallbacks* callbacks,
@@ -462,8 +462,8 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def,
- const DexFile::CodeItem* code_item,
+ const dex::ClassDef& class_def,
+ const dex::CodeItem* code_item,
ArtMethod* method,
uint32_t method_access_flags,
uint32_t api_level) {
@@ -500,8 +500,8 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def,
- const DexFile::CodeItem* code_item,
+ const dex::ClassDef& class_def,
+ const dex::CodeItem* code_item,
uint32_t dex_method_idx,
ArtMethod* method,
uint32_t method_access_flags,
@@ -602,7 +602,7 @@
bool MethodVerifier::Verify() {
// Some older code doesn't correctly mark constructors as such. Test for this case by looking at
// the name.
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
const char* method_name = dex_file_->StringDataByIdx(method_id.name_idx_);
bool instance_constructor_by_name = strcmp("<init>", method_name) == 0;
bool static_constructor_by_name = strcmp("<clinit>", method_name) == 0;
@@ -917,7 +917,7 @@
return true;
}
const uint32_t insns_size = code_item_accessor_.InsnsSizeInCodeUnits();
- for (const DexFile::TryItem& try_item : code_item_accessor_.TryItems()) {
+ for (const dex::TryItem& try_item : code_item_accessor_.TryItems()) {
const uint32_t start = try_item.start_addr_;
const uint32_t end = start + try_item.insn_count_;
if ((start >= end) || (start >= insns_size) || (end > insns_size)) {
@@ -1637,7 +1637,7 @@
cur_arg++;
}
- const DexFile::ProtoId& proto_id =
+ const dex::ProtoId& proto_id =
dex_file_->GetMethodPrototype(dex_file_->GetMethodId(dex_method_idx_));
DexFileParameterIterator iterator(*dex_file_, proto_id);
@@ -1876,7 +1876,7 @@
// Returns the index of the first final instance field of the given class, or kDexNoIndex if there
// is no such field.
static uint32_t GetFirstFinalInstanceFieldIndex(const DexFile& dex_file, dex::TypeIndex type_idx) {
- const DexFile::ClassDef* class_def = dex_file.FindClassDef(type_idx);
+ const dex::ClassDef* class_def = dex_file.FindClassDef(type_idx);
DCHECK(class_def != nullptr);
ClassAccessor accessor(dex_file, *class_def);
for (const ClassAccessor::Field& field : accessor.GetInstanceFields()) {
@@ -2885,7 +2885,7 @@
}
if (return_type == nullptr) {
uint32_t method_idx = GetMethodIdxOfInvoke(inst);
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(method_idx);
dex::TypeIndex return_type_idx =
dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
const char* descriptor = dex_file_->StringByTypeIdx(return_type_idx);
@@ -2908,7 +2908,7 @@
const RegType* return_type = nullptr;
if (called_method == nullptr) {
uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(method_idx);
is_constructor = strcmp("<init>", dex_file_->StringDataByIdx(method_id.name_idx_)) == 0;
dex::TypeIndex return_type_idx =
dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
@@ -2986,7 +2986,7 @@
const char* descriptor;
if (called_method == nullptr) {
uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(method_idx);
dex::TypeIndex return_type_idx =
dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
descriptor = dex_file_->StringByTypeIdx(return_type_idx);
@@ -3041,7 +3041,7 @@
const char* descriptor;
if (abs_method == nullptr) {
uint32_t method_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(method_idx);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(method_idx);
dex::TypeIndex return_type_idx =
dex_file_->GetProtoId(method_id.proto_idx_).return_type_idx_;
descriptor = dex_file_->StringByTypeIdx(return_type_idx);
@@ -3106,7 +3106,7 @@
// method handle produced by step 1. The dex file verifier has checked ranges for
// the first three arguments and CheckCallSite has checked the method handle type.
const dex::ProtoIndex proto_idx = dex_file_->GetProtoIndexForCallSite(call_site_idx);
- const DexFile::ProtoId& proto_id = dex_file_->GetProtoId(proto_idx);
+ const dex::ProtoId& proto_id = dex_file_->GetProtoId(proto_idx);
DexFileParameterIterator param_it(*dex_file_, proto_id);
// Treat method as static as it has yet to be determined.
VerifyInvocationArgsFromIterator(¶m_it, inst, METHOD_STATIC, is_range, nullptr);
@@ -3497,7 +3497,7 @@
*/
if ((opcode_flags & Instruction::kThrow) != 0 && GetInstructionFlags(work_insn_idx_).IsInTry()) {
bool has_catch_all_handler = false;
- const DexFile::TryItem* try_item = code_item_accessor_.FindTryItem(work_insn_idx_);
+ const dex::TryItem* try_item = code_item_accessor_.FindTryItem(work_insn_idx_);
CHECK(try_item != nullptr);
CatchHandlerIterator iterator(code_item_accessor_, *try_item);
@@ -3749,7 +3749,7 @@
ArtMethod* MethodVerifier::ResolveMethodAndCheckAccess(
uint32_t dex_method_idx, MethodType method_type) {
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx);
const RegType& klass_type = ResolveClass<CheckAccess::kYes>(method_id.class_idx_);
if (klass_type.IsConflict()) {
std::string append(" in attempt to access method ");
@@ -4093,7 +4093,7 @@
}
// Check method handle kind is valid.
- const DexFile::MethodHandleItem& mh = dex_file_->GetMethodHandle(index[0]);
+ const dex::MethodHandleItem& mh = dex_file_->GetMethodHandle(index[0]);
if (mh.method_handle_type_ != static_cast<uint16_t>(DexFile::MethodHandleType::kInvokeStatic)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Call site #" << call_site_idx
<< " argument 0 method handle type is not InvokeStatic: "
@@ -4125,7 +4125,7 @@
private:
ArtMethod* res_method_;
size_t pos_;
- const DexFile::TypeList* params_;
+ const dex::TypeList* params_;
const size_t params_size_;
};
@@ -4231,7 +4231,7 @@
return false;
}
- const DexFile::TypeList* types = method->GetParameterTypeList();
+ const dex::TypeList* types = method->GetParameterTypeList();
if (types->Size() != 1) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD)
<< "Signature polymorphic method has too many arguments " << types->Size() << " != 1";
@@ -4553,7 +4553,7 @@
}
ArtField* MethodVerifier::GetStaticField(int field_idx) {
- const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file_->GetFieldId(field_idx);
// Check access to class
const RegType& klass_type = ResolveClass<CheckAccess::kYes>(field_id.class_idx_);
if (klass_type.IsConflict()) { // bad class
@@ -4596,7 +4596,7 @@
}
ArtField* MethodVerifier::GetInstanceField(const RegType& obj_type, int field_idx) {
- const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file_->GetFieldId(field_idx);
// Check access to class.
const RegType& klass_type = ResolveClass<CheckAccess::kYes>(field_id.class_idx_);
if (klass_type.IsConflict()) {
@@ -4756,7 +4756,7 @@
//
// Note: see b/34966607. This and above may be changed in the future.
if (kAccType == FieldAccessType::kAccPut) {
- const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file_->GetFieldId(field_idx);
const char* field_class_descriptor = dex_file_->GetFieldDeclaringClassDescriptor(field_id);
const RegType* field_class_type = ®_types_.FromDescriptor(GetClassLoader(),
field_class_descriptor,
@@ -4772,7 +4772,7 @@
}
}
if (field_type == nullptr) {
- const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
+ const dex::FieldId& field_id = dex_file_->GetFieldId(field_idx);
const char* descriptor = dex_file_->GetFieldTypeDescriptor(field_id);
field_type = ®_types_.FromDescriptor(GetClassLoader(), descriptor, false);
}
@@ -4935,8 +4935,8 @@
}
}
if (return_type_ == nullptr) {
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
- const DexFile::ProtoId& proto_id = dex_file_->GetMethodPrototype(method_id);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
+ const dex::ProtoId& proto_id = dex_file_->GetMethodPrototype(method_id);
dex::TypeIndex return_type_idx = proto_id.return_type_idx_;
const char* descriptor = dex_file_->GetTypeDescriptor(dex_file_->GetTypeId(return_type_idx));
return_type_ = ®_types_.FromDescriptor(GetClassLoader(), descriptor, false);
@@ -4947,7 +4947,7 @@
const RegType& MethodVerifier::GetDeclaringClass() {
if (declaring_class_ == nullptr) {
- const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
+ const dex::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
const char* descriptor
= dex_file_->GetTypeDescriptor(dex_file_->GetTypeId(method_id.class_idx_));
if (method_being_verified_ != nullptr) {
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index eef2280..c178df0 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -26,7 +26,6 @@
#include "base/scoped_arena_containers.h"
#include "base/value_object.h"
#include "dex/code_item_accessors.h"
-#include "dex/dex_file.h"
#include "dex/dex_file_types.h"
#include "dex/method_reference.h"
#include "handle.h"
@@ -39,11 +38,17 @@
class ClassLinker;
class CompilerCallbacks;
+class DexFile;
class Instruction;
struct ReferenceMap2Visitor;
class Thread;
class VariableIndentationOutputStream;
+namespace dex {
+struct ClassDef;
+struct CodeItem;
+} // namespace dex
+
namespace mirror {
class DexCache;
} // namespace mirror
@@ -107,7 +112,7 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def,
+ const dex::ClassDef& class_def,
CompilerCallbacks* callbacks,
bool allow_soft_failures,
HardFailLogMode log_level,
@@ -121,8 +126,8 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def,
- const DexFile::CodeItem* code_item, ArtMethod* method,
+ const dex::ClassDef& class_def,
+ const dex::CodeItem* code_item, ArtMethod* method,
uint32_t method_access_flags,
uint32_t api_level)
REQUIRES_SHARED(Locks::mutator_lock_);
@@ -238,8 +243,8 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def,
- const DexFile::CodeItem* code_item,
+ const dex::ClassDef& class_def,
+ const dex::CodeItem* code_item,
uint32_t method_idx,
ArtMethod* method,
uint32_t access_flags,
@@ -297,8 +302,8 @@
const DexFile* dex_file,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
- const DexFile::ClassDef& class_def_idx,
- const DexFile::CodeItem* code_item,
+ const dex::ClassDef& class_def_idx,
+ const dex::CodeItem* code_item,
ArtMethod* method,
uint32_t method_access_flags,
CompilerCallbacks* callbacks,
@@ -716,7 +721,7 @@
Handle<mirror::DexCache> dex_cache_ GUARDED_BY(Locks::mutator_lock_);
// The class loader for the declaring class of the method.
Handle<mirror::ClassLoader> class_loader_ GUARDED_BY(Locks::mutator_lock_);
- const DexFile::ClassDef& class_def_; // The class def of the declaring class of the method.
+ const dex::ClassDef& class_def_; // The class def of the declaring class of the method.
const CodeItemDataAccessor code_item_accessor_;
const RegType* declaring_class_; // Lazily computed reg type of the method's declaring class.
// Instruction widths and flags, one entry per code unit.
diff --git a/runtime/verifier/method_verifier_test.cc b/runtime/verifier/method_verifier_test.cc
index 7519257..36890a6 100644
--- a/runtime/verifier/method_verifier_test.cc
+++ b/runtime/verifier/method_verifier_test.cc
@@ -57,7 +57,7 @@
REQUIRES_SHARED(Locks::mutator_lock_) {
// Verify all the classes defined in this file
for (size_t i = 0; i < dex.NumClassDefs(); i++) {
- const DexFile::ClassDef& class_def = dex.GetClassDef(i);
+ const dex::ClassDef& class_def = dex.GetClassDef(i);
const char* descriptor = dex.GetClassDescriptor(class_def);
VerifyClass(descriptor);
}
diff --git a/runtime/verifier/verifier_deps.cc b/runtime/verifier/verifier_deps.cc
index d346a95..bdcadd9 100644
--- a/runtime/verifier/verifier_deps.cc
+++ b/runtime/verifier/verifier_deps.cc
@@ -99,9 +99,9 @@
DCHECK(dex_cache != nullptr) << klass->PrettyClass();
if (dex_cache->GetDexFile() == &dex_file) {
// FindStringId is slow, try to go through the class def if we have one.
- const DexFile::ClassDef* class_def = klass->GetClassDef();
+ const dex::ClassDef* class_def = klass->GetClassDef();
DCHECK(class_def != nullptr) << klass->PrettyClass();
- const DexFile::TypeId& type_id = dex_file.GetTypeId(class_def->class_idx_);
+ const dex::TypeId& type_id = dex_file.GetTypeId(class_def->class_idx_);
if (kIsDebugBuild) {
std::string temp;
CHECK_EQ(GetIdFromString(dex_file, klass->GetDescriptor(&temp)), type_id.descriptor_idx_);
@@ -119,9 +119,9 @@
ObjPtr<mirror::Class> klass)
REQUIRES_SHARED(Locks::mutator_lock_) {
if (!klass->IsArrayClass()) {
- const DexFile::TypeId& type_id = dex_file.GetTypeId(type_idx);
+ const dex::TypeId& type_id = dex_file.GetTypeId(type_idx);
const DexFile& klass_dex = klass->GetDexFile();
- const DexFile::TypeId& klass_type_id = klass_dex.GetTypeId(klass->GetClassDef()->class_idx_);
+ const dex::TypeId& klass_type_id = klass_dex.GetTypeId(klass->GetClassDef()->class_idx_);
if (strcmp(dex_file.GetTypeDescriptor(type_id),
klass_dex.GetTypeDescriptor(klass_type_id)) == 0) {
return type_id.descriptor_idx_;
@@ -201,7 +201,7 @@
}
dex::StringIndex VerifierDeps::GetIdFromString(const DexFile& dex_file, const std::string& str) {
- const DexFile::StringId* string_id = dex_file.FindStringId(str.c_str());
+ const dex::StringId* string_id = dex_file.FindStringId(str.c_str());
if (string_id != nullptr) {
// String is in the DEX file. Return its ID.
return dex_file.GetIndexForStringId(*string_id);
@@ -805,7 +805,7 @@
}
for (const FieldResolution& entry : dep.second->fields_) {
- const DexFile::FieldId& field_id = dex_file.GetFieldId(entry.GetDexFieldIndex());
+ const dex::FieldId& field_id = dex_file.GetFieldId(entry.GetDexFieldIndex());
vios->Stream()
<< dex_file.GetFieldDeclaringClassDescriptor(field_id) << "->"
<< dex_file.GetFieldName(field_id) << ":"
@@ -823,7 +823,7 @@
}
for (const MethodResolution& method : dep.second->methods_) {
- const DexFile::MethodId& method_id = dex_file.GetMethodId(method.GetDexMethodIndex());
+ const dex::MethodId& method_id = dex_file.GetMethodId(method.GetDexMethodIndex());
vios->Stream()
<< dex_file.GetMethodDeclaringClassDescriptor(method_id) << "->"
<< dex_file.GetMethodName(method_id)
@@ -949,7 +949,7 @@
}
static std::string GetFieldDescription(const DexFile& dex_file, uint32_t index) {
- const DexFile::FieldId& field_id = dex_file.GetFieldId(index);
+ const dex::FieldId& field_id = dex_file.GetFieldId(index);
return std::string(dex_file.GetFieldDeclaringClassDescriptor(field_id))
+ "->"
+ dex_file.GetFieldName(field_id)
@@ -965,7 +965,7 @@
// and have the same recorded flags.
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
for (const auto& entry : fields) {
- const DexFile::FieldId& field_id = dex_file.GetFieldId(entry.GetDexFieldIndex());
+ const dex::FieldId& field_id = dex_file.GetFieldId(entry.GetDexFieldIndex());
StringPiece name(dex_file.StringDataByIdx(field_id.name_idx_));
StringPiece type(dex_file.StringDataByIdx(dex_file.GetTypeId(field_id.type_idx_).descriptor_idx_));
// Only use field_id.class_idx_ when the entry is unresolved, which is rare.
@@ -1011,7 +1011,7 @@
}
static std::string GetMethodDescription(const DexFile& dex_file, uint32_t index) {
- const DexFile::MethodId& method_id = dex_file.GetMethodId(index);
+ const dex::MethodId& method_id = dex_file.GetMethodId(index);
return std::string(dex_file.GetMethodDeclaringClassDescriptor(method_id))
+ "->"
+ dex_file.GetMethodName(method_id)
@@ -1026,7 +1026,7 @@
PointerSize pointer_size = class_linker->GetImagePointerSize();
for (const auto& entry : methods) {
- const DexFile::MethodId& method_id = dex_file.GetMethodId(entry.GetDexMethodIndex());
+ const dex::MethodId& method_id = dex_file.GetMethodId(entry.GetDexMethodIndex());
const char* name = dex_file.GetMethodName(method_id);
const Signature signature = dex_file.GetMethodSignature(method_id);