1/*
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 */
16
17#include "class_linker.h"
18
19#include <memory>
20#include <string>
21
22#include "art_field-inl.h"
23#include "art_method-inl.h"
24#include "class_linker-inl.h"
25#include "common_runtime_test.h"
26#include "dex_file.h"
27#include "entrypoints/entrypoint_utils-inl.h"
28#include "gc/heap.h"
29#include "mirror/abstract_method.h"
30#include "mirror/accessible_object.h"
31#include "mirror/class-inl.h"
32#include "mirror/dex_cache.h"
33#include "mirror/field.h"
34#include "mirror/object-inl.h"
35#include "mirror/object_array-inl.h"
36#include "mirror/proxy.h"
37#include "mirror/reference.h"
38#include "mirror/stack_trace_element.h"
39#include "mirror/string-inl.h"
40#include "handle_scope-inl.h"
41#include "scoped_thread_state_change.h"
42#include "thread-inl.h"
43
44namespace art {
45
46class ClassLinkerTest : public CommonRuntimeTest {
47 protected:
48  void AssertNonExistentClass(const std::string& descriptor)
49      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
50    Thread* self = Thread::Current();
51    EXPECT_TRUE(class_linker_->FindSystemClass(self, descriptor.c_str()) == nullptr);
52    EXPECT_TRUE(self->IsExceptionPending());
53    mirror::Object* exception = self->GetException();
54    self->ClearException();
55    mirror::Class* exception_class =
56        class_linker_->FindSystemClass(self, "Ljava/lang/NoClassDefFoundError;");
57    EXPECT_TRUE(exception->InstanceOf(exception_class));
58  }
59
60  void AssertPrimitiveClass(const std::string& descriptor)
61      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
62    Thread* self = Thread::Current();
63    AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(self, descriptor.c_str()));
64  }
65
66  void AssertPrimitiveClass(const std::string& descriptor, mirror::Class* primitive)
67      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
68    ASSERT_TRUE(primitive != nullptr);
69    ASSERT_TRUE(primitive->GetClass() != nullptr);
70    ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
71    EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != nullptr);
72    std::string temp;
73    ASSERT_STREQ(descriptor.c_str(), primitive->GetDescriptor(&temp));
74    EXPECT_TRUE(primitive->GetSuperClass() == nullptr);
75    EXPECT_FALSE(primitive->HasSuperClass());
76    EXPECT_TRUE(primitive->GetClassLoader() == nullptr);
77    EXPECT_EQ(mirror::Class::kStatusInitialized, primitive->GetStatus());
78    EXPECT_FALSE(primitive->IsErroneous());
79    EXPECT_TRUE(primitive->IsLoaded());
80    EXPECT_TRUE(primitive->IsResolved());
81    EXPECT_TRUE(primitive->IsVerified());
82    EXPECT_TRUE(primitive->IsInitialized());
83    EXPECT_FALSE(primitive->IsArrayInstance());
84    EXPECT_FALSE(primitive->IsArrayClass());
85    EXPECT_TRUE(primitive->GetComponentType() == nullptr);
86    EXPECT_FALSE(primitive->IsInterface());
87    EXPECT_TRUE(primitive->IsPublic());
88    EXPECT_TRUE(primitive->IsFinal());
89    EXPECT_TRUE(primitive->IsPrimitive());
90    EXPECT_FALSE(primitive->IsSynthetic());
91    EXPECT_EQ(0U, primitive->NumDirectMethods());
92    EXPECT_EQ(0U, primitive->NumVirtualMethods());
93    EXPECT_EQ(0U, primitive->NumInstanceFields());
94    EXPECT_EQ(0U, primitive->NumStaticFields());
95    EXPECT_EQ(0U, primitive->NumDirectInterfaces());
96    EXPECT_FALSE(primitive->HasVTable());
97    EXPECT_EQ(0, primitive->GetIfTableCount());
98    EXPECT_TRUE(primitive->GetIfTable() == nullptr);
99    EXPECT_EQ(kAccPublic | kAccFinal | kAccAbstract, primitive->GetAccessFlags());
100  }
101
102  void AssertArrayClass(const std::string& array_descriptor,
103                        const std::string& component_type,
104                        mirror::ClassLoader* class_loader)
105      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
106    Thread* self = Thread::Current();
107    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)));
111    std::string temp;
112    EXPECT_STREQ(component_type.c_str(), array->GetComponentType()->GetDescriptor(&temp));
113    EXPECT_EQ(class_loader, array->GetClassLoader());
114    EXPECT_EQ(kAccFinal | kAccAbstract, (array->GetAccessFlags() & (kAccFinal | kAccAbstract)));
115    AssertArrayClass(array_descriptor, array);
116  }
117
118  void AssertArrayClass(const std::string& array_descriptor, Handle<mirror::Class> array)
119      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
120    ASSERT_TRUE(array.Get() != nullptr);
121    ASSERT_TRUE(array->GetClass() != nullptr);
122    ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
123    EXPECT_TRUE(array->GetClass()->GetSuperClass() != nullptr);
124    std::string temp;
125    ASSERT_STREQ(array_descriptor.c_str(), array->GetDescriptor(&temp));
126    EXPECT_TRUE(array->GetSuperClass() != nullptr);
127    Thread* self = Thread::Current();
128    EXPECT_EQ(class_linker_->FindSystemClass(self, "Ljava/lang/Object;"), array->GetSuperClass());
129    EXPECT_TRUE(array->HasSuperClass());
130    ASSERT_TRUE(array->GetComponentType() != nullptr);
131    ASSERT_GT(strlen(array->GetComponentType()->GetDescriptor(&temp)), 0U);
132    EXPECT_EQ(mirror::Class::kStatusInitialized, array->GetStatus());
133    EXPECT_FALSE(array->IsErroneous());
134    EXPECT_TRUE(array->IsLoaded());
135    EXPECT_TRUE(array->IsResolved());
136    EXPECT_TRUE(array->IsVerified());
137    EXPECT_TRUE(array->IsInitialized());
138    EXPECT_FALSE(array->IsArrayInstance());
139    EXPECT_TRUE(array->IsArrayClass());
140    EXPECT_FALSE(array->IsInterface());
141    EXPECT_EQ(array->GetComponentType()->IsPublic(), array->IsPublic());
142    EXPECT_TRUE(array->IsFinal());
143    EXPECT_FALSE(array->IsPrimitive());
144    EXPECT_FALSE(array->IsSynthetic());
145    EXPECT_EQ(0U, array->NumDirectMethods());
146    EXPECT_EQ(0U, array->NumVirtualMethods());
147    EXPECT_EQ(0U, array->NumInstanceFields());
148    EXPECT_EQ(0U, array->NumStaticFields());
149    EXPECT_EQ(2U, array->NumDirectInterfaces());
150    EXPECT_TRUE(array->ShouldHaveEmbeddedImtAndVTable());
151    EXPECT_EQ(2, array->GetIfTableCount());
152    ASSERT_TRUE(array->GetIfTable() != nullptr);
153    mirror::Class* direct_interface0 = mirror::Class::GetDirectInterface(self, array, 0);
154    EXPECT_TRUE(direct_interface0 != nullptr);
155    EXPECT_STREQ(direct_interface0->GetDescriptor(&temp), "Ljava/lang/Cloneable;");
156    mirror::Class* direct_interface1 = mirror::Class::GetDirectInterface(self, array, 1);
157    EXPECT_STREQ(direct_interface1->GetDescriptor(&temp), "Ljava/io/Serializable;");
158    mirror::Class* array_ptr = array->GetComponentType();
159    EXPECT_EQ(class_linker_->FindArrayClass(self, &array_ptr), array.Get());
160  }
161
162  void AssertMethod(ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
163    EXPECT_TRUE(method != nullptr);
164    EXPECT_TRUE(method->GetDeclaringClass() != nullptr);
165    EXPECT_TRUE(method->GetName() != nullptr);
166    EXPECT_TRUE(method->GetSignature() != Signature::NoSignature());
167
168    EXPECT_TRUE(method->HasDexCacheResolvedMethods());
169    EXPECT_TRUE(method->HasDexCacheResolvedTypes());
170    EXPECT_TRUE(method->HasSameDexCacheResolvedMethods(
171        method->GetDeclaringClass()->GetDexCache()->GetResolvedMethods()));
172    EXPECT_TRUE(method->HasSameDexCacheResolvedTypes(
173        method->GetDeclaringClass()->GetDexCache()->GetResolvedTypes()));
174  }
175
176  void AssertField(mirror::Class* klass, ArtField* field)
177      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
178    EXPECT_TRUE(field != nullptr);
179    EXPECT_EQ(klass, field->GetDeclaringClass());
180    EXPECT_TRUE(field->GetName() != nullptr);
181    EXPECT_TRUE(field->GetType<true>() != nullptr);
182  }
183
184  void AssertClass(const std::string& descriptor, Handle<mirror::Class> klass)
185      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
186    std::string temp;
187    EXPECT_STREQ(descriptor.c_str(), klass->GetDescriptor(&temp));
188    if (descriptor == "Ljava/lang/Object;") {
189      EXPECT_FALSE(klass->HasSuperClass());
190    } else {
191      EXPECT_TRUE(klass->HasSuperClass());
192      EXPECT_TRUE(klass->GetSuperClass() != nullptr);
193    }
194    EXPECT_TRUE(klass->GetClass() != nullptr);
195    EXPECT_EQ(klass->GetClass(), klass->GetClass()->GetClass());
196    EXPECT_TRUE(klass->GetDexCache() != nullptr);
197    EXPECT_TRUE(klass->IsLoaded());
198    EXPECT_TRUE(klass->IsResolved());
199    EXPECT_FALSE(klass->IsErroneous());
200    EXPECT_FALSE(klass->IsArrayClass());
201    EXPECT_TRUE(klass->GetComponentType() == nullptr);
202    EXPECT_TRUE(klass->IsInSamePackage(klass.Get()));
203    EXPECT_TRUE(klass->GetDexCacheStrings() != nullptr);
204    EXPECT_EQ(klass->GetDexCacheStrings(), klass->GetDexCache()->GetStrings());
205    std::string temp2;
206    EXPECT_TRUE(mirror::Class::IsInSamePackage(klass->GetDescriptor(&temp),
207                                               klass->GetDescriptor(&temp2)));
208    if (klass->IsInterface()) {
209      EXPECT_TRUE(klass->IsAbstract());
210      if (klass->NumDirectMethods() == 1) {
211        EXPECT_TRUE(klass->GetDirectMethod(0, sizeof(void*))->IsClassInitializer());
212        EXPECT_TRUE(klass->GetDirectMethod(0, sizeof(void*))->IsDirect());
213      } else {
214        EXPECT_EQ(0U, klass->NumDirectMethods());
215      }
216    } else {
217      if (!klass->IsSynthetic()) {
218        EXPECT_NE(0U, klass->NumDirectMethods());
219      }
220    }
221    EXPECT_EQ(klass->IsInterface(), !klass->HasVTable());
222    mirror::IfTable* iftable = klass->GetIfTable();
223    for (int i = 0; i < klass->GetIfTableCount(); i++) {
224      mirror::Class* interface = iftable->GetInterface(i);
225      ASSERT_TRUE(interface != nullptr);
226      if (klass->IsInterface()) {
227        EXPECT_EQ(0U, iftable->GetMethodArrayCount(i));
228      } else {
229        EXPECT_EQ(interface->NumVirtualMethods(), iftable->GetMethodArrayCount(i));
230      }
231    }
232    if (klass->IsAbstract()) {
233      EXPECT_FALSE(klass->IsFinal());
234    } else {
235      EXPECT_FALSE(klass->IsAnnotation());
236    }
237    if (klass->IsFinal()) {
238      EXPECT_FALSE(klass->IsAbstract());
239      EXPECT_FALSE(klass->IsAnnotation());
240    }
241    if (klass->IsAnnotation()) {
242      EXPECT_FALSE(klass->IsFinal());
243      EXPECT_TRUE(klass->IsAbstract());
244    }
245
246    EXPECT_FALSE(klass->IsPrimitive());
247    EXPECT_TRUE(klass->CanAccess(klass.Get()));
248
249    for (ArtMethod& method : klass->GetDirectMethods(sizeof(void*))) {
250      AssertMethod(&method);
251      EXPECT_TRUE(method.IsDirect());
252      EXPECT_EQ(klass.Get(), method.GetDeclaringClass());
253    }
254
255    for (ArtMethod& method : klass->GetVirtualMethods(sizeof(void*))) {
256      AssertMethod(&method);
257      EXPECT_FALSE(method.IsDirect());
258      EXPECT_TRUE(method.GetDeclaringClass()->IsAssignableFrom(klass.Get()));
259    }
260
261    for (size_t i = 0; i < klass->NumInstanceFields(); i++) {
262      ArtField* field = klass->GetInstanceField(i);
263      AssertField(klass.Get(), field);
264      EXPECT_FALSE(field->IsStatic());
265    }
266
267    for (size_t i = 0; i < klass->NumStaticFields(); i++) {
268      ArtField* field = klass->GetStaticField(i);
269      AssertField(klass.Get(), field);
270      EXPECT_TRUE(field->IsStatic());
271    }
272
273    // Confirm that all instances field offsets are packed together at the start.
274    EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
275    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++) {
281      ArtField* field = klass->GetInstanceField(i);
282      mirror::Class* field_type = field->GetType<true>();
283      ASSERT_TRUE(field_type != nullptr);
284      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.
290          EXPECT_EQ(PrettyField(field),
291                    "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        }
302      }
303    }
304    ASSERT_EQ(end_ref_offset.Uint32Value(), current_ref_offset.Uint32Value());
305
306    uint32_t total_num_reference_instance_fields = 0;
307    mirror::Class* k = klass.Get();
308    while (k != nullptr) {
309      total_num_reference_instance_fields += k->NumReferenceInstanceFields();
310      k = k->GetSuperClass();
311    }
312    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    }
319  }
320
321  void AssertDexFileClass(mirror::ClassLoader* class_loader, const std::string& descriptor)
322      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
323    ASSERT_TRUE(descriptor != nullptr);
324    Thread* self = Thread::Current();
325    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);
329    std::string temp;
330    EXPECT_STREQ(descriptor.c_str(), klass.Get()->GetDescriptor(&temp));
331    EXPECT_EQ(class_loader, klass->GetClassLoader());
332    if (klass->IsPrimitive()) {
333      AssertPrimitiveClass(descriptor, klass.Get());
334    } else if (klass->IsArrayClass()) {
335      AssertArrayClass(descriptor, klass);
336    } else {
337      AssertClass(descriptor, klass);
338    }
339  }
340
341  void AssertDexFile(const DexFile& dex, mirror::ClassLoader* class_loader)
342      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
343    // Verify all the classes defined in this file
344    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);
347      AssertDexFileClass(class_loader, descriptor);
348    }
349    // Verify all the types referenced by this file
350    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);
353      AssertDexFileClass(class_loader, descriptor);
354    }
355    TestRootVisitor visitor;
356    class_linker_->VisitRoots(&visitor, kVisitRootFlagAllRoots);
357    // Verify the dex cache has resolution methods in all resolved method slots
358    mirror::DexCache* dex_cache = class_linker_->FindDexCache(dex);
359    auto* resolved_methods = dex_cache->GetResolvedMethods();
360    for (size_t i = 0; i < static_cast<size_t>(resolved_methods->GetLength()); i++) {
361      EXPECT_TRUE(resolved_methods->GetElementPtrSize<ArtMethod*>(i, sizeof(void*)) != nullptr)
362          << dex.GetLocation() << " i=" << i;
363    }
364  }
365
366  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  };
372};
373
374struct 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
380template <typename T>
381struct CheckOffsets {
382  CheckOffsets(bool is_static_in, const char* class_descriptor_in)
383      : is_static(is_static_in), class_descriptor(class_descriptor_in) {}
384  bool is_static;
385  std::string class_descriptor;
386  std::vector<CheckOffset> offsets;
387
388  bool Check() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
389    Thread* self = Thread::Current();
390    mirror::Class* klass =
391        Runtime::Current()->GetClassLinker()->FindSystemClass(self, class_descriptor.c_str());
392    CHECK(klass != nullptr) << class_descriptor;
393
394    bool error = false;
395
396    // Classes have a different size due to padding field. Strings are variable length.
397    if (!klass->IsClassClass() && !klass->IsStringClass() && !is_static) {
398      // 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);
404      if (sizeof(T) != expected_size) {
405        LOG(ERROR) << "Class size mismatch:"
406           << " class=" << class_descriptor
407           << " Java=" << expected_size
408           << " C++=" << sizeof(T);
409        error = true;
410      }
411    }
412
413    size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
414    if (offsets.size() != num_fields) {
415      LOG(ERROR) << "Field count mismatch:"
416         << " class=" << class_descriptor
417         << " Java=" << num_fields
418         << " C++=" << offsets.size();
419      error = true;
420    }
421
422    for (size_t i = 0; i < offsets.size(); i++) {
423      ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
424      StringPiece field_name(field->GetName());
425      if (field_name != offsets[i].java_name) {
426        error = true;
427      }
428    }
429    if (error) {
430      for (size_t i = 0; i < offsets.size(); i++) {
431        CheckOffset& offset = offsets[i];
432        ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
433        StringPiece field_name(field->GetName());
434        if (field_name != offsets[i].java_name) {
435          LOG(ERROR) << "JAVA FIELD ORDER MISMATCH NEXT LINE:";
436        }
437        LOG(ERROR) << "Java field order:"
438           << " i=" << i << " class=" << class_descriptor
439           << " Java=" << field_name
440           << " CheckOffsets=" << offset.java_name;
441      }
442    }
443
444    for (size_t i = 0; i < offsets.size(); i++) {
445      CheckOffset& offset = offsets[i];
446      ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
447      if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
448        error = true;
449      }
450    }
451    if (error) {
452      for (size_t i = 0; i < offsets.size(); i++) {
453        CheckOffset& offset = offsets[i];
454        ArtField* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
455        if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
456          LOG(ERROR) << "OFFSET MISMATCH NEXT LINE:";
457        }
458        LOG(ERROR) << "Offset: class=" << class_descriptor << " field=" << offset.java_name
459           << " Java=" << field->GetOffset().Uint32Value() << " C++=" << offset.cpp_offset;
460      }
461    }
462
463    return !error;
464  };
465
466  void addOffset(size_t offset, const char* name) {
467    offsets.push_back(CheckOffset(offset, name));
468  }
469
470 private:
471  DISALLOW_IMPLICIT_CONSTRUCTORS(CheckOffsets);
472};
473
474// Note that ClassLinkerTest.ValidateFieldOrderOfJavaCppUnionClasses
475// is first since if it is failing, others are unlikely to succeed.
476
477struct ObjectOffsets : public CheckOffsets<mirror::Object> {
478  ObjectOffsets() : CheckOffsets<mirror::Object>(false, "Ljava/lang/Object;") {
479    addOffset(OFFSETOF_MEMBER(mirror::Object, klass_), "shadow$_klass_");
480    addOffset(OFFSETOF_MEMBER(mirror::Object, monitor_), "shadow$_monitor_");
481#ifdef USE_BROOKS_READ_BARRIER
482    addOffset(OFFSETOF_MEMBER(mirror::Object, x_rb_ptr_), "shadow$_x_rb_ptr_");
483    addOffset(OFFSETOF_MEMBER(mirror::Object, x_xpadding_), "shadow$_x_xpadding_");
484#endif
485  };
486};
487
488struct ClassOffsets : public CheckOffsets<mirror::Class> {
489  ClassOffsets() : CheckOffsets<mirror::Class>(false, "Ljava/lang/Class;") {
490    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");
503    addOffset(OFFSETOF_MEMBER(mirror::Class, num_direct_methods_), "numDirectMethods");
504    addOffset(OFFSETOF_MEMBER(mirror::Class, num_instance_fields_), "numInstanceFields");
505    addOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_instance_fields_),
506              "numReferenceInstanceFields");
507    addOffset(OFFSETOF_MEMBER(mirror::Class, num_reference_static_fields_),
508              "numReferenceStaticFields");
509    addOffset(OFFSETOF_MEMBER(mirror::Class, num_static_fields_), "numStaticFields");
510    addOffset(OFFSETOF_MEMBER(mirror::Class, num_virtual_methods_), "numVirtualMethods");
511    addOffset(OFFSETOF_MEMBER(mirror::Class, object_size_), "objectSize");
512    addOffset(OFFSETOF_MEMBER(mirror::Class, primitive_type_), "primitiveType");
513    addOffset(OFFSETOF_MEMBER(mirror::Class, reference_instance_offsets_),
514              "referenceInstanceOffsets");
515    addOffset(OFFSETOF_MEMBER(mirror::Class, sfields_), "sFields");
516    addOffset(OFFSETOF_MEMBER(mirror::Class, status_), "status");
517    addOffset(OFFSETOF_MEMBER(mirror::Class, super_class_), "superClass");
518    addOffset(OFFSETOF_MEMBER(mirror::Class, verify_error_class_), "verifyErrorClass");
519    addOffset(OFFSETOF_MEMBER(mirror::Class, virtual_methods_), "virtualMethods");
520    addOffset(OFFSETOF_MEMBER(mirror::Class, vtable_), "vtable");
521  };
522};
523
524struct StringOffsets : public CheckOffsets<mirror::String> {
525  StringOffsets() : CheckOffsets<mirror::String>(false, "Ljava/lang/String;") {
526    addOffset(OFFSETOF_MEMBER(mirror::String, count_), "count");
527    addOffset(OFFSETOF_MEMBER(mirror::String, hash_code_), "hashCode");
528  };
529};
530
531struct ThrowableOffsets : public CheckOffsets<mirror::Throwable> {
532  ThrowableOffsets() : CheckOffsets<mirror::Throwable>(false, "Ljava/lang/Throwable;") {
533    addOffset(OFFSETOF_MEMBER(mirror::Throwable, cause_), "cause");
534    addOffset(OFFSETOF_MEMBER(mirror::Throwable, detail_message_), "detailMessage");
535    addOffset(OFFSETOF_MEMBER(mirror::Throwable, stack_state_), "stackState");
536    addOffset(OFFSETOF_MEMBER(mirror::Throwable, stack_trace_), "stackTrace");
537    addOffset(OFFSETOF_MEMBER(mirror::Throwable, suppressed_exceptions_), "suppressedExceptions");
538  };
539};
540
541struct StackTraceElementOffsets : public CheckOffsets<mirror::StackTraceElement> {
542  StackTraceElementOffsets() : CheckOffsets<mirror::StackTraceElement>(
543      false, "Ljava/lang/StackTraceElement;") {
544    addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, declaring_class_), "declaringClass");
545    addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, file_name_), "fileName");
546    addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, line_number_), "lineNumber");
547    addOffset(OFFSETOF_MEMBER(mirror::StackTraceElement, method_name_), "methodName");
548  };
549};
550
551struct ClassLoaderOffsets : public CheckOffsets<mirror::ClassLoader> {
552  ClassLoaderOffsets() : CheckOffsets<mirror::ClassLoader>(false, "Ljava/lang/ClassLoader;") {
553    addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, packages_), "packages");
554    addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, parent_), "parent");
555    addOffset(OFFSETOF_MEMBER(mirror::ClassLoader, proxyCache_), "proxyCache");
556  };
557};
558
559struct ProxyOffsets : public CheckOffsets<mirror::Proxy> {
560  ProxyOffsets() : CheckOffsets<mirror::Proxy>(false, "Ljava/lang/reflect/Proxy;") {
561    addOffset(OFFSETOF_MEMBER(mirror::Proxy, h_), "h");
562  };
563};
564
565struct DexCacheOffsets : public CheckOffsets<mirror::DexCache> {
566  DexCacheOffsets() : CheckOffsets<mirror::DexCache>(false, "Ljava/lang/DexCache;") {
567    addOffset(OFFSETOF_MEMBER(mirror::DexCache, dex_), "dex");
568    addOffset(OFFSETOF_MEMBER(mirror::DexCache, dex_file_), "dexFile");
569    addOffset(OFFSETOF_MEMBER(mirror::DexCache, location_), "location");
570    addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_fields_), "resolvedFields");
571    addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_methods_), "resolvedMethods");
572    addOffset(OFFSETOF_MEMBER(mirror::DexCache, resolved_types_), "resolvedTypes");
573    addOffset(OFFSETOF_MEMBER(mirror::DexCache, strings_), "strings");
574  };
575};
576
577struct ReferenceOffsets : public CheckOffsets<mirror::Reference> {
578  ReferenceOffsets() : CheckOffsets<mirror::Reference>(false, "Ljava/lang/ref/Reference;") {
579    addOffset(OFFSETOF_MEMBER(mirror::Reference, pending_next_), "pendingNext");
580    addOffset(OFFSETOF_MEMBER(mirror::Reference, queue_), "queue");
581    addOffset(OFFSETOF_MEMBER(mirror::Reference, queue_next_), "queueNext");
582    addOffset(OFFSETOF_MEMBER(mirror::Reference, referent_), "referent");
583  };
584};
585
586struct FinalizerReferenceOffsets : public CheckOffsets<mirror::FinalizerReference> {
587  FinalizerReferenceOffsets() : CheckOffsets<mirror::FinalizerReference>(
588      false, "Ljava/lang/ref/FinalizerReference;") {
589    addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, next_), "next");
590    addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, prev_), "prev");
591    addOffset(OFFSETOF_MEMBER(mirror::FinalizerReference, zombie_), "zombie");
592  };
593};
594
595struct AccessibleObjectOffsets : public CheckOffsets<mirror::AccessibleObject> {
596  AccessibleObjectOffsets() : CheckOffsets<mirror::AccessibleObject>(
597      false, "Ljava/lang/reflect/AccessibleObject;") {
598    addOffset(mirror::AccessibleObject::FlagOffset().Uint32Value(), "flag");
599  };
600};
601
602struct FieldOffsets : public CheckOffsets<mirror::Field> {
603  FieldOffsets() : CheckOffsets<mirror::Field>(false, "Ljava/lang/reflect/Field;") {
604    addOffset(OFFSETOF_MEMBER(mirror::Field, access_flags_), "accessFlags");
605    addOffset(OFFSETOF_MEMBER(mirror::Field, declaring_class_), "declaringClass");
606    addOffset(OFFSETOF_MEMBER(mirror::Field, dex_field_index_), "dexFieldIndex");
607    addOffset(OFFSETOF_MEMBER(mirror::Field, offset_), "offset");
608    addOffset(OFFSETOF_MEMBER(mirror::Field, type_), "type");
609  };
610};
611
612struct AbstractMethodOffsets : public CheckOffsets<mirror::AbstractMethod> {
613  AbstractMethodOffsets() : CheckOffsets<mirror::AbstractMethod>(
614      false, "Ljava/lang/reflect/AbstractMethod;") {
615    addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, access_flags_), "accessFlags");
616    addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, art_method_), "artMethod");
617    addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, declaring_class_), "declaringClass");
618    addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, declaring_class_of_overridden_method_),
619              "declaringClassOfOverriddenMethod");
620    addOffset(OFFSETOF_MEMBER(mirror::AbstractMethod, dex_method_index_), "dexMethodIndex");
621  };
622};
623
624// C++ fields must exactly match the fields in the Java classes. If this fails,
625// reorder the fields in the C++ class. Managed class fields are ordered by
626// ClassLinker::LinkFields.
627TEST_F(ClassLinkerTest, ValidateFieldOrderOfJavaCppUnionClasses) {
628  ScopedObjectAccess soa(Thread::Current());
629  EXPECT_TRUE(ObjectOffsets().Check());
630  EXPECT_TRUE(ClassOffsets().Check());
631  EXPECT_TRUE(StringOffsets().Check());
632  EXPECT_TRUE(ThrowableOffsets().Check());
633  EXPECT_TRUE(StackTraceElementOffsets().Check());
634  EXPECT_TRUE(ClassLoaderOffsets().Check());
635  EXPECT_TRUE(ProxyOffsets().Check());
636  EXPECT_TRUE(DexCacheOffsets().Check());
637  EXPECT_TRUE(ReferenceOffsets().Check());
638  EXPECT_TRUE(FinalizerReferenceOffsets().Check());
639  EXPECT_TRUE(AccessibleObjectOffsets().Check());
640  EXPECT_TRUE(FieldOffsets().Check());
641  EXPECT_TRUE(AbstractMethodOffsets().Check());
642}
643
644TEST_F(ClassLinkerTest, FindClassNonexistent) {
645  ScopedObjectAccess soa(Thread::Current());
646  AssertNonExistentClass("NoSuchClass;");
647  AssertNonExistentClass("LNoSuchClass;");
648}
649
650TEST_F(ClassLinkerTest, GetDexFiles) {
651  ScopedObjectAccess soa(Thread::Current());
652
653  jobject jclass_loader = LoadDex("Nested");
654  std::vector<const DexFile*> dex_files(GetDexFiles(jclass_loader));
655  ASSERT_EQ(dex_files.size(), 1U);
656  EXPECT_TRUE(EndsWith(dex_files[0]->GetLocation(), "Nested.jar"));
657
658  jobject jclass_loader2 = LoadDex("MultiDex");
659  std::vector<const DexFile*> dex_files2(GetDexFiles(jclass_loader2));
660  ASSERT_EQ(dex_files2.size(), 2U);
661  EXPECT_TRUE(EndsWith(dex_files2[0]->GetLocation(), "MultiDex.jar"));
662}
663
664TEST_F(ClassLinkerTest, FindClassNested) {
665  ScopedObjectAccess soa(Thread::Current());
666  StackHandleScope<1> hs(soa.Self());
667  Handle<mirror::ClassLoader> class_loader(
668      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Nested"))));
669
670  mirror::Class* outer = class_linker_->FindClass(soa.Self(), "LNested;", class_loader);
671  ASSERT_TRUE(outer != nullptr);
672  EXPECT_EQ(0U, outer->NumVirtualMethods());
673  EXPECT_EQ(1U, outer->NumDirectMethods());
674
675  mirror::Class* inner = class_linker_->FindClass(soa.Self(), "LNested$Inner;", class_loader);
676  ASSERT_TRUE(inner != nullptr);
677  EXPECT_EQ(0U, inner->NumVirtualMethods());
678  EXPECT_EQ(1U, inner->NumDirectMethods());
679}
680
681TEST_F(ClassLinkerTest, FindClass_Primitives) {
682  ScopedObjectAccess soa(Thread::Current());
683  const std::string expected("BCDFIJSZV");
684  for (int ch = 1; ch < 256; ++ch) {
685    std::string descriptor;
686    descriptor.push_back(ch);
687    if (expected.find(ch) == std::string::npos) {
688      AssertNonExistentClass(descriptor);
689    } else {
690      AssertPrimitiveClass(descriptor);
691    }
692  }
693}
694
695TEST_F(ClassLinkerTest, FindClass) {
696  ScopedObjectAccess soa(Thread::Current());
697  mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
698  ASSERT_TRUE(JavaLangObject != nullptr);
699  ASSERT_TRUE(JavaLangObject->GetClass() != nullptr);
700  ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
701  EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
702  std::string temp;
703  ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;");
704  EXPECT_TRUE(JavaLangObject->GetSuperClass() == nullptr);
705  EXPECT_FALSE(JavaLangObject->HasSuperClass());
706  EXPECT_TRUE(JavaLangObject->GetClassLoader() == nullptr);
707  EXPECT_EQ(mirror::Class::kStatusInitialized, JavaLangObject->GetStatus());
708  EXPECT_FALSE(JavaLangObject->IsErroneous());
709  EXPECT_TRUE(JavaLangObject->IsLoaded());
710  EXPECT_TRUE(JavaLangObject->IsResolved());
711  EXPECT_TRUE(JavaLangObject->IsVerified());
712  EXPECT_TRUE(JavaLangObject->IsInitialized());
713  EXPECT_FALSE(JavaLangObject->IsArrayInstance());
714  EXPECT_FALSE(JavaLangObject->IsArrayClass());
715  EXPECT_TRUE(JavaLangObject->GetComponentType() == nullptr);
716  EXPECT_FALSE(JavaLangObject->IsInterface());
717  EXPECT_TRUE(JavaLangObject->IsPublic());
718  EXPECT_FALSE(JavaLangObject->IsFinal());
719  EXPECT_FALSE(JavaLangObject->IsPrimitive());
720  EXPECT_FALSE(JavaLangObject->IsSynthetic());
721  EXPECT_EQ(2U, JavaLangObject->NumDirectMethods());
722  EXPECT_EQ(11U, JavaLangObject->NumVirtualMethods());
723  if (!kUseBrooksReadBarrier) {
724    EXPECT_EQ(2U, JavaLangObject->NumInstanceFields());
725  } else {
726    EXPECT_EQ(4U, JavaLangObject->NumInstanceFields());
727  }
728  EXPECT_STREQ(JavaLangObject->GetInstanceField(0)->GetName(), "shadow$_klass_");
729  EXPECT_STREQ(JavaLangObject->GetInstanceField(1)->GetName(), "shadow$_monitor_");
730  if (kUseBrooksReadBarrier) {
731    EXPECT_STREQ(JavaLangObject->GetInstanceField(2)->GetName(), "shadow$_x_rb_ptr_");
732    EXPECT_STREQ(JavaLangObject->GetInstanceField(3)->GetName(), "shadow$_x_xpadding_");
733  }
734
735  EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
736  EXPECT_EQ(0U, JavaLangObject->NumDirectInterfaces());
737
738  StackHandleScope<1> hs(soa.Self());
739  Handle<mirror::ClassLoader> class_loader(
740      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass"))));
741  AssertNonExistentClass("LMyClass;");
742  mirror::Class* MyClass = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader);
743  ASSERT_TRUE(MyClass != nullptr);
744  ASSERT_TRUE(MyClass->GetClass() != nullptr);
745  ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
746  EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass());
747  ASSERT_STREQ(MyClass->GetDescriptor(&temp), "LMyClass;");
748  EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
749  EXPECT_TRUE(MyClass->HasSuperClass());
750  EXPECT_EQ(class_loader.Get(), MyClass->GetClassLoader());
751  EXPECT_EQ(mirror::Class::kStatusResolved, MyClass->GetStatus());
752  EXPECT_FALSE(MyClass->IsErroneous());
753  EXPECT_TRUE(MyClass->IsLoaded());
754  EXPECT_TRUE(MyClass->IsResolved());
755  EXPECT_FALSE(MyClass->IsVerified());
756  EXPECT_FALSE(MyClass->IsInitialized());
757  EXPECT_FALSE(MyClass->IsArrayInstance());
758  EXPECT_FALSE(MyClass->IsArrayClass());
759  EXPECT_TRUE(MyClass->GetComponentType() == nullptr);
760  EXPECT_FALSE(MyClass->IsInterface());
761  EXPECT_FALSE(MyClass->IsPublic());
762  EXPECT_FALSE(MyClass->IsFinal());
763  EXPECT_FALSE(MyClass->IsPrimitive());
764  EXPECT_FALSE(MyClass->IsSynthetic());
765  EXPECT_EQ(1U, MyClass->NumDirectMethods());
766  EXPECT_EQ(0U, MyClass->NumVirtualMethods());
767  EXPECT_EQ(0U, MyClass->NumInstanceFields());
768  EXPECT_EQ(0U, MyClass->NumStaticFields());
769  EXPECT_EQ(0U, MyClass->NumDirectInterfaces());
770
771  EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
772
773  // created by class_linker
774  AssertArrayClass("[C", "C", nullptr);
775  AssertArrayClass("[Ljava/lang/Object;", "Ljava/lang/Object;", nullptr);
776  // synthesized on the fly
777  AssertArrayClass("[[C", "[C", nullptr);
778  AssertArrayClass("[[[LMyClass;", "[[LMyClass;", class_loader.Get());
779  // or not available at all
780  AssertNonExistentClass("[[[[LNonExistentClass;");
781}
782
783TEST_F(ClassLinkerTest, LibCore) {
784  ScopedObjectAccess soa(Thread::Current());
785  ASSERT_TRUE(java_lang_dex_file_ != nullptr);
786  AssertDexFile(*java_lang_dex_file_, nullptr);
787}
788
789// The first reference array element must be a multiple of 4 bytes from the
790// start of the object
791TEST_F(ClassLinkerTest, ValidateObjectArrayElementsOffset) {
792  ScopedObjectAccess soa(Thread::Current());
793  mirror::Class* array_class = class_linker_->FindSystemClass(soa.Self(), "[Ljava/lang/String;");
794  mirror::ObjectArray<mirror::String>* array =
795      mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), array_class, 0);
796  uintptr_t data_offset =
797      reinterpret_cast<uintptr_t>(array->GetRawData(sizeof(mirror::HeapReference<mirror::String>),
798                                                    0));
799  if (sizeof(mirror::HeapReference<mirror::String>) == sizeof(int32_t)) {
800    EXPECT_TRUE(IsAligned<4>(data_offset));  // Check 4 byte alignment.
801  } else {
802    EXPECT_TRUE(IsAligned<8>(data_offset));  // Check 8 byte alignment.
803  }
804}
805
806TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) {
807  ScopedObjectAccess soa(Thread::Current());
808  StackHandleScope<5> hs(soa.Self());
809  Handle<mirror::LongArray> long_array(hs.NewHandle(mirror::LongArray::Alloc(soa.Self(), 0)));
810  EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[J"), long_array->GetClass());
811  uintptr_t data_offset = reinterpret_cast<uintptr_t>(long_array->GetData());
812  EXPECT_TRUE(IsAligned<8>(data_offset));  // Longs require 8 byte alignment
813
814  Handle<mirror::DoubleArray> double_array(hs.NewHandle(mirror::DoubleArray::Alloc(soa.Self(), 0)));
815  EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[D"), double_array->GetClass());
816  data_offset = reinterpret_cast<uintptr_t>(double_array->GetData());
817  EXPECT_TRUE(IsAligned<8>(data_offset));  // Doubles require 8 byte alignment
818
819  Handle<mirror::IntArray> int_array(hs.NewHandle(mirror::IntArray::Alloc(soa.Self(), 0)));
820  EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[I"), int_array->GetClass());
821  data_offset = reinterpret_cast<uintptr_t>(int_array->GetData());
822  EXPECT_TRUE(IsAligned<4>(data_offset));  // Ints require 4 byte alignment
823
824  Handle<mirror::CharArray> char_array(hs.NewHandle(mirror::CharArray::Alloc(soa.Self(), 0)));
825  EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[C"), char_array->GetClass());
826  data_offset = reinterpret_cast<uintptr_t>(char_array->GetData());
827  EXPECT_TRUE(IsAligned<2>(data_offset));  // Chars require 2 byte alignment
828
829  Handle<mirror::ShortArray> short_array(hs.NewHandle(mirror::ShortArray::Alloc(soa.Self(), 0)));
830  EXPECT_EQ(class_linker_->FindSystemClass(soa.Self(), "[S"), short_array->GetClass());
831  data_offset = reinterpret_cast<uintptr_t>(short_array->GetData());
832  EXPECT_TRUE(IsAligned<2>(data_offset));  // Shorts require 2 byte alignment
833
834  // Take it as given that bytes and booleans have byte alignment
835}
836
837TEST_F(ClassLinkerTest, ValidateBoxedTypes) {
838  // Validate that the "value" field is always the 0th field in each of java.lang's box classes.
839  // This lets UnboxPrimitive avoid searching for the field by name at runtime.
840  ScopedObjectAccess soa(Thread::Current());
841  NullHandle<mirror::ClassLoader> class_loader;
842  mirror::Class* c;
843  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Boolean;", class_loader);
844  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
845  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Byte;", class_loader);
846  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
847  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Character;", class_loader);
848  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
849  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Double;", class_loader);
850  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
851  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Float;", class_loader);
852  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
853  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Integer;", class_loader);
854  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
855  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Long;", class_loader);
856  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
857  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Short;", class_loader);
858  EXPECT_STREQ("value", c->GetIFields()[0].GetName());
859}
860
861TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
862  ScopedObjectAccess soa(Thread::Current());
863  StackHandleScope<2> hs(soa.Self());
864  Handle<mirror::ClassLoader> class_loader_1(
865      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass"))));
866  Handle<mirror::ClassLoader> class_loader_2(
867      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("MyClass"))));
868  mirror::Class* MyClass_1 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_1);
869  mirror::Class* MyClass_2 = class_linker_->FindClass(soa.Self(), "LMyClass;", class_loader_2);
870  EXPECT_TRUE(MyClass_1 != nullptr);
871  EXPECT_TRUE(MyClass_2 != nullptr);
872  EXPECT_NE(MyClass_1, MyClass_2);
873}
874
875TEST_F(ClassLinkerTest, StaticFields) {
876  ScopedObjectAccess soa(Thread::Current());
877  StackHandleScope<2> hs(soa.Self());
878  Handle<mirror::ClassLoader> class_loader(
879      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Statics"))));
880  Handle<mirror::Class> statics(
881      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
882  class_linker_->EnsureInitialized(soa.Self(), statics, true, true);
883
884  // Static final primitives that are initialized by a compile-time constant
885  // expression resolve to a copy of a constant value from the constant pool.
886  // So <clinit> should be null.
887  ArtMethod* clinit = statics->FindDirectMethod("<clinit>", "()V", sizeof(void*));
888  EXPECT_TRUE(clinit == nullptr);
889
890  EXPECT_EQ(9U, statics->NumStaticFields());
891
892  ArtField* s0 = mirror::Class::FindStaticField(soa.Self(), statics, "s0", "Z");
893  EXPECT_EQ(s0->GetTypeAsPrimitiveType(), Primitive::kPrimBoolean);
894  EXPECT_EQ(true, s0->GetBoolean(statics.Get()));
895  s0->SetBoolean<false>(statics.Get(), false);
896
897  ArtField* s1 = mirror::Class::FindStaticField(soa.Self(), statics, "s1", "B");
898  EXPECT_EQ(s1->GetTypeAsPrimitiveType(), Primitive::kPrimByte);
899  EXPECT_EQ(5, s1->GetByte(statics.Get()));
900  s1->SetByte<false>(statics.Get(), 6);
901
902  ArtField* s2 = mirror::Class::FindStaticField(soa.Self(), statics, "s2", "C");
903  EXPECT_EQ(s2->GetTypeAsPrimitiveType(), Primitive::kPrimChar);
904  EXPECT_EQ('a', s2->GetChar(statics.Get()));
905  s2->SetChar<false>(statics.Get(), 'b');
906
907  ArtField* s3 = mirror::Class::FindStaticField(soa.Self(), statics, "s3", "S");
908  EXPECT_EQ(s3->GetTypeAsPrimitiveType(), Primitive::kPrimShort);
909  EXPECT_EQ(-536, s3->GetShort(statics.Get()));
910  s3->SetShort<false>(statics.Get(), -535);
911
912  ArtField* s4 = mirror::Class::FindStaticField(soa.Self(), statics, "s4", "I");
913  EXPECT_EQ(s4->GetTypeAsPrimitiveType(), Primitive::kPrimInt);
914  EXPECT_EQ(2000000000, s4->GetInt(statics.Get()));
915  s4->SetInt<false>(statics.Get(), 2000000001);
916
917  ArtField* s5 = mirror::Class::FindStaticField(soa.Self(), statics, "s5", "J");
918  EXPECT_EQ(s5->GetTypeAsPrimitiveType(), Primitive::kPrimLong);
919  EXPECT_EQ(0x1234567890abcdefLL, s5->GetLong(statics.Get()));
920  s5->SetLong<false>(statics.Get(), INT64_C(0x34567890abcdef12));
921
922  ArtField* s6 = mirror::Class::FindStaticField(soa.Self(), statics, "s6", "F");
923  EXPECT_EQ(s6->GetTypeAsPrimitiveType(), Primitive::kPrimFloat);
924  EXPECT_DOUBLE_EQ(0.5, s6->GetFloat(statics.Get()));
925  s6->SetFloat<false>(statics.Get(), 0.75);
926
927  ArtField* s7 = mirror::Class::FindStaticField(soa.Self(), statics, "s7", "D");
928  EXPECT_EQ(s7->GetTypeAsPrimitiveType(), Primitive::kPrimDouble);
929  EXPECT_DOUBLE_EQ(16777217.0, s7->GetDouble(statics.Get()));
930  s7->SetDouble<false>(statics.Get(), 16777219);
931
932  ArtField* s8 = mirror::Class::FindStaticField(soa.Self(), statics, "s8",
933                                                        "Ljava/lang/String;");
934  EXPECT_EQ(s8->GetTypeAsPrimitiveType(), Primitive::kPrimNot);
935  EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("android"));
936  s8->SetObject<false>(s8->GetDeclaringClass(),
937                       mirror::String::AllocFromModifiedUtf8(soa.Self(), "robot"));
938
939  // TODO: Remove EXPECT_FALSE when GCC can handle EXPECT_EQ
940  // http://code.google.com/p/googletest/issues/detail?id=322
941  EXPECT_FALSE(s0->GetBoolean(statics.Get()));
942  EXPECT_EQ(6, s1->GetByte(statics.Get()));
943  EXPECT_EQ('b', s2->GetChar(statics.Get()));
944  EXPECT_EQ(-535, s3->GetShort(statics.Get()));
945  EXPECT_EQ(2000000001, s4->GetInt(statics.Get()));
946  EXPECT_EQ(INT64_C(0x34567890abcdef12), s5->GetLong(statics.Get()));
947  EXPECT_FLOAT_EQ(0.75, s6->GetFloat(statics.Get()));
948  EXPECT_DOUBLE_EQ(16777219.0, s7->GetDouble(statics.Get()));
949  EXPECT_TRUE(s8->GetObject(statics.Get())->AsString()->Equals("robot"));
950}
951
952TEST_F(ClassLinkerTest, Interfaces) {
953  ScopedObjectAccess soa(Thread::Current());
954  StackHandleScope<6> hs(soa.Self());
955  Handle<mirror::ClassLoader> class_loader(
956      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Interfaces"))));
957  Handle<mirror::Class> I(
958      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$I;", class_loader)));
959  Handle<mirror::Class> J(
960      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$J;", class_loader)));
961  Handle<mirror::Class> K(
962      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$K;", class_loader)));
963  Handle<mirror::Class> A(
964      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$A;", class_loader)));
965  Handle<mirror::Class> B(
966      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LInterfaces$B;", class_loader)));
967  EXPECT_TRUE(I->IsAssignableFrom(A.Get()));
968  EXPECT_TRUE(J->IsAssignableFrom(A.Get()));
969  EXPECT_TRUE(J->IsAssignableFrom(K.Get()));
970  EXPECT_TRUE(K->IsAssignableFrom(B.Get()));
971  EXPECT_TRUE(J->IsAssignableFrom(B.Get()));
972
973  const Signature void_sig = I->GetDexCache()->GetDexFile()->CreateSignature("()V");
974  ArtMethod* Ii = I->FindVirtualMethod("i", void_sig, sizeof(void*));
975  ArtMethod* Jj1 = J->FindVirtualMethod("j1", void_sig, sizeof(void*));
976  ArtMethod* Jj2 = J->FindVirtualMethod("j2", void_sig, sizeof(void*));
977  ArtMethod* Kj1 = K->FindInterfaceMethod("j1", void_sig, sizeof(void*));
978  ArtMethod* Kj2 = K->FindInterfaceMethod("j2", void_sig, sizeof(void*));
979  ArtMethod* Kk = K->FindInterfaceMethod("k", void_sig, sizeof(void*));
980  ArtMethod* Ai = A->FindVirtualMethod("i", void_sig, sizeof(void*));
981  ArtMethod* Aj1 = A->FindVirtualMethod("j1", void_sig, sizeof(void*));
982  ArtMethod* Aj2 = A->FindVirtualMethod("j2", void_sig, sizeof(void*));
983  ASSERT_TRUE(Ii != nullptr);
984  ASSERT_TRUE(Jj1 != nullptr);
985  ASSERT_TRUE(Jj2 != nullptr);
986  ASSERT_TRUE(Kj1 != nullptr);
987  ASSERT_TRUE(Kj2 != nullptr);
988  ASSERT_TRUE(Kk != nullptr);
989  ASSERT_TRUE(Ai != nullptr);
990  ASSERT_TRUE(Aj1 != nullptr);
991  ASSERT_TRUE(Aj2 != nullptr);
992  EXPECT_NE(Ii, Ai);
993  EXPECT_NE(Jj1, Aj1);
994  EXPECT_NE(Jj2, Aj2);
995  EXPECT_EQ(Kj1, Jj1);
996  EXPECT_EQ(Kj2, Jj2);
997  EXPECT_EQ(Ai, A->FindVirtualMethodForInterface(Ii, sizeof(void*)));
998  EXPECT_EQ(Aj1, A->FindVirtualMethodForInterface(Jj1, sizeof(void*)));
999  EXPECT_EQ(Aj2, A->FindVirtualMethodForInterface(Jj2, sizeof(void*)));
1000  EXPECT_EQ(Ai, A->FindVirtualMethodForVirtualOrInterface(Ii, sizeof(void*)));
1001  EXPECT_EQ(Aj1, A->FindVirtualMethodForVirtualOrInterface(Jj1, sizeof(void*)));
1002  EXPECT_EQ(Aj2, A->FindVirtualMethodForVirtualOrInterface(Jj2, sizeof(void*)));
1003
1004  ArtField* Afoo = mirror::Class::FindStaticField(soa.Self(), A, "foo", "Ljava/lang/String;");
1005  ArtField* Bfoo = mirror::Class::FindStaticField(soa.Self(), B, "foo", "Ljava/lang/String;");
1006  ArtField* Jfoo = mirror::Class::FindStaticField(soa.Self(), J, "foo", "Ljava/lang/String;");
1007  ArtField* Kfoo = mirror::Class::FindStaticField(soa.Self(), K, "foo", "Ljava/lang/String;");
1008  ASSERT_TRUE(Afoo != nullptr);
1009  EXPECT_EQ(Afoo, Bfoo);
1010  EXPECT_EQ(Afoo, Jfoo);
1011  EXPECT_EQ(Afoo, Kfoo);
1012}
1013
1014TEST_F(ClassLinkerTest, ResolveVerifyAndClinit) {
1015  // pretend we are trying to get the static storage for the StaticsFromCode class.
1016
1017  // case 1, get the uninitialized storage from StaticsFromCode.<clinit>
1018  // case 2, get the initialized storage from StaticsFromCode.getS0
1019
1020  ScopedObjectAccess soa(Thread::Current());
1021  jobject jclass_loader = LoadDex("StaticsFromCode");
1022  const DexFile* dex_file = GetFirstDexFile(jclass_loader);
1023  StackHandleScope<1> hs(soa.Self());
1024  Handle<mirror::ClassLoader> class_loader(
1025      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(jclass_loader)));
1026  mirror::Class* klass = class_linker_->FindClass(soa.Self(), "LStaticsFromCode;", class_loader);
1027  ArtMethod* clinit = klass->FindClassInitializer(sizeof(void*));
1028  ArtMethod* getS0 = klass->FindDirectMethod("getS0", "()Ljava/lang/Object;", sizeof(void*));
1029  const DexFile::StringId* string_id = dex_file->FindStringId("LStaticsFromCode;");
1030  ASSERT_TRUE(string_id != nullptr);
1031  const DexFile::TypeId* type_id = dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
1032  ASSERT_TRUE(type_id != nullptr);
1033  uint32_t type_idx = dex_file->GetIndexForTypeId(*type_id);
1034  mirror::Class* uninit = ResolveVerifyAndClinit(type_idx, clinit, soa.Self(), true, false);
1035  EXPECT_TRUE(uninit != nullptr);
1036  EXPECT_FALSE(uninit->IsInitialized());
1037  mirror::Class* init = ResolveVerifyAndClinit(type_idx, getS0, soa.Self(), true, false);
1038  EXPECT_TRUE(init != nullptr);
1039  EXPECT_TRUE(init->IsInitialized());
1040}
1041
1042TEST_F(ClassLinkerTest, FinalizableBit) {
1043  ScopedObjectAccess soa(Thread::Current());
1044  mirror::Class* c;
1045
1046  // Object has a finalize method, but we know it's empty.
1047  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
1048  EXPECT_FALSE(c->IsFinalizable());
1049
1050  // Enum has a finalize method to prevent its subclasses from implementing one.
1051  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Enum;");
1052  EXPECT_FALSE(c->IsFinalizable());
1053
1054  // RoundingMode is an enum.
1055  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/math/RoundingMode;");
1056  EXPECT_FALSE(c->IsFinalizable());
1057
1058  // RandomAccessFile extends Object and overrides finalize.
1059  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/RandomAccessFile;");
1060  EXPECT_TRUE(c->IsFinalizable());
1061
1062  // FileInputStream is finalizable and extends InputStream which isn't.
1063  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/InputStream;");
1064  EXPECT_FALSE(c->IsFinalizable());
1065  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/io/FileInputStream;");
1066  EXPECT_TRUE(c->IsFinalizable());
1067
1068  // ScheduledThreadPoolExecutor doesn't have a finalize method but
1069  // extends ThreadPoolExecutor which does.
1070  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/util/concurrent/ThreadPoolExecutor;");
1071  EXPECT_TRUE(c->IsFinalizable());
1072  c = class_linker_->FindSystemClass(soa.Self(), "Ljava/util/concurrent/ScheduledThreadPoolExecutor;");
1073  EXPECT_TRUE(c->IsFinalizable());
1074}
1075
1076TEST_F(ClassLinkerTest, ClassRootDescriptors) {
1077  ScopedObjectAccess soa(Thread::Current());
1078  std::string temp;
1079  for (int i = 0; i < ClassLinker::kClassRootsMax; i++) {
1080    mirror::Class* klass = class_linker_->GetClassRoot(ClassLinker::ClassRoot(i));
1081    EXPECT_GT(strlen(klass->GetDescriptor(&temp)), 0U);
1082    EXPECT_STREQ(klass->GetDescriptor(&temp),
1083                 class_linker_->GetClassRootDescriptor(ClassLinker::ClassRoot(i))) << " i = " << i;
1084  }
1085}
1086
1087TEST_F(ClassLinkerTest, ValidatePredefinedClassSizes) {
1088  ScopedObjectAccess soa(Thread::Current());
1089  NullHandle<mirror::ClassLoader> class_loader;
1090  mirror::Class* c;
1091
1092  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Class;", class_loader);
1093  ASSERT_TRUE(c != nullptr);
1094  EXPECT_EQ(c->GetClassSize(), mirror::Class::ClassClassSize(sizeof(void*)));
1095
1096  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/Object;", class_loader);
1097  ASSERT_TRUE(c != nullptr);
1098  EXPECT_EQ(c->GetClassSize(), mirror::Object::ClassSize(sizeof(void*)));
1099
1100  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/String;", class_loader);
1101  ASSERT_TRUE(c != nullptr);
1102  EXPECT_EQ(c->GetClassSize(), mirror::String::ClassSize(sizeof(void*)));
1103
1104  c = class_linker_->FindClass(soa.Self(), "Ljava/lang/DexCache;", class_loader);
1105  ASSERT_TRUE(c != nullptr);
1106  EXPECT_EQ(c->GetClassSize(), mirror::DexCache::ClassSize(sizeof(void*)));
1107}
1108
1109static void CheckMethod(ArtMethod* method, bool verified)
1110    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1111  if (!method->IsNative() && !method->IsAbstract()) {
1112    EXPECT_EQ((method->GetAccessFlags() & kAccPreverified) != 0U, verified)
1113        << PrettyMethod(method, true);
1114  }
1115}
1116
1117static void CheckPreverified(mirror::Class* c, bool preverified)
1118    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1119  EXPECT_EQ((c->GetAccessFlags() & kAccPreverified) != 0U, preverified)
1120      << "Class " << PrettyClass(c) << " not as expected";
1121  for (auto& m : c->GetDirectMethods(sizeof(void*))) {
1122    CheckMethod(&m, preverified);
1123  }
1124  for (auto& m : c->GetVirtualMethods(sizeof(void*))) {
1125    CheckMethod(&m, preverified);
1126  }
1127}
1128
1129TEST_F(ClassLinkerTest, Preverified_InitializedBoot) {
1130  ScopedObjectAccess soa(Thread::Current());
1131
1132  mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
1133  ASSERT_TRUE(JavaLangObject != nullptr);
1134  EXPECT_TRUE(JavaLangObject->IsInitialized()) << "Not testing already initialized class from the "
1135                                                  "core";
1136  CheckPreverified(JavaLangObject, true);
1137}
1138
1139TEST_F(ClassLinkerTest, Preverified_UninitializedBoot) {
1140  ScopedObjectAccess soa(Thread::Current());
1141
1142  StackHandleScope<1> hs(soa.Self());
1143
1144  Handle<mirror::Class> security_manager(hs.NewHandle(class_linker_->FindSystemClass(
1145      soa.Self(), "Ljava/lang/SecurityManager;")));
1146  EXPECT_FALSE(security_manager->IsInitialized()) << "Not testing uninitialized class from the "
1147                                                     "core";
1148
1149  CheckPreverified(security_manager.Get(), false);
1150
1151  class_linker_->EnsureInitialized(soa.Self(), security_manager, true, true);
1152  CheckPreverified(security_manager.Get(), true);
1153}
1154
1155TEST_F(ClassLinkerTest, Preverified_App) {
1156  ScopedObjectAccess soa(Thread::Current());
1157
1158  StackHandleScope<2> hs(soa.Self());
1159  Handle<mirror::ClassLoader> class_loader(
1160      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Statics"))));
1161  Handle<mirror::Class> statics(
1162      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
1163
1164  CheckPreverified(statics.Get(), false);
1165
1166  class_linker_->EnsureInitialized(soa.Self(), statics, true, true);
1167  CheckPreverified(statics.Get(), true);
1168}
1169
1170TEST_F(ClassLinkerTest, IsBootStrapClassLoaded) {
1171  ScopedObjectAccess soa(Thread::Current());
1172
1173  StackHandleScope<3> hs(soa.Self());
1174  Handle<mirror::ClassLoader> class_loader(
1175      hs.NewHandle(soa.Decode<mirror::ClassLoader*>(LoadDex("Statics"))));
1176
1177  // java.lang.Object is a bootstrap class.
1178  Handle<mirror::Class> jlo_class(
1179      hs.NewHandle(class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;")));
1180  ASSERT_TRUE(jlo_class.Get() != nullptr);
1181  EXPECT_TRUE(jlo_class.Get()->IsBootStrapClassLoaded());
1182
1183  // Statics is not a bootstrap class.
1184  Handle<mirror::Class> statics(
1185      hs.NewHandle(class_linker_->FindClass(soa.Self(), "LStatics;", class_loader)));
1186  ASSERT_TRUE(statics.Get() != nullptr);
1187  EXPECT_FALSE(statics.Get()->IsBootStrapClassLoaded());
1188}
1189
1190}  // namespace art
1191