blob: 64b31a2c71dbd4cf1c44f8fd77ecd372d76c1bb3 [file] [log] [blame]
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001// Copyright 2011 Google Inc. All Rights Reserved.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07002
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003#include "class_linker.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07004
5#include <vector>
6#include <utility>
7
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07008#include "casts.h"
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07009#include "dex_cache.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070010#include "dex_verifier.h"
11#include "heap.h"
12#include "logging.h"
13#include "monitor.h"
14#include "object.h"
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070015#include "dex_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070016#include "scoped_ptr.h"
17#include "thread.h"
18#include "utils.h"
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070019
20namespace art {
21
Carl Shapiro2ed144c2011-07-26 16:52:08 -070022ClassLinker* ClassLinker::Create(const std::vector<DexFile*>& boot_class_path) {
Carl Shapiro61e019d2011-07-14 16:53:09 -070023 scoped_ptr<ClassLinker> class_linker(new ClassLinker);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070024 class_linker->Init(boot_class_path);
Carl Shapiro61e019d2011-07-14 16:53:09 -070025 // TODO: check for failure during initialization
26 return class_linker.release();
27}
28
Carl Shapiro2ed144c2011-07-26 16:52:08 -070029void ClassLinker::Init(const std::vector<DexFile*>& boot_class_path) {
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070030 init_done_ = false;
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070031
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070032 // java_lang_Class comes first, its needed for AllocClass
33 Class* java_lang_Class = down_cast<Class*>(Heap::AllocObject(NULL, sizeof(Class)));
34 CHECK(java_lang_Class != NULL);
35 java_lang_Class->descriptor_ = "Ljava/lang/Class;";
36 java_lang_Class->object_size_ = sizeof(Class);
37 java_lang_Class->klass_ = java_lang_Class;
38 // AllocClass(Class*) can now be used
Brian Carlstroma0808032011-07-18 00:39:23 -070039
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070040 // java_lang_Object comes next so that object_array_class can be created
41 Class* java_lang_Object = AllocClass(java_lang_Class);
42 CHECK(java_lang_Object != NULL);
43 java_lang_Object->descriptor_ = "Ljava/lang/Object;";
44 // backfill Object as the super class of Class
45 java_lang_Class->super_class_ = java_lang_Object;
Brian Carlstroma0808032011-07-18 00:39:23 -070046
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070047 // object_array_class is for root_classes to provide the storage for these classes
48 Class* object_array_class = AllocClass(java_lang_Class);
49 CHECK(object_array_class != NULL);
Brian Carlstroma0808032011-07-18 00:39:23 -070050
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070051 // String and char[] are necessary so that FindClass can assign names to members
Jesse Wilson14150742011-07-29 19:04:44 -040052 Class* java_lang_String = AllocClass(java_lang_Class);
53 CHECK(java_lang_String != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070054 java_lang_String->descriptor_ = "Ljava/lang/String;";
55 CHECK_LT(java_lang_String->object_size_, sizeof(String));
Jesse Wilson14150742011-07-29 19:04:44 -040056 java_lang_String->object_size_ = sizeof(String);
Jesse Wilson8989d992011-08-02 13:39:42 -070057 Class* char_array_class = AllocClass(java_lang_Class);
58 CHECK(char_array_class != NULL);
Jesse Wilson14150742011-07-29 19:04:44 -040059
Jesse Wilson7833bd22011-08-09 18:31:44 -040060 // int[] and long[] are used for static field storage
61 Class* int_array_class = AllocClass(java_lang_Class);
62 CHECK(int_array_class != NULL);
63 Class* long_array_class = AllocClass(java_lang_Class);
64 CHECK(long_array_class != NULL);
65
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070066 // Field and Method are necessary so that FindClass can link members
67 Class* java_lang_reflect_Field = AllocClass(java_lang_Class);
68 CHECK(java_lang_reflect_Field != NULL);
69 java_lang_reflect_Field->descriptor_ = "Ljava/lang/reflect/Field;";
Jesse Wilson35baaab2011-08-10 16:18:03 -040070 CHECK_LT(java_lang_reflect_Field->object_size_, sizeof(Field));
71 java_lang_reflect_Field->object_size_ = sizeof(Field);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070072 Class* java_lang_reflect_Method = AllocClass(java_lang_Class);
73 java_lang_reflect_Method->descriptor_ = "Ljava/lang/reflect/Method;";
74 CHECK(java_lang_reflect_Method != NULL);
75 CHECK_LT(java_lang_reflect_Method->object_size_, sizeof(Method));
76 java_lang_reflect_Method->object_size_ = sizeof(Method);
77
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070078 // create storage for root classes, save away our work so far
79 class_roots_ = ObjectArray<Class>::Alloc(object_array_class, kClassRootsMax);
80 class_roots_->Set(kJavaLangClass, java_lang_Class);
81 class_roots_->Set(kJavaLangObject, java_lang_Object);
82 class_roots_->Set(kObjectArrayClass, object_array_class);
Jesse Wilson14150742011-07-29 19:04:44 -040083 class_roots_->Set(kJavaLangString, java_lang_String);
Jesse Wilson8989d992011-08-02 13:39:42 -070084 class_roots_->Set(kCharArrayClass, char_array_class);
Jesse Wilson7833bd22011-08-09 18:31:44 -040085 class_roots_->Set(kIntArrayClass, int_array_class);
86 class_roots_->Set(kLongArrayClass, long_array_class);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070087 class_roots_->Set(kJavaLangReflectField, java_lang_reflect_Field);
88 class_roots_->Set(kJavaLangReflectMethod, java_lang_reflect_Method);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070089 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -070090
Jesse Wilson8989d992011-08-02 13:39:42 -070091 String::InitClasses(java_lang_String, char_array_class);
92 // Now AllocString* can be used
93
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070094 // setup boot_class_path_ now that we can use AllocObjectArray to
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070095 // create DexCache instances
Brian Carlstrom913af1b2011-07-23 21:41:13 -070096 for (size_t i = 0; i != boot_class_path.size(); ++i) {
97 AppendToBootClassPath(boot_class_path[i]);
98 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070099 // now we can use FindSystemClass, at least for non-arrays classes.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700100
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700101 // run Class, Field, and Method through FindSystemClass.
102 // this initializes their dex_cache_ fields and register them in classes_.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700103 // we also override their object_size_ values to accommodate the extra C++ fields.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700104 Class* Class_class = FindSystemClass(java_lang_Class->GetDescriptor());
105 CHECK_EQ(java_lang_Class, Class_class);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700106 CHECK_LT(java_lang_Class->object_size_, sizeof(Class));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700107 java_lang_Class->object_size_ = sizeof(Class);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700108 Class* Field_class = FindSystemClass(java_lang_reflect_Field->GetDescriptor());
109 CHECK_EQ(java_lang_reflect_Field, Field_class);
Jesse Wilson35baaab2011-08-10 16:18:03 -0400110 CHECK_LT(java_lang_reflect_Field->object_size_, sizeof(Field));
111 java_lang_reflect_Field->object_size_ = sizeof(Field);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700112 Class* Method_class = FindSystemClass(java_lang_reflect_Method->GetDescriptor());
113 CHECK_EQ(java_lang_reflect_Method, Method_class);
114 CHECK_LT(java_lang_reflect_Method->object_size_, sizeof(Method));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700115 java_lang_reflect_Method->object_size_ = sizeof(Method);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700116
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700117 // Object and String just need more minimal setup, since they do not have extra C++ fields.
118 Class* Object_class = FindSystemClass(java_lang_Object->GetDescriptor());
119 CHECK_EQ(java_lang_Object, Object_class);
120 CHECK_EQ(java_lang_Object->object_size_, sizeof(Object));
121 Class* String_class = FindSystemClass(java_lang_String->GetDescriptor());
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700122 CHECK_EQ(java_lang_String, String_class);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700123 CHECK_EQ(java_lang_String->object_size_, sizeof(String));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700124
125 // Setup the ClassLoaders, adjusting the object_size_ as necessary
126 Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
127 CHECK(java_lang_ClassLoader != NULL);
128 CHECK_LT(java_lang_ClassLoader->object_size_, sizeof(ClassLoader));
129 java_lang_ClassLoader->object_size_ = sizeof(ClassLoader);
130 class_roots_->Set(kJavaLangClassLoader, java_lang_ClassLoader);
131 Class* dalvik_system_BaseDexClassLoader = FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
132 CHECK(dalvik_system_BaseDexClassLoader != NULL);
133 CHECK_EQ(dalvik_system_BaseDexClassLoader->object_size_, sizeof(BaseDexClassLoader));
134 class_roots_->Set(kDalvikSystemBaseDexClassLoader, dalvik_system_BaseDexClassLoader);
135 Class* dalvik_system_PathClassLoader = FindSystemClass("Ldalvik/system/PathClassLoader;");
136 CHECK(dalvik_system_PathClassLoader != NULL);
137 CHECK_EQ(dalvik_system_PathClassLoader->object_size_, sizeof(PathClassLoader));
138 class_roots_->Set(kDalvikSystemPathClassLoader, dalvik_system_PathClassLoader);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700139
140 // Setup a single, global copy of "interfaces" and "iftable" for
141 // reuse across array classes
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700142 Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700143 CHECK(java_lang_Cloneable != NULL);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700144 Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700145 CHECK(java_io_Serializable != NULL);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700146
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700147 array_interfaces_ = AllocObjectArray<Class>(2);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700148 CHECK(array_interfaces_ != NULL);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700149 array_interfaces_->Set(0, java_lang_Cloneable);
150 array_interfaces_->Set(1, java_io_Serializable);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700151
152 // We assume that Cloneable/Serializable don't have superinterfaces --
153 // normally we'd have to crawl up and explicitly list all of the
154 // supers as well. These interfaces don't have any methods, so we
155 // don't have to worry about the ifviPool either.
156 array_iftable_ = new InterfaceEntry[2];
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700157 array_iftable_[0].SetClass(array_interfaces_->Get(0));
158 array_iftable_[1].SetClass(array_interfaces_->Get(1));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700159 // now FindClass can be used for non-primitive array classes
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700160
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700161 // run Object[] through FindClass to complete initialization
Jesse Wilson8989d992011-08-02 13:39:42 -0700162 Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
163 CHECK_EQ(object_array_class, found_object_array_class);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700164 CHECK_EQ(java_lang_Cloneable, object_array_class->GetInterface(0));
165 CHECK_EQ(java_io_Serializable, object_array_class->GetInterface(1));
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700166
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700167 // Setup the primitive type classes.
168 class_roots_->Set(kPrimitiveByte, CreatePrimitiveClass("B"));
169 class_roots_->Set(kPrimitiveChar, CreatePrimitiveClass("C"));
170 class_roots_->Set(kPrimitiveDouble, CreatePrimitiveClass("D"));
171 class_roots_->Set(kPrimitiveFloat, CreatePrimitiveClass("F"));
172 class_roots_->Set(kPrimitiveInt, CreatePrimitiveClass("I"));
173 class_roots_->Set(kPrimitiveLong, CreatePrimitiveClass("J"));
174 class_roots_->Set(kPrimitiveShort, CreatePrimitiveClass("S"));
175 class_roots_->Set(kPrimitiveBoolean, CreatePrimitiveClass("Z"));
176 class_roots_->Set(kPrimitiveVoid, CreatePrimitiveClass("V"));
177 // now we can use FindSystemClass for anything, including for "[C"
178
Jesse Wilson7833bd22011-08-09 18:31:44 -0400179 // run char[], int[] and long[] through FindClass to complete initialization
Jesse Wilson8989d992011-08-02 13:39:42 -0700180 Class* found_char_array_class = FindSystemClass("[C");
181 CHECK_EQ(char_array_class, found_char_array_class);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400182 Class* found_int_array_class = FindSystemClass("[I");
183 CHECK_EQ(int_array_class, found_int_array_class);
184 Class* found_long_array_class = FindSystemClass("[J");
185 CHECK_EQ(long_array_class, found_long_array_class);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700186
187 // ensure all class_roots_ were initialized
188 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700189 CHECK(GetClassRoot(static_cast<ClassRoot>(i)));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700190 }
191
192 // disable the slow paths in FindClass and CreatePrimitiveClass now
193 // that Object, Class, and Object[] are setup
194 init_done_ = true;
195}
196
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700197void ClassLinker::VisitRoots(Heap::RootVistor* root_visitor, void* arg) {
Brian Carlstromb88e9442011-07-28 15:15:51 -0700198 root_visitor(class_roots_, arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700199
200 for (size_t i = 0; i < dex_caches_.size(); i++) {
Brian Carlstromb88e9442011-07-28 15:15:51 -0700201 root_visitor(dex_caches_[i], arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700202 }
203
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700204 {
205 MutexLock mu(classes_lock_);
206 typedef Table::const_iterator It; // TODO: C++0x auto
207 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
208 root_visitor(it->second, arg);
209 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700210 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700211
212 intern_table_.VisitRoots(root_visitor, arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700213
Brian Carlstromb88e9442011-07-28 15:15:51 -0700214 root_visitor(array_interfaces_, arg);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700215}
216
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700217DexCache* ClassLinker::AllocDexCache() {
Brian Carlstroma40f9bc2011-07-26 21:26:07 -0700218 return down_cast<DexCache*>(AllocObjectArray<Object>(DexCache::kMax));
Brian Carlstroma0808032011-07-18 00:39:23 -0700219}
220
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700221Class* ClassLinker::AllocClass(Class* java_lang_Class) {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700222 return down_cast<Class*>(java_lang_Class->NewInstance());
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700223}
224
225Class* ClassLinker::AllocClass() {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700226 return AllocClass(GetClassRoot(kJavaLangClass));
Brian Carlstroma0808032011-07-18 00:39:23 -0700227}
228
Jesse Wilson35baaab2011-08-10 16:18:03 -0400229Field* ClassLinker::AllocField() {
230 return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->NewInstance());
Brian Carlstroma0808032011-07-18 00:39:23 -0700231}
232
233Method* ClassLinker::AllocMethod() {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700234 return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->NewInstance());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700235}
236
237// TODO remove once we can use java.lang.Class.getSystemClassLoader
238PathClassLoader* ClassLinker::AllocPathClassLoader(std::vector<const DexFile*> dex_files) {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700239 PathClassLoader* cl = down_cast<PathClassLoader*>(GetClassRoot(kDalvikSystemPathClassLoader)->NewInstance());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700240 cl->SetClassPath(dex_files);
241 return cl;
Carl Shapiro565f5072011-07-10 13:39:43 -0700242}
243
Brian Carlstrom6cc18452011-07-18 15:10:33 -0700244Class* ClassLinker::FindClass(const StringPiece& descriptor,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700245 ClassLoader* class_loader) {
246 // TODO remove this contrived parent class loader check when we have a real ClassLoader.
247 if (class_loader != NULL) {
248 Class* klass = FindClass(descriptor, NULL);
249 if (klass != NULL) {
250 return klass;
251 }
252 }
253
Carl Shapirob5573532011-07-12 18:22:59 -0700254 Thread* self = Thread::Current();
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700255 DCHECK(self != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700256 CHECK(!self->IsExceptionPending());
257 // Find the class in the loaded classes table.
258 Class* klass = LookupClass(descriptor, class_loader);
259 if (klass == NULL) {
260 // Class is not yet loaded.
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700261 if (descriptor[0] == '[') {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700262 return CreateArrayClass(descriptor, class_loader);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700263 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700264 DexFile::ClassPath& class_path = ((class_loader != NULL) ? class_loader->GetClassPath() : boot_class_path_);
265 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700266 if (pair.second == NULL) {
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700267 LG << "Class " << PrintableString(descriptor) << " not found in class loader " << class_loader; // TODO: NoClassDefFoundError
Brian Carlstrom6cc18452011-07-18 15:10:33 -0700268 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700269 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700270 const DexFile& dex_file = *pair.first;
271 const DexFile::ClassDef& dex_class_def = *pair.second;
272 DexCache* dex_cache = FindDexCache(pair.first);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700273 // Load the class from the dex file.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700274 if (!init_done_) {
275 // finish up init of hand crafted class_roots_
276 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700277 klass = GetClassRoot(kJavaLangObject);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700278 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700279 klass = GetClassRoot(kJavaLangClass);
Jesse Wilson14150742011-07-29 19:04:44 -0400280 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700281 klass = GetClassRoot(kJavaLangString);
282 } else if (descriptor == "Ljava/lang/reflect/Field;") {
283 klass = GetClassRoot(kJavaLangReflectField);
284 } else if (descriptor == "Ljava/lang/reflect/Method;") {
285 klass = GetClassRoot(kJavaLangReflectMethod);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700286 } else {
287 klass = AllocClass();
288 }
Carl Shapiro565f5072011-07-10 13:39:43 -0700289 } else {
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700290 klass = AllocClass();
Carl Shapiro565f5072011-07-10 13:39:43 -0700291 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700292 klass->dex_cache_ = dex_cache;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700293 LoadClass(dex_file, dex_class_def, klass, class_loader);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700294 // Check for a pending exception during load
295 if (self->IsExceptionPending()) {
296 // TODO: free native allocations in klass
297 return NULL;
298 }
299 {
300 ObjectLock lock(klass);
Carl Shapirob5573532011-07-12 18:22:59 -0700301 klass->clinit_thread_id_ = self->GetId();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700302 // Add the newly loaded class to the loaded classes table.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700303 bool success = InsertClass(klass); // TODO just return collision
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700304 if (!success) {
305 // We may fail to insert if we raced with another thread.
306 klass->clinit_thread_id_ = 0;
307 // TODO: free native allocations in klass
308 klass = LookupClass(descriptor, class_loader);
309 CHECK(klass != NULL);
310 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700311 // Finish loading (if necessary) by finding parents
312 if (!klass->IsLoaded() && !LoadSuperAndInterfaces(klass, dex_file)) {
313 // Loading failed.
314 // TODO: CHECK(self->IsExceptionPending());
315 lock.NotifyAll();
316 return NULL;
317 }
318 CHECK(klass->IsLoaded());
319 // Link the class (if necessary)
320 if (!klass->IsLinked() && !LinkClass(klass, dex_file)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700321 // Linking failed.
322 // TODO: CHECK(self->IsExceptionPending());
323 lock.NotifyAll();
324 return NULL;
325 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700326 CHECK(klass->IsLinked());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700327 }
328 }
329 }
330 // Link the class if it has not already been linked.
331 if (!klass->IsLinked() && !klass->IsErroneous()) {
332 ObjectLock lock(klass);
333 // Check for circular dependencies between classes.
Carl Shapirob5573532011-07-12 18:22:59 -0700334 if (!klass->IsLinked() && klass->clinit_thread_id_ == self->GetId()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700335 LG << "Recursive link"; // TODO: ClassCircularityError
336 return NULL;
337 }
338 // Wait for the pending initialization to complete.
339 while (!klass->IsLinked() && !klass->IsErroneous()) {
340 lock.Wait();
341 }
342 }
343 if (klass->IsErroneous()) {
344 LG << "EarlierClassFailure"; // TODO: EarlierClassFailure
345 return NULL;
346 }
347 // Return the loaded class. No exceptions should be pending.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700348 CHECK(klass->IsLinked());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700349 CHECK(!self->IsExceptionPending());
350 return klass;
351}
352
Brian Carlstromf615a612011-07-23 12:50:34 -0700353void ClassLinker::LoadClass(const DexFile& dex_file,
354 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700355 Class* klass,
356 ClassLoader* class_loader) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700357 CHECK(klass != NULL);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700358 CHECK(klass->dex_cache_ != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700359 CHECK_EQ(Class::kStatusNotReady, klass->status_);
Brian Carlstromf615a612011-07-23 12:50:34 -0700360 const byte* class_data = dex_file.GetClassData(dex_class_def);
361 DexFile::ClassDataHeader header = dex_file.ReadClassDataHeader(&class_data);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700362
Brian Carlstromf615a612011-07-23 12:50:34 -0700363 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700364 CHECK(descriptor != NULL);
365
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700366 klass->klass_ = GetClassRoot(kJavaLangClass);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700367 klass->descriptor_.set(descriptor);
368 klass->descriptor_alloc_ = NULL;
Brian Carlstromf615a612011-07-23 12:50:34 -0700369 klass->access_flags_ = dex_class_def.access_flags_;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700370 klass->class_loader_ = class_loader;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700371 klass->primitive_type_ = Class::kPrimNot;
372 klass->status_ = Class::kStatusIdx;
373
374 klass->super_class_ = NULL;
Brian Carlstromf615a612011-07-23 12:50:34 -0700375 klass->super_class_idx_ = dex_class_def.superclass_idx_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700376
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700377 size_t num_static_fields = header.static_fields_size_;
378 size_t num_instance_fields = header.instance_fields_size_;
379 size_t num_direct_methods = header.direct_methods_size_;
380 size_t num_virtual_methods = header.virtual_methods_size_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700381
Brian Carlstromf615a612011-07-23 12:50:34 -0700382 klass->source_file_ = dex_file.dexGetSourceFile(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700383
384 // Load class interfaces.
Brian Carlstromf615a612011-07-23 12:50:34 -0700385 LoadInterfaces(dex_file, dex_class_def, klass);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700386
387 // Load static fields.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700388 DCHECK(klass->sfields_ == NULL);
389 if (num_static_fields != 0) {
Jesse Wilson35baaab2011-08-10 16:18:03 -0400390 klass->sfields_ = AllocObjectArray<Field>(num_static_fields);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700391 uint32_t last_idx = 0;
Carl Shapiro69759ea2011-07-21 18:13:35 -0700392 for (size_t i = 0; i < klass->NumStaticFields(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700393 DexFile::Field dex_field;
394 dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
Jesse Wilson35baaab2011-08-10 16:18:03 -0400395 Field* sfield = AllocField();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700396 klass->SetStaticField(i, sfield);
Brian Carlstromf615a612011-07-23 12:50:34 -0700397 LoadField(dex_file, dex_field, klass, sfield);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700398 }
399 }
400
401 // Load instance fields.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700402 DCHECK(klass->ifields_ == NULL);
403 if (num_instance_fields != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700404 // TODO: allocate on the object heap.
Jesse Wilson35baaab2011-08-10 16:18:03 -0400405 klass->ifields_ = AllocObjectArray<Field>(num_instance_fields);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700406 uint32_t last_idx = 0;
407 for (size_t i = 0; i < klass->NumInstanceFields(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700408 DexFile::Field dex_field;
409 dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
Jesse Wilson35baaab2011-08-10 16:18:03 -0400410 Field* ifield = AllocField();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700411 klass->SetInstanceField(i, ifield);
Brian Carlstromf615a612011-07-23 12:50:34 -0700412 LoadField(dex_file, dex_field, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700413 }
414 }
415
416 // Load direct methods.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700417 DCHECK(klass->direct_methods_ == NULL);
418 if (num_direct_methods != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700419 // TODO: append direct methods to class object
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700420 klass->direct_methods_ = AllocObjectArray<Method>(num_direct_methods);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700421 uint32_t last_idx = 0;
422 for (size_t i = 0; i < klass->NumDirectMethods(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700423 DexFile::Method dex_method;
424 dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
Brian Carlstroma0808032011-07-18 00:39:23 -0700425 Method* meth = AllocMethod();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700426 klass->SetDirectMethod(i, meth);
Brian Carlstromf615a612011-07-23 12:50:34 -0700427 LoadMethod(dex_file, dex_method, klass, meth);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700428 // TODO: register maps
429 }
430 }
431
432 // Load virtual methods.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700433 DCHECK(klass->virtual_methods_ == NULL);
434 if (num_virtual_methods != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700435 // TODO: append virtual methods to class object
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700436 klass->virtual_methods_ = AllocObjectArray<Method>(num_virtual_methods);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700437 uint32_t last_idx = 0;
438 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700439 DexFile::Method dex_method;
440 dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
Brian Carlstroma0808032011-07-18 00:39:23 -0700441 Method* meth = AllocMethod();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700442 klass->SetVirtualMethod(i, meth);
Brian Carlstromf615a612011-07-23 12:50:34 -0700443 LoadMethod(dex_file, dex_method, klass, meth);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700444 // TODO: register maps
445 }
446 }
Brian Carlstrom934486c2011-07-12 23:42:50 -0700447}
448
Brian Carlstromf615a612011-07-23 12:50:34 -0700449void ClassLinker::LoadInterfaces(const DexFile& dex_file,
450 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700451 Class* klass) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700452 const DexFile::TypeList* list = dex_file.GetInterfacesList(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700453 if (list != NULL) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700454 DCHECK(klass->interfaces_ == NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700455 klass->interfaces_ = AllocObjectArray<Class>(list->Size());
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700456 DCHECK(klass->interfaces_idx_ == NULL);
457 klass->interfaces_idx_ = new uint32_t[list->Size()];
Brian Carlstrom934486c2011-07-12 23:42:50 -0700458 for (size_t i = 0; i < list->Size(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700459 const DexFile::TypeItem& type_item = list->GetTypeItem(i);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700460 klass->interfaces_idx_[i] = type_item.type_idx_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700461 }
462 }
463}
464
Brian Carlstromf615a612011-07-23 12:50:34 -0700465void ClassLinker::LoadField(const DexFile& dex_file,
466 const DexFile::Field& src,
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700467 Class* klass,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700468 Field* dst) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700469 const DexFile::FieldId& field_id = dex_file.GetFieldId(src.field_idx_);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400470 dst->declaring_class_ = klass;
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700471 dst->name_ = ResolveString(klass, field_id.name_idx_, dex_file);
Brian Carlstromae3ac012011-07-27 01:30:28 -0700472 dst->descriptor_.set(dex_file.dexStringByTypeIdx(field_id.type_idx_));
Jesse Wilson35baaab2011-08-10 16:18:03 -0400473 // TODO: Assign dst->type_.
Brian Carlstrom934486c2011-07-12 23:42:50 -0700474 dst->access_flags_ = src.access_flags_;
475}
476
Brian Carlstromf615a612011-07-23 12:50:34 -0700477void ClassLinker::LoadMethod(const DexFile& dex_file,
478 const DexFile::Method& src,
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700479 Class* klass,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700480 Method* dst) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700481 const DexFile::MethodId& method_id = dex_file.GetMethodId(src.method_idx_);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400482 dst->declaring_class_ = klass;
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700483 dst->name_ = ResolveString(klass, method_id.name_idx_, dex_file);
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700484 {
485 int32_t utf16_length;
Elliott Hughes40ef99e2011-08-11 17:44:34 -0700486 scoped_array<char> utf8(dex_file.CreateMethodDescriptor(method_id.proto_idx_,
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700487 &utf16_length));
488 dst->descriptor_ = String::AllocFromModifiedUtf8(utf16_length, utf8.get());
489 }
Brian Carlstrom934486c2011-07-12 23:42:50 -0700490 dst->proto_idx_ = method_id.proto_idx_;
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700491 dst->code_off_ = src.code_off_;
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700492 dst->shorty_ = dex_file.GetShorty(method_id.proto_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700493 dst->access_flags_ = src.access_flags_;
494
495 // TODO: check for finalize method
496
Brian Carlstromf615a612011-07-23 12:50:34 -0700497 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(src);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700498 if (code_item != NULL) {
499 dst->num_registers_ = code_item->registers_size_;
500 dst->num_ins_ = code_item->ins_size_;
501 dst->num_outs_ = code_item->outs_size_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700502 } else {
503 uint16_t num_args = dst->NumArgRegisters();
504 if (!dst->IsStatic()) {
505 ++num_args;
506 }
507 dst->num_registers_ = dst->num_ins_ + num_args;
508 // TODO: native methods
509 }
510}
511
Brian Carlstromf615a612011-07-23 12:50:34 -0700512void ClassLinker::AppendToBootClassPath(DexFile* dex_file) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700513 CHECK(dex_file != NULL);
Brian Carlstromf615a612011-07-23 12:50:34 -0700514 boot_class_path_.push_back(dex_file);
515 RegisterDexFile(dex_file);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700516}
517
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700518void ClassLinker::RegisterDexFile(const DexFile* dex_file) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700519 CHECK(dex_file != NULL);
Brian Carlstromf615a612011-07-23 12:50:34 -0700520 dex_files_.push_back(dex_file);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700521 DexCache* dex_cache = AllocDexCache();
522 CHECK(dex_cache != NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700523 dex_cache->Init(AllocObjectArray<String>(dex_file->NumStringIds()),
524 AllocObjectArray<Class>(dex_file->NumTypeIds()),
525 AllocObjectArray<Method>(dex_file->NumMethodIds()),
526 AllocObjectArray<Field>(dex_file->NumFieldIds()));
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700527 dex_caches_.push_back(dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700528}
529
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700530const DexFile& ClassLinker::FindDexFile(const DexCache* dex_cache) const {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700531 for (size_t i = 0; i != dex_caches_.size(); ++i) {
532 if (dex_caches_[i] == dex_cache) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700533 return *dex_files_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700534 }
535 }
Brian Carlstromf615a612011-07-23 12:50:34 -0700536 CHECK(false) << "Could not find DexFile";
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700537 return *dex_files_[-1];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700538}
539
Brian Carlstromf615a612011-07-23 12:50:34 -0700540DexCache* ClassLinker::FindDexCache(const DexFile* dex_file) const {
Brian Carlstromf615a612011-07-23 12:50:34 -0700541 for (size_t i = 0; i != dex_files_.size(); ++i) {
542 if (dex_files_[i] == dex_file) {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700543 return dex_caches_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700544 }
545 }
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700546 CHECK(false) << "Could not find DexCache";
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700547 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700548}
549
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700550Class* ClassLinker::CreatePrimitiveClass(const StringPiece& descriptor) {
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700551 Class* klass = AllocClass();
Carl Shapiro565f5072011-07-10 13:39:43 -0700552 CHECK(klass != NULL);
Brian Carlstroma0808032011-07-18 00:39:23 -0700553 klass->super_class_ = NULL;
Carl Shapiro565f5072011-07-10 13:39:43 -0700554 klass->access_flags_ = kAccPublic | kAccFinal | kAccAbstract;
555 klass->descriptor_ = descriptor;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700556 klass->descriptor_alloc_ = NULL;
Carl Shapiro565f5072011-07-10 13:39:43 -0700557 klass->status_ = Class::kStatusInitialized;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700558 bool success = InsertClass(klass);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700559 CHECK(success) << "CreatePrimitiveClass(" << descriptor << ") failed";
Carl Shapiro565f5072011-07-10 13:39:43 -0700560 return klass;
561}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700562
Brian Carlstrombe977852011-07-19 14:54:54 -0700563// Create an array class (i.e. the class object for the array, not the
564// array itself). "descriptor" looks like "[C" or "[[[[B" or
565// "[Ljava/lang/String;".
566//
567// If "descriptor" refers to an array of primitives, look up the
568// primitive type's internally-generated class object.
569//
570// "loader" is the class loader of the class that's referring to us. It's
571// used to ensure that we're looking for the element type in the right
572// context. It does NOT become the class loader for the array class; that
573// always comes from the base element class.
574//
575// Returns NULL with an exception raised on failure.
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700576Class* ClassLinker::CreateArrayClass(const StringPiece& descriptor,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700577 ClassLoader* class_loader)
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700578{
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700579 CHECK(descriptor[0] == '[');
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700580
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700581 // Identify the underlying element class and the array dimension depth.
582 Class* component_type_ = NULL;
583 int array_rank;
584 if (descriptor[1] == '[') {
585 // array of arrays; keep descriptor and grab stuff from parent
586 Class* outer = FindClass(descriptor.substr(1), class_loader);
587 if (outer != NULL) {
588 // want the base class, not "outer", in our component_type_
589 component_type_ = outer->component_type_;
590 array_rank = outer->array_rank_ + 1;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700591 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700592 DCHECK(component_type_ == NULL); // make sure we fail
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700593 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700594 } else {
595 array_rank = 1;
596 if (descriptor[1] == 'L') {
597 // array of objects; strip off "[" and look up descriptor.
598 const StringPiece subDescriptor = descriptor.substr(1);
599 component_type_ = FindClass(subDescriptor, class_loader);
600 } else {
601 // array of a primitive type
602 component_type_ = FindPrimitiveClass(descriptor[1]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700603 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700604 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700605
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700606 if (component_type_ == NULL) {
607 // failed
608 // DCHECK(Thread::Current()->IsExceptionPending()); // TODO
609 return NULL;
610 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700611
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700612 // See if the component type is already loaded. Array classes are
613 // always associated with the class loader of their underlying
614 // element type -- an array of Strings goes with the loader for
615 // java/lang/String -- so we need to look for it there. (The
616 // caller should have checked for the existence of the class
617 // before calling here, but they did so with *their* class loader,
618 // not the component type's loader.)
619 //
620 // If we find it, the caller adds "loader" to the class' initiating
621 // loader list, which should prevent us from going through this again.
622 //
623 // This call is unnecessary if "loader" and "component_type_->class_loader_"
624 // are the same, because our caller (FindClass) just did the
625 // lookup. (Even if we get this wrong we still have correct behavior,
626 // because we effectively do this lookup again when we add the new
627 // class to the hash table --- necessary because of possible races with
628 // other threads.)
629 if (class_loader != component_type_->class_loader_) {
630 Class* new_class = LookupClass(descriptor, component_type_->class_loader_);
631 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700632 return new_class;
633 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700634 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700635
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700636 // Fill out the fields in the Class.
637 //
638 // It is possible to execute some methods against arrays, because
639 // all arrays are subclasses of java_lang_Object_, so we need to set
640 // up a vtable. We can just point at the one in java_lang_Object_.
641 //
642 // Array classes are simple enough that we don't need to do a full
643 // link step.
644
645 Class* new_class = NULL;
646 if (!init_done_) {
647 if (descriptor == "[Ljava/lang/Object;") {
648 new_class = GetClassRoot(kObjectArrayClass);
649 } else if (descriptor == "[C") {
650 new_class = GetClassRoot(kCharArrayClass);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400651 } else if (descriptor == "[I") {
652 new_class = GetClassRoot(kIntArrayClass);
653 } else if (descriptor == "[J") {
654 new_class = GetClassRoot(kLongArrayClass);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700655 }
656 }
657 if (new_class == NULL) {
658 new_class = AllocClass();
659 if (new_class == NULL) {
660 return NULL;
661 }
662 }
663 new_class->descriptor_alloc_ = new std::string(descriptor.data(),
664 descriptor.size());
665 new_class->descriptor_.set(new_class->descriptor_alloc_->data(),
666 new_class->descriptor_alloc_->size());
667 Class* java_lang_Object = GetClassRoot(kJavaLangObject);
668 new_class->super_class_ = java_lang_Object;
669 new_class->vtable_ = java_lang_Object->vtable_;
670 new_class->primitive_type_ = Class::kPrimNot;
671 new_class->component_type_ = component_type_;
672 new_class->class_loader_ = component_type_->class_loader_;
673 new_class->array_rank_ = array_rank;
674 new_class->status_ = Class::kStatusInitialized;
675 // don't need to set new_class->object_size_
676
677
678 // All arrays have java/lang/Cloneable and java/io/Serializable as
679 // interfaces. We need to set that up here, so that stuff like
680 // "instanceof" works right.
681 //
682 // Note: The GC could run during the call to FindSystemClass,
683 // so we need to make sure the class object is GC-valid while we're in
684 // there. Do this by clearing the interface list so the GC will just
685 // think that the entries are null.
686
687
688 // Use the single, global copies of "interfaces" and "iftable"
689 // (remember not to free them for arrays).
690 DCHECK(array_interfaces_ != NULL);
691 new_class->interfaces_ = array_interfaces_;
692 new_class->iftable_count_ = 2;
693 DCHECK(array_iftable_ != NULL);
694 new_class->iftable_ = array_iftable_;
695
696 // Inherit access flags from the component type. Arrays can't be
697 // used as a superclass or interface, so we want to add "final"
698 // and remove "interface".
699 //
700 // Don't inherit any non-standard flags (e.g., kAccFinal)
701 // from component_type_. We assume that the array class does not
702 // override finalize().
703 new_class->access_flags_ = ((new_class->component_type_->access_flags_ &
704 ~kAccInterface) | kAccFinal) & kAccJavaFlagsMask;
705
706 if (InsertClass(new_class)) {
707 return new_class;
708 }
709 // Another thread must have loaded the class after we
710 // started but before we finished. Abandon what we've
711 // done.
712 //
713 // (Yes, this happens.)
714
715 // Grab the winning class.
716 Class* other_class = LookupClass(descriptor, component_type_->class_loader_);
717 DCHECK(other_class != NULL);
718 return other_class;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700719}
720
721Class* ClassLinker::FindPrimitiveClass(char type) {
Carl Shapiro565f5072011-07-10 13:39:43 -0700722 switch (type) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700723 case 'B':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700724 return GetClassRoot(kPrimitiveByte);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700725 case 'C':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700726 return GetClassRoot(kPrimitiveChar);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700727 case 'D':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700728 return GetClassRoot(kPrimitiveDouble);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700729 case 'F':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700730 return GetClassRoot(kPrimitiveFloat);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700731 case 'I':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700732 return GetClassRoot(kPrimitiveInt);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700733 case 'J':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700734 return GetClassRoot(kPrimitiveLong);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700735 case 'S':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700736 return GetClassRoot(kPrimitiveShort);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700737 case 'Z':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700738 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700739 case 'V':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700740 return GetClassRoot(kPrimitiveVoid);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700741 case 'L':
742 case '[':
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700743 LOG(ERROR) << "Not a primitive type " << PrintableChar(type);
Carl Shapiro565f5072011-07-10 13:39:43 -0700744 default:
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700745 LOG(ERROR) << "Unknown primitive type " << PrintableChar(type);
Carl Shapiro744ad052011-08-06 15:53:36 -0700746 }
Carl Shapiro565f5072011-07-10 13:39:43 -0700747 return NULL; // Not reachable.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700748}
749
750bool ClassLinker::InsertClass(Class* klass) {
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700751 MutexLock mu(classes_lock_);
Brian Carlstrom6cc18452011-07-18 15:10:33 -0700752 const StringPiece& key = klass->GetDescriptor();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700753 Table::iterator it = classes_.insert(std::make_pair(key, klass));
754 return ((*it).second == klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700755}
756
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700757Class* ClassLinker::LookupClass(const StringPiece& descriptor, ClassLoader* class_loader) {
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700758 MutexLock mu(classes_lock_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700759 typedef Table::const_iterator It; // TODO: C++0x auto
760 for (It it = classes_.find(descriptor), end = classes_.end(); it != end; ++it) {
761 Class* klass = it->second;
762 if (klass->descriptor_ == descriptor && klass->class_loader_ == class_loader) {
763 return klass;
764 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700765 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700766 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700767}
768
769bool ClassLinker::InitializeClass(Class* klass) {
770 CHECK(klass->GetStatus() == Class::kStatusResolved ||
771 klass->GetStatus() == Class::kStatusError);
772
Carl Shapirob5573532011-07-12 18:22:59 -0700773 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700774
775 {
776 ObjectLock lock(klass);
777
778 if (klass->GetStatus() < Class::kStatusVerified) {
779 if (klass->IsErroneous()) {
780 LG << "re-initializing failed class"; // TODO: throw
781 return false;
782 }
783
784 CHECK(klass->GetStatus() == Class::kStatusResolved);
785
786 klass->status_ = Class::kStatusVerifying;
787 if (!DexVerify::VerifyClass(klass)) {
788 LG << "Verification failed"; // TODO: ThrowVerifyError
789 Object* exception = self->GetException();
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700790 klass->SetVerifyErrorClass(exception->GetClass());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700791 klass->SetStatus(Class::kStatusError);
792 return false;
793 }
794
795 klass->SetStatus(Class::kStatusVerified);
796 }
797
798 if (klass->status_ == Class::kStatusInitialized) {
799 return true;
800 }
801
802 while (klass->status_ == Class::kStatusInitializing) {
803 // we caught somebody else in the act; was it us?
Carl Shapirob5573532011-07-12 18:22:59 -0700804 if (klass->clinit_thread_id_ == self->GetId()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700805 LG << "recursive <clinit>";
806 return true;
807 }
808
809 CHECK(!self->IsExceptionPending());
810
811 lock.Wait(); // TODO: check for interruption
812
813 // When we wake up, repeat the test for init-in-progress. If
814 // there's an exception pending (only possible if
815 // "interruptShouldThrow" was set), bail out.
816 if (self->IsExceptionPending()) {
817 CHECK(false);
818 LG << "Exception in initialization."; // TODO: ExceptionInInitializerError
819 klass->SetStatus(Class::kStatusError);
820 return false;
821 }
822 if (klass->GetStatus() == Class::kStatusInitializing) {
823 continue;
824 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700825 DCHECK(klass->GetStatus() == Class::kStatusInitialized ||
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700826 klass->GetStatus() == Class::kStatusError);
827 if (klass->IsErroneous()) {
Brian Carlstrombe977852011-07-19 14:54:54 -0700828 // The caller wants an exception, but it was thrown in a
829 // different thread. Synthesize one here.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700830 LG << "<clinit> failed"; // TODO: throw UnsatisfiedLinkError
831 return false;
832 }
833 return true; // otherwise, initialized
834 }
835
836 // see if we failed previously
837 if (klass->IsErroneous()) {
838 // might be wise to unlock before throwing; depends on which class
839 // it is that we have locked
840
841 // TODO: throwEarlierClassFailure(klass);
842 return false;
843 }
844
845 if (!ValidateSuperClassDescriptors(klass)) {
846 klass->SetStatus(Class::kStatusError);
847 return false;
848 }
849
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700850 DCHECK(klass->status_ < Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700851
Carl Shapirob5573532011-07-12 18:22:59 -0700852 klass->clinit_thread_id_ = self->GetId();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700853 klass->status_ = Class::kStatusInitializing;
854 }
855
856 if (!InitializeSuperClass(klass)) {
857 return false;
858 }
859
860 InitializeStaticFields(klass);
861
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700862 Method* clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700863 if (clinit != NULL) {
864 } else {
865 // JValue unused;
866 // TODO: dvmCallMethod(self, method, NULL, &unused);
Elliott Hughes53b61312011-08-12 18:28:20 -0700867 // UNIMPLEMENTED(FATAL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700868 }
869
870 {
871 ObjectLock lock(klass);
872
873 if (self->IsExceptionPending()) {
874 klass->SetStatus(Class::kStatusError);
875 } else {
876 klass->SetStatus(Class::kStatusInitialized);
877 }
878 lock.NotifyAll();
879 }
880
881 return true;
882}
883
884bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
885 if (klass->IsInterface()) {
886 return true;
887 }
888 // begin with the methods local to the superclass
889 if (klass->HasSuperClass() &&
890 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
891 const Class* super = klass->GetSuperClass();
892 for (int i = super->NumVirtualMethods() - 1; i >= 0; --i) {
893 const Method* method = klass->GetVirtualMethod(i);
894 if (method != super->GetVirtualMethod(i) &&
895 !HasSameMethodDescriptorClasses(method, super, klass)) {
896 LG << "Classes resolve differently in superclass";
897 return false;
898 }
899 }
900 }
901 for (size_t i = 0; i < klass->iftable_count_; ++i) {
902 const InterfaceEntry* iftable = &klass->iftable_[i];
903 Class* interface = iftable->GetClass();
904 if (klass->GetClassLoader() != interface->GetClassLoader()) {
905 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
906 uint32_t vtable_index = iftable->method_index_array_[j];
907 const Method* method = klass->GetVirtualMethod(vtable_index);
908 if (!HasSameMethodDescriptorClasses(method, interface,
909 method->GetClass())) {
910 LG << "Classes resolve differently in interface"; // TODO: LinkageError
911 return false;
912 }
913 }
914 }
915 }
916 return true;
917}
918
919bool ClassLinker::HasSameMethodDescriptorClasses(const Method* method,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700920 const Class* klass1,
921 const Class* klass2) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700922 const DexFile& dex_file = FindDexFile(method->GetClass()->GetDexCache());
923 const DexFile::ProtoId& proto_id = dex_file.GetProtoId(method->proto_idx_);
Brian Carlstromf615a612011-07-23 12:50:34 -0700924 DexFile::ParameterIterator *it;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700925 for (it = dex_file.GetParameterIterator(proto_id); it->HasNext(); it->Next()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700926 const char* descriptor = it->GetDescriptor();
927 if (descriptor == NULL) {
928 break;
929 }
930 if (descriptor[0] == 'L' || descriptor[0] == '[') {
931 // Found a non-primitive type.
932 if (!HasSameDescriptorClasses(descriptor, klass1, klass2)) {
933 return false;
934 }
935 }
936 }
937 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700938 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700939 if (descriptor[0] == 'L' || descriptor[0] == '[') {
940 if (HasSameDescriptorClasses(descriptor, klass1, klass2)) {
941 return false;
942 }
943 }
944 return true;
945}
946
947// Returns true if classes referenced by the descriptor are the
948// same classes in klass1 as they are in klass2.
949bool ClassLinker::HasSameDescriptorClasses(const char* descriptor,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700950 const Class* klass1,
951 const Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700952 CHECK(descriptor != NULL);
953 CHECK(klass1 != NULL);
954 CHECK(klass2 != NULL);
955#if 0
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700956 Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700957 // TODO: found1 == NULL
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700958 Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700959 // TODO: found2 == NULL
960 // TODO: lookup found1 in initiating loader list
961 if (found1 == NULL || found2 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -0700962 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700963 if (found1 == found2) {
964 return true;
965 } else {
966 return false;
967 }
968 }
969#endif
970 return true;
971}
972
973bool ClassLinker::InitializeSuperClass(Class* klass) {
974 CHECK(klass != NULL);
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700975 MutexLock mu(classes_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700976 if (!klass->IsInterface() && klass->HasSuperClass()) {
977 Class* super_class = klass->GetSuperClass();
978 if (super_class->GetStatus() != Class::kStatusInitialized) {
979 CHECK(!super_class->IsInterface());
980 klass->MonitorExit();
981 bool super_initialized = InitializeClass(super_class);
982 klass->MonitorEnter();
983 // TODO: check for a pending exception
984 if (!super_initialized) {
985 klass->SetStatus(Class::kStatusError);
986 klass->NotifyAll();
987 return false;
988 }
989 }
990 }
991 return true;
992}
993
994void ClassLinker::InitializeStaticFields(Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -0700995 size_t num_static_fields = klass->NumStaticFields();
996 if (num_static_fields == 0) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700997 return;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -0700998 }
Brian Carlstromf615a612011-07-23 12:50:34 -0700999 DexCache* dex_cache = klass->GetDexCache();
1000 if (dex_cache == NULL) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001001 return;
1002 }
Brian Carlstrom6cc18452011-07-18 15:10:33 -07001003 const StringPiece& descriptor = klass->GetDescriptor();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001004 const DexFile& dex_file = FindDexFile(dex_cache);
1005 const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
Brian Carlstromf615a612011-07-23 12:50:34 -07001006 CHECK(dex_class_def != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001007 const byte* addr = dex_file.GetEncodedArray(*dex_class_def);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001008 size_t array_size = DecodeUnsignedLeb128(&addr);
1009 for (size_t i = 0; i < array_size; ++i) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001010 Field* field = klass->GetStaticField(i);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001011 JValue value;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001012 DexFile::ValueType type = dex_file.ReadEncodedValue(&addr, &value);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001013 switch (type) {
Brian Carlstromf615a612011-07-23 12:50:34 -07001014 case DexFile::kByte:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001015 field->SetByte(value.b);
1016 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001017 case DexFile::kShort:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001018 field->SetShort(value.s);
1019 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001020 case DexFile::kChar:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001021 field->SetChar(value.c);
1022 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001023 case DexFile::kInt:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001024 field->SetInt(value.i);
1025 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001026 case DexFile::kLong:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001027 field->SetLong(value.j);
1028 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001029 case DexFile::kFloat:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001030 field->SetFloat(value.f);
1031 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001032 case DexFile::kDouble:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001033 field->SetDouble(value.d);
1034 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001035 case DexFile::kString: {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001036 uint32_t string_idx = value.i;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001037 String* resolved = ResolveString(klass, string_idx, dex_file);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001038 field->SetObject(resolved);
1039 break;
1040 }
Brian Carlstromf615a612011-07-23 12:50:34 -07001041 case DexFile::kBoolean:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001042 field->SetBoolean(value.z);
1043 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001044 case DexFile::kNull:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001045 field->SetObject(value.l);
1046 break;
1047 default:
Carl Shapiro606258b2011-07-09 16:09:09 -07001048 LOG(FATAL) << "Unknown type " << static_cast<int>(type);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001049 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001050 }
1051}
1052
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001053bool ClassLinker::LinkClass(Class* klass, const DexFile& dex_file) {
1054 CHECK_EQ(Class::kStatusLoaded, klass->status_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001055 if (!LinkSuperClass(klass)) {
1056 return false;
1057 }
1058 if (!LinkMethods(klass)) {
1059 return false;
1060 }
Jesse Wilson7833bd22011-08-09 18:31:44 -04001061 if (!LinkStaticFields(klass)) {
1062 return false;
1063 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001064 if (!LinkInstanceFields(klass)) {
1065 return false;
1066 }
1067 CreateReferenceOffsets(klass);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001068 CHECK_EQ(Class::kStatusLoaded, klass->status_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001069 klass->status_ = Class::kStatusResolved;
1070 return true;
1071}
1072
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001073bool ClassLinker::LoadSuperAndInterfaces(Class* klass, const DexFile& dex_file) {
1074 CHECK_EQ(Class::kStatusIdx, klass->status_);
Brian Carlstromf615a612011-07-23 12:50:34 -07001075 if (klass->super_class_idx_ != DexFile::kDexNoIndex) {
1076 Class* super_class = ResolveClass(klass, klass->super_class_idx_, dex_file);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001077 if (super_class == NULL) {
1078 LG << "Failed to resolve superclass";
1079 return false;
1080 }
1081 klass->super_class_ = super_class; // TODO: write barrier
1082 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001083 if (klass->NumInterfaces() > 0) {
1084 for (size_t i = 0; i < klass->NumInterfaces(); ++i) {
1085 uint32_t idx = klass->interfaces_idx_[i];
1086 klass->SetInterface(i, ResolveClass(klass, idx, dex_file));
1087 if (klass->GetInterface(i) == NULL) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001088 LG << "Failed to resolve interface";
1089 return false;
1090 }
1091 // Verify
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001092 if (!klass->CanAccess(klass->GetInterface(i))) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001093 LG << "Inaccessible interface";
1094 return false;
1095 }
1096 }
1097 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001098 // Mark the class as loaded.
1099 klass->status_ = Class::kStatusLoaded;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001100 return true;
1101}
1102
1103bool ClassLinker::LinkSuperClass(Class* klass) {
1104 CHECK(!klass->IsPrimitive());
1105 const Class* super = klass->GetSuperClass();
1106 if (klass->GetDescriptor() == "Ljava/lang/Object;") {
1107 if (super != NULL) {
1108 LG << "Superclass must not be defined"; // TODO: ClassFormatError
1109 return false;
1110 }
1111 // TODO: clear finalize attribute
1112 return true;
1113 }
1114 if (super == NULL) {
1115 LG << "No superclass defined"; // TODO: LinkageError
1116 return false;
1117 }
1118 // Verify
1119 if (super->IsFinal()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001120 LG << "Superclass " << super->descriptor_ << " is declared final"; // TODO: IncompatibleClassChangeError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001121 return false;
1122 }
1123 if (super->IsInterface()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001124 LG << "Superclass " << super->descriptor_ << " is an interface"; // TODO: IncompatibleClassChangeError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001125 return false;
1126 }
1127 if (!klass->CanAccess(super)) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001128 LG << "Superclass " << super->descriptor_ << " is inaccessible"; // TODO: IllegalAccessError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001129 return false;
1130 }
1131 return true;
1132}
1133
1134// Populate the class vtable and itable.
1135bool ClassLinker::LinkMethods(Class* klass) {
1136 if (klass->IsInterface()) {
1137 // No vtable.
1138 size_t count = klass->NumVirtualMethods();
1139 if (!IsUint(16, count)) {
1140 LG << "Too many methods on interface"; // TODO: VirtualMachineError
1141 return false;
1142 }
Carl Shapiro565f5072011-07-10 13:39:43 -07001143 for (size_t i = 0; i < count; ++i) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001144 klass->GetVirtualMethod(i)->method_index_ = i;
1145 }
1146 } else {
1147 // Link virtual method tables
1148 LinkVirtualMethods(klass);
1149
1150 // Link interface method tables
1151 LinkInterfaceMethods(klass);
1152
1153 // Insert stubs.
1154 LinkAbstractMethods(klass);
1155 }
1156 return true;
1157}
1158
1159bool ClassLinker::LinkVirtualMethods(Class* klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001160 if (klass->HasSuperClass()) {
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001161 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->vtable_->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001162 size_t actual_count = klass->GetSuperClass()->vtable_->GetLength();
1163 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001164 // TODO: do not assign to the vtable field until it is fully constructed.
1165 klass->vtable_ = klass->GetSuperClass()->vtable_->CopyOf(max_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001166 // See if any of our virtual methods override the superclass.
1167 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
1168 Method* local_method = klass->GetVirtualMethod(i);
1169 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001170 for (; j < actual_count; ++j) {
1171 Method* super_method = klass->vtable_->Get(j);
Carl Shapiro8860c0e2011-08-04 17:36:16 -07001172 if (local_method->HasSameNameAndDescriptor(super_method)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001173 // Verify
1174 if (super_method->IsFinal()) {
Brian Carlstrombe977852011-07-19 14:54:54 -07001175 LG << "Method overrides final method"; // TODO: VirtualMachineError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001176 return false;
1177 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001178 klass->vtable_->Set(j, local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001179 local_method->method_index_ = j;
1180 break;
1181 }
1182 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001183 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001184 // Not overriding, append.
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001185 klass->vtable_->Set(actual_count, local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001186 local_method->method_index_ = actual_count;
1187 actual_count += 1;
1188 }
1189 }
1190 if (!IsUint(16, actual_count)) {
1191 LG << "Too many methods defined on class"; // TODO: VirtualMachineError
1192 return false;
1193 }
1194 CHECK_LE(actual_count, max_count);
1195 if (actual_count < max_count) {
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001196 // TODO: do not assign to the vtable field until it is fully constructed.
1197 klass->vtable_ = klass->vtable_->CopyOf(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001198 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001199 } else {
1200 CHECK(klass->GetDescriptor() == "Ljava/lang/Object;");
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001201 uint32_t num_virtual_methods = klass->NumVirtualMethods();
1202 CHECK(klass->GetDescriptor() == "Ljava/lang/Object;");
1203 if (!IsUint(16, num_virtual_methods)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001204 LG << "Too many methods"; // TODO: VirtualMachineError
1205 return false;
1206 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001207 // TODO: do not assign to the vtable field until it is fully constructed.
1208 klass->vtable_ = AllocObjectArray<Method>(num_virtual_methods);
1209 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001210 klass->vtable_->Set(i, klass->GetVirtualMethod(i));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001211 klass->GetVirtualMethod(i)->method_index_ = i & 0xFFFF;
1212 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001213 }
1214 return true;
1215}
1216
1217bool ClassLinker::LinkInterfaceMethods(Class* klass) {
1218 int pool_offset = 0;
1219 int pool_size = 0;
1220 int miranda_count = 0;
1221 int miranda_alloc = 0;
1222 size_t super_ifcount;
1223 if (klass->HasSuperClass()) {
1224 super_ifcount = klass->GetSuperClass()->iftable_count_;
1225 } else {
1226 super_ifcount = 0;
1227 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001228 size_t ifcount = super_ifcount;
1229 ifcount += klass->NumInterfaces();
1230 for (size_t i = 0; i < klass->NumInterfaces(); i++) {
1231 ifcount += klass->GetInterface(i)->iftable_count_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001232 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001233 if (ifcount == 0) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001234 DCHECK(klass->iftable_count_ == 0);
1235 DCHECK(klass->iftable_ == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001236 return true;
1237 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001238 klass->iftable_ = new InterfaceEntry[ifcount * sizeof(InterfaceEntry)];
1239 memset(klass->iftable_, 0x00, sizeof(InterfaceEntry) * ifcount);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001240 if (super_ifcount != 0) {
1241 memcpy(klass->iftable_, klass->GetSuperClass()->iftable_,
1242 sizeof(InterfaceEntry) * super_ifcount);
1243 }
1244 // Flatten the interface inheritance hierarchy.
1245 size_t idx = super_ifcount;
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001246 for (size_t i = 0; i < klass->NumInterfaces(); i++) {
1247 Class* interf = klass->GetInterface(i);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001248 DCHECK(interf != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001249 if (!interf->IsInterface()) {
1250 LG << "Class implements non-interface class"; // TODO: IncompatibleClassChangeError
1251 return false;
1252 }
1253 klass->iftable_[idx++].SetClass(interf);
1254 for (size_t j = 0; j < interf->iftable_count_; j++) {
1255 klass->iftable_[idx++].SetClass(interf->iftable_[j].GetClass());
1256 }
1257 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001258 CHECK_EQ(idx, ifcount);
1259 klass->iftable_count_ = ifcount;
1260 if (klass->IsInterface() || super_ifcount == ifcount) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001261 return true;
1262 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001263 for (size_t i = super_ifcount; i < ifcount; i++) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001264 pool_size += klass->iftable_[i].GetClass()->NumVirtualMethods();
1265 }
1266 if (pool_size == 0) {
1267 return true;
1268 }
1269 klass->ifvi_pool_count_ = pool_size;
1270 klass->ifvi_pool_ = new uint32_t[pool_size];
1271 std::vector<Method*> miranda_list;
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001272 for (size_t i = super_ifcount; i < ifcount; ++i) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001273 klass->iftable_[i].method_index_array_ = klass->ifvi_pool_ + pool_offset;
1274 Class* interface = klass->iftable_[i].GetClass();
1275 pool_offset += interface->NumVirtualMethods(); // end here
1276 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
1277 Method* interface_method = interface->GetVirtualMethod(j);
1278 int k; // must be signed
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001279 for (k = klass->vtable_->GetLength() - 1; k >= 0; --k) {
Carl Shapiro8860c0e2011-08-04 17:36:16 -07001280 Method* vtable_method = klass->vtable_->Get(k);
1281 if (interface_method->HasSameNameAndDescriptor(vtable_method)) {
1282 if (!vtable_method->IsPublic()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001283 LG << "Implementation not public";
1284 return false;
1285 }
1286 klass->iftable_[i].method_index_array_[j] = k;
1287 break;
1288 }
1289 }
1290 if (k < 0) {
1291 if (miranda_count == miranda_alloc) {
1292 miranda_alloc += 8;
1293 if (miranda_list.empty()) {
1294 miranda_list.resize(miranda_alloc);
1295 } else {
1296 miranda_list.resize(miranda_alloc);
1297 }
1298 }
1299 int mir;
1300 for (mir = 0; mir < miranda_count; mir++) {
Carl Shapiro8860c0e2011-08-04 17:36:16 -07001301 Method* miranda_method = miranda_list[mir];
1302 if (miranda_method->HasSameNameAndDescriptor(interface_method)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001303 break;
1304 }
1305 }
1306 // point the interface table at a phantom slot index
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001307 klass->iftable_[i].method_index_array_[j] = klass->vtable_->GetLength() + mir;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001308 if (mir == miranda_count) {
1309 miranda_list[miranda_count++] = interface_method;
1310 }
1311 }
1312 }
1313 }
1314 if (miranda_count != 0) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001315 int old_method_count = klass->NumVirtualMethods();
1316 int new_method_count = old_method_count + miranda_count;
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001317 klass->virtual_methods_ = klass->virtual_methods_->CopyOf(new_method_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001318
1319 CHECK(klass->vtable_ != NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001320 int old_vtable_count = klass->vtable_->GetLength();
1321 int new_vtable_count = old_vtable_count + miranda_count;
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001322 // TODO: do not assign to the vtable field until it is fully constructed.
1323 klass->vtable_ = klass->vtable_->CopyOf(new_vtable_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001324
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001325 for (int i = 0; i < miranda_count; i++) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001326 Method* meth = AllocMethod();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001327 memcpy(meth, miranda_list[i], sizeof(Method));
1328 meth->klass_ = klass;
1329 meth->access_flags_ |= kAccMiranda;
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001330 meth->method_index_ = 0xFFFF & (old_vtable_count + i);
1331 klass->SetVirtualMethod(old_method_count + i, meth);
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001332 klass->vtable_->Set(old_vtable_count + i, meth);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001333 }
1334 }
1335 return true;
1336}
1337
1338void ClassLinker::LinkAbstractMethods(Class* klass) {
1339 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
1340 Method* method = klass->GetVirtualMethod(i);
1341 if (method->IsAbstract()) {
Shih-wei Liao2fb97532011-08-11 16:17:23 -07001342 LG << "AbstractMethodError";
1343 method->code_off_ = 0xFFFFFFFF;
1344 // TODO: throw AbstractMethodError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001345 }
1346 }
1347}
1348
Jesse Wilson7833bd22011-08-09 18:31:44 -04001349// Each static field will be stored in one of three arrays: static_references_,
1350// static_32bit_primitives_, or static_64bit_primitives_. This assigns each
1351// field a slot in its array and create the arrays.
1352bool ClassLinker::LinkStaticFields(Class* klass) {
1353 size_t next_reference_slot = 0;
1354 size_t next_32bit_primitive_slot = 0;
1355 size_t next_64bit_primitive_slot = 0;
1356
1357 for (size_t i = 0; i < klass->NumStaticFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001358 Field* field = klass->GetStaticField(i);
Jesse Wilson7833bd22011-08-09 18:31:44 -04001359 char type = field->GetType();
1360 if (type == '[' || type == 'L') {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001361 field->offset_ = next_reference_slot++;
Jesse Wilson7833bd22011-08-09 18:31:44 -04001362 } else if (type == 'J' || type == 'D') {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001363 field->offset_ = next_64bit_primitive_slot++;
Jesse Wilson7833bd22011-08-09 18:31:44 -04001364 } else {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001365 field->offset_ = next_32bit_primitive_slot++;
Jesse Wilson7833bd22011-08-09 18:31:44 -04001366 }
1367 }
1368
1369 if (next_reference_slot > 0) {
1370 Class* array_class = GetClassRoot(kObjectArrayClass);
1371 klass->static_references_ = ObjectArray<Object>::Alloc(array_class, next_reference_slot);
1372 }
1373 if (next_32bit_primitive_slot > 0) {
1374 Class* array_class = GetClassRoot(kIntArrayClass);
1375 klass->static_32bit_primitives_ = IntArray::Alloc(array_class, next_32bit_primitive_slot);
1376 }
1377 if (next_64bit_primitive_slot > 0) {
1378 Class* array_class = GetClassRoot(kLongArrayClass);
1379 klass->static_64bit_primitives_ = LongArray::Alloc(array_class, next_64bit_primitive_slot);
1380 }
1381
1382 return true;
1383}
1384
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001385bool ClassLinker::LinkInstanceFields(Class* klass) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001386 int field_offset;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001387 if (klass->GetSuperClass() != NULL) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001388 field_offset = klass->GetSuperClass()->object_size_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001389 } else {
Brian Carlstroma0808032011-07-18 00:39:23 -07001390 field_offset = OFFSETOF_MEMBER(DataObject, fields_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001391 }
1392 // Move references to the front.
Carl Shapiro69759ea2011-07-21 18:13:35 -07001393 klass->num_reference_instance_fields_ = 0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001394 size_t i = 0;
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001395 for ( ; i < klass->NumInstanceFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001396 Field* pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001397 char c = pField->GetType();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001398 if (c != '[' && c != 'L') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001399 for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001400 Field* refField = klass->GetInstanceField(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001401 char rc = refField->GetType();
1402 if (rc == '[' || rc == 'L') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001403 klass->SetInstanceField(i, refField);
1404 klass->SetInstanceField(j, pField);
1405 pField = refField;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001406 c = rc;
Carl Shapiro69759ea2011-07-21 18:13:35 -07001407 klass->num_reference_instance_fields_++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001408 break;
1409 }
1410 }
1411 } else {
Carl Shapiro69759ea2011-07-21 18:13:35 -07001412 klass->num_reference_instance_fields_++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001413 }
1414 if (c != '[' && c != 'L') {
1415 break;
1416 }
Brian Carlstroma0808032011-07-18 00:39:23 -07001417 pField->SetOffset(field_offset);
1418 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001419 }
1420
1421 // Now we want to pack all of the double-wide fields together. If
1422 // we're not aligned, though, we want to shuffle one 32-bit field
1423 // into place. If we can't find one, we'll have to pad it.
Brian Carlstroma0808032011-07-18 00:39:23 -07001424 if (i != klass->NumInstanceFields() && (field_offset & 0x04) != 0) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001425 Field* pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001426 char c = pField->GetType();
1427
1428 if (c != 'J' && c != 'D') {
1429 // The field that comes next is 32-bit, so just advance past it.
Brian Carlstrombe977852011-07-19 14:54:54 -07001430 DCHECK(c != '[');
1431 DCHECK(c != 'L');
Brian Carlstroma0808032011-07-18 00:39:23 -07001432 pField->SetOffset(field_offset);
1433 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001434 i++;
1435 } else {
1436 // Next field is 64-bit, so search for a 32-bit field we can
1437 // swap into it.
1438 bool found = false;
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001439 for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001440 Field* singleField = klass->GetInstanceField(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001441 char rc = singleField->GetType();
1442 if (rc != 'J' && rc != 'D') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001443 klass->SetInstanceField(i, singleField);
1444 klass->SetInstanceField(j, pField);
1445 pField = singleField;
Brian Carlstroma0808032011-07-18 00:39:23 -07001446 pField->SetOffset(field_offset);
1447 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001448 found = true;
1449 i++;
1450 break;
1451 }
1452 }
1453 if (!found) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001454 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001455 }
1456 }
1457 }
1458
1459 // Alignment is good, shuffle any double-wide fields forward, and
1460 // finish assigning field offsets to all fields.
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001461 DCHECK(i == klass->NumInstanceFields() || (field_offset & 0x04) == 0);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001462 for ( ; i < klass->NumInstanceFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001463 Field* pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001464 char c = pField->GetType();
1465 if (c != 'D' && c != 'J') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001466 for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001467 Field* doubleField = klass->GetInstanceField(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001468 char rc = doubleField->GetType();
1469 if (rc == 'D' || rc == 'J') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001470 klass->SetInstanceField(i, doubleField);
1471 klass->SetInstanceField(j, pField);
1472 pField = doubleField;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001473 c = rc;
1474 break;
1475 }
1476 }
1477 } else {
1478 // This is a double-wide field, leave it be.
1479 }
1480
Brian Carlstroma0808032011-07-18 00:39:23 -07001481 pField->SetOffset(field_offset);
1482 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001483 if (c == 'J' || c == 'D')
Brian Carlstroma0808032011-07-18 00:39:23 -07001484 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001485 }
1486
1487#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07001488 // Make sure that all reference fields appear before
1489 // non-reference fields, and all double-wide fields are aligned.
1490 bool seen_non_ref = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001491 for (i = 0; i < klass->NumInstanceFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001492 Field *pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001493 char c = pField->GetType();
1494
1495 if (c == 'D' || c == 'J') {
Brian Carlstrombe977852011-07-19 14:54:54 -07001496 DCHECK_EQ(0U, pField->GetOffset() & 0x07);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001497 }
1498
1499 if (c != '[' && c != 'L') {
Brian Carlstrombe977852011-07-19 14:54:54 -07001500 if (!seen_non_ref) {
1501 seen_non_ref = true;
Brian Carlstrom07d579f2011-07-27 13:31:51 -07001502 DCHECK_EQ(klass->NumReferenceInstanceFields(), i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001503 }
Brian Carlstrombe977852011-07-19 14:54:54 -07001504 } else {
1505 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001506 }
1507 }
Brian Carlstrombe977852011-07-19 14:54:54 -07001508 if (!seen_non_ref) {
Brian Carlstrom07d579f2011-07-27 13:31:51 -07001509 DCHECK_EQ(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001510 }
1511#endif
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001512 klass->object_size_ = field_offset;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001513 return true;
1514}
1515
1516// Set the bitmap of reference offsets, refOffsets, from the ifields
1517// list.
1518void ClassLinker::CreateReferenceOffsets(Class* klass) {
1519 uint32_t reference_offsets = 0;
1520 if (klass->HasSuperClass()) {
1521 reference_offsets = klass->GetSuperClass()->GetReferenceOffsets();
1522 }
1523 // If our superclass overflowed, we don't stand a chance.
1524 if (reference_offsets != CLASS_WALK_SUPER) {
1525 // All of the fields that contain object references are guaranteed
1526 // to be at the beginning of the ifields list.
1527 for (size_t i = 0; i < klass->NumReferenceInstanceFields(); ++i) {
1528 // Note that, per the comment on struct InstField, f->byteOffset
1529 // is the offset from the beginning of obj, not the offset into
1530 // obj->instanceData.
Jesse Wilson35baaab2011-08-10 16:18:03 -04001531 const Field* field = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001532 size_t byte_offset = field->GetOffset();
1533 CHECK_GE(byte_offset, CLASS_SMALLEST_OFFSET);
Elliott Hughes1f359b02011-07-17 14:27:17 -07001534 CHECK_EQ(byte_offset & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001535 if (CLASS_CAN_ENCODE_OFFSET(byte_offset)) {
1536 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset);
Elliott Hughes1f359b02011-07-17 14:27:17 -07001537 CHECK_NE(new_bit, 0U);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001538 reference_offsets |= new_bit;
1539 } else {
1540 reference_offsets = CLASS_WALK_SUPER;
1541 break;
1542 }
1543 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001544 }
Brian Carlstromae3ac012011-07-27 01:30:28 -07001545 klass->SetReferenceOffsets(reference_offsets);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001546}
1547
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001548Class* ClassLinker::ResolveClass(const Class* referrer,
1549 uint32_t class_idx,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001550 const DexFile& dex_file) {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001551 DexCache* dex_cache = referrer->GetDexCache();
1552 Class* resolved = dex_cache->GetResolvedClass(class_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001553 if (resolved != NULL) {
1554 return resolved;
1555 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001556 const char* descriptor = dex_file.dexStringByTypeIdx(class_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001557 if (descriptor[0] != '\0' && descriptor[1] == '\0') {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001558 resolved = FindPrimitiveClass(descriptor[0]);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001559 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001560 resolved = FindClass(descriptor, referrer->GetClassLoader());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001561 }
1562 if (resolved != NULL) {
1563 Class* check = resolved->IsArray() ? resolved->component_type_ : resolved;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001564 if (referrer->GetDexCache() != check->GetDexCache()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001565 if (check->GetClassLoader() != NULL) {
1566 LG << "Class resolved by unexpected DEX"; // TODO: IllegalAccessError
1567 return NULL;
1568 }
1569 }
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001570 dex_cache->SetResolvedClass(class_idx, resolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001571 } else {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001572 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001573 }
1574 return resolved;
1575}
1576
1577Method* ResolveMethod(const Class* referrer, uint32_t method_idx,
1578 /*MethodType*/ int method_type) {
1579 CHECK(false);
1580 return NULL;
1581}
1582
Carl Shapiro69759ea2011-07-21 18:13:35 -07001583String* ClassLinker::ResolveString(const Class* referring,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001584 uint32_t string_idx,
1585 const DexFile& dex_file) {
1586 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
1587 int32_t utf16_length = dex_file.GetStringLength(string_id);
1588 const char* utf8_data = dex_file.GetStringData(string_id);
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001589 String* string = intern_table_.Intern(utf16_length, utf8_data);
1590 referring->GetDexCache()->SetResolvedString(string_idx, string);
1591 return string;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001592}
1593
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001594} // namespace art