Do not pass DexFile to ClassLinker::ResolveField*().
The DexFile can be easily retrieved from the DexCache,
so reduce the number of arguments that need to be passed.
Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Change-Id: I0579db64c63afea789c7c9ad8db81e37c9248e97
diff --git a/runtime/class_linker-inl.h b/runtime/class_linker-inl.h
index 648b455..2d8d4b4 100644
--- a/runtime/class_linker-inl.h
+++ b/runtime/class_linker-inl.h
@@ -299,8 +299,7 @@
StackHandleScope<2> hs(Thread::Current());
Handle<mirror::DexCache> dex_cache(hs.NewHandle(referrer->GetDexCache()));
Handle<mirror::ClassLoader> class_loader(hs.NewHandle(declaring_class->GetClassLoader()));
- const DexFile& dex_file = *dex_cache->GetDexFile();
- resolved_field = ResolveField(dex_file, field_idx, dex_cache, class_loader, is_static);
+ resolved_field = ResolveField(field_idx, dex_cache, class_loader, is_static);
// Note: We cannot check here to see whether we added the field to the cache. The type
// might be an erroneous class, which results in it being hidden from us.
}
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 81aa371..095cb30 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -4818,7 +4818,6 @@
if (num_static_fields > 0) {
const DexFile::ClassDef* dex_class_def = klass->GetClassDef();
CHECK(dex_class_def != nullptr);
- const DexFile& dex_file = klass->GetDexFile();
StackHandleScope<3> hs(self);
Handle<mirror::ClassLoader> class_loader(hs.NewHandle(klass->GetClassLoader()));
Handle<mirror::DexCache> dex_cache(hs.NewHandle(klass->GetDexCache()));
@@ -4836,11 +4835,11 @@
}
}
- annotations::RuntimeEncodedStaticFieldValueIterator value_it(dex_file,
- &dex_cache,
- &class_loader,
+ annotations::RuntimeEncodedStaticFieldValueIterator value_it(dex_cache,
+ class_loader,
this,
*dex_class_def);
+ const DexFile& dex_file = *dex_cache->GetDexFile();
const uint8_t* class_data = dex_file.GetClassData(*dex_class_def);
ClassDataItemIterator field_it(dex_file, class_data);
if (value_it.HasNext()) {
@@ -4848,7 +4847,7 @@
CHECK(can_init_statics);
for ( ; value_it.HasNext(); value_it.Next(), field_it.Next()) {
ArtField* field = ResolveField(
- dex_file, field_it.GetMemberIndex(), dex_cache, class_loader, true);
+ field_it.GetMemberIndex(), dex_cache, class_loader, /* is_static */ true);
if (Runtime::Current()->IsActiveTransaction()) {
value_it.ReadValueToField<true>(field);
} else {
@@ -8114,8 +8113,7 @@
return resolved_field;
}
-ArtField* ClassLinker::ResolveField(const DexFile& dex_file,
- uint32_t field_idx,
+ArtField* ClassLinker::ResolveField(uint32_t field_idx,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader,
bool is_static) {
@@ -8125,6 +8123,7 @@
if (resolved != nullptr) {
return resolved;
}
+ const DexFile& dex_file = *dex_cache->GetDexFile();
const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Thread* const self = Thread::Current();
ObjPtr<mirror::Class> klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
@@ -8156,8 +8155,7 @@
return resolved;
}
-ArtField* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
- uint32_t field_idx,
+ArtField* ClassLinker::ResolveFieldJLS(uint32_t field_idx,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader) {
DCHECK(dex_cache != nullptr);
@@ -8166,6 +8164,7 @@
if (resolved != nullptr) {
return resolved;
}
+ const DexFile& dex_file = *dex_cache->GetDexFile();
const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
Thread* self = Thread::Current();
ObjPtr<mirror::Class> klass(ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader));
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 16255f4..6a8c7c1 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -345,23 +345,22 @@
REQUIRES_SHARED(Locks::mutator_lock_)
REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
- // Resolve a field with a given ID from the DexFile, storing the
- // result in DexCache. The ClassLinker and ClassLoader are used as
- // in ResolveType. What is unique is the is_static argument which is
- // used to determine if we are resolving a static or non-static
- // field.
- ArtField* ResolveField(const DexFile& dex_file, uint32_t field_idx,
+ // Resolve a field with a given ID from the DexFile associated with the given DexCache
+ // and ClassLoader, storing the result in DexCache. The ClassLinker and ClassLoader
+ // are used as in ResolveType. What is unique is the is_static argument which is used
+ // to determine if we are resolving a static or non-static field.
+ ArtField* ResolveField(uint32_t field_idx,
Handle<mirror::DexCache> dex_cache,
- Handle<mirror::ClassLoader> class_loader, bool is_static)
+ Handle<mirror::ClassLoader> class_loader,
+ bool is_static)
REQUIRES_SHARED(Locks::mutator_lock_)
REQUIRES(!Locks::dex_lock_, !Roles::uninterruptible_);
- // Resolve a field with a given ID from the DexFile, storing the
- // result in DexCache. The ClassLinker and ClassLoader are used as
- // in ResolveType. No is_static argument is provided so that Java
+ // Resolve a field with a given ID from the DexFile associated with the given DexCache
+ // and ClassLoader, storing the result in DexCache. The ClassLinker and ClassLoader
+ // are used as in ResolveType. No is_static argument is provided so that Java
// field resolution semantics are followed.
- ArtField* ResolveFieldJLS(const DexFile& dex_file,
- uint32_t field_idx,
+ ArtField* ResolveFieldJLS(uint32_t field_idx,
Handle<mirror::DexCache> dex_cache,
Handle<mirror::ClassLoader> class_loader)
REQUIRES_SHARED(Locks::mutator_lock_)
diff --git a/runtime/dex_file_annotations.cc b/runtime/dex_file_annotations.cc
index 27b9202..4373474 100644
--- a/runtime/dex_file_annotations.cc
+++ b/runtime/dex_file_annotations.cc
@@ -540,7 +540,6 @@
} else {
StackHandleScope<2> hs(self);
ArtField* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(
- klass.GetDexFile(),
index,
hs.NewHandle(klass.GetDexCache()),
hs.NewHandle(klass.GetClassLoader()));
@@ -569,7 +568,6 @@
} else {
StackHandleScope<3> hs(self);
ArtField* enum_field = Runtime::Current()->GetClassLinker()->ResolveField(
- klass.GetDexFile(),
index,
hs.NewHandle(klass.GetDexCache()),
hs.NewHandle(klass.GetClassLoader()),
@@ -1580,7 +1578,6 @@
template<bool kTransactionActive>
void RuntimeEncodedStaticFieldValueIterator::ReadValueToField(ArtField* field) const {
DCHECK(dex_cache_ != nullptr);
- DCHECK(class_loader_ != nullptr);
switch (type_) {
case kBoolean: field->SetBoolean<kTransactionActive>(field->GetDeclaringClass(), jval_.z);
break;
@@ -1595,15 +1592,15 @@
case kString: {
ObjPtr<mirror::String> resolved = linker_->ResolveString(dex_file_,
dex::StringIndex(jval_.i),
- *dex_cache_);
+ dex_cache_);
field->SetObject<kTransactionActive>(field->GetDeclaringClass(), resolved);
break;
}
case kType: {
ObjPtr<mirror::Class> resolved = linker_->ResolveType(dex_file_,
dex::TypeIndex(jval_.i),
- *dex_cache_,
- *class_loader_);
+ dex_cache_,
+ class_loader_);
field->SetObject<kTransactionActive>(field->GetDeclaringClass(), resolved);
break;
}
diff --git a/runtime/dex_file_annotations.h b/runtime/dex_file_annotations.h
index a934a4f..9ff0929 100644
--- a/runtime/dex_file_annotations.h
+++ b/runtime/dex_file_annotations.h
@@ -19,18 +19,18 @@
#include "dex_file.h"
+#include "handle.h"
+#include "mirror/dex_cache.h"
#include "mirror/object_array.h"
namespace art {
namespace mirror {
class ClassLoader;
-class DexCache;
} // namespace mirror
class ArtField;
class ArtMethod;
class ClassLinker;
-template<class T> class MutableHandle;
namespace annotations {
@@ -116,13 +116,12 @@
class RuntimeEncodedStaticFieldValueIterator : public EncodedStaticFieldValueIterator {
public:
// A constructor meant to be called from runtime code.
- RuntimeEncodedStaticFieldValueIterator(const DexFile& dex_file,
- Handle<mirror::DexCache>* dex_cache,
- Handle<mirror::ClassLoader>* class_loader,
+ RuntimeEncodedStaticFieldValueIterator(Handle<mirror::DexCache> dex_cache,
+ Handle<mirror::ClassLoader> class_loader,
ClassLinker* linker,
const DexFile::ClassDef& class_def)
REQUIRES_SHARED(Locks::mutator_lock_)
- : EncodedStaticFieldValueIterator(dex_file, class_def),
+ : EncodedStaticFieldValueIterator(*dex_cache->GetDexFile(), class_def),
dex_cache_(dex_cache),
class_loader_(class_loader),
linker_(linker) {
@@ -132,9 +131,9 @@
void ReadValueToField(ArtField* field) const REQUIRES_SHARED(Locks::mutator_lock_);
private:
- Handle<mirror::DexCache>* const dex_cache_; // Dex cache to resolve literal objects.
- Handle<mirror::ClassLoader>* const class_loader_; // ClassLoader to resolve types.
- ClassLinker* linker_; // Linker to resolve literal objects.
+ const Handle<mirror::DexCache> dex_cache_; // Dex cache to resolve literal objects.
+ const Handle<mirror::ClassLoader> class_loader_; // ClassLoader to resolve types.
+ ClassLinker* const linker_; // Linker to resolve literal objects.
DISALLOW_IMPLICIT_CONSTRUCTORS(RuntimeEncodedStaticFieldValueIterator);
};
diff --git a/runtime/entrypoints/entrypoint_utils-inl.h b/runtime/entrypoints/entrypoint_utils-inl.h
index 475c1e7..df17b30 100644
--- a/runtime/entrypoints/entrypoint_utils-inl.h
+++ b/runtime/entrypoints/entrypoint_utils-inl.h
@@ -349,8 +349,7 @@
Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(method->GetDexCache()));
Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(method->GetClassLoader()));
- resolved_field = class_linker->ResolveFieldJLS(*method->GetDexFile(),
- field_idx,
+ resolved_field = class_linker->ResolveFieldJLS(field_idx,
h_dex_cache,
h_class_loader);
} else {
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 3ca34a7..8bd00b8 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -4883,7 +4883,7 @@
return nullptr; // Can't resolve Class so no more to do here, will do checking at runtime.
}
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- ArtField* field = class_linker->ResolveFieldJLS(*dex_file_, field_idx, dex_cache_, class_loader_);
+ ArtField* field = class_linker->ResolveFieldJLS(field_idx, dex_cache_, class_loader_);
// Record result of the field resolution attempt.
VerifierDeps::MaybeRecordFieldResolution(*dex_file_, field_idx, field);
@@ -4924,7 +4924,7 @@
return nullptr; // Can't resolve Class so no more to do here
}
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- ArtField* field = class_linker->ResolveFieldJLS(*dex_file_, field_idx, dex_cache_, class_loader_);
+ ArtField* field = class_linker->ResolveFieldJLS(field_idx, dex_cache_, class_loader_);
// Record result of the field resolution attempt.
VerifierDeps::MaybeRecordFieldResolution(*dex_file_, field_idx, field);