Clean up Constructor/Method/Field construction.
Simplify the code by ignoring active transactions. Writing
to fields of a newly allocated object does not need to be
recorded as aborting the transaction removes all references
to the new object and it's unnecessary to roll back writes
to unreachable object's fields.
Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Test: aosp_taimen-userdebug boots.
Change-Id: Ib5cd60c003d2ad3e6a246ff86d6b9288428c60ee
diff --git a/runtime/dex/dex_file_annotations.cc b/runtime/dex/dex_file_annotations.cc
index 24b3a3e..99c56a1 100644
--- a/runtime/dex/dex_file_annotations.cc
+++ b/runtime/dex/dex_file_annotations.cc
@@ -525,21 +525,13 @@
PointerSize pointer_size = class_linker->GetImagePointerSize();
set_object = true;
if (method->IsConstructor()) {
- if (pointer_size == PointerSize::k64) {
- element_object = mirror::Constructor::CreateFromArtMethod<PointerSize::k64,
- kTransactionActive>(self, method);
- } else {
- element_object = mirror::Constructor::CreateFromArtMethod<PointerSize::k32,
- kTransactionActive>(self, method);
- }
+ element_object = (pointer_size == PointerSize::k64)
+ ? mirror::Constructor::CreateFromArtMethod<PointerSize::k64>(self, method)
+ : mirror::Constructor::CreateFromArtMethod<PointerSize::k32>(self, method);
} else {
- if (pointer_size == PointerSize::k64) {
- element_object = mirror::Method::CreateFromArtMethod<PointerSize::k64,
- kTransactionActive>(self, method);
- } else {
- element_object = mirror::Method::CreateFromArtMethod<PointerSize::k32,
- kTransactionActive>(self, method);
- }
+ element_object = (pointer_size == PointerSize::k64)
+ ? mirror::Method::CreateFromArtMethod<PointerSize::k64>(self, method)
+ : mirror::Method::CreateFromArtMethod<PointerSize::k32>(self, method);
}
if (element_object == nullptr) {
return false;
@@ -562,13 +554,9 @@
}
set_object = true;
PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
- if (pointer_size == PointerSize::k64) {
- element_object = mirror::Field::CreateFromArtField<PointerSize::k64,
- kTransactionActive>(self, field, true);
- } else {
- element_object = mirror::Field::CreateFromArtField<PointerSize::k32,
- kTransactionActive>(self, field, true);
- }
+ element_object = (pointer_size == PointerSize::k64)
+ ? mirror::Field::CreateFromArtField<PointerSize::k64>(self, field, true)
+ : mirror::Field::CreateFromArtField<PointerSize::k32>(self, field, true);
if (element_object == nullptr) {
return false;
}
@@ -743,15 +731,9 @@
ObjPtr<mirror::Class> annotation_member_class =
WellKnownClasses::ToClass(WellKnownClasses::libcore_reflect_AnnotationMember);
Handle<mirror::Object> new_member(hs.NewHandle(annotation_member_class->AllocObject(self)));
- ObjPtr<mirror::Method> method_obj_ptr;
- DCHECK(!Runtime::Current()->IsActiveTransaction());
- if (pointer_size == PointerSize::k64) {
- method_obj_ptr = mirror::Method::CreateFromArtMethod<PointerSize::k64, false>(
- self, annotation_method);
- } else {
- method_obj_ptr = mirror::Method::CreateFromArtMethod<PointerSize::k32, false>(
- self, annotation_method);
- }
+ ObjPtr<mirror::Method> method_obj_ptr = (pointer_size == PointerSize::k64)
+ ? mirror::Method::CreateFromArtMethod<PointerSize::k64>(self, annotation_method)
+ : mirror::Method::CreateFromArtMethod<PointerSize::k32>(self, annotation_method);
Handle<mirror::Method> method_object(hs.NewHandle(method_obj_ptr));
if (new_member == nullptr || string_name == nullptr ||
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index b04f26e..55be920 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -845,7 +845,7 @@
DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
DCHECK(!Runtime::Current()->IsActiveTransaction());
ObjPtr<mirror::Method> interface_reflect_method =
- mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), interface_method);
+ mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), interface_method);
if (interface_reflect_method == nullptr) {
soa.Self()->AssertPendingOOMException();
return 0;
diff --git a/runtime/interpreter/unstarted_runtime.cc b/runtime/interpreter/unstarted_runtime.cc
index 5986982..1bdffa3 100644
--- a/runtime/interpreter/unstarted_runtime.cc
+++ b/runtime/interpreter/unstarted_runtime.cc
@@ -360,26 +360,10 @@
klass->PrettyDescriptor().c_str());
return;
}
- Runtime* runtime = Runtime::Current();
- PointerSize pointer_size = runtime->GetClassLinker()->GetImagePointerSize();
- ObjPtr<mirror::Field> field;
- if (runtime->IsActiveTransaction()) {
- if (pointer_size == PointerSize::k64) {
- field = mirror::Field::CreateFromArtField<PointerSize::k64, true>(
- self, found, true);
- } else {
- field = mirror::Field::CreateFromArtField<PointerSize::k32, true>(
- self, found, true);
- }
- } else {
- if (pointer_size == PointerSize::k64) {
- field = mirror::Field::CreateFromArtField<PointerSize::k64, false>(
- self, found, true);
- } else {
- field = mirror::Field::CreateFromArtField<PointerSize::k32, false>(
- self, found, true);
- }
- }
+ PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
+ ObjPtr<mirror::Field> field = (pointer_size == PointerSize::k64)
+ ? mirror::Field::CreateFromArtField<PointerSize::k64>(self, found, true)
+ : mirror::Field::CreateFromArtField<PointerSize::k32>(self, found, true);
result->SetL(field);
}
@@ -395,28 +379,13 @@
ObjPtr<mirror::String> name = shadow_frame->GetVRegReference(arg_offset + 1)->AsString();
ObjPtr<mirror::ObjectArray<mirror::Class>> args =
shadow_frame->GetVRegReference(arg_offset + 2)->AsObjectArray<mirror::Class>();
- Runtime* runtime = Runtime::Current();
- bool transaction = runtime->IsActiveTransaction();
- PointerSize pointer_size = runtime->GetClassLinker()->GetImagePointerSize();
+ PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
auto fn_hiddenapi_access_context = GetHiddenapiAccessContextFunction(shadow_frame);
- ObjPtr<mirror::Method> method;
- if (transaction) {
- if (pointer_size == PointerSize::k64) {
- method = mirror::Class::GetDeclaredMethodInternal<PointerSize::k64, true>(
- self, klass, name, args, fn_hiddenapi_access_context);
- } else {
- method = mirror::Class::GetDeclaredMethodInternal<PointerSize::k32, true>(
- self, klass, name, args, fn_hiddenapi_access_context);
- }
- } else {
- if (pointer_size == PointerSize::k64) {
- method = mirror::Class::GetDeclaredMethodInternal<PointerSize::k64, false>(
- self, klass, name, args, fn_hiddenapi_access_context);
- } else {
- method = mirror::Class::GetDeclaredMethodInternal<PointerSize::k32, false>(
- self, klass, name, args, fn_hiddenapi_access_context);
- }
- }
+ ObjPtr<mirror::Method> method = (pointer_size == PointerSize::k64)
+ ? mirror::Class::GetDeclaredMethodInternal<PointerSize::k64>(
+ self, klass, name, args, fn_hiddenapi_access_context)
+ : mirror::Class::GetDeclaredMethodInternal<PointerSize::k32>(
+ self, klass, name, args, fn_hiddenapi_access_context);
if (method != nullptr && ShouldDenyAccessToMember(method->GetArtMethod(), shadow_frame)) {
method = nullptr;
}
@@ -433,27 +402,10 @@
}
ObjPtr<mirror::ObjectArray<mirror::Class>> args =
shadow_frame->GetVRegReference(arg_offset + 1)->AsObjectArray<mirror::Class>();
- Runtime* runtime = Runtime::Current();
- bool transaction = runtime->IsActiveTransaction();
- PointerSize pointer_size = runtime->GetClassLinker()->GetImagePointerSize();
- ObjPtr<mirror::Constructor> constructor;
- if (transaction) {
- if (pointer_size == PointerSize::k64) {
- constructor = mirror::Class::GetDeclaredConstructorInternal<PointerSize::k64,
- true>(self, klass, args);
- } else {
- constructor = mirror::Class::GetDeclaredConstructorInternal<PointerSize::k32,
- true>(self, klass, args);
- }
- } else {
- if (pointer_size == PointerSize::k64) {
- constructor = mirror::Class::GetDeclaredConstructorInternal<PointerSize::k64,
- false>(self, klass, args);
- } else {
- constructor = mirror::Class::GetDeclaredConstructorInternal<PointerSize::k32,
- false>(self, klass, args);
- }
- }
+ PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
+ ObjPtr<mirror::Constructor> constructor = (pointer_size == PointerSize::k64)
+ ? mirror::Class::GetDeclaredConstructorInternal<PointerSize::k64>(self, klass, args)
+ : mirror::Class::GetDeclaredConstructorInternal<PointerSize::k32>(self, klass, args);
if (constructor != nullptr &&
ShouldDenyAccessToMember(constructor->GetArtMethod(), shadow_frame)) {
constructor = nullptr;
diff --git a/runtime/interpreter/unstarted_runtime_test.cc b/runtime/interpreter/unstarted_runtime_test.cc
index 4429f63..8020962 100644
--- a/runtime/interpreter/unstarted_runtime_test.cc
+++ b/runtime/interpreter/unstarted_runtime_test.cc
@@ -1322,19 +1322,13 @@
Handle<mirror::String> input = hs.NewHandle(mirror::String::AllocFromModifiedUtf8(self, "abd"));
// Find the constructor.
- ArtMethod* throw_cons = throw_class->FindConstructor(
- "(Ljava/lang/String;)V", class_linker->GetImagePointerSize());
+ PointerSize pointer_size = class_linker->GetImagePointerSize();
+ ArtMethod* throw_cons = throw_class->FindConstructor("(Ljava/lang/String;)V", pointer_size);
ASSERT_TRUE(throw_cons != nullptr);
- Handle<mirror::Constructor> cons;
- if (class_linker->GetImagePointerSize() == PointerSize::k64) {
- cons = hs.NewHandle(
- mirror::Constructor::CreateFromArtMethod<PointerSize::k64, false>(self, throw_cons));
- ASSERT_TRUE(cons != nullptr);
- } else {
- cons = hs.NewHandle(
- mirror::Constructor::CreateFromArtMethod<PointerSize::k32, false>(self, throw_cons));
- ASSERT_TRUE(cons != nullptr);
- }
+ Handle<mirror::Constructor> cons = hs.NewHandle((pointer_size == PointerSize::k64)
+ ? mirror::Constructor::CreateFromArtMethod<PointerSize::k64>(self, throw_cons)
+ : mirror::Constructor::CreateFromArtMethod<PointerSize::k32>(self, throw_cons));
+ ASSERT_TRUE(cons != nullptr);
Handle<mirror::ObjectArray<mirror::Object>> args = hs.NewHandle(
mirror::ObjectArray<mirror::Object>::Alloc(
diff --git a/runtime/jni/jni_internal.cc b/runtime/jni/jni_internal.cc
index b228d99..9bbde23 100644
--- a/runtime/jni/jni_internal.cc
+++ b/runtime/jni/jni_internal.cc
@@ -531,11 +531,10 @@
ArtMethod* m = jni::DecodeArtMethod(mid);
ObjPtr<mirror::Executable> method;
DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
- DCHECK(!Runtime::Current()->IsActiveTransaction());
if (m->IsConstructor()) {
- method = mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), m);
+ method = mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), m);
} else {
- method = mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), m);
+ method = mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), m);
}
return soa.AddLocalReference<jobject>(method);
}
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index a2d76cd..b1c36ab 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -1453,7 +1453,7 @@
return false;
}
-template <PointerSize kPointerSize, bool kTransactionActive>
+template <PointerSize kPointerSize>
ObjPtr<Method> Class::GetDeclaredMethodInternal(
Thread* self,
ObjPtr<Class> klass,
@@ -1494,7 +1494,7 @@
bool m_hidden = hiddenapi::ShouldDenyAccessToMember(&m, fn_get_access_context, access_method);
if (!m_hidden && !m.IsSynthetic()) {
// Non-hidden, virtual, non-synthetic. Best possible result, exit early.
- return Method::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, &m);
+ return Method::CreateFromArtMethod<kPointerSize>(self, &m);
} else if (IsMethodPreferredOver(result, result_hidden, &m, m_hidden)) {
// Remember as potential result.
result = &m;
@@ -1533,7 +1533,7 @@
// Non-hidden, direct, non-synthetic. Any virtual result could only have been
// hidden, therefore this is the best possible match. Exit now.
DCHECK((result == nullptr) || result_hidden);
- return Method::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, &m);
+ return Method::CreateFromArtMethod<kPointerSize>(self, &m);
} else if (IsMethodPreferredOver(result, result_hidden, &m, m_hidden)) {
// Remember as potential result.
result = &m;
@@ -1543,40 +1543,26 @@
}
return result != nullptr
- ? Method::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, result)
+ ? Method::CreateFromArtMethod<kPointerSize>(self, result)
: nullptr;
}
template
-ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k32, false>(
+ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k32>(
Thread* self,
ObjPtr<Class> klass,
ObjPtr<String> name,
ObjPtr<ObjectArray<Class>> args,
const std::function<hiddenapi::AccessContext()>& fn_get_access_context);
template
-ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k32, true>(
- Thread* self,
- ObjPtr<Class> klass,
- ObjPtr<String> name,
- ObjPtr<ObjectArray<Class>> args,
- const std::function<hiddenapi::AccessContext()>& fn_get_access_context);
-template
-ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k64, false>(
- Thread* self,
- ObjPtr<Class> klass,
- ObjPtr<String> name,
- ObjPtr<ObjectArray<Class>> args,
- const std::function<hiddenapi::AccessContext()>& fn_get_access_context);
-template
-ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k64, true>(
+ObjPtr<Method> Class::GetDeclaredMethodInternal<PointerSize::k64>(
Thread* self,
ObjPtr<Class> klass,
ObjPtr<String> name,
ObjPtr<ObjectArray<Class>> args,
const std::function<hiddenapi::AccessContext()>& fn_get_access_context);
-template <PointerSize kPointerSize, bool kTransactionActive>
+template <PointerSize kPointerSize>
ObjPtr<Constructor> Class::GetDeclaredConstructorInternal(
Thread* self,
ObjPtr<Class> klass,
@@ -1584,29 +1570,19 @@
StackHandleScope<1> hs(self);
ArtMethod* result = klass->GetDeclaredConstructor(self, hs.NewHandle(args), kPointerSize);
return result != nullptr
- ? Constructor::CreateFromArtMethod<kPointerSize, kTransactionActive>(self, result)
+ ? Constructor::CreateFromArtMethod<kPointerSize>(self, result)
: nullptr;
}
// Constructor::CreateFromArtMethod<kTransactionActive>(self, result)
template
-ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k32, false>(
+ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k32>(
Thread* self,
ObjPtr<Class> klass,
ObjPtr<ObjectArray<Class>> args);
template
-ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k32, true>(
- Thread* self,
- ObjPtr<Class> klass,
- ObjPtr<ObjectArray<Class>> args);
-template
-ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k64, false>(
- Thread* self,
- ObjPtr<Class> klass,
- ObjPtr<ObjectArray<Class>> args);
-template
-ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k64, true>(
+ObjPtr<Constructor> Class::GetDeclaredConstructorInternal<PointerSize::k64>(
Thread* self,
ObjPtr<Class> klass,
ObjPtr<ObjectArray<Class>> args);
diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h
index 48e1c3c..9b6390e 100644
--- a/runtime/mirror/class.h
+++ b/runtime/mirror/class.h
@@ -740,7 +740,7 @@
PointerSize pointer_size)
REQUIRES_SHARED(Locks::mutator_lock_);
- template <PointerSize kPointerSize, bool kTransactionActive>
+ template <PointerSize kPointerSize>
static ObjPtr<Method> GetDeclaredMethodInternal(
Thread* self,
ObjPtr<Class> klass,
@@ -749,7 +749,7 @@
const std::function<hiddenapi::AccessContext()>& fn_get_access_context)
REQUIRES_SHARED(Locks::mutator_lock_);
- template <PointerSize kPointerSize, bool kTransactionActive>
+ template <PointerSize kPointerSize>
static ObjPtr<Constructor> GetDeclaredConstructorInternal(Thread* self,
ObjPtr<Class> klass,
ObjPtr<ObjectArray<Class>> args)
diff --git a/runtime/mirror/executable.cc b/runtime/mirror/executable.cc
index d2a2ec5..3996f49 100644
--- a/runtime/mirror/executable.cc
+++ b/runtime/mirror/executable.cc
@@ -22,22 +22,24 @@
namespace art {
namespace mirror {
-template <PointerSize kPointerSize, bool kTransactionActive>
-bool Executable::CreateFromArtMethod(ArtMethod* method) {
+template <PointerSize kPointerSize>
+void Executable::InitializeFromArtMethod(ArtMethod* method) {
+ // We're initializing a newly allocated object, so we do not need to record that under
+ // a transaction. If the transaction is aborted, the whole object shall be unreachable.
auto* interface_method = method->GetInterfaceMethodIfProxy(kPointerSize);
- SetArtMethod<kTransactionActive>(method);
- SetFieldObject<kTransactionActive>(DeclaringClassOffset(), method->GetDeclaringClass());
- SetFieldObject<kTransactionActive>(
+ SetArtMethod</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(method);
+ SetFieldObject</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+ DeclaringClassOffset(), method->GetDeclaringClass());
+ SetFieldObject</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
DeclaringClassOfOverriddenMethodOffset(), interface_method->GetDeclaringClass());
- SetField32<kTransactionActive>(AccessFlagsOffset(), method->GetAccessFlags());
- SetField32<kTransactionActive>(DexMethodIndexOffset(), method->GetDexMethodIndex());
- return true;
+ SetField32</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+ AccessFlagsOffset(), method->GetAccessFlags());
+ SetField32</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+ DexMethodIndexOffset(), method->GetDexMethodIndex());
}
-template bool Executable::CreateFromArtMethod<PointerSize::k32, false>(ArtMethod* method);
-template bool Executable::CreateFromArtMethod<PointerSize::k32, true>(ArtMethod* method);
-template bool Executable::CreateFromArtMethod<PointerSize::k64, false>(ArtMethod* method);
-template bool Executable::CreateFromArtMethod<PointerSize::k64, true>(ArtMethod* method);
+template void Executable::InitializeFromArtMethod<PointerSize::k32>(ArtMethod* method);
+template void Executable::InitializeFromArtMethod<PointerSize::k64>(ArtMethod* method);
} // namespace mirror
} // namespace art
diff --git a/runtime/mirror/executable.h b/runtime/mirror/executable.h
index 750a167..6e072af 100644
--- a/runtime/mirror/executable.h
+++ b/runtime/mirror/executable.h
@@ -32,11 +32,6 @@
// C++ mirror of java.lang.reflect.Executable.
class MANAGED Executable : public AccessibleObject {
public:
- // Called from Constructor::CreateFromArtMethod, Method::CreateFromArtMethod.
- template <PointerSize kPointerSize, bool kTransactionActive>
- bool CreateFromArtMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_)
- REQUIRES(!Roles::uninterruptible_);
-
template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
ArtMethod* GetArtMethod() REQUIRES_SHARED(Locks::mutator_lock_) {
return reinterpret_cast64<ArtMethod*>(GetField64<kVerifyFlags>(ArtMethodOffset()));
@@ -56,6 +51,13 @@
return MemberOffset(OFFSETOF_MEMBER(Executable, art_method_));
}
+ protected:
+ // Called from Constructor::CreateFromArtMethod, Method::CreateFromArtMethod.
+ template <PointerSize kPointerSize>
+ void InitializeFromArtMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_)
+ REQUIRES(!Roles::uninterruptible_);
+
+
private:
uint16_t has_real_parameter_data_;
HeapReference<mirror::Class> declaring_class_;
diff --git a/runtime/mirror/field-inl.h b/runtime/mirror/field-inl.h
index 8a9cec4..4f544c9 100644
--- a/runtime/mirror/field-inl.h
+++ b/runtime/mirror/field-inl.h
@@ -41,7 +41,7 @@
return GetFieldObject<mirror::Class>(OFFSET_OF_OBJECT_MEMBER(Field, type_));
}
-template <PointerSize kPointerSize, bool kTransactionActive>
+template <PointerSize kPointerSize>
inline ObjPtr<mirror::Field> Field::CreateFromArtField(Thread* self,
ArtField* field,
bool force_resolve) {
@@ -86,27 +86,33 @@
field->GetDexCache()->SetResolvedField(dex_field_index, field, kPointerSize);
}
}
- ret->SetType<kTransactionActive>(type.Get());
- ret->SetDeclaringClass<kTransactionActive>(field->GetDeclaringClass());
- ret->SetAccessFlags<kTransactionActive>(field->GetAccessFlags());
+ // We're initializing a newly allocated object, so we do not need to record that under
+ // a transaction. If the transaction is aborted, the whole object shall be unreachable.
+ ret->SetType</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(type.Get());
+ ret->SetDeclaringClass</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+ field->GetDeclaringClass());
+ ret->SetAccessFlags</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+ field->GetAccessFlags());
auto iter_range = field->IsStatic() ? field->GetDeclaringClass()->GetSFields()
: field->GetDeclaringClass()->GetIFields();
auto position = std::find_if(
iter_range.begin(), iter_range.end(), [&](const auto& f) { return &f == field; });
DCHECK(position != iter_range.end());
- ret->SetArtFieldIndex<kTransactionActive>(std::distance(iter_range.begin(), position));
- ret->SetOffset<kTransactionActive>(field->GetOffset().Int32Value());
+ ret->SetArtFieldIndex</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+ std::distance(iter_range.begin(), position));
+ ret->SetOffset</*kTransactionActive=*/ false, /*kCheckTransaction=*/ false>(
+ field->GetOffset().Int32Value());
return ret.Get();
}
-template<bool kTransactionActive>
-inline void Field::SetDeclaringClass(ObjPtr<mirror::Class> c) {
- SetFieldObject<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), c);
+template<bool kTransactionActive, bool kCheckTransaction>
+inline void Field::SetDeclaringClass(ObjPtr<Class> c) {
+ SetFieldObject<kTransactionActive, kCheckTransaction>(DeclaringClassOffset(), c);
}
-template<bool kTransactionActive>
-inline void Field::SetType(ObjPtr<mirror::Class> type) {
- SetFieldObject<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, type_), type);
+template<bool kTransactionActive, bool kCheckTransaction>
+inline void Field::SetType(ObjPtr<Class> type) {
+ SetFieldObject<kTransactionActive, kCheckTransaction>(TypeOffset(), type);
}
} // namespace mirror
diff --git a/runtime/mirror/field.h b/runtime/mirror/field.h
index dd5ee76..f841908 100644
--- a/runtime/mirror/field.h
+++ b/runtime/mirror/field.h
@@ -42,12 +42,6 @@
ALWAYS_INLINE uint32_t GetArtFieldIndex() REQUIRES_SHARED(Locks::mutator_lock_) {
return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, art_field_index_));
}
- // Public for use by class redefinition code.
- template<bool kTransactionActive>
- void SetArtFieldIndex(uint32_t idx) REQUIRES_SHARED(Locks::mutator_lock_) {
- SetField32<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, art_field_index_), idx);
- }
-
ObjPtr<mirror::Class> GetDeclaringClass() REQUIRES_SHARED(Locks::mutator_lock_);
@@ -77,7 +71,7 @@
ArtField* GetArtField() REQUIRES_SHARED(Locks::mutator_lock_);
- template <PointerSize kPointerSize, bool kTransactionActive = false>
+ template <PointerSize kPointerSize>
static ObjPtr<mirror::Field> CreateFromArtField(Thread* self,
ArtField* field,
bool force_resolve)
@@ -98,20 +92,45 @@
int32_t art_field_index_;
int32_t offset_;
- template<bool kTransactionActive>
- void SetDeclaringClass(ObjPtr<mirror::Class> c) REQUIRES_SHARED(Locks::mutator_lock_);
-
- template<bool kTransactionActive>
- void SetType(ObjPtr<mirror::Class> type) REQUIRES_SHARED(Locks::mutator_lock_);
-
- template<bool kTransactionActive>
- void SetAccessFlags(uint32_t flags) REQUIRES_SHARED(Locks::mutator_lock_) {
- SetField32<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), flags);
+ static constexpr MemberOffset DeclaringClassOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_);
}
- template<bool kTransactionActive>
+ static constexpr MemberOffset TypeOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Field, type_);
+ }
+
+ static constexpr MemberOffset AccessFlagsOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Field, access_flags_);
+ }
+
+ static constexpr MemberOffset ArtFieldIndexOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Field, art_field_index_);
+ }
+
+ static constexpr MemberOffset OffsetOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Field, offset_);
+ }
+
+ template<bool kTransactionActive, bool kCheckTransaction = true>
+ void SetDeclaringClass(ObjPtr<Class> c) REQUIRES_SHARED(Locks::mutator_lock_);
+
+ template<bool kTransactionActive, bool kCheckTransaction = true>
+ void SetType(ObjPtr<Class> type) REQUIRES_SHARED(Locks::mutator_lock_);
+
+ template<bool kTransactionActive, bool kCheckTransaction = true>
+ void SetAccessFlags(uint32_t access_flags) REQUIRES_SHARED(Locks::mutator_lock_) {
+ SetField32<kTransactionActive, kCheckTransaction>(AccessFlagsOffset(), access_flags);
+ }
+
+ template<bool kTransactionActive, bool kCheckTransaction = true>
+ void SetArtFieldIndex(uint32_t idx) REQUIRES_SHARED(Locks::mutator_lock_) {
+ SetField32<kTransactionActive, kCheckTransaction>(ArtFieldIndexOffset(), idx);
+ }
+
+ template<bool kTransactionActive, bool kCheckTransaction = true>
void SetOffset(uint32_t offset) REQUIRES_SHARED(Locks::mutator_lock_) {
- SetField32<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, offset_), offset);
+ SetField32<kTransactionActive, kCheckTransaction>(OffsetOffset(), offset);
}
friend struct art::FieldOffsets; // for verifying offset information
diff --git a/runtime/mirror/method.cc b/runtime/mirror/method.cc
index 20a6979..c829026 100644
--- a/runtime/mirror/method.cc
+++ b/runtime/mirror/method.cc
@@ -25,43 +25,35 @@
namespace art {
namespace mirror {
-template <PointerSize kPointerSize, bool kTransactionActive>
+template <PointerSize kPointerSize>
ObjPtr<Method> Method::CreateFromArtMethod(Thread* self, ArtMethod* method) {
DCHECK(!method->IsConstructor()) << method->PrettyMethod();
ObjPtr<Method> ret = ObjPtr<Method>::DownCast(GetClassRoot<Method>()->AllocObject(self));
if (LIKELY(ret != nullptr)) {
- ret->Executable::CreateFromArtMethod<kPointerSize, kTransactionActive>(method);
+ ret->InitializeFromArtMethod<kPointerSize>(method);
}
return ret;
}
-template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k32, false>(
+template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k32>(
Thread* self, ArtMethod* method);
-template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k32, true>(
- Thread* self, ArtMethod* method);
-template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k64, false>(
- Thread* self, ArtMethod* method);
-template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k64, true>(
+template ObjPtr<Method> Method::CreateFromArtMethod<PointerSize::k64>(
Thread* self, ArtMethod* method);
-template <PointerSize kPointerSize, bool kTransactionActive>
+template <PointerSize kPointerSize>
ObjPtr<Constructor> Constructor::CreateFromArtMethod(Thread* self, ArtMethod* method) {
DCHECK(method->IsConstructor()) << method->PrettyMethod();
ObjPtr<Constructor> ret =
ObjPtr<Constructor>::DownCast(GetClassRoot<Constructor>()->AllocObject(self));
if (LIKELY(ret != nullptr)) {
- ret->Executable::CreateFromArtMethod<kPointerSize, kTransactionActive>(method);
+ ret->InitializeFromArtMethod<kPointerSize>(method);
}
return ret;
}
-template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k32, false>(
+template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k32>(
Thread* self, ArtMethod* method);
-template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k32, true>(
- Thread* self, ArtMethod* method);
-template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k64, false>(
- Thread* self, ArtMethod* method);
-template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k64, true>(
+template ObjPtr<Constructor> Constructor::CreateFromArtMethod<PointerSize::k64>(
Thread* self, ArtMethod* method);
} // namespace mirror
diff --git a/runtime/mirror/method.h b/runtime/mirror/method.h
index a73cd45..93d61b6 100644
--- a/runtime/mirror/method.h
+++ b/runtime/mirror/method.h
@@ -30,7 +30,7 @@
// C++ mirror of java.lang.reflect.Method.
class MANAGED Method : public Executable {
public:
- template <PointerSize kPointerSize, bool kTransactionActive>
+ template <PointerSize kPointerSize>
static ObjPtr<Method> CreateFromArtMethod(Thread* self, ArtMethod* method)
REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
@@ -41,7 +41,7 @@
// C++ mirror of java.lang.reflect.Constructor.
class MANAGED Constructor: public Executable {
public:
- template <PointerSize kPointerSize, bool kTransactionActive>
+ template <PointerSize kPointerSize>
static ObjPtr<Constructor> CreateFromArtMethod(Thread* self, ArtMethod* method)
REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc
index 2c537c6..5a73bf3 100644
--- a/runtime/native/java_lang_Class.cc
+++ b/runtime/native/java_lang_Class.cc
@@ -540,10 +540,10 @@
return nullptr;
}
Handle<mirror::Constructor> result = hs.NewHandle(
- mirror::Class::GetDeclaredConstructorInternal<kRuntimePointerSize, false>(
- soa.Self(),
- klass,
- soa.Decode<mirror::ObjectArray<mirror::Class>>(args)));
+ mirror::Class::GetDeclaredConstructorInternal<kRuntimePointerSize>(
+ soa.Self(),
+ klass,
+ soa.Decode<mirror::ObjectArray<mirror::Class>>(args)));
if (result == nullptr || ShouldDenyAccessToMember(result->GetArtMethod(), soa.Self())) {
return nullptr;
}
@@ -588,7 +588,7 @@
DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
DCHECK(!Runtime::Current()->IsActiveTransaction());
ObjPtr<mirror::Constructor> constructor =
- mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), &m);
+ mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), &m);
if (UNLIKELY(constructor == nullptr)) {
soa.Self()->AssertPendingOOMException();
return nullptr;
@@ -611,7 +611,7 @@
return nullptr;
}
Handle<mirror::Method> result = hs.NewHandle(
- mirror::Class::GetDeclaredMethodInternal<kRuntimePointerSize, false>(
+ mirror::Class::GetDeclaredMethodInternal<kRuntimePointerSize>(
soa.Self(),
klass,
soa.Decode<mirror::String>(name),
@@ -659,7 +659,7 @@
DCHECK_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
DCHECK(!Runtime::Current()->IsActiveTransaction());
ObjPtr<mirror::Method> method =
- mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), &m);
+ mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), &m);
if (method == nullptr) {
soa.Self()->AssertPendingException();
return nullptr;
diff --git a/runtime/native/java_lang_invoke_MethodHandleImpl.cc b/runtime/native/java_lang_invoke_MethodHandleImpl.cc
index 0b26bd7..c1060fe 100644
--- a/runtime/native/java_lang_invoke_MethodHandleImpl.cc
+++ b/runtime/native/java_lang_invoke_MethodHandleImpl.cc
@@ -40,23 +40,18 @@
// a Method for method invokers and a Constructor for constructors.
const mirror::MethodHandle::Kind handle_kind = handle->GetHandleKind();
- // We check this here because we pass false to CreateFromArtField and
- // CreateFromArtMethod.
- DCHECK(!Runtime::Current()->IsActiveTransaction());
-
MutableHandle<mirror::Object> h_object(hs.NewHandle<mirror::Object>(nullptr));
if (handle_kind >= mirror::MethodHandle::kFirstAccessorKind) {
ArtField* const field = handle->GetTargetField();
- h_object.Assign(mirror::Field::CreateFromArtField<kRuntimePointerSize, false>(
+ h_object.Assign(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
soa.Self(), field, /* force_resolve= */ false));
} else {
ArtMethod* const method = handle->GetTargetMethod();
if (method->IsConstructor()) {
- h_object.Assign(mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize, false>(
- soa.Self(), method));
+ h_object.Assign(
+ mirror::Constructor::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), method));
} else {
- h_object.Assign(mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(
- soa.Self(), method));
+ h_object.Assign(mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), method));
}
}
diff --git a/runtime/proxy_test.cc b/runtime/proxy_test.cc
index b78855f..76e036a 100644
--- a/runtime/proxy_test.cc
+++ b/runtime/proxy_test.cc
@@ -173,16 +173,16 @@
ASSERT_EQ(Runtime::Current()->GetClassLinker()->GetImagePointerSize(), kRuntimePointerSize);
ASSERT_FALSE(Runtime::Current()->IsActiveTransaction());
Handle<mirror::Field> field00 =
- hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize, false>(
+ hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
soa.Self(), &static_fields0->At(0), true));
Handle<mirror::Field> field01 =
- hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize, false>(
+ hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
soa.Self(), &static_fields0->At(1), true));
Handle<mirror::Field> field10 =
- hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize, false>(
+ hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
soa.Self(), &static_fields1->At(0), true));
Handle<mirror::Field> field11 =
- hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize, false>(
+ hs.NewHandle(mirror::Field::CreateFromArtField<kRuntimePointerSize>(
soa.Self(), &static_fields1->At(1), true));
EXPECT_EQ(field00->GetArtField(), &static_fields0->At(0));
EXPECT_EQ(field01->GetArtField(), &static_fields0->At(1));
diff --git a/runtime/proxy_test.h b/runtime/proxy_test.h
index 23e536d..bdd902f 100644
--- a/runtime/proxy_test.h
+++ b/runtime/proxy_test.h
@@ -76,14 +76,14 @@
DCHECK(!Runtime::Current()->IsActiveTransaction());
soa.Env()->SetObjectArrayElement(
proxyClassMethods, array_index++, soa.AddLocalReference<jobject>(
- mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), method)));
+ mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), method)));
method = javaLangObject->FindClassMethod("hashCode", "()I", kRuntimePointerSize);
CHECK(method != nullptr);
CHECK(!method->IsDirect());
CHECK(method->GetDeclaringClass() == javaLangObject.Get());
soa.Env()->SetObjectArrayElement(
proxyClassMethods, array_index++, soa.AddLocalReference<jobject>(
- mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), method)));
+ mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), method)));
method = javaLangObject->FindClassMethod(
"toString", "()Ljava/lang/String;", kRuntimePointerSize);
CHECK(method != nullptr);
@@ -91,13 +91,13 @@
CHECK(method->GetDeclaringClass() == javaLangObject.Get());
soa.Env()->SetObjectArrayElement(
proxyClassMethods, array_index++, soa.AddLocalReference<jobject>(
- mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), method)));
+ mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), method)));
// Now adds all interfaces virtual methods.
for (Handle<mirror::Class> interface : interfaces) {
for (auto& m : interface->GetDeclaredVirtualMethods(kRuntimePointerSize)) {
soa.Env()->SetObjectArrayElement(
proxyClassMethods, array_index++, soa.AddLocalReference<jobject>(
- mirror::Method::CreateFromArtMethod<kRuntimePointerSize, false>(soa.Self(), &m)));
+ mirror::Method::CreateFromArtMethod<kRuntimePointerSize>(soa.Self(), &m)));
}
}
CHECK_EQ(array_index, methods_count);