blob: 4212dda55b4fa9c30df32eb5b7556854a292b069 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070016
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "class_linker.h"
Elliott Hughes90a33692011-08-30 13:27:07 -070018
Ian Rogers700a4022014-05-19 16:49:03 -070019#include <memory>
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070020#include <string>
21
Mathieu Chartierc7853442015-03-27 14:35:38 -070022#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070023#include "art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080024#include "class_linker-inl.h"
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080025#include "common_runtime_test.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070026#include "dex_file.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070027#include "entrypoints/entrypoint_utils-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070028#include "gc/heap.h"
Mathieu Chartierfc58af42015-04-16 18:00:39 -070029#include "mirror/abstract_method.h"
Mathieu Chartierdaaf3262015-03-24 13:30:28 -070030#include "mirror/accessible_object.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080031#include "mirror/class-inl.h"
32#include "mirror/dex_cache.h"
Mathieu Chartierdaaf3262015-03-24 13:30:28 -070033#include "mirror/field.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034#include "mirror/object-inl.h"
35#include "mirror/object_array-inl.h"
36#include "mirror/proxy.h"
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -070037#include "mirror/reference.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080038#include "mirror/stack_trace_element.h"
Mingyao Yang98d1cc82014-05-15 17:02:16 -070039#include "mirror/string-inl.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070040#include "handle_scope-inl.h"
Ian Rogerse63db272014-07-15 15:36:11 -070041#include "scoped_thread_state_change.h"
42#include "thread-inl.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070043
44namespace art {
45
Brian Carlstroma1ce1fe2014-02-24 23:23:58 -080046class ClassLinkerTest : public CommonRuntimeTest {
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070047 protected:
Ian Rogers00f7d0e2012-07-19 15:28:27 -070048 void AssertNonExistentClass(const std::string& descriptor)
Mathieu Chartier90443472015-07-16 20:32:27 -070049 SHARED_REQUIRES(Locks::mutator_lock_) {
Elliott Hughes885c3bd2011-08-22 16:59:20 -070050 Thread* self = Thread::Current();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070051 EXPECT_TRUE(class_linker_->FindSystemClass(self, descriptor.c_str()) == nullptr);
Elliott Hughes885c3bd2011-08-22 16:59:20 -070052 EXPECT_TRUE(self->IsExceptionPending());
Nicolas Geoffray14691c52015-03-05 10:40:17 +000053 mirror::Object* exception = self->GetException();
Elliott Hughes885c3bd2011-08-22 16:59:20 -070054 self->ClearException();
Ian Rogers98379392014-02-24 16:53:16 -080055 mirror::Class* exception_class =
56 class_linker_->FindSystemClass(self, "Ljava/lang/NoClassDefFoundError;");
Elliott Hughes885c3bd2011-08-22 16:59:20 -070057 EXPECT_TRUE(exception->InstanceOf(exception_class));
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070058 }
59
Ian Rogers00f7d0e2012-07-19 15:28:27 -070060 void AssertPrimitiveClass(const std::string& descriptor)
Mathieu Chartier90443472015-07-16 20:32:27 -070061 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogers98379392014-02-24 16:53:16 -080062 Thread* self = Thread::Current();
63 AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(self, descriptor.c_str()));
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -070064 }
65
Ian Rogersef7d42f2014-01-06 12:55:46 -080066 void AssertPrimitiveClass(const std::string& descriptor, mirror::Class* primitive)
Mathieu Chartier90443472015-07-16 20:32:27 -070067 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070068 ASSERT_TRUE(primitive != nullptr);
69 ASSERT_TRUE(primitive->GetClass() != nullptr);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070070 ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070071 EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != nullptr);
Ian Rogers1ff3c982014-08-12 02:30:58 -070072 std::string temp;
73 ASSERT_STREQ(descriptor.c_str(), primitive->GetDescriptor(&temp));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070074 EXPECT_TRUE(primitive->GetSuperClass() == nullptr);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070075 EXPECT_FALSE(primitive->HasSuperClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070076 EXPECT_TRUE(primitive->GetClassLoader() == nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -070077 EXPECT_EQ(mirror::Class::kStatusInitialized, primitive->GetStatus());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070078 EXPECT_FALSE(primitive->IsErroneous());
Brian Carlstrom25c33252011-09-18 15:58:35 -070079 EXPECT_TRUE(primitive->IsLoaded());
Elliott Hughes5fe594f2011-09-08 12:33:17 -070080 EXPECT_TRUE(primitive->IsResolved());
Brian Carlstrom25c33252011-09-18 15:58:35 -070081 EXPECT_TRUE(primitive->IsVerified());
82 EXPECT_TRUE(primitive->IsInitialized());
Brian Carlstromb63ec392011-08-27 17:38:27 -070083 EXPECT_FALSE(primitive->IsArrayInstance());
84 EXPECT_FALSE(primitive->IsArrayClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070085 EXPECT_TRUE(primitive->GetComponentType() == nullptr);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070086 EXPECT_FALSE(primitive->IsInterface());
87 EXPECT_TRUE(primitive->IsPublic());
88 EXPECT_TRUE(primitive->IsFinal());
89 EXPECT_TRUE(primitive->IsPrimitive());
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070090 EXPECT_FALSE(primitive->IsSynthetic());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070091 EXPECT_EQ(0U, primitive->NumDirectMethods());
92 EXPECT_EQ(0U, primitive->NumVirtualMethods());
93 EXPECT_EQ(0U, primitive->NumInstanceFields());
94 EXPECT_EQ(0U, primitive->NumStaticFields());
Mathieu Chartierf8322842014-05-16 10:59:25 -070095 EXPECT_EQ(0U, primitive->NumDirectInterfaces());
Mingyao Yang2cdbad72014-07-16 10:44:41 -070096 EXPECT_FALSE(primitive->HasVTable());
Brian Carlstrom86927212011-09-15 11:31:11 -070097 EXPECT_EQ(0, primitive->GetIfTableCount());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -070098 EXPECT_TRUE(primitive->GetIfTable() == nullptr);
Elliott Hughes00626c22013-06-14 15:04:14 -070099 EXPECT_EQ(kAccPublic | kAccFinal | kAccAbstract, primitive->GetAccessFlags());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700100 }
101
Brian Carlstromaded5f72011-10-07 17:15:04 -0700102 void AssertArrayClass(const std::string& array_descriptor,
103 const std::string& component_type,
Brian Carlstromea46f952013-07-30 01:26:50 -0700104 mirror::ClassLoader* class_loader)
Mathieu Chartier90443472015-07-16 20:32:27 -0700105 SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800106 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700107 StackHandleScope<2> hs(self);
108 Handle<mirror::ClassLoader> loader(hs.NewHandle(class_loader));
109 Handle<mirror::Class> array(
110 hs.NewHandle(class_linker_->FindClass(self, array_descriptor.c_str(), loader)));
Ian Rogers1ff3c982014-08-12 02:30:58 -0700111 std::string temp;
112 EXPECT_STREQ(component_type.c_str(), array->GetComponentType()->GetDescriptor(&temp));
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700113 EXPECT_EQ(class_loader, array->GetClassLoader());
Elliott Hughes00626c22013-06-14 15:04:14 -0700114 EXPECT_EQ(kAccFinal | kAccAbstract, (array->GetAccessFlags() & (kAccFinal | kAccAbstract)));
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700115 AssertArrayClass(array_descriptor, array);
116 }
117
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700118 void AssertArrayClass(const std::string& array_descriptor, Handle<mirror::Class> array)
Mathieu Chartier90443472015-07-16 20:32:27 -0700119 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700120 ASSERT_TRUE(array.Get() != nullptr);
121 ASSERT_TRUE(array->GetClass() != nullptr);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700122 ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700123 EXPECT_TRUE(array->GetClass()->GetSuperClass() != nullptr);
Ian Rogers1ff3c982014-08-12 02:30:58 -0700124 std::string temp;
125 ASSERT_STREQ(array_descriptor.c_str(), array->GetDescriptor(&temp));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700126 EXPECT_TRUE(array->GetSuperClass() != nullptr);
Ian Rogers98379392014-02-24 16:53:16 -0800127 Thread* self = Thread::Current();
128 EXPECT_EQ(class_linker_->FindSystemClass(self, "Ljava/lang/Object;"), array->GetSuperClass());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700129 EXPECT_TRUE(array->HasSuperClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700130 ASSERT_TRUE(array->GetComponentType() != nullptr);
Ian Rogers1ff3c982014-08-12 02:30:58 -0700131 ASSERT_GT(strlen(array->GetComponentType()->GetDescriptor(&temp)), 0U);
Brian Carlstromea46f952013-07-30 01:26:50 -0700132 EXPECT_EQ(mirror::Class::kStatusInitialized, array->GetStatus());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700133 EXPECT_FALSE(array->IsErroneous());
Brian Carlstrom25c33252011-09-18 15:58:35 -0700134 EXPECT_TRUE(array->IsLoaded());
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700135 EXPECT_TRUE(array->IsResolved());
Brian Carlstrom25c33252011-09-18 15:58:35 -0700136 EXPECT_TRUE(array->IsVerified());
137 EXPECT_TRUE(array->IsInitialized());
Brian Carlstromb63ec392011-08-27 17:38:27 -0700138 EXPECT_FALSE(array->IsArrayInstance());
139 EXPECT_TRUE(array->IsArrayClass());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700140 EXPECT_FALSE(array->IsInterface());
141 EXPECT_EQ(array->GetComponentType()->IsPublic(), array->IsPublic());
142 EXPECT_TRUE(array->IsFinal());
143 EXPECT_FALSE(array->IsPrimitive());
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700144 EXPECT_FALSE(array->IsSynthetic());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700145 EXPECT_EQ(0U, array->NumDirectMethods());
146 EXPECT_EQ(0U, array->NumVirtualMethods());
147 EXPECT_EQ(0U, array->NumInstanceFields());
148 EXPECT_EQ(0U, array->NumStaticFields());
Mathieu Chartierf8322842014-05-16 10:59:25 -0700149 EXPECT_EQ(2U, array->NumDirectInterfaces());
Mingyao Yang2cdbad72014-07-16 10:44:41 -0700150 EXPECT_TRUE(array->ShouldHaveEmbeddedImtAndVTable());
Brian Carlstrom86927212011-09-15 11:31:11 -0700151 EXPECT_EQ(2, array->GetIfTableCount());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700152 ASSERT_TRUE(array->GetIfTable() != nullptr);
Mathieu Chartierf8322842014-05-16 10:59:25 -0700153 mirror::Class* direct_interface0 = mirror::Class::GetDirectInterface(self, array, 0);
154 EXPECT_TRUE(direct_interface0 != nullptr);
Ian Rogers1ff3c982014-08-12 02:30:58 -0700155 EXPECT_STREQ(direct_interface0->GetDescriptor(&temp), "Ljava/lang/Cloneable;");
Mathieu Chartierf8322842014-05-16 10:59:25 -0700156 mirror::Class* direct_interface1 = mirror::Class::GetDirectInterface(self, array, 1);
Ian Rogers1ff3c982014-08-12 02:30:58 -0700157 EXPECT_STREQ(direct_interface1->GetDescriptor(&temp), "Ljava/io/Serializable;");
Mathieu Chartierb74cd292014-05-29 14:31:33 -0700158 mirror::Class* array_ptr = array->GetComponentType();
159 EXPECT_EQ(class_linker_->FindArrayClass(self, &array_ptr), array.Get());
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700160 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700161
Mathieu Chartier90443472015-07-16 20:32:27 -0700162 void AssertMethod(ArtMethod* method) SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe58a5af82014-07-31 16:23:49 -0700163 EXPECT_TRUE(method != nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700164 EXPECT_TRUE(method->GetDeclaringClass() != nullptr);
Andreas Gampe58a5af82014-07-31 16:23:49 -0700165 EXPECT_TRUE(method->GetName() != nullptr);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700166 EXPECT_TRUE(method->GetSignature() != Signature::NoSignature());
Brian Carlstromc4fa2c02011-08-21 03:00:12 -0700167
Andreas Gampe58a5af82014-07-31 16:23:49 -0700168 EXPECT_TRUE(method->HasDexCacheResolvedMethods());
169 EXPECT_TRUE(method->HasDexCacheResolvedTypes());
Andreas Gampe58a5af82014-07-31 16:23:49 -0700170 EXPECT_TRUE(method->HasSameDexCacheResolvedMethods(
171 method->GetDeclaringClass()->GetDexCache()->GetResolvedMethods()));
172 EXPECT_TRUE(method->HasSameDexCacheResolvedTypes(
173 method->GetDeclaringClass()->GetDexCache()->GetResolvedTypes()));
Brian Carlstromc4fa2c02011-08-21 03:00:12 -0700174 }
175
Mathieu Chartierc7853442015-03-27 14:35:38 -0700176 void AssertField(mirror::Class* klass, ArtField* field)
Mathieu Chartier90443472015-07-16 20:32:27 -0700177 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700178 EXPECT_TRUE(field != nullptr);
Brian Carlstromc4fa2c02011-08-21 03:00:12 -0700179 EXPECT_EQ(klass, field->GetDeclaringClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700180 EXPECT_TRUE(field->GetName() != nullptr);
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700181 EXPECT_TRUE(field->GetType<true>() != nullptr);
Brian Carlstromc4fa2c02011-08-21 03:00:12 -0700182 }
183
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700184 void AssertClass(const std::string& descriptor, Handle<mirror::Class> klass)
Mathieu Chartier90443472015-07-16 20:32:27 -0700185 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogers1ff3c982014-08-12 02:30:58 -0700186 std::string temp;
187 EXPECT_STREQ(descriptor.c_str(), klass->GetDescriptor(&temp));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800188 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700189 EXPECT_FALSE(klass->HasSuperClass());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700190 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700191 EXPECT_TRUE(klass->HasSuperClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700192 EXPECT_TRUE(klass->GetSuperClass() != nullptr);
Brian Carlstromae3ac012011-07-27 01:30:28 -0700193 }
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700194 EXPECT_TRUE(klass->GetClass() != nullptr);
Brian Carlstroma5a97a22011-09-15 14:08:49 -0700195 EXPECT_EQ(klass->GetClass(), klass->GetClass()->GetClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700196 EXPECT_TRUE(klass->GetDexCache() != nullptr);
Brian Carlstrom25c33252011-09-18 15:58:35 -0700197 EXPECT_TRUE(klass->IsLoaded());
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700198 EXPECT_TRUE(klass->IsResolved());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700199 EXPECT_FALSE(klass->IsErroneous());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700200 EXPECT_FALSE(klass->IsArrayClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700201 EXPECT_TRUE(klass->GetComponentType() == nullptr);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700202 EXPECT_TRUE(klass->IsInSamePackage(klass.Get()));
Mathieu Chartiereace4582014-11-24 18:29:54 -0800203 EXPECT_TRUE(klass->GetDexCacheStrings() != nullptr);
204 EXPECT_EQ(klass->GetDexCacheStrings(), klass->GetDexCache()->GetStrings());
Ian Rogers1ff3c982014-08-12 02:30:58 -0700205 std::string temp2;
206 EXPECT_TRUE(mirror::Class::IsInSamePackage(klass->GetDescriptor(&temp),
207 klass->GetDescriptor(&temp2)));
Brian Carlstromae3ac012011-07-27 01:30:28 -0700208 if (klass->IsInterface()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700209 EXPECT_TRUE(klass->IsAbstract());
210 if (klass->NumDirectMethods() == 1) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700211 EXPECT_TRUE(klass->GetDirectMethod(0, sizeof(void*))->IsClassInitializer());
212 EXPECT_TRUE(klass->GetDirectMethod(0, sizeof(void*))->IsDirect());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700213 } else {
214 EXPECT_EQ(0U, klass->NumDirectMethods());
215 }
Brian Carlstromae3ac012011-07-27 01:30:28 -0700216 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700217 if (!klass->IsSynthetic()) {
218 EXPECT_NE(0U, klass->NumDirectMethods());
219 }
Brian Carlstromae3ac012011-07-27 01:30:28 -0700220 }
Mingyao Yang2cdbad72014-07-16 10:44:41 -0700221 EXPECT_EQ(klass->IsInterface(), !klass->HasVTable());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800222 mirror::IfTable* iftable = klass->GetIfTable();
Brian Carlstrom86927212011-09-15 11:31:11 -0700223 for (int i = 0; i < klass->GetIfTableCount(); i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700224 mirror::Class* interface = iftable->GetInterface(i);
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700225 ASSERT_TRUE(interface != nullptr);
Brian Carlstrom86927212011-09-15 11:31:11 -0700226 if (klass->IsInterface()) {
Ian Rogers9bc81912012-10-11 21:43:36 -0700227 EXPECT_EQ(0U, iftable->GetMethodArrayCount(i));
Brian Carlstrom86927212011-09-15 11:31:11 -0700228 } else {
Ian Rogers9bc81912012-10-11 21:43:36 -0700229 EXPECT_EQ(interface->NumVirtualMethods(), iftable->GetMethodArrayCount(i));
Brian Carlstrom86927212011-09-15 11:31:11 -0700230 }
231 }
Brian Carlstromae3ac012011-07-27 01:30:28 -0700232 if (klass->IsAbstract()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700233 EXPECT_FALSE(klass->IsFinal());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700234 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700235 EXPECT_FALSE(klass->IsAnnotation());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700236 }
237 if (klass->IsFinal()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700238 EXPECT_FALSE(klass->IsAbstract());
239 EXPECT_FALSE(klass->IsAnnotation());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700240 }
241 if (klass->IsAnnotation()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700242 EXPECT_FALSE(klass->IsFinal());
243 EXPECT_TRUE(klass->IsAbstract());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700244 }
245
246 EXPECT_FALSE(klass->IsPrimitive());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700247 EXPECT_TRUE(klass->CanAccess(klass.Get()));
Brian Carlstromae3ac012011-07-27 01:30:28 -0700248
Mathieu Chartiere401d142015-04-22 13:56:20 -0700249 for (ArtMethod& method : klass->GetDirectMethods(sizeof(void*))) {
250 AssertMethod(&method);
251 EXPECT_TRUE(method.IsDirect());
252 EXPECT_EQ(klass.Get(), method.GetDeclaringClass());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700253 }
254
Mathieu Chartiere401d142015-04-22 13:56:20 -0700255 for (ArtMethod& method : klass->GetVirtualMethods(sizeof(void*))) {
256 AssertMethod(&method);
257 EXPECT_FALSE(method.IsDirect());
258 EXPECT_TRUE(method.GetDeclaringClass()->IsAssignableFrom(klass.Get()));
Brian Carlstromae3ac012011-07-27 01:30:28 -0700259 }
260
261 for (size_t i = 0; i < klass->NumInstanceFields(); i++) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700262 ArtField* field = klass->GetInstanceField(i);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700263 AssertField(klass.Get(), field);
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700264 EXPECT_FALSE(field->IsStatic());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700265 }
266
267 for (size_t i = 0; i < klass->NumStaticFields(); i++) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700268 ArtField* field = klass->GetStaticField(i);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700269 AssertField(klass.Get(), field);
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700270 EXPECT_TRUE(field->IsStatic());
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700271 }
Brian Carlstromae3ac012011-07-27 01:30:28 -0700272
Vladimir Marko76649e82014-11-10 18:32:59 +0000273 // Confirm that all instances field offsets are packed together at the start.
Brian Carlstromae3ac012011-07-27 01:30:28 -0700274 EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
Vladimir Marko76649e82014-11-10 18:32:59 +0000275 MemberOffset start_ref_offset = klass->GetFirstReferenceInstanceFieldOffset();
276 MemberOffset end_ref_offset(start_ref_offset.Uint32Value() +
277 klass->NumReferenceInstanceFields() *
278 sizeof(mirror::HeapReference<mirror::Object>));
279 MemberOffset current_ref_offset = start_ref_offset;
280 for (size_t i = 0; i < klass->NumInstanceFields(); i++) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700281 ArtField* field = klass->GetInstanceField(i);
282 mirror::Class* field_type = field->GetType<true>();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700283 ASSERT_TRUE(field_type != nullptr);
Vladimir Marko76649e82014-11-10 18:32:59 +0000284 if (!field->IsPrimitiveType()) {
285 ASSERT_TRUE(!field_type->IsPrimitive());
286 ASSERT_EQ(current_ref_offset.Uint32Value(), field->GetOffset().Uint32Value());
287 if (current_ref_offset.Uint32Value() == end_ref_offset.Uint32Value()) {
288 // While Reference.referent is not primitive, the ClassLinker
289 // treats it as such so that the garbage collector won't scan it.
Mathieu Chartierc7853442015-03-27 14:35:38 -0700290 EXPECT_EQ(PrettyField(field),
Vladimir Marko76649e82014-11-10 18:32:59 +0000291 "java.lang.Object java.lang.ref.Reference.referent");
292 } else {
293 current_ref_offset = MemberOffset(current_ref_offset.Uint32Value() +
294 sizeof(mirror::HeapReference<mirror::Object>));
295 }
296 } else {
297 if (field->GetOffset().Uint32Value() < end_ref_offset.Uint32Value()) {
298 // Shuffled before references.
299 ASSERT_LT(field->GetOffset().Uint32Value(), start_ref_offset.Uint32Value());
300 CHECK(!IsAligned<4>(field->GetOffset().Uint32Value()));
301 }
Brian Carlstromfbfdce62011-10-05 17:33:32 -0700302 }
Brian Carlstromae3ac012011-07-27 01:30:28 -0700303 }
Vladimir Marko76649e82014-11-10 18:32:59 +0000304 ASSERT_EQ(end_ref_offset.Uint32Value(), current_ref_offset.Uint32Value());
Brian Carlstromae3ac012011-07-27 01:30:28 -0700305
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700306 uint32_t total_num_reference_instance_fields = 0;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700307 mirror::Class* k = klass.Get();
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700308 while (k != nullptr) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700309 total_num_reference_instance_fields += k->NumReferenceInstanceFields();
310 k = k->GetSuperClass();
Brian Carlstromae3ac012011-07-27 01:30:28 -0700311 }
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700312 EXPECT_GE(total_num_reference_instance_fields, 1U); // Should always have Object's class.
313 if (klass->GetReferenceInstanceOffsets() != mirror::Class::kClassWalkSuper) {
314 // The reference instance offsets have a bit set for each reference offset.
315 // +1 for Object's class.
316 EXPECT_EQ(static_cast<uint32_t>(POPCOUNT(klass->GetReferenceInstanceOffsets())) + 1,
317 total_num_reference_instance_fields);
318 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700319 }
320
Brian Carlstromea46f952013-07-30 01:26:50 -0700321 void AssertDexFileClass(mirror::ClassLoader* class_loader, const std::string& descriptor)
Mathieu Chartier90443472015-07-16 20:32:27 -0700322 SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700323 ASSERT_TRUE(descriptor != nullptr);
Ian Rogers98379392014-02-24 16:53:16 -0800324 Thread* self = Thread::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700325 StackHandleScope<1> hs(self);
326 Handle<mirror::Class> klass(
327 hs.NewHandle(class_linker_->FindSystemClass(self, descriptor.c_str())));
328 ASSERT_TRUE(klass.Get() != nullptr);
Ian Rogers1ff3c982014-08-12 02:30:58 -0700329 std::string temp;
330 EXPECT_STREQ(descriptor.c_str(), klass.Get()->GetDescriptor(&temp));
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700331 EXPECT_EQ(class_loader, klass->GetClassLoader());
332 if (klass->IsPrimitive()) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700333 AssertPrimitiveClass(descriptor, klass.Get());
Brian Carlstromb63ec392011-08-27 17:38:27 -0700334 } else if (klass->IsArrayClass()) {
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700335 AssertArrayClass(descriptor, klass);
336 } else {
337 AssertClass(descriptor, klass);
338 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700339 }
340
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800341 void AssertDexFile(const DexFile& dex, mirror::ClassLoader* class_loader)
Mathieu Chartier90443472015-07-16 20:32:27 -0700342 SHARED_REQUIRES(Locks::mutator_lock_) {
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700343 // Verify all the classes defined in this file
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800344 for (size_t i = 0; i < dex.NumClassDefs(); i++) {
345 const DexFile::ClassDef& class_def = dex.GetClassDef(i);
346 const char* descriptor = dex.GetClassDescriptor(class_def);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700347 AssertDexFileClass(class_loader, descriptor);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700348 }
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700349 // Verify all the types referenced by this file
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800350 for (size_t i = 0; i < dex.NumTypeIds(); i++) {
351 const DexFile::TypeId& type_id = dex.GetTypeId(i);
352 const char* descriptor = dex.GetTypeDescriptor(type_id);
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700353 AssertDexFileClass(class_loader, descriptor);
354 }
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700355 TestRootVisitor visitor;
356 class_linker_->VisitRoots(&visitor, kVisitRootFlagAllRoots);
Ian Rogers19846512012-02-24 11:42:47 -0800357 // Verify the dex cache has resolution methods in all resolved method slots
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800358 mirror::DexCache* dex_cache = class_linker_->FindDexCache(dex);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700359 auto* resolved_methods = dex_cache->GetResolvedMethods();
Ian Rogers19846512012-02-24 11:42:47 -0800360 for (size_t i = 0; i < static_cast<size_t>(resolved_methods->GetLength()); i++) {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700361 EXPECT_TRUE(resolved_methods->GetElementPtrSize<ArtMethod*>(i, sizeof(void*)) != nullptr)
362 << dex.GetLocation() << " i=" << i;
Ian Rogers19846512012-02-24 11:42:47 -0800363 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700364 }
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700365
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700366 class TestRootVisitor : public SingleRootVisitor {
367 public:
368 void VisitRoot(mirror::Object* root, const RootInfo& info ATTRIBUTE_UNUSED) OVERRIDE {
369 EXPECT_TRUE(root != nullptr);
370 }
371 };
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700372};
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700373
Brian Carlstrom693267a2011-09-06 09:25:34 -0700374struct CheckOffset {
375 size_t cpp_offset;
376 const char* java_name;
377 CheckOffset(size_t c, const char* j) : cpp_offset(c), java_name(j) {}
378};
379
Elliott Hughes80609252011-09-23 17:24:51 -0700380template <typename T>
Brian Carlstrom693267a2011-09-06 09:25:34 -0700381struct CheckOffsets {
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800382 CheckOffsets(bool is_static_in, const char* class_descriptor_in)
383 : is_static(is_static_in), class_descriptor(class_descriptor_in) {}
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700384 bool is_static;
Brian Carlstromdbc05252011-09-09 01:59:59 -0700385 std::string class_descriptor;
386 std::vector<CheckOffset> offsets;
Brian Carlstrom693267a2011-09-06 09:25:34 -0700387
Mathieu Chartier90443472015-07-16 20:32:27 -0700388 bool Check() SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogers98379392014-02-24 16:53:16 -0800389 Thread* self = Thread::Current();
390 mirror::Class* klass =
391 Runtime::Current()->GetClassLinker()->FindSystemClass(self, class_descriptor.c_str());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700392 CHECK(klass != nullptr) << class_descriptor;
Brian Carlstrom693267a2011-09-06 09:25:34 -0700393
394 bool error = false;
395
Mathieu Chartiere401d142015-04-22 13:56:20 -0700396 // Classes have a different size due to padding field. Strings are variable length.
397 if (!klass->IsClassClass() && !klass->IsStringClass() && !is_static) {
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700398 // Currently only required for AccessibleObject since of the padding fields. The class linker
399 // says AccessibleObject is 9 bytes but sizeof(AccessibleObject) is 12 bytes due to padding.
400 // The RoundUp is to get around this case.
401 static constexpr size_t kPackAlignment = 4;
402 size_t expected_size = RoundUp(is_static ? klass->GetClassSize(): klass->GetObjectSize(),
403 kPackAlignment);
Elliott Hughes80609252011-09-23 17:24:51 -0700404 if (sizeof(T) != expected_size) {
Brian Carlstrom265091e2013-01-30 14:08:26 -0800405 LOG(ERROR) << "Class size mismatch:"
Brian Carlstromdbc05252011-09-09 01:59:59 -0700406 << " class=" << class_descriptor
Elliott Hughes80609252011-09-23 17:24:51 -0700407 << " Java=" << expected_size
408 << " C++=" << sizeof(T);
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700409 error = true;
410 }
411 }
412
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700413 size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700414 if (offsets.size() != num_fields) {
Brian Carlstrom265091e2013-01-30 14:08:26 -0800415 LOG(ERROR) << "Field count mismatch:"
Brian Carlstrom4b620ff2011-09-11 01:11:01 -0700416 << " class=" << class_descriptor
417 << " Java=" << num_fields
418 << " C++=" << offsets.size();
Brian Carlstrom693267a2011-09-06 09:25:34 -0700419 error = true;
420 }
421
Brian Carlstromdbc05252011-09-09 01:59:59 -0700422 for (size_t i = 0; i < offsets.size(); i++) {
Mathieu Chartierc7853442015-03-27 14:35:38 -0700423 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700424 StringPiece field_name(field->GetName());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800425 if (field_name != offsets[i].java_name) {
Brian Carlstrom693267a2011-09-06 09:25:34 -0700426 error = true;
427 }
428 }
429 if (error) {
Brian Carlstromdbc05252011-09-09 01:59:59 -0700430 for (size_t i = 0; i < offsets.size(); i++) {
431 CheckOffset& offset = offsets[i];
Mathieu Chartierc7853442015-03-27 14:35:38 -0700432 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700433 StringPiece field_name(field->GetName());
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800434 if (field_name != offsets[i].java_name) {
Brian Carlstrom265091e2013-01-30 14:08:26 -0800435 LOG(ERROR) << "JAVA FIELD ORDER MISMATCH NEXT LINE:";
Brian Carlstrom693267a2011-09-06 09:25:34 -0700436 }
Brian Carlstrom265091e2013-01-30 14:08:26 -0800437 LOG(ERROR) << "Java field order:"
Brian Carlstromdbc05252011-09-09 01:59:59 -0700438 << " i=" << i << " class=" << class_descriptor
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800439 << " Java=" << field_name
Brian Carlstrom693267a2011-09-06 09:25:34 -0700440 << " CheckOffsets=" << offset.java_name;
441 }
442 }
443
Brian Carlstromdbc05252011-09-09 01:59:59 -0700444 for (size_t i = 0; i < offsets.size(); i++) {
445 CheckOffset& offset = offsets[i];
Mathieu Chartierc7853442015-03-27 14:35:38 -0700446 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
Brian Carlstrom693267a2011-09-06 09:25:34 -0700447 if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
448 error = true;
449 }
450 }
451 if (error) {
Brian Carlstromdbc05252011-09-09 01:59:59 -0700452 for (size_t i = 0; i < offsets.size(); i++) {
453 CheckOffset& offset = offsets[i];
Mathieu Chartierc7853442015-03-27 14:35:38 -0700454 ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
Brian Carlstrom693267a2011-09-06 09:25:34 -0700455 if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
Brian Carlstrom265091e2013-01-30 14:08:26 -0800456 LOG(ERROR) << "OFFSET MISMATCH NEXT LINE:";
Brian Carlstrom693267a2011-09-06 09:25:34 -0700457 }
Brian Carlstrom265091e2013-01-30 14:08:26 -0800458 LOG(ERROR) << "Offset: class=" << class_descriptor << " field=" << offset.java_name
Brian Carlstrom693267a2011-09-06 09:25:34 -0700459 << " Java=" << field->GetOffset().Uint32Value() << " C++=" << offset.cpp_offset;
460 }
461 }
462
463 return !error;
464 };
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700465
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700466 void addOffset(size_t offset, const char* name) {
467 offsets.push_back(CheckOffset(offset, name));
468 }
469
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700470 private:
471 DISALLOW_IMPLICIT_CONSTRUCTORS(CheckOffsets);
Brian Carlstrom693267a2011-09-06 09:25:34 -0700472};
473
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700474// Note that ClassLinkerTest.ValidateFieldOrderOfJavaCppUnionClasses
475// is first since if it is failing, others are unlikely to succeed.
476
Brian Carlstromea46f952013-07-30 01:26:50 -0700477struct ObjectOffsets : public CheckOffsets<mirror::Object> {
478 ObjectOffsets() : CheckOffsets<mirror::Object>(false, "Ljava/lang/Object;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700479 addOffset(OFFSETOF_MEMBER(mirror::Object, klass_), "shadow$_klass_");
480 addOffset(OFFSETOF_MEMBER(mirror::Object, monitor_), "shadow$_monitor_");
Hiroshi Yamauchi60f63f52015-04-23 16:12:40 -0700481#ifdef USE_BROOKS_READ_BARRIER
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700482 addOffset(OFFSETOF_MEMBER(mirror::Object, x_rb_ptr_), "shadow$_x_rb_ptr_");
483 addOffset(OFFSETOF_MEMBER(mirror::Object, x_xpadding_), "shadow$_x_xpadding_");
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800484#endif
Brian Carlstrom693267a2011-09-06 09:25:34 -0700485 };
486};
487
Brian Carlstromea46f952013-07-30 01:26:50 -0700488struct ClassOffsets : public CheckOffsets<mirror::Class> {
489 ClassOffsets() : CheckOffsets<mirror::Class>(false, "Ljava/lang/Class;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700490 addOffset(OFFSETOF_MEMBER(mirror::Class, access_flags_), "accessFlags");
491 addOffset(OFFSETOF_MEMBER(mirror::Class, class_loader_), "classLoader");
492 addOffset(OFFSETOF_MEMBER(mirror::Class, class_size_), "classSize");
493 addOffset(OFFSETOF_MEMBER(mirror::Class, clinit_thread_id_), "clinitThreadId");
494 addOffset(OFFSETOF_MEMBER(mirror::Class, component_type_), "componentType");
495 addOffset(OFFSETOF_MEMBER(mirror::Class, dex_cache_), "dexCache");
496 addOffset(OFFSETOF_MEMBER(mirror::Class, dex_cache_strings_), "dexCacheStrings");
497 addOffset(OFFSETOF_MEMBER(mirror::Class, dex_class_def_idx_), "dexClassDefIndex");
498 addOffset(OFFSETOF_MEMBER(mirror::Class, dex_type_idx_), "dexTypeIndex");
499 addOffset(OFFSETOF_MEMBER(mirror::Class, direct_methods_), "directMethods");
500 addOffset(OFFSETOF_MEMBER(mirror::Class, ifields_), "iFields");
501 addOffset(OFFSETOF_MEMBER(mirror::Class, iftable_), "ifTable");
502 addOffset(OFFSETOF_MEMBER(mirror::Class, name_), "name");
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700503 addOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_instance_fields_),
504 "numReferenceInstanceFields");
505 addOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_static_fields_),
506 "numReferenceStaticFields");
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700507 addOffset(OFFSETOF_MEMBER(mirror::Class, object_size_), "objectSize");
508 addOffset(OFFSETOF_MEMBER(mirror::Class, primitive_type_), "primitiveType");
509 addOffset(OFFSETOF_MEMBER(mirror::Class, reference_instance_offsets_),
510 "referenceInstanceOffsets");
511 addOffset(OFFSETOF_MEMBER(mirror::Class, sfields_), "sFields");
512 addOffset(OFFSETOF_MEMBER(mirror::Class, status_), "status");
513 addOffset(OFFSETOF_MEMBER(mirror::Class, super_class_), "superClass");
514 addOffset(OFFSETOF_MEMBER(mirror::Class, verify_error_class_), "verifyErrorClass");
515 addOffset(OFFSETOF_MEMBER(mirror::Class, virtual_methods_), "virtualMethods");
516 addOffset(OFFSETOF_MEMBER(mirror::Class, vtable_), "vtable");
Brian Carlstrom693267a2011-09-06 09:25:34 -0700517 };
518};
519
Brian Carlstromea46f952013-07-30 01:26:50 -0700520struct StringOffsets : public CheckOffsets<mirror::String> {
521 StringOffsets() : CheckOffsets<mirror::String>(false, "Ljava/lang/String;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700522 addOffset(OFFSETOF_MEMBER(mirror::String, count_), "count");
523 addOffset(OFFSETOF_MEMBER(mirror::String, hash_code_), "hashCode");
Brian Carlstrom693267a2011-09-06 09:25:34 -0700524 };
525};
526
Brian Carlstromea46f952013-07-30 01:26:50 -0700527struct ThrowableOffsets : public CheckOffsets<mirror::Throwable> {
528 ThrowableOffsets() : CheckOffsets<mirror::Throwable>(false, "Ljava/lang/Throwable;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700529 addOffset(OFFSETOF_MEMBER(mirror::Throwable, cause_), "cause");
530 addOffset(OFFSETOF_MEMBER(mirror::Throwable, detail_message_), "detailMessage");
531 addOffset(OFFSETOF_MEMBER(mirror::Throwable, stack_state_), "stackState");
532 addOffset(OFFSETOF_MEMBER(mirror::Throwable, stack_trace_), "stackTrace");
533 addOffset(OFFSETOF_MEMBER(mirror::Throwable, suppressed_exceptions_), "suppressedExceptions");
Brian Carlstrom693267a2011-09-06 09:25:34 -0700534 };
535};
536
Brian Carlstromea46f952013-07-30 01:26:50 -0700537struct StackTraceElementOffsets : public CheckOffsets<mirror::StackTraceElement> {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700538 StackTraceElementOffsets() : CheckOffsets<mirror::StackTraceElement>(
539 false, "Ljava/lang/StackTraceElement;") {
540 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, declaring_class_), "declaringClass");
541 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, file_name_), "fileName");
542 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, line_number_), "lineNumber");
543 addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, method_name_), "methodName");
Brian Carlstrom693267a2011-09-06 09:25:34 -0700544 };
545};
546
Brian Carlstromea46f952013-07-30 01:26:50 -0700547struct ClassLoaderOffsets : public CheckOffsets<mirror::ClassLoader> {
548 ClassLoaderOffsets() : CheckOffsets<mirror::ClassLoader>(false, "Ljava/lang/ClassLoader;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700549 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, packages_), "packages");
550 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, parent_), "parent");
551 addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, proxyCache_), "proxyCache");
Brian Carlstrom693267a2011-09-06 09:25:34 -0700552 };
553};
554
Brian Carlstromea46f952013-07-30 01:26:50 -0700555struct ProxyOffsets : public CheckOffsets<mirror::Proxy> {
556 ProxyOffsets() : CheckOffsets<mirror::Proxy>(false, "Ljava/lang/reflect/Proxy;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700557 addOffset(OFFSETOF_MEMBER(mirror::Proxy, h_), "h");
Jesse Wilson95caa792011-10-12 18:14:17 -0400558 };
559};
560
Brian Carlstromea46f952013-07-30 01:26:50 -0700561struct DexCacheOffsets : public CheckOffsets<mirror::DexCache> {
562 DexCacheOffsets() : CheckOffsets<mirror::DexCache>(false, "Ljava/lang/DexCache;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700563 addOffset(OFFSETOF_MEMBER(mirror::DexCache, dex_), "dex");
564 addOffset(OFFSETOF_MEMBER(mirror::DexCache, dex_file_), "dexFile");
565 addOffset(OFFSETOF_MEMBER(mirror::DexCache, location_), "location");
566 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_fields_), "resolvedFields");
567 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_methods_), "resolvedMethods");
568 addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_types_), "resolvedTypes");
569 addOffset(OFFSETOF_MEMBER(mirror::DexCache, strings_), "strings");
Mathieu Chartier66f19252012-09-18 08:57:04 -0700570 };
571};
572
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -0700573struct ReferenceOffsets : public CheckOffsets<mirror::Reference> {
574 ReferenceOffsets() : CheckOffsets<mirror::Reference>(false, "Ljava/lang/ref/Reference;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700575 addOffset(OFFSETOF_MEMBER(mirror::Reference, pending_next_), "pendingNext");
576 addOffset(OFFSETOF_MEMBER(mirror::Reference, queue_), "queue");
577 addOffset(OFFSETOF_MEMBER(mirror::Reference, queue_next_), "queueNext");
578 addOffset(OFFSETOF_MEMBER(mirror::Reference, referent_), "referent");
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -0700579 };
580};
581
582struct FinalizerReferenceOffsets : public CheckOffsets<mirror::FinalizerReference> {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700583 FinalizerReferenceOffsets() : CheckOffsets<mirror::FinalizerReference>(
584 false, "Ljava/lang/ref/FinalizerReference;") {
585 addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, next_), "next");
586 addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, prev_), "prev");
587 addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, zombie_), "zombie");
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -0700588 };
589};
590
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700591struct AccessibleObjectOffsets : public CheckOffsets<mirror::AccessibleObject> {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700592 AccessibleObjectOffsets() : CheckOffsets<mirror::AccessibleObject>(
593 false, "Ljava/lang/reflect/AccessibleObject;") {
594 addOffset(mirror::AccessibleObject::FlagOffset().Uint32Value(), "flag");
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700595 };
596};
597
598struct FieldOffsets : public CheckOffsets<mirror::Field> {
599 FieldOffsets() : CheckOffsets<mirror::Field>(false, "Ljava/lang/reflect/Field;") {
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700600 addOffset(OFFSETOF_MEMBER(mirror::Field, access_flags_), "accessFlags");
601 addOffset(OFFSETOF_MEMBER(mirror::Field, declaring_class_), "declaringClass");
602 addOffset(OFFSETOF_MEMBER(mirror::Field, dex_field_index_), "dexFieldIndex");
603 addOffset(OFFSETOF_MEMBER(mirror::Field, offset_), "offset");
604 addOffset(OFFSETOF_MEMBER(mirror::Field, type_), "type");
605 };
606};
607
608struct AbstractMethodOffsets : public CheckOffsets<mirror::AbstractMethod> {
609 AbstractMethodOffsets() : CheckOffsets<mirror::AbstractMethod>(
610 false, "Ljava/lang/reflect/AbstractMethod;") {
611 addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, access_flags_), "accessFlags");
612 addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, art_method_), "artMethod");
613 addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, declaring_class_), "declaringClass");
614 addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, declaring_class_of_overridden_method_),
615 "declaringClassOfOverriddenMethod");
616 addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, dex_method_index_), "dexMethodIndex");
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700617 };
618};
619
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400620// C++ fields must exactly match the fields in the Java classes. If this fails,
Jesse Wilsonac5b9e22011-07-27 15:11:13 -0400621// reorder the fields in the C++ class. Managed class fields are ordered by
Brian Carlstrom693267a2011-09-06 09:25:34 -0700622// ClassLinker::LinkFields.
Jesse Wilson46cdd4b2011-07-28 17:40:48 -0400623TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700624 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom693267a2011-09-06 09:25:34 -0700625 EXPECT_TRUE(ObjectOffsets().Check());
Brian Carlstrom693267a2011-09-06 09:25:34 -0700626 EXPECT_TRUE(ClassOffsets().Check());
627 EXPECT_TRUE(StringOffsets().Check());
628 EXPECT_TRUE(ThrowableOffsets().Check());
629 EXPECT_TRUE(StackTraceElementOffsets().Check());
630 EXPECT_TRUE(ClassLoaderOffsets().Check());
Jesse Wilson95caa792011-10-12 18:14:17 -0400631 EXPECT_TRUE(ProxyOffsets().Check());
Mathieu Chartier66f19252012-09-18 08:57:04 -0700632 EXPECT_TRUE(DexCacheOffsets().Check());
Mathieu Chartier8fa2dad2014-03-13 12:22:56 -0700633 EXPECT_TRUE(ReferenceOffsets().Check());
634 EXPECT_TRUE(FinalizerReferenceOffsets().Check());
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700635 EXPECT_TRUE(AccessibleObjectOffsets().Check());
636 EXPECT_TRUE(FieldOffsets().Check());
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700637 EXPECT_TRUE(AbstractMethodOffsets().Check());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700638}
639
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700640TEST_F(ClassLinkerTest, FindClassNonexistent) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700641 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700642 AssertNonExistentClass("NoSuchClass;");
643 AssertNonExistentClass("LNoSuchClass;");
644}
645
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700646TEST_F(ClassLinkerTest, GetDexFiles) {
647 ScopedObjectAccess soa(Thread::Current());
648
649 jobject jclass_loader = LoadDex("Nested");
650 std::vector<const DexFile*> dex_files(GetDexFiles(jclass_loader));
651 ASSERT_EQ(dex_files.size(), 1U);
652 EXPECT_TRUE(EndsWith(dex_files[0]->GetLocation(), "Nested.jar"));
653
654 jobject jclass_loader2 = LoadDex("MultiDex");
655 std::vector<const DexFile*> dex_files2(GetDexFiles(jclass_loader2));
656 ASSERT_EQ(dex_files2.size(), 2U);
657 EXPECT_TRUE(EndsWith(dex_files2[0]->GetLocation(), "MultiDex.jar"));
658}
659
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700660TEST_F(ClassLinkerTest, FindClassNested) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700661 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700662 StackHandleScope<1> hs(soa.Self());
663 Handle<mirror::ClassLoader> class_loader(
664 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Nested"))));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700665
Ian Rogers98379392014-02-24 16:53:16 -0800666 mirror::Class* outer = class_linker_->FindClass(soa.Self(), "LNested;", class_loader);
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700667 ASSERT_TRUE(outer != nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700668 EXPECT_EQ(0U, outer->NumVirtualMethods());
669 EXPECT_EQ(1U, outer->NumDirectMethods());
670
Ian Rogers98379392014-02-24 16:53:16 -0800671 mirror::Class* inner = class_linker_->FindClass(soa.Self(), "LNested$Inner;", class_loader);
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700672 ASSERT_TRUE(inner != nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700673 EXPECT_EQ(0U, inner->NumVirtualMethods());
674 EXPECT_EQ(1U, inner->NumDirectMethods());
675}
676
677TEST_F(ClassLinkerTest, FindClass_Primitives) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700678 ScopedObjectAccess soa(Thread::Current());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700679 const std::string expected("BCDFIJSZV");
Elliott Hughesdb7d5e92011-12-16 18:47:37 -0800680 for (int ch = 1; ch < 256; ++ch) {
681 std::string descriptor;
682 descriptor.push_back(ch);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700683 if (expected.find(ch) == std::string::npos) {
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700684 AssertNonExistentClass(descriptor);
685 } else {
686 AssertPrimitiveClass(descriptor);
687 }
688 }
689}
690
691TEST_F(ClassLinkerTest, FindClass) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700692 ScopedObjectAccess soa(Thread::Current());
Ian Rogers98379392014-02-24 16:53:16 -0800693 mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700694 ASSERT_TRUE(JavaLangObject != nullptr);
695 ASSERT_TRUE(JavaLangObject->GetClass() != nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700696 ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
697 EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
Ian Rogers1ff3c982014-08-12 02:30:58 -0700698 std::string temp;
699 ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;");
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700700 EXPECT_TRUE(JavaLangObject->GetSuperClass() == nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700701 EXPECT_FALSE(JavaLangObject->HasSuperClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700702 EXPECT_TRUE(JavaLangObject->GetClassLoader() == nullptr);
Brian Carlstromea46f952013-07-30 01:26:50 -0700703 EXPECT_EQ(mirror::Class::kStatusInitialized, JavaLangObject->GetStatus());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700704 EXPECT_FALSE(JavaLangObject->IsErroneous());
Brian Carlstrom25c33252011-09-18 15:58:35 -0700705 EXPECT_TRUE(JavaLangObject->IsLoaded());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700706 EXPECT_TRUE(JavaLangObject->IsResolved());
Brian Carlstromea46f952013-07-30 01:26:50 -0700707 EXPECT_TRUE(JavaLangObject->IsVerified());
708 EXPECT_TRUE(JavaLangObject->IsInitialized());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700709 EXPECT_FALSE(JavaLangObject->IsArrayInstance());
710 EXPECT_FALSE(JavaLangObject->IsArrayClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700711 EXPECT_TRUE(JavaLangObject->GetComponentType() == nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700712 EXPECT_FALSE(JavaLangObject->IsInterface());
713 EXPECT_TRUE(JavaLangObject->IsPublic());
714 EXPECT_FALSE(JavaLangObject->IsFinal());
715 EXPECT_FALSE(JavaLangObject->IsPrimitive());
716 EXPECT_FALSE(JavaLangObject->IsSynthetic());
717 EXPECT_EQ(2U, JavaLangObject->NumDirectMethods());
718 EXPECT_EQ(11U, JavaLangObject->NumVirtualMethods());
Hiroshi Yamauchi60f63f52015-04-23 16:12:40 -0700719 if (!kUseBrooksReadBarrier) {
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800720 EXPECT_EQ(2U, JavaLangObject->NumInstanceFields());
721 } else {
722 EXPECT_EQ(4U, JavaLangObject->NumInstanceFields());
723 }
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700724 EXPECT_STREQ(JavaLangObject->GetInstanceField(0)->GetName(), "shadow$_klass_");
725 EXPECT_STREQ(JavaLangObject->GetInstanceField(1)->GetName(), "shadow$_monitor_");
Hiroshi Yamauchi60f63f52015-04-23 16:12:40 -0700726 if (kUseBrooksReadBarrier) {
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700727 EXPECT_STREQ(JavaLangObject->GetInstanceField(2)->GetName(), "shadow$_x_rb_ptr_");
728 EXPECT_STREQ(JavaLangObject->GetInstanceField(3)->GetName(), "shadow$_x_xpadding_");
Hiroshi Yamauchi9d04a202014-01-31 13:35:49 -0800729 }
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700730
731 EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
Mathieu Chartierf8322842014-05-16 10:59:25 -0700732 EXPECT_EQ(0U, JavaLangObject->NumDirectInterfaces());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700733
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700734 StackHandleScope<1> hs(soa.Self());
735 Handle<mirror::ClassLoader> class_loader(
736 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass"))));
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700737 AssertNonExistentClass("LMyClass;");
Ian Rogers98379392014-02-24 16:53:16 -0800738 mirror::Class* MyClass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader);
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700739 ASSERT_TRUE(MyClass != nullptr);
740 ASSERT_TRUE(MyClass->GetClass() != nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700741 ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
742 EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass());
Ian Rogers1ff3c982014-08-12 02:30:58 -0700743 ASSERT_STREQ(MyClass->GetDescriptor(&temp), "LMyClass;");
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700744 EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
745 EXPECT_TRUE(MyClass->HasSuperClass());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700746 EXPECT_EQ(class_loader.Get(), MyClass->GetClassLoader());
Brian Carlstromea46f952013-07-30 01:26:50 -0700747 EXPECT_EQ(mirror::Class::kStatusResolved, MyClass->GetStatus());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700748 EXPECT_FALSE(MyClass->IsErroneous());
Brian Carlstrom25c33252011-09-18 15:58:35 -0700749 EXPECT_TRUE(MyClass->IsLoaded());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700750 EXPECT_TRUE(MyClass->IsResolved());
Brian Carlstrom25c33252011-09-18 15:58:35 -0700751 EXPECT_FALSE(MyClass->IsVerified());
752 EXPECT_FALSE(MyClass->IsInitialized());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700753 EXPECT_FALSE(MyClass->IsArrayInstance());
754 EXPECT_FALSE(MyClass->IsArrayClass());
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700755 EXPECT_TRUE(MyClass->GetComponentType() == nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700756 EXPECT_FALSE(MyClass->IsInterface());
757 EXPECT_FALSE(MyClass->IsPublic());
758 EXPECT_FALSE(MyClass->IsFinal());
759 EXPECT_FALSE(MyClass->IsPrimitive());
760 EXPECT_FALSE(MyClass->IsSynthetic());
761 EXPECT_EQ(1U, MyClass->NumDirectMethods());
762 EXPECT_EQ(0U, MyClass->NumVirtualMethods());
763 EXPECT_EQ(0U, MyClass->NumInstanceFields());
764 EXPECT_EQ(0U, MyClass->NumStaticFields());
Mathieu Chartierf8322842014-05-16 10:59:25 -0700765 EXPECT_EQ(0U, MyClass->NumDirectInterfaces());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700766
767 EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
768
769 // created by class_linker
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700770 AssertArrayClass("[C", "C", nullptr);
771 AssertArrayClass("[Ljava/lang/Object;", "Ljava/lang/Object;", nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700772 // synthesized on the fly
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700773 AssertArrayClass("[[C", "[C", nullptr);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700774 AssertArrayClass("[[[LMyClass;", "[[LMyClass;", class_loader.Get());
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700775 // or not available at all
776 AssertNonExistentClass("[[[[LNonExistentClass;");
777}
778
779TEST_F(ClassLinkerTest, LibCore) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700780 ScopedObjectAccess soa(Thread::Current());
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800781 ASSERT_TRUE(java_lang_dex_file_ != nullptr);
782 AssertDexFile(*java_lang_dex_file_, nullptr);
Brian Carlstrom5b8e4c82011-09-18 01:38:59 -0700783}
784
Ian Rogersa15e67d2012-02-28 13:51:55 -0800785// The first reference array element must be a multiple of 4 bytes from the
Jesse Wilsondf4189c2011-08-09 17:10:28 -0400786// start of the object
787TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700788 ScopedObjectAccess soa(Thread::Current());
Ian Rogers98379392014-02-24 16:53:16 -0800789 mirror::Class* array_class = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
Brian Carlstromea46f952013-07-30 01:26:50 -0700790 mirror::ObjectArray<mirror::String>* array =
791 mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), array_class, 0);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800792 uintptr_t data_offset =
793 reinterpret_cast<uintptr_t>(array->GetRawData(sizeof(mirror::HeapReference<mirror::String>),
794 0));
795 if (sizeof(mirror::HeapReference<mirror::String>) == sizeof(int32_t)) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800796 EXPECT_TRUE(IsAligned<4>(data_offset)); // Check 4 byte alignment.
797 } else {
798 EXPECT_TRUE(IsAligned<8>(data_offset)); // Check 8 byte alignment.
799 }
Jesse Wilsondf4189c2011-08-09 17:10:28 -0400800}
801
802TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700803 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700804 StackHandleScope<5> hs(soa.Self());
805 Handle<mirror::LongArray> long_array(hs.NewHandle(mirror::LongArray::Alloc(soa.Self(), 0)));
Ian Rogers98379392014-02-24 16:53:16 -0800806 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[J"), long_array->GetClass());
Ian Rogersa15e67d2012-02-28 13:51:55 -0800807 uintptr_t data_offset = reinterpret_cast<uintptr_t>(long_array->GetData());
808 EXPECT_TRUE(IsAligned<8>(data_offset)); // Longs require 8 byte alignment
809
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700810 Handle<mirror::DoubleArray> double_array(hs.NewHandle(mirror::DoubleArray::Alloc(soa.Self(), 0)));
Ian Rogers98379392014-02-24 16:53:16 -0800811 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[D"), double_array->GetClass());
Ian Rogersa15e67d2012-02-28 13:51:55 -0800812 data_offset = reinterpret_cast<uintptr_t>(double_array->GetData());
813 EXPECT_TRUE(IsAligned<8>(data_offset)); // Doubles require 8 byte alignment
814
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700815 Handle<mirror::IntArray> int_array(hs.NewHandle(mirror::IntArray::Alloc(soa.Self(), 0)));
Ian Rogers98379392014-02-24 16:53:16 -0800816 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[I"), int_array->GetClass());
Ian Rogersa15e67d2012-02-28 13:51:55 -0800817 data_offset = reinterpret_cast<uintptr_t>(int_array->GetData());
818 EXPECT_TRUE(IsAligned<4>(data_offset)); // Ints require 4 byte alignment
819
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700820 Handle<mirror::CharArray> char_array(hs.NewHandle(mirror::CharArray::Alloc(soa.Self(), 0)));
Ian Rogers98379392014-02-24 16:53:16 -0800821 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[C"), char_array->GetClass());
Ian Rogersa15e67d2012-02-28 13:51:55 -0800822 data_offset = reinterpret_cast<uintptr_t>(char_array->GetData());
823 EXPECT_TRUE(IsAligned<2>(data_offset)); // Chars require 2 byte alignment
824
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700825 Handle<mirror::ShortArray> short_array(hs.NewHandle(mirror::ShortArray::Alloc(soa.Self(), 0)));
Ian Rogers98379392014-02-24 16:53:16 -0800826 EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[S"), short_array->GetClass());
Ian Rogersa15e67d2012-02-28 13:51:55 -0800827 data_offset = reinterpret_cast<uintptr_t>(short_array->GetData());
828 EXPECT_TRUE(IsAligned<2>(data_offset)); // Shorts require 2 byte alignment
829
830 // Take it as given that bytes and booleans have byte alignment
Jesse Wilsondf4189c2011-08-09 17:10:28 -0400831}
832
Elliott Hughes33203b52011-09-20 19:42:01 -0700833TEST_F(ClassLinkerTest, ValidateBoxedTypes) {
834 // Validate that the "value" field is always the 0th field in each of java.lang's box classes.
835 // This lets UnboxPrimitive avoid searching for the field by name at runtime.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700836 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier0cd81352014-05-22 16:48:55 -0700837 NullHandle<mirror::ClassLoader> class_loader;
Brian Carlstromea46f952013-07-30 01:26:50 -0700838 mirror::Class* c;
Ian Rogers98379392014-02-24 16:53:16 -0800839 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Boolean;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700840 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Ian Rogers98379392014-02-24 16:53:16 -0800841 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Byte;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700842 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Ian Rogers98379392014-02-24 16:53:16 -0800843 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Character;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700844 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Ian Rogers98379392014-02-24 16:53:16 -0800845 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Double;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700846 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Ian Rogers98379392014-02-24 16:53:16 -0800847 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Float;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700848 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Ian Rogers98379392014-02-24 16:53:16 -0800849 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Integer;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700850 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Ian Rogers98379392014-02-24 16:53:16 -0800851 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Long;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700852 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Ian Rogers98379392014-02-24 16:53:16 -0800853 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Short;", class_loader);
Mathieu Chartier54d220e2015-07-30 16:20:06 -0700854 EXPECT_STREQ("value", c->GetIFieldsPtr()->At(0).GetName());
Elliott Hughes33203b52011-09-20 19:42:01 -0700855}
856
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700857TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700858 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700859 StackHandleScope<2> hs(soa.Self());
860 Handle<mirror::ClassLoader> class_loader_1(
861 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass"))));
862 Handle<mirror::ClassLoader> class_loader_2(
863 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass"))));
Ian Rogers98379392014-02-24 16:53:16 -0800864 mirror::Class* MyClass_1 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_1);
865 mirror::Class* MyClass_2 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_2);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700866 EXPECT_TRUE(MyClass_1 != nullptr);
867 EXPECT_TRUE(MyClass_2 != nullptr);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700868 EXPECT_NE(MyClass_1, MyClass_2);
Jesse Wilsonac5b9e22011-07-27 15:11:13 -0400869}
870
Jesse Wilson7833bd22011-08-09 18:31:44 -0400871TEST_F(ClassLinkerTest, StaticFields) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700872 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700873 StackHandleScope<2> hs(soa.Self());
874 Handle<mirror::ClassLoader> class_loader(
875 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Statics"))));
876 Handle<mirror::Class> statics(
877 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
Ian Rogers7b078e82014-09-10 14:44:24 -0700878 class_linker_->EnsureInitialized(soa.Self(), statics, true, true);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400879
jeffhaoabcfde32011-09-29 15:05:18 -0700880 // Static final primitives that are initialized by a compile-time constant
881 // expression resolve to a copy of a constant value from the constant pool.
882 // So <clinit> should be null.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700883 ArtMethod* clinit = statics->FindDirectMethod("<clinit>", "()V", sizeof(void*));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700884 EXPECT_TRUE(clinit == nullptr);
jeffhaoabcfde32011-09-29 15:05:18 -0700885
886 EXPECT_EQ(9U, statics->NumStaticFields());
Jesse Wilson7833bd22011-08-09 18:31:44 -0400887
Mathieu Chartierc7853442015-03-27 14:35:38 -0700888 ArtField* s0 = mirror::Class::FindStaticField(soa.Self(), statics, "s0", "Z");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700889 EXPECT_EQ(s0->GetTypeAsPrimitiveType(), Primitive::kPrimBoolean);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700890 EXPECT_EQ(true, s0->GetBoolean(statics.Get()));
891 s0->SetBoolean<false>(statics.Get(), false);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400892
Mathieu Chartierc7853442015-03-27 14:35:38 -0700893 ArtField* s1 = mirror::Class::FindStaticField(soa.Self(), statics, "s1", "B");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700894 EXPECT_EQ(s1->GetTypeAsPrimitiveType(), Primitive::kPrimByte);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700895 EXPECT_EQ(5, s1->GetByte(statics.Get()));
896 s1->SetByte<false>(statics.Get(), 6);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400897
Mathieu Chartierc7853442015-03-27 14:35:38 -0700898 ArtField* s2 = mirror::Class::FindStaticField(soa.Self(), statics, "s2", "C");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700899 EXPECT_EQ(s2->GetTypeAsPrimitiveType(), Primitive::kPrimChar);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700900 EXPECT_EQ('a', s2->GetChar(statics.Get()));
901 s2->SetChar<false>(statics.Get(), 'b');
Jesse Wilson7833bd22011-08-09 18:31:44 -0400902
Mathieu Chartierc7853442015-03-27 14:35:38 -0700903 ArtField* s3 = mirror::Class::FindStaticField(soa.Self(), statics, "s3", "S");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700904 EXPECT_EQ(s3->GetTypeAsPrimitiveType(), Primitive::kPrimShort);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700905 EXPECT_EQ(-536, s3->GetShort(statics.Get()));
906 s3->SetShort<false>(statics.Get(), -535);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400907
Mathieu Chartierc7853442015-03-27 14:35:38 -0700908 ArtField* s4 = mirror::Class::FindStaticField(soa.Self(), statics, "s4", "I");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700909 EXPECT_EQ(s4->GetTypeAsPrimitiveType(), Primitive::kPrimInt);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700910 EXPECT_EQ(2000000000, s4->GetInt(statics.Get()));
911 s4->SetInt<false>(statics.Get(), 2000000001);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400912
Mathieu Chartierc7853442015-03-27 14:35:38 -0700913 ArtField* s5 = mirror::Class::FindStaticField(soa.Self(), statics, "s5", "J");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700914 EXPECT_EQ(s5->GetTypeAsPrimitiveType(), Primitive::kPrimLong);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700915 EXPECT_EQ(0x1234567890abcdefLL, s5->GetLong(statics.Get()));
916 s5->SetLong<false>(statics.Get(), INT64_C(0x34567890abcdef12));
Jesse Wilson7833bd22011-08-09 18:31:44 -0400917
Mathieu Chartierc7853442015-03-27 14:35:38 -0700918 ArtField* s6 = mirror::Class::FindStaticField(soa.Self(), statics, "s6", "F");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700919 EXPECT_EQ(s6->GetTypeAsPrimitiveType(), Primitive::kPrimFloat);
Ian Rogers647b1a82014-10-10 11:02:11 -0700920 EXPECT_DOUBLE_EQ(0.5, s6->GetFloat(statics.Get()));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700921 s6->SetFloat<false>(statics.Get(), 0.75);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400922
Mathieu Chartierc7853442015-03-27 14:35:38 -0700923 ArtField* s7 = mirror::Class::FindStaticField(soa.Self(), statics, "s7", "D");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700924 EXPECT_EQ(s7->GetTypeAsPrimitiveType(), Primitive::kPrimDouble);
Ian Rogers647b1a82014-10-10 11:02:11 -0700925 EXPECT_DOUBLE_EQ(16777217.0, s7->GetDouble(statics.Get()));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700926 s7->SetDouble<false>(statics.Get(), 16777219);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400927
Mathieu Chartierc7853442015-03-27 14:35:38 -0700928 ArtField* s8 = mirror::Class::FindStaticField(soa.Self(), statics, "s8",
Mathieu Chartierf8322842014-05-16 10:59:25 -0700929 "Ljava/lang/String;");
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -0700930 EXPECT_EQ(s8->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700931 EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("android"));
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100932 s8->SetObject<false>(s8->GetDeclaringClass(),
933 mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot"));
Jesse Wilson7833bd22011-08-09 18:31:44 -0400934
Brian Carlstrom2e3d1b22012-01-09 18:01:56 -0800935 // TODO: Remove EXPECT_FALSE when GCC can handle EXPECT_EQ
936 // http://code.google.com/p/googletest/issues/detail?id=322
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700937 EXPECT_FALSE(s0->GetBoolean(statics.Get()));
938 EXPECT_EQ(6, s1->GetByte(statics.Get()));
939 EXPECT_EQ('b', s2->GetChar(statics.Get()));
940 EXPECT_EQ(-535, s3->GetShort(statics.Get()));
941 EXPECT_EQ(2000000001, s4->GetInt(statics.Get()));
942 EXPECT_EQ(INT64_C(0x34567890abcdef12), s5->GetLong(statics.Get()));
Ian Rogers647b1a82014-10-10 11:02:11 -0700943 EXPECT_FLOAT_EQ(0.75, s6->GetFloat(statics.Get()));
944 EXPECT_DOUBLE_EQ(16777219.0, s7->GetDouble(statics.Get()));
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700945 EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("robot"));
Jesse Wilson7833bd22011-08-09 18:31:44 -0400946}
947
Brian Carlstrom30b94452011-08-25 21:35:26 -0700948TEST_F(ClassLinkerTest, Interfaces) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700949 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartierf8322842014-05-16 10:59:25 -0700950 StackHandleScope<6> hs(soa.Self());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700951 Handle<mirror::ClassLoader> class_loader(
952 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Interfaces"))));
Mathieu Chartierf8322842014-05-16 10:59:25 -0700953 Handle<mirror::Class> I(
954 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$I;", class_loader)));
955 Handle<mirror::Class> J(
956 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$J;", class_loader)));
957 Handle<mirror::Class> K(
958 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$K;", class_loader)));
959 Handle<mirror::Class> A(
960 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$A;", class_loader)));
961 Handle<mirror::Class> B(
962 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$B;", class_loader)));
963 EXPECT_TRUE(I->IsAssignableFrom(A.Get()));
964 EXPECT_TRUE(J->IsAssignableFrom(A.Get()));
965 EXPECT_TRUE(J->IsAssignableFrom(K.Get()));
966 EXPECT_TRUE(K->IsAssignableFrom(B.Get()));
967 EXPECT_TRUE(J->IsAssignableFrom(B.Get()));
Brian Carlstrom30b94452011-08-25 21:35:26 -0700968
Ian Rogersd91d6d62013-09-25 20:26:14 -0700969 const Signature void_sig = I->GetDexCache()->GetDexFile()->CreateSignature("()V");
Mathieu Chartiere401d142015-04-22 13:56:20 -0700970 ArtMethod* Ii = I->FindVirtualMethod("i", void_sig, sizeof(void*));
971 ArtMethod* Jj1 = J->FindVirtualMethod("j1", void_sig, sizeof(void*));
972 ArtMethod* Jj2 = J->FindVirtualMethod("j2", void_sig, sizeof(void*));
973 ArtMethod* Kj1 = K->FindInterfaceMethod("j1", void_sig, sizeof(void*));
974 ArtMethod* Kj2 = K->FindInterfaceMethod("j2", void_sig, sizeof(void*));
975 ArtMethod* Kk = K->FindInterfaceMethod("k", void_sig, sizeof(void*));
976 ArtMethod* Ai = A->FindVirtualMethod("i", void_sig, sizeof(void*));
977 ArtMethod* Aj1 = A->FindVirtualMethod("j1", void_sig, sizeof(void*));
978 ArtMethod* Aj2 = A->FindVirtualMethod("j2", void_sig, sizeof(void*));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -0700979 ASSERT_TRUE(Ii != nullptr);
980 ASSERT_TRUE(Jj1 != nullptr);
981 ASSERT_TRUE(Jj2 != nullptr);
982 ASSERT_TRUE(Kj1 != nullptr);
983 ASSERT_TRUE(Kj2 != nullptr);
984 ASSERT_TRUE(Kk != nullptr);
985 ASSERT_TRUE(Ai != nullptr);
986 ASSERT_TRUE(Aj1 != nullptr);
987 ASSERT_TRUE(Aj2 != nullptr);
Brian Carlstrom30b94452011-08-25 21:35:26 -0700988 EXPECT_NE(Ii, Ai);
989 EXPECT_NE(Jj1, Aj1);
990 EXPECT_NE(Jj2, Aj2);
jeffhao5dbddee2011-09-07 16:38:26 -0700991 EXPECT_EQ(Kj1, Jj1);
992 EXPECT_EQ(Kj2, Jj2);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700993 EXPECT_EQ(Ai, A->FindVirtualMethodForInterface(Ii, sizeof(void*)));
994 EXPECT_EQ(Aj1, A->FindVirtualMethodForInterface(Jj1, sizeof(void*)));
995 EXPECT_EQ(Aj2, A->FindVirtualMethodForInterface(Jj2, sizeof(void*)));
996 EXPECT_EQ(Ai, A->FindVirtualMethodForVirtualOrInterface(Ii, sizeof(void*)));
997 EXPECT_EQ(Aj1, A->FindVirtualMethodForVirtualOrInterface(Jj1, sizeof(void*)));
998 EXPECT_EQ(Aj2, A->FindVirtualMethodForVirtualOrInterface(Jj2, sizeof(void*)));
Ian Rogersd24e2642012-06-06 21:21:43 -0700999
Mathieu Chartiere401d142015-04-22 13:56:20 -07001000 ArtField* Afoo = mirror::Class::FindStaticField(soa.Self(), A, "foo", "Ljava/lang/String;");
1001 ArtField* Bfoo = mirror::Class::FindStaticField(soa.Self(), B, "foo", "Ljava/lang/String;");
1002 ArtField* Jfoo = mirror::Class::FindStaticField(soa.Self(), J, "foo", "Ljava/lang/String;");
1003 ArtField* Kfoo = mirror::Class::FindStaticField(soa.Self(), K, "foo", "Ljava/lang/String;");
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07001004 ASSERT_TRUE(Afoo != nullptr);
Ian Rogersd24e2642012-06-06 21:21:43 -07001005 EXPECT_EQ(Afoo, Bfoo);
1006 EXPECT_EQ(Afoo, Jfoo);
1007 EXPECT_EQ(Afoo, Kfoo);
Brian Carlstrom30b94452011-08-25 21:35:26 -07001008}
1009
Elliott Hughesf3778f62012-01-26 14:14:35 -08001010TEST_F(ClassLinkerTest, ResolveVerifyAndClinit) {
jeffhaoabcfde32011-09-29 15:05:18 -07001011 // pretend we are trying to get the static storage for the StaticsFromCode class.
Brian Carlstrom193a44d2011-09-04 12:01:42 -07001012
jeffhaoabcfde32011-09-29 15:05:18 -07001013 // case 1, get the uninitialized storage from StaticsFromCode.<clinit>
1014 // case 2, get the initialized storage from StaticsFromCode.getS0
Brian Carlstrom193a44d2011-09-04 12:01:42 -07001015
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001016 ScopedObjectAccess soa(Thread::Current());
1017 jobject jclass_loader = LoadDex("StaticsFromCode");
Andreas Gampe81c6f8d2015-03-25 17:19:53 -07001018 const DexFile* dex_file = GetFirstDexFile(jclass_loader);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001019 StackHandleScope<1> hs(soa.Self());
1020 Handle<mirror::ClassLoader> class_loader(
1021 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
Ian Rogers98379392014-02-24 16:53:16 -08001022 mirror::Class* klass = class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", class_loader);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001023 ArtMethod* clinit = klass->FindClassInitializer(sizeof(void*));
1024 ArtMethod* getS0 = klass->FindDirectMethod("getS0", "()Ljava/lang/Object;", sizeof(void*));
Ian Rogers9b1a4f42011-11-14 18:35:10 -08001025 const DexFile::StringId* string_id = dex_file->FindStringId("LStaticsFromCode;");
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07001026 ASSERT_TRUE(string_id != nullptr);
Ian Rogers9b1a4f42011-11-14 18:35:10 -08001027 const DexFile::TypeId* type_id = dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07001028 ASSERT_TRUE(type_id != nullptr);
Ian Rogers9b1a4f42011-11-14 18:35:10 -08001029 uint32_t type_idx = dex_file->GetIndexForTypeId(*type_id);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001030 mirror::Class* uninit = ResolveVerifyAndClinit(type_idx, clinit, soa.Self(), true, false);
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07001031 EXPECT_TRUE(uninit != nullptr);
Ian Rogers5ddb4102014-01-07 08:58:46 -08001032 EXPECT_FALSE(uninit->IsInitialized());
Mathieu Chartiere401d142015-04-22 13:56:20 -07001033 mirror::Class* init = ResolveVerifyAndClinit(type_idx, getS0, soa.Self(), true, false);
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07001034 EXPECT_TRUE(init != nullptr);
Ian Rogers5ddb4102014-01-07 08:58:46 -08001035 EXPECT_TRUE(init->IsInitialized());
Brian Carlstrom848a4b32011-09-04 11:29:27 -07001036}
1037
Elliott Hughes20cde902011-10-04 17:37:27 -07001038TEST_F(ClassLinkerTest, FinalizableBit) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001039 ScopedObjectAccess soa(Thread::Current());
Brian Carlstromea46f952013-07-30 01:26:50 -07001040 mirror::Class* c;
Elliott Hughes20cde902011-10-04 17:37:27 -07001041
1042 // Object has a finalize method, but we know it's empty.
Ian Rogers98379392014-02-24 16:53:16 -08001043 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001044 EXPECT_FALSE(c->IsFinalizable());
1045
1046 // Enum has a finalize method to prevent its subclasses from implementing one.
Ian Rogers98379392014-02-24 16:53:16 -08001047 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Enum;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001048 EXPECT_FALSE(c->IsFinalizable());
1049
1050 // RoundingMode is an enum.
Ian Rogers98379392014-02-24 16:53:16 -08001051 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/math/RoundingMode;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001052 EXPECT_FALSE(c->IsFinalizable());
1053
1054 // RandomAccessFile extends Object and overrides finalize.
Ian Rogers98379392014-02-24 16:53:16 -08001055 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/RandomAccessFile;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001056 EXPECT_TRUE(c->IsFinalizable());
1057
1058 // FileInputStream is finalizable and extends InputStream which isn't.
Ian Rogers98379392014-02-24 16:53:16 -08001059 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/InputStream;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001060 EXPECT_FALSE(c->IsFinalizable());
Ian Rogers98379392014-02-24 16:53:16 -08001061 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/FileInputStream;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001062 EXPECT_TRUE(c->IsFinalizable());
1063
1064 // ScheduledThreadPoolExecutor doesn't have a finalize method but
1065 // extends ThreadPoolExecutor which does.
Ian Rogers98379392014-02-24 16:53:16 -08001066 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/util/concurrent/ThreadPoolExecutor;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001067 EXPECT_TRUE(c->IsFinalizable());
Ian Rogers98379392014-02-24 16:53:16 -08001068 c = class_linker_->FindSystemClass(soa.Self(), "Ljava/util/concurrent/ScheduledThreadPoolExecutor;");
Elliott Hughes20cde902011-10-04 17:37:27 -07001069 EXPECT_TRUE(c->IsFinalizable());
1070}
1071
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001072TEST_F(ClassLinkerTest, ClassRootDescriptors) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001073 ScopedObjectAccess soa(Thread::Current());
Ian Rogers1ff3c982014-08-12 02:30:58 -07001074 std::string temp;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001075 for (int i = 0; i < ClassLinker::kClassRootsMax; i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001076 mirror::Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
Ian Rogers1ff3c982014-08-12 02:30:58 -07001077 EXPECT_GT(strlen(klass->GetDescriptor(&temp)), 0U);
1078 EXPECT_STREQ(klass->GetDescriptor(&temp),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001079 class_linker_->GetClassRootDescriptor(ClassLinker::ClassRoot(i))) << " i = " << i;
1080 }
1081}
1082
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001083TEST_F(ClassLinkerTest, ValidatePredefinedClassSizes) {
1084 ScopedObjectAccess soa(Thread::Current());
1085 NullHandle<mirror::ClassLoader> class_loader;
1086 mirror::Class* c;
1087
1088 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Class;", class_loader);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001089 ASSERT_TRUE(c != nullptr);
1090 EXPECT_EQ(c->GetClassSize(), mirror::Class::ClassClassSize(sizeof(void*)));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001091
1092 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Object;", class_loader);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001093 ASSERT_TRUE(c != nullptr);
1094 EXPECT_EQ(c->GetClassSize(), mirror::Object::ClassSize(sizeof(void*)));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001095
1096 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/String;", class_loader);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001097 ASSERT_TRUE(c != nullptr);
1098 EXPECT_EQ(c->GetClassSize(), mirror::String::ClassSize(sizeof(void*)));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001099
1100 c = class_linker_->FindClass(soa.Self(), "Ljava/lang/DexCache;", class_loader);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001101 ASSERT_TRUE(c != nullptr);
1102 EXPECT_EQ(c->GetClassSize(), mirror::DexCache::ClassSize(sizeof(void*)));
Mingyao Yang98d1cc82014-05-15 17:02:16 -07001103}
1104
Mathieu Chartiere401d142015-04-22 13:56:20 -07001105static void CheckMethod(ArtMethod* method, bool verified)
Mathieu Chartier90443472015-07-16 20:32:27 -07001106 SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe48498592014-09-10 19:48:05 -07001107 if (!method->IsNative() && !method->IsAbstract()) {
1108 EXPECT_EQ((method->GetAccessFlags() & kAccPreverified) != 0U, verified)
1109 << PrettyMethod(method, true);
1110 }
1111}
1112
1113static void CheckPreverified(mirror::Class* c, bool preverified)
Mathieu Chartier90443472015-07-16 20:32:27 -07001114 SHARED_REQUIRES(Locks::mutator_lock_) {
Andreas Gampe48498592014-09-10 19:48:05 -07001115 EXPECT_EQ((c->GetAccessFlags() & kAccPreverified) != 0U, preverified)
1116 << "Class " << PrettyClass(c) << " not as expected";
Mathieu Chartiere401d142015-04-22 13:56:20 -07001117 for (auto& m : c->GetDirectMethods(sizeof(void*))) {
1118 CheckMethod(&m, preverified);
Andreas Gampe48498592014-09-10 19:48:05 -07001119 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001120 for (auto& m : c->GetVirtualMethods(sizeof(void*))) {
1121 CheckMethod(&m, preverified);
Andreas Gampe48498592014-09-10 19:48:05 -07001122 }
1123}
1124
1125TEST_F(ClassLinkerTest, Preverified_InitializedBoot) {
1126 ScopedObjectAccess soa(Thread::Current());
1127
1128 mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
Ian Rogerscdc1aaf2014-10-09 13:21:38 -07001129 ASSERT_TRUE(JavaLangObject != nullptr);
Andreas Gampe48498592014-09-10 19:48:05 -07001130 EXPECT_TRUE(JavaLangObject->IsInitialized()) << "Not testing already initialized class from the "
1131 "core";
1132 CheckPreverified(JavaLangObject, true);
1133}
1134
1135TEST_F(ClassLinkerTest, Preverified_UninitializedBoot) {
1136 ScopedObjectAccess soa(Thread::Current());
1137
1138 StackHandleScope<1> hs(soa.Self());
1139
1140 Handle<mirror::Class> security_manager(hs.NewHandle(class_linker_->FindSystemClass(
1141 soa.Self(), "Ljava/lang/SecurityManager;")));
1142 EXPECT_FALSE(security_manager->IsInitialized()) << "Not testing uninitialized class from the "
1143 "core";
1144
1145 CheckPreverified(security_manager.Get(), false);
1146
Ian Rogers7b078e82014-09-10 14:44:24 -07001147 class_linker_->EnsureInitialized(soa.Self(), security_manager, true, true);
Andreas Gampe48498592014-09-10 19:48:05 -07001148 CheckPreverified(security_manager.Get(), true);
1149}
1150
1151TEST_F(ClassLinkerTest, Preverified_App) {
1152 ScopedObjectAccess soa(Thread::Current());
1153
1154 StackHandleScope<2> hs(soa.Self());
1155 Handle<mirror::ClassLoader> class_loader(
1156 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Statics"))));
1157 Handle<mirror::Class> statics(
1158 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
1159
1160 CheckPreverified(statics.Get(), false);
1161
Ian Rogers7b078e82014-09-10 14:44:24 -07001162 class_linker_->EnsureInitialized(soa.Self(), statics, true, true);
Andreas Gampe48498592014-09-10 19:48:05 -07001163 CheckPreverified(statics.Get(), true);
1164}
1165
Sebastien Hertz6963e442014-11-26 22:11:27 +01001166TEST_F(ClassLinkerTest, IsBootStrapClassLoaded) {
1167 ScopedObjectAccess soa(Thread::Current());
1168
1169 StackHandleScope<3> hs(soa.Self());
1170 Handle<mirror::ClassLoader> class_loader(
1171 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Statics"))));
1172
1173 // java.lang.Object is a bootstrap class.
1174 Handle<mirror::Class> jlo_class(
1175 hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
1176 ASSERT_TRUE(jlo_class.Get() != nullptr);
1177 EXPECT_TRUE(jlo_class.Get()->IsBootStrapClassLoaded());
1178
1179 // Statics is not a bootstrap class.
1180 Handle<mirror::Class> statics(
1181 hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
1182 ASSERT_TRUE(statics.Get() != nullptr);
1183 EXPECT_FALSE(statics.Get()->IsBootStrapClassLoaded());
1184}
1185
Jesse Wilsondf4189c2011-08-09 17:10:28 -04001186} // namespace art