blob: 50b1a07d58fed4ad562bd14df41f46fefed5c600 [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 Carlstromdb4d5402011-08-09 12:18:28 -070046 // mark as non-primitive for object_array_class
47 java_lang_Object->primitive_type_ = Class::kPrimNot;
Brian Carlstroma0808032011-07-18 00:39:23 -070048
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070049 // object_array_class is for root_classes to provide the storage for these classes
50 Class* object_array_class = AllocClass(java_lang_Class);
51 CHECK(object_array_class != NULL);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070052 object_array_class->descriptor_ = "[Ljava/lang/Object;";
53 object_array_class->component_type_ = java_lang_Object;
Brian Carlstroma0808032011-07-18 00:39:23 -070054
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070055 // String and char[] are necessary so that FindClass can assign names to members
Jesse Wilson14150742011-07-29 19:04:44 -040056 Class* java_lang_String = AllocClass(java_lang_Class);
57 CHECK(java_lang_String != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070058 java_lang_String->descriptor_ = "Ljava/lang/String;";
59 CHECK_LT(java_lang_String->object_size_, sizeof(String));
Jesse Wilson14150742011-07-29 19:04:44 -040060 java_lang_String->object_size_ = sizeof(String);
Jesse Wilson8989d992011-08-02 13:39:42 -070061 Class* char_array_class = AllocClass(java_lang_Class);
62 CHECK(char_array_class != NULL);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070063 char_array_class->descriptor_ = "[C";
Jesse Wilson14150742011-07-29 19:04:44 -040064
Jesse Wilson7833bd22011-08-09 18:31:44 -040065 // int[] and long[] are used for static field storage
66 Class* int_array_class = AllocClass(java_lang_Class);
67 CHECK(int_array_class != NULL);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070068 int_array_class->descriptor_ = "[I";
Jesse Wilson7833bd22011-08-09 18:31:44 -040069 Class* long_array_class = AllocClass(java_lang_Class);
70 CHECK(long_array_class != NULL);
Brian Carlstromdb4d5402011-08-09 12:18:28 -070071 long_array_class->descriptor_ = "[J";
Jesse Wilson7833bd22011-08-09 18:31:44 -040072
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070073 // Field and Method are necessary so that FindClass can link members
74 Class* java_lang_reflect_Field = AllocClass(java_lang_Class);
75 CHECK(java_lang_reflect_Field != NULL);
76 java_lang_reflect_Field->descriptor_ = "Ljava/lang/reflect/Field;";
Jesse Wilson35baaab2011-08-10 16:18:03 -040077 CHECK_LT(java_lang_reflect_Field->object_size_, sizeof(Field));
78 java_lang_reflect_Field->object_size_ = sizeof(Field);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070079 Class* java_lang_reflect_Method = AllocClass(java_lang_Class);
80 java_lang_reflect_Method->descriptor_ = "Ljava/lang/reflect/Method;";
81 CHECK(java_lang_reflect_Method != NULL);
82 CHECK_LT(java_lang_reflect_Method->object_size_, sizeof(Method));
83 java_lang_reflect_Method->object_size_ = sizeof(Method);
84
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070085 // create storage for root classes, save away our work so far
86 class_roots_ = ObjectArray<Class>::Alloc(object_array_class, kClassRootsMax);
87 class_roots_->Set(kJavaLangClass, java_lang_Class);
88 class_roots_->Set(kJavaLangObject, java_lang_Object);
89 class_roots_->Set(kObjectArrayClass, object_array_class);
Jesse Wilson14150742011-07-29 19:04:44 -040090 class_roots_->Set(kJavaLangString, java_lang_String);
Jesse Wilson8989d992011-08-02 13:39:42 -070091 class_roots_->Set(kCharArrayClass, char_array_class);
Jesse Wilson7833bd22011-08-09 18:31:44 -040092 class_roots_->Set(kIntArrayClass, int_array_class);
93 class_roots_->Set(kLongArrayClass, long_array_class);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070094 class_roots_->Set(kJavaLangReflectField, java_lang_reflect_Field);
95 class_roots_->Set(kJavaLangReflectMethod, java_lang_reflect_Method);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -070096 // now that these are registered, we can use AllocClass() and AllocObjectArray
Brian Carlstroma0808032011-07-18 00:39:23 -070097
Jesse Wilson8989d992011-08-02 13:39:42 -070098 String::InitClasses(java_lang_String, char_array_class);
99 // Now AllocString* can be used
100
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700101 // setup boot_class_path_ now that we can use AllocObjectArray to
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700102 // create DexCache instances
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700103 for (size_t i = 0; i != boot_class_path.size(); ++i) {
104 AppendToBootClassPath(boot_class_path[i]);
105 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700106 // now we can use FindSystemClass, at least for non-arrays classes.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700107
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700108 // run Class, Field, and Method through FindSystemClass.
109 // this initializes their dex_cache_ fields and register them in classes_.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700110 // we also override their object_size_ values to accommodate the extra C++ fields.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700111 Class* Class_class = FindSystemClass(java_lang_Class->GetDescriptor());
112 CHECK_EQ(java_lang_Class, Class_class);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700113 CHECK_LT(java_lang_Class->object_size_, sizeof(Class));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700114 java_lang_Class->object_size_ = sizeof(Class);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700115 Class* Field_class = FindSystemClass(java_lang_reflect_Field->GetDescriptor());
116 CHECK_EQ(java_lang_reflect_Field, Field_class);
Jesse Wilson35baaab2011-08-10 16:18:03 -0400117 CHECK_LT(java_lang_reflect_Field->object_size_, sizeof(Field));
118 java_lang_reflect_Field->object_size_ = sizeof(Field);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700119 Class* Method_class = FindSystemClass(java_lang_reflect_Method->GetDescriptor());
120 CHECK_EQ(java_lang_reflect_Method, Method_class);
121 CHECK_LT(java_lang_reflect_Method->object_size_, sizeof(Method));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700122 java_lang_reflect_Method->object_size_ = sizeof(Method);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700123
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700124 // Object and String just need more minimal setup, since they do not have extra C++ fields.
125 Class* Object_class = FindSystemClass(java_lang_Object->GetDescriptor());
126 CHECK_EQ(java_lang_Object, Object_class);
127 CHECK_EQ(java_lang_Object->object_size_, sizeof(Object));
128 Class* String_class = FindSystemClass(java_lang_String->GetDescriptor());
Jesse Wilsonf7e85a52011-08-01 18:45:58 -0700129 CHECK_EQ(java_lang_String, String_class);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700130 CHECK_EQ(java_lang_String->object_size_, sizeof(String));
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700131
132 // Setup the ClassLoaders, adjusting the object_size_ as necessary
133 Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
134 CHECK(java_lang_ClassLoader != NULL);
135 CHECK_LT(java_lang_ClassLoader->object_size_, sizeof(ClassLoader));
136 java_lang_ClassLoader->object_size_ = sizeof(ClassLoader);
137 class_roots_->Set(kJavaLangClassLoader, java_lang_ClassLoader);
138 Class* dalvik_system_BaseDexClassLoader = FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
139 CHECK(dalvik_system_BaseDexClassLoader != NULL);
140 CHECK_EQ(dalvik_system_BaseDexClassLoader->object_size_, sizeof(BaseDexClassLoader));
141 class_roots_->Set(kDalvikSystemBaseDexClassLoader, dalvik_system_BaseDexClassLoader);
142 Class* dalvik_system_PathClassLoader = FindSystemClass("Ldalvik/system/PathClassLoader;");
143 CHECK(dalvik_system_PathClassLoader != NULL);
144 CHECK_EQ(dalvik_system_PathClassLoader->object_size_, sizeof(PathClassLoader));
145 class_roots_->Set(kDalvikSystemPathClassLoader, dalvik_system_PathClassLoader);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700146
147 // Setup a single, global copy of "interfaces" and "iftable" for
148 // reuse across array classes
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700149 Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700150 CHECK(java_lang_Cloneable != NULL);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700151 Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700152 CHECK(java_io_Serializable != NULL);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700153
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700154 array_interfaces_ = AllocObjectArray<Class>(2);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700155 CHECK(array_interfaces_ != NULL);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700156 array_interfaces_->Set(0, java_lang_Cloneable);
157 array_interfaces_->Set(1, java_io_Serializable);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700158
159 // We assume that Cloneable/Serializable don't have superinterfaces --
160 // normally we'd have to crawl up and explicitly list all of the
161 // supers as well. These interfaces don't have any methods, so we
162 // don't have to worry about the ifviPool either.
163 array_iftable_ = new InterfaceEntry[2];
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700164 array_iftable_[0].SetClass(array_interfaces_->Get(0));
165 array_iftable_[1].SetClass(array_interfaces_->Get(1));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700166 // now FindClass can be used for non-primitive array classes
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700167
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700168 // run Object[] through FindClass to complete initialization
Jesse Wilson8989d992011-08-02 13:39:42 -0700169 Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
170 CHECK_EQ(object_array_class, found_object_array_class);
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700171 CHECK_EQ(java_lang_Cloneable, object_array_class->GetInterface(0));
172 CHECK_EQ(java_io_Serializable, object_array_class->GetInterface(1));
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700173
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700174 // Setup the primitive type classes.
175 class_roots_->Set(kPrimitiveByte, CreatePrimitiveClass("B"));
176 class_roots_->Set(kPrimitiveChar, CreatePrimitiveClass("C"));
177 class_roots_->Set(kPrimitiveDouble, CreatePrimitiveClass("D"));
178 class_roots_->Set(kPrimitiveFloat, CreatePrimitiveClass("F"));
179 class_roots_->Set(kPrimitiveInt, CreatePrimitiveClass("I"));
180 class_roots_->Set(kPrimitiveLong, CreatePrimitiveClass("J"));
181 class_roots_->Set(kPrimitiveShort, CreatePrimitiveClass("S"));
182 class_roots_->Set(kPrimitiveBoolean, CreatePrimitiveClass("Z"));
183 class_roots_->Set(kPrimitiveVoid, CreatePrimitiveClass("V"));
184 // now we can use FindSystemClass for anything, including for "[C"
185
Jesse Wilson7833bd22011-08-09 18:31:44 -0400186 // run char[], int[] and long[] through FindClass to complete initialization
Jesse Wilson8989d992011-08-02 13:39:42 -0700187 Class* found_char_array_class = FindSystemClass("[C");
188 CHECK_EQ(char_array_class, found_char_array_class);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400189 Class* found_int_array_class = FindSystemClass("[I");
190 CHECK_EQ(int_array_class, found_int_array_class);
191 Class* found_long_array_class = FindSystemClass("[J");
192 CHECK_EQ(long_array_class, found_long_array_class);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700193
194 // ensure all class_roots_ were initialized
195 for (size_t i = 0; i < kClassRootsMax; i++) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700196 CHECK(GetClassRoot(static_cast<ClassRoot>(i)));
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700197 }
198
199 // disable the slow paths in FindClass and CreatePrimitiveClass now
200 // that Object, Class, and Object[] are setup
201 init_done_ = true;
202}
203
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700204void ClassLinker::VisitRoots(Heap::RootVistor* root_visitor, void* arg) {
Brian Carlstromb88e9442011-07-28 15:15:51 -0700205 root_visitor(class_roots_, arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700206
207 for (size_t i = 0; i < dex_caches_.size(); i++) {
Brian Carlstromb88e9442011-07-28 15:15:51 -0700208 root_visitor(dex_caches_[i], arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700209 }
210
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700211 {
212 MutexLock mu(classes_lock_);
213 typedef Table::const_iterator It; // TODO: C++0x auto
214 for (It it = classes_.begin(), end = classes_.end(); it != end; ++it) {
215 root_visitor(it->second, arg);
216 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700217 }
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700218
219 intern_table_.VisitRoots(root_visitor, arg);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700220
Brian Carlstromb88e9442011-07-28 15:15:51 -0700221 root_visitor(array_interfaces_, arg);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700222}
223
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700224DexCache* ClassLinker::AllocDexCache() {
Brian Carlstroma40f9bc2011-07-26 21:26:07 -0700225 return down_cast<DexCache*>(AllocObjectArray<Object>(DexCache::kMax));
Brian Carlstroma0808032011-07-18 00:39:23 -0700226}
227
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700228Class* ClassLinker::AllocClass(Class* java_lang_Class) {
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700229 return java_lang_Class->NewInstance()->AsClass();
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700230}
231
232Class* ClassLinker::AllocClass() {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700233 return AllocClass(GetClassRoot(kJavaLangClass));
Brian Carlstroma0808032011-07-18 00:39:23 -0700234}
235
Jesse Wilson35baaab2011-08-10 16:18:03 -0400236Field* ClassLinker::AllocField() {
237 return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->NewInstance());
Brian Carlstroma0808032011-07-18 00:39:23 -0700238}
239
240Method* ClassLinker::AllocMethod() {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700241 return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->NewInstance());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700242}
243
244// TODO remove once we can use java.lang.Class.getSystemClassLoader
245PathClassLoader* ClassLinker::AllocPathClassLoader(std::vector<const DexFile*> dex_files) {
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700246 PathClassLoader* cl = down_cast<PathClassLoader*>(GetClassRoot(kDalvikSystemPathClassLoader)->NewInstance());
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700247 cl->SetClassPath(dex_files);
248 return cl;
Carl Shapiro565f5072011-07-10 13:39:43 -0700249}
250
Brian Carlstrom6cc18452011-07-18 15:10:33 -0700251Class* ClassLinker::FindClass(const StringPiece& descriptor,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700252 ClassLoader* class_loader) {
253 // TODO remove this contrived parent class loader check when we have a real ClassLoader.
254 if (class_loader != NULL) {
255 Class* klass = FindClass(descriptor, NULL);
256 if (klass != NULL) {
257 return klass;
258 }
259 }
260
Carl Shapirob5573532011-07-12 18:22:59 -0700261 Thread* self = Thread::Current();
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700262 DCHECK(self != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700263 CHECK(!self->IsExceptionPending());
264 // Find the class in the loaded classes table.
265 Class* klass = LookupClass(descriptor, class_loader);
266 if (klass == NULL) {
267 // Class is not yet loaded.
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700268 if (descriptor[0] == '[') {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700269 return CreateArrayClass(descriptor, class_loader);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700270 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700271 DexFile::ClassPath& class_path = ((class_loader != NULL) ? class_loader->GetClassPath() : boot_class_path_);
272 DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700273 if (pair.second == NULL) {
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700274 LG << "Class " << PrintableString(descriptor) << " not found in class loader " << class_loader; // TODO: NoClassDefFoundError
Brian Carlstrom6cc18452011-07-18 15:10:33 -0700275 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700276 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700277 const DexFile& dex_file = *pair.first;
278 const DexFile::ClassDef& dex_class_def = *pair.second;
279 DexCache* dex_cache = FindDexCache(pair.first);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700280 // Load the class from the dex file.
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700281 if (!init_done_) {
282 // finish up init of hand crafted class_roots_
283 if (descriptor == "Ljava/lang/Object;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700284 klass = GetClassRoot(kJavaLangObject);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700285 } else if (descriptor == "Ljava/lang/Class;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700286 klass = GetClassRoot(kJavaLangClass);
Jesse Wilson14150742011-07-29 19:04:44 -0400287 } else if (descriptor == "Ljava/lang/String;") {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700288 klass = GetClassRoot(kJavaLangString);
289 } else if (descriptor == "Ljava/lang/reflect/Field;") {
290 klass = GetClassRoot(kJavaLangReflectField);
291 } else if (descriptor == "Ljava/lang/reflect/Method;") {
292 klass = GetClassRoot(kJavaLangReflectMethod);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700293 } else {
294 klass = AllocClass();
295 }
Carl Shapiro565f5072011-07-10 13:39:43 -0700296 } else {
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700297 klass = AllocClass();
Carl Shapiro565f5072011-07-10 13:39:43 -0700298 }
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700299 klass->dex_cache_ = dex_cache;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700300 LoadClass(dex_file, dex_class_def, klass, class_loader);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700301 // Check for a pending exception during load
302 if (self->IsExceptionPending()) {
303 // TODO: free native allocations in klass
304 return NULL;
305 }
306 {
307 ObjectLock lock(klass);
Carl Shapirob5573532011-07-12 18:22:59 -0700308 klass->clinit_thread_id_ = self->GetId();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700309 // Add the newly loaded class to the loaded classes table.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700310 bool success = InsertClass(klass); // TODO just return collision
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700311 if (!success) {
312 // We may fail to insert if we raced with another thread.
313 klass->clinit_thread_id_ = 0;
314 // TODO: free native allocations in klass
315 klass = LookupClass(descriptor, class_loader);
316 CHECK(klass != NULL);
317 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700318 // Finish loading (if necessary) by finding parents
319 if (!klass->IsLoaded() && !LoadSuperAndInterfaces(klass, dex_file)) {
320 // Loading failed.
321 // TODO: CHECK(self->IsExceptionPending());
322 lock.NotifyAll();
323 return NULL;
324 }
325 CHECK(klass->IsLoaded());
326 // Link the class (if necessary)
327 if (!klass->IsLinked() && !LinkClass(klass, dex_file)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700328 // Linking failed.
329 // TODO: CHECK(self->IsExceptionPending());
330 lock.NotifyAll();
331 return NULL;
332 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700333 CHECK(klass->IsLinked());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700334 }
335 }
336 }
337 // Link the class if it has not already been linked.
338 if (!klass->IsLinked() && !klass->IsErroneous()) {
339 ObjectLock lock(klass);
340 // Check for circular dependencies between classes.
Carl Shapirob5573532011-07-12 18:22:59 -0700341 if (!klass->IsLinked() && klass->clinit_thread_id_ == self->GetId()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700342 LG << "Recursive link"; // TODO: ClassCircularityError
343 return NULL;
344 }
345 // Wait for the pending initialization to complete.
346 while (!klass->IsLinked() && !klass->IsErroneous()) {
347 lock.Wait();
348 }
349 }
350 if (klass->IsErroneous()) {
351 LG << "EarlierClassFailure"; // TODO: EarlierClassFailure
352 return NULL;
353 }
354 // Return the loaded class. No exceptions should be pending.
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700355 CHECK(klass->IsLinked());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700356 CHECK(!self->IsExceptionPending());
357 return klass;
358}
359
Brian Carlstromf615a612011-07-23 12:50:34 -0700360void ClassLinker::LoadClass(const DexFile& dex_file,
361 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700362 Class* klass,
363 ClassLoader* class_loader) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700364 CHECK(klass != NULL);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700365 CHECK(klass->dex_cache_ != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700366 CHECK_EQ(Class::kStatusNotReady, klass->status_);
Brian Carlstromf615a612011-07-23 12:50:34 -0700367 const byte* class_data = dex_file.GetClassData(dex_class_def);
368 DexFile::ClassDataHeader header = dex_file.ReadClassDataHeader(&class_data);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700369
Brian Carlstromf615a612011-07-23 12:50:34 -0700370 const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700371 CHECK(descriptor != NULL);
372
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700373 klass->klass_ = GetClassRoot(kJavaLangClass);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700374 klass->descriptor_.set(descriptor);
375 klass->descriptor_alloc_ = NULL;
Brian Carlstromf615a612011-07-23 12:50:34 -0700376 klass->access_flags_ = dex_class_def.access_flags_;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700377 klass->class_loader_ = class_loader;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700378 klass->primitive_type_ = Class::kPrimNot;
379 klass->status_ = Class::kStatusIdx;
380
381 klass->super_class_ = NULL;
Brian Carlstromf615a612011-07-23 12:50:34 -0700382 klass->super_class_idx_ = dex_class_def.superclass_idx_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700383
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700384 size_t num_static_fields = header.static_fields_size_;
385 size_t num_instance_fields = header.instance_fields_size_;
386 size_t num_direct_methods = header.direct_methods_size_;
387 size_t num_virtual_methods = header.virtual_methods_size_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700388
Brian Carlstromf615a612011-07-23 12:50:34 -0700389 klass->source_file_ = dex_file.dexGetSourceFile(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700390
391 // Load class interfaces.
Brian Carlstromf615a612011-07-23 12:50:34 -0700392 LoadInterfaces(dex_file, dex_class_def, klass);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700393
394 // Load static fields.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700395 DCHECK(klass->sfields_ == NULL);
396 if (num_static_fields != 0) {
Jesse Wilson35baaab2011-08-10 16:18:03 -0400397 klass->sfields_ = AllocObjectArray<Field>(num_static_fields);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700398 uint32_t last_idx = 0;
Carl Shapiro69759ea2011-07-21 18:13:35 -0700399 for (size_t i = 0; i < klass->NumStaticFields(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700400 DexFile::Field dex_field;
401 dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
Jesse Wilson35baaab2011-08-10 16:18:03 -0400402 Field* sfield = AllocField();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700403 klass->SetStaticField(i, sfield);
Brian Carlstromf615a612011-07-23 12:50:34 -0700404 LoadField(dex_file, dex_field, klass, sfield);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700405 }
406 }
407
408 // Load instance fields.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700409 DCHECK(klass->ifields_ == NULL);
410 if (num_instance_fields != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700411 // TODO: allocate on the object heap.
Jesse Wilson35baaab2011-08-10 16:18:03 -0400412 klass->ifields_ = AllocObjectArray<Field>(num_instance_fields);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700413 uint32_t last_idx = 0;
414 for (size_t i = 0; i < klass->NumInstanceFields(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700415 DexFile::Field dex_field;
416 dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
Jesse Wilson35baaab2011-08-10 16:18:03 -0400417 Field* ifield = AllocField();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700418 klass->SetInstanceField(i, ifield);
Brian Carlstromf615a612011-07-23 12:50:34 -0700419 LoadField(dex_file, dex_field, klass, ifield);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700420 }
421 }
422
423 // Load direct methods.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700424 DCHECK(klass->direct_methods_ == NULL);
425 if (num_direct_methods != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700426 // TODO: append direct methods to class object
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700427 klass->direct_methods_ = AllocObjectArray<Method>(num_direct_methods);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700428 uint32_t last_idx = 0;
429 for (size_t i = 0; i < klass->NumDirectMethods(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700430 DexFile::Method dex_method;
431 dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
Brian Carlstroma0808032011-07-18 00:39:23 -0700432 Method* meth = AllocMethod();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700433 klass->SetDirectMethod(i, meth);
Brian Carlstromf615a612011-07-23 12:50:34 -0700434 LoadMethod(dex_file, dex_method, klass, meth);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700435 // TODO: register maps
436 }
437 }
438
439 // Load virtual methods.
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700440 DCHECK(klass->virtual_methods_ == NULL);
441 if (num_virtual_methods != 0) {
Brian Carlstrom934486c2011-07-12 23:42:50 -0700442 // TODO: append virtual methods to class object
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700443 klass->virtual_methods_ = AllocObjectArray<Method>(num_virtual_methods);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700444 uint32_t last_idx = 0;
445 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700446 DexFile::Method dex_method;
447 dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
Brian Carlstroma0808032011-07-18 00:39:23 -0700448 Method* meth = AllocMethod();
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700449 klass->SetVirtualMethod(i, meth);
Brian Carlstromf615a612011-07-23 12:50:34 -0700450 LoadMethod(dex_file, dex_method, klass, meth);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700451 // TODO: register maps
452 }
453 }
Brian Carlstrom934486c2011-07-12 23:42:50 -0700454}
455
Brian Carlstromf615a612011-07-23 12:50:34 -0700456void ClassLinker::LoadInterfaces(const DexFile& dex_file,
457 const DexFile::ClassDef& dex_class_def,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700458 Class* klass) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700459 const DexFile::TypeList* list = dex_file.GetInterfacesList(dex_class_def);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700460 if (list != NULL) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700461 DCHECK(klass->interfaces_ == NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700462 klass->interfaces_ = AllocObjectArray<Class>(list->Size());
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700463 DCHECK(klass->interfaces_idx_ == NULL);
464 klass->interfaces_idx_ = new uint32_t[list->Size()];
Brian Carlstrom934486c2011-07-12 23:42:50 -0700465 for (size_t i = 0; i < list->Size(); ++i) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700466 const DexFile::TypeItem& type_item = list->GetTypeItem(i);
Brian Carlstrom913af1b2011-07-23 21:41:13 -0700467 klass->interfaces_idx_[i] = type_item.type_idx_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700468 }
469 }
470}
471
Brian Carlstromf615a612011-07-23 12:50:34 -0700472void ClassLinker::LoadField(const DexFile& dex_file,
473 const DexFile::Field& src,
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700474 Class* klass,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700475 Field* dst) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700476 const DexFile::FieldId& field_id = dex_file.GetFieldId(src.field_idx_);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400477 dst->declaring_class_ = klass;
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700478 dst->name_ = ResolveString(klass, field_id.name_idx_, dex_file);
Brian Carlstromae3ac012011-07-27 01:30:28 -0700479 dst->descriptor_.set(dex_file.dexStringByTypeIdx(field_id.type_idx_));
Jesse Wilson35baaab2011-08-10 16:18:03 -0400480 // TODO: Assign dst->type_.
Brian Carlstrom934486c2011-07-12 23:42:50 -0700481 dst->access_flags_ = src.access_flags_;
482}
483
Brian Carlstromf615a612011-07-23 12:50:34 -0700484void ClassLinker::LoadMethod(const DexFile& dex_file,
485 const DexFile::Method& src,
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700486 Class* klass,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700487 Method* dst) {
Brian Carlstromf615a612011-07-23 12:50:34 -0700488 const DexFile::MethodId& method_id = dex_file.GetMethodId(src.method_idx_);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400489 dst->declaring_class_ = klass;
Jesse Wilsonfd687c52011-08-04 19:27:35 -0700490 dst->name_ = ResolveString(klass, method_id.name_idx_, dex_file);
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700491 {
492 int32_t utf16_length;
Elliott Hughes40ef99e2011-08-11 17:44:34 -0700493 scoped_array<char> utf8(dex_file.CreateMethodDescriptor(method_id.proto_idx_,
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700494 &utf16_length));
495 dst->descriptor_ = String::AllocFromModifiedUtf8(utf16_length, utf8.get());
496 }
Brian Carlstrom934486c2011-07-12 23:42:50 -0700497 dst->proto_idx_ = method_id.proto_idx_;
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700498 dst->code_off_ = src.code_off_;
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700499 dst->shorty_ = dex_file.GetShorty(method_id.proto_idx_);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700500 dst->access_flags_ = src.access_flags_;
501
502 // TODO: check for finalize method
503
Brian Carlstromf615a612011-07-23 12:50:34 -0700504 const DexFile::CodeItem* code_item = dex_file.GetCodeItem(src);
Brian Carlstrom934486c2011-07-12 23:42:50 -0700505 if (code_item != NULL) {
506 dst->num_registers_ = code_item->registers_size_;
507 dst->num_ins_ = code_item->ins_size_;
508 dst->num_outs_ = code_item->outs_size_;
Brian Carlstrom934486c2011-07-12 23:42:50 -0700509 } else {
510 uint16_t num_args = dst->NumArgRegisters();
511 if (!dst->IsStatic()) {
512 ++num_args;
513 }
514 dst->num_registers_ = dst->num_ins_ + num_args;
515 // TODO: native methods
516 }
517}
518
Brian Carlstromf615a612011-07-23 12:50:34 -0700519void ClassLinker::AppendToBootClassPath(DexFile* dex_file) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700520 CHECK(dex_file != NULL);
Brian Carlstromf615a612011-07-23 12:50:34 -0700521 boot_class_path_.push_back(dex_file);
522 RegisterDexFile(dex_file);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700523}
524
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700525void ClassLinker::RegisterDexFile(const DexFile* dex_file) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700526 CHECK(dex_file != NULL);
Brian Carlstromf615a612011-07-23 12:50:34 -0700527 dex_files_.push_back(dex_file);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700528 DexCache* dex_cache = AllocDexCache();
529 CHECK(dex_cache != NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700530 dex_cache->Init(AllocObjectArray<String>(dex_file->NumStringIds()),
531 AllocObjectArray<Class>(dex_file->NumTypeIds()),
532 AllocObjectArray<Method>(dex_file->NumMethodIds()),
533 AllocObjectArray<Field>(dex_file->NumFieldIds()));
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700534 dex_caches_.push_back(dex_cache);
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700535}
536
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700537const DexFile& ClassLinker::FindDexFile(const DexCache* dex_cache) const {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700538 for (size_t i = 0; i != dex_caches_.size(); ++i) {
539 if (dex_caches_[i] == dex_cache) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700540 return *dex_files_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700541 }
542 }
Brian Carlstromf615a612011-07-23 12:50:34 -0700543 CHECK(false) << "Could not find DexFile";
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700544 return *dex_files_[-1];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700545}
546
Brian Carlstromf615a612011-07-23 12:50:34 -0700547DexCache* ClassLinker::FindDexCache(const DexFile* dex_file) const {
Brian Carlstromf615a612011-07-23 12:50:34 -0700548 for (size_t i = 0; i != dex_files_.size(); ++i) {
549 if (dex_files_[i] == dex_file) {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700550 return dex_caches_[i];
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700551 }
552 }
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700553 CHECK(false) << "Could not find DexCache";
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700554 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700555}
556
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700557Class* ClassLinker::CreatePrimitiveClass(const StringPiece& descriptor) {
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700558 Class* klass = AllocClass();
Carl Shapiro565f5072011-07-10 13:39:43 -0700559 CHECK(klass != NULL);
Brian Carlstroma0808032011-07-18 00:39:23 -0700560 klass->super_class_ = NULL;
Carl Shapiro565f5072011-07-10 13:39:43 -0700561 klass->access_flags_ = kAccPublic | kAccFinal | kAccAbstract;
562 klass->descriptor_ = descriptor;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700563 klass->descriptor_alloc_ = NULL;
Carl Shapiro565f5072011-07-10 13:39:43 -0700564 klass->status_ = Class::kStatusInitialized;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700565 bool success = InsertClass(klass);
Brian Carlstrom75cb3b42011-07-28 02:13:36 -0700566 CHECK(success) << "CreatePrimitiveClass(" << descriptor << ") failed";
Carl Shapiro565f5072011-07-10 13:39:43 -0700567 return klass;
568}
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700569
Brian Carlstrombe977852011-07-19 14:54:54 -0700570// Create an array class (i.e. the class object for the array, not the
571// array itself). "descriptor" looks like "[C" or "[[[[B" or
572// "[Ljava/lang/String;".
573//
574// If "descriptor" refers to an array of primitives, look up the
575// primitive type's internally-generated class object.
576//
577// "loader" is the class loader of the class that's referring to us. It's
578// used to ensure that we're looking for the element type in the right
579// context. It does NOT become the class loader for the array class; that
580// always comes from the base element class.
581//
582// Returns NULL with an exception raised on failure.
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700583Class* ClassLinker::CreateArrayClass(const StringPiece& descriptor,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700584 ClassLoader* class_loader)
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700585{
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700586 CHECK(descriptor[0] == '[');
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700587
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700588 // Identify the underlying element class and the array dimension depth.
589 Class* component_type_ = NULL;
590 int array_rank;
591 if (descriptor[1] == '[') {
592 // array of arrays; keep descriptor and grab stuff from parent
593 Class* outer = FindClass(descriptor.substr(1), class_loader);
594 if (outer != NULL) {
595 // want the base class, not "outer", in our component_type_
596 component_type_ = outer->component_type_;
597 array_rank = outer->array_rank_ + 1;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700598 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700599 DCHECK(component_type_ == NULL); // make sure we fail
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700600 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700601 } else {
602 array_rank = 1;
603 if (descriptor[1] == 'L') {
604 // array of objects; strip off "[" and look up descriptor.
605 const StringPiece subDescriptor = descriptor.substr(1);
606 component_type_ = FindClass(subDescriptor, class_loader);
607 } else {
608 // array of a primitive type
609 component_type_ = FindPrimitiveClass(descriptor[1]);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700610 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700611 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700612
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700613 if (component_type_ == NULL) {
614 // failed
615 // DCHECK(Thread::Current()->IsExceptionPending()); // TODO
616 return NULL;
617 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700618
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700619 // See if the component type is already loaded. Array classes are
620 // always associated with the class loader of their underlying
621 // element type -- an array of Strings goes with the loader for
622 // java/lang/String -- so we need to look for it there. (The
623 // caller should have checked for the existence of the class
624 // before calling here, but they did so with *their* class loader,
625 // not the component type's loader.)
626 //
627 // If we find it, the caller adds "loader" to the class' initiating
628 // loader list, which should prevent us from going through this again.
629 //
630 // This call is unnecessary if "loader" and "component_type_->class_loader_"
631 // are the same, because our caller (FindClass) just did the
632 // lookup. (Even if we get this wrong we still have correct behavior,
633 // because we effectively do this lookup again when we add the new
634 // class to the hash table --- necessary because of possible races with
635 // other threads.)
636 if (class_loader != component_type_->class_loader_) {
637 Class* new_class = LookupClass(descriptor, component_type_->class_loader_);
638 if (new_class != NULL) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700639 return new_class;
640 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700641 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700642
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700643 // Fill out the fields in the Class.
644 //
645 // It is possible to execute some methods against arrays, because
646 // all arrays are subclasses of java_lang_Object_, so we need to set
647 // up a vtable. We can just point at the one in java_lang_Object_.
648 //
649 // Array classes are simple enough that we don't need to do a full
650 // link step.
651
652 Class* new_class = NULL;
653 if (!init_done_) {
654 if (descriptor == "[Ljava/lang/Object;") {
655 new_class = GetClassRoot(kObjectArrayClass);
656 } else if (descriptor == "[C") {
657 new_class = GetClassRoot(kCharArrayClass);
Jesse Wilson7833bd22011-08-09 18:31:44 -0400658 } else if (descriptor == "[I") {
659 new_class = GetClassRoot(kIntArrayClass);
660 } else if (descriptor == "[J") {
661 new_class = GetClassRoot(kLongArrayClass);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700662 }
663 }
664 if (new_class == NULL) {
665 new_class = AllocClass();
666 if (new_class == NULL) {
667 return NULL;
668 }
669 }
670 new_class->descriptor_alloc_ = new std::string(descriptor.data(),
671 descriptor.size());
672 new_class->descriptor_.set(new_class->descriptor_alloc_->data(),
673 new_class->descriptor_alloc_->size());
674 Class* java_lang_Object = GetClassRoot(kJavaLangObject);
675 new_class->super_class_ = java_lang_Object;
676 new_class->vtable_ = java_lang_Object->vtable_;
677 new_class->primitive_type_ = Class::kPrimNot;
678 new_class->component_type_ = component_type_;
679 new_class->class_loader_ = component_type_->class_loader_;
680 new_class->array_rank_ = array_rank;
681 new_class->status_ = Class::kStatusInitialized;
682 // don't need to set new_class->object_size_
683
684
685 // All arrays have java/lang/Cloneable and java/io/Serializable as
686 // interfaces. We need to set that up here, so that stuff like
687 // "instanceof" works right.
688 //
689 // Note: The GC could run during the call to FindSystemClass,
690 // so we need to make sure the class object is GC-valid while we're in
691 // there. Do this by clearing the interface list so the GC will just
692 // think that the entries are null.
693
694
695 // Use the single, global copies of "interfaces" and "iftable"
696 // (remember not to free them for arrays).
697 DCHECK(array_interfaces_ != NULL);
698 new_class->interfaces_ = array_interfaces_;
699 new_class->iftable_count_ = 2;
700 DCHECK(array_iftable_ != NULL);
701 new_class->iftable_ = array_iftable_;
702
703 // Inherit access flags from the component type. Arrays can't be
704 // used as a superclass or interface, so we want to add "final"
705 // and remove "interface".
706 //
707 // Don't inherit any non-standard flags (e.g., kAccFinal)
708 // from component_type_. We assume that the array class does not
709 // override finalize().
710 new_class->access_flags_ = ((new_class->component_type_->access_flags_ &
711 ~kAccInterface) | kAccFinal) & kAccJavaFlagsMask;
712
713 if (InsertClass(new_class)) {
714 return new_class;
715 }
716 // Another thread must have loaded the class after we
717 // started but before we finished. Abandon what we've
718 // done.
719 //
720 // (Yes, this happens.)
721
722 // Grab the winning class.
723 Class* other_class = LookupClass(descriptor, component_type_->class_loader_);
724 DCHECK(other_class != NULL);
725 return other_class;
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700726}
727
728Class* ClassLinker::FindPrimitiveClass(char type) {
Carl Shapiro565f5072011-07-10 13:39:43 -0700729 switch (type) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700730 case 'B':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700731 return GetClassRoot(kPrimitiveByte);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700732 case 'C':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700733 return GetClassRoot(kPrimitiveChar);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700734 case 'D':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700735 return GetClassRoot(kPrimitiveDouble);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700736 case 'F':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700737 return GetClassRoot(kPrimitiveFloat);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700738 case 'I':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700739 return GetClassRoot(kPrimitiveInt);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700740 case 'J':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700741 return GetClassRoot(kPrimitiveLong);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700742 case 'S':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700743 return GetClassRoot(kPrimitiveShort);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700744 case 'Z':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700745 return GetClassRoot(kPrimitiveBoolean);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700746 case 'V':
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700747 return GetClassRoot(kPrimitiveVoid);
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700748 case 'L':
749 case '[':
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700750 LOG(ERROR) << "Not a primitive type " << PrintableChar(type);
Carl Shapiro565f5072011-07-10 13:39:43 -0700751 default:
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700752 LOG(ERROR) << "Unknown primitive type " << PrintableChar(type);
Carl Shapiro744ad052011-08-06 15:53:36 -0700753 }
Carl Shapiro565f5072011-07-10 13:39:43 -0700754 return NULL; // Not reachable.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700755}
756
757bool ClassLinker::InsertClass(Class* klass) {
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700758 MutexLock mu(classes_lock_);
Brian Carlstrom6cc18452011-07-18 15:10:33 -0700759 const StringPiece& key = klass->GetDescriptor();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700760 Table::iterator it = classes_.insert(std::make_pair(key, klass));
761 return ((*it).second == klass);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700762}
763
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700764Class* ClassLinker::LookupClass(const StringPiece& descriptor, ClassLoader* class_loader) {
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700765 MutexLock mu(classes_lock_);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700766 typedef Table::const_iterator It; // TODO: C++0x auto
767 for (It it = classes_.find(descriptor), end = classes_.end(); it != end; ++it) {
768 Class* klass = it->second;
769 if (klass->descriptor_ == descriptor && klass->class_loader_ == class_loader) {
770 return klass;
771 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700772 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700773 return NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700774}
775
776bool ClassLinker::InitializeClass(Class* klass) {
777 CHECK(klass->GetStatus() == Class::kStatusResolved ||
778 klass->GetStatus() == Class::kStatusError);
779
Carl Shapirob5573532011-07-12 18:22:59 -0700780 Thread* self = Thread::Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700781
782 {
783 ObjectLock lock(klass);
784
785 if (klass->GetStatus() < Class::kStatusVerified) {
786 if (klass->IsErroneous()) {
787 LG << "re-initializing failed class"; // TODO: throw
788 return false;
789 }
790
791 CHECK(klass->GetStatus() == Class::kStatusResolved);
792
793 klass->status_ = Class::kStatusVerifying;
794 if (!DexVerify::VerifyClass(klass)) {
795 LG << "Verification failed"; // TODO: ThrowVerifyError
796 Object* exception = self->GetException();
Brian Carlstromf7ed11a2011-08-09 17:55:51 -0700797 klass->SetVerifyErrorClass(exception->GetClass());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700798 klass->SetStatus(Class::kStatusError);
799 return false;
800 }
801
802 klass->SetStatus(Class::kStatusVerified);
803 }
804
805 if (klass->status_ == Class::kStatusInitialized) {
806 return true;
807 }
808
809 while (klass->status_ == Class::kStatusInitializing) {
810 // we caught somebody else in the act; was it us?
Carl Shapirob5573532011-07-12 18:22:59 -0700811 if (klass->clinit_thread_id_ == self->GetId()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700812 LG << "recursive <clinit>";
813 return true;
814 }
815
816 CHECK(!self->IsExceptionPending());
817
818 lock.Wait(); // TODO: check for interruption
819
820 // When we wake up, repeat the test for init-in-progress. If
821 // there's an exception pending (only possible if
822 // "interruptShouldThrow" was set), bail out.
823 if (self->IsExceptionPending()) {
824 CHECK(false);
825 LG << "Exception in initialization."; // TODO: ExceptionInInitializerError
826 klass->SetStatus(Class::kStatusError);
827 return false;
828 }
829 if (klass->GetStatus() == Class::kStatusInitializing) {
830 continue;
831 }
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700832 DCHECK(klass->GetStatus() == Class::kStatusInitialized ||
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700833 klass->GetStatus() == Class::kStatusError);
834 if (klass->IsErroneous()) {
Brian Carlstrombe977852011-07-19 14:54:54 -0700835 // The caller wants an exception, but it was thrown in a
836 // different thread. Synthesize one here.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700837 LG << "<clinit> failed"; // TODO: throw UnsatisfiedLinkError
838 return false;
839 }
840 return true; // otherwise, initialized
841 }
842
843 // see if we failed previously
844 if (klass->IsErroneous()) {
845 // might be wise to unlock before throwing; depends on which class
846 // it is that we have locked
847
848 // TODO: throwEarlierClassFailure(klass);
849 return false;
850 }
851
852 if (!ValidateSuperClassDescriptors(klass)) {
853 klass->SetStatus(Class::kStatusError);
854 return false;
855 }
856
Brian Carlstroma331b3c2011-07-18 17:47:56 -0700857 DCHECK(klass->status_ < Class::kStatusInitializing);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700858
Carl Shapirob5573532011-07-12 18:22:59 -0700859 klass->clinit_thread_id_ = self->GetId();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700860 klass->status_ = Class::kStatusInitializing;
861 }
862
863 if (!InitializeSuperClass(klass)) {
864 return false;
865 }
866
867 InitializeStaticFields(klass);
868
Carl Shapiro419ec7b2011-08-03 14:48:33 -0700869 Method* clinit = klass->FindDeclaredDirectMethod("<clinit>", "()V");
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700870 if (clinit != NULL) {
871 } else {
872 // JValue unused;
873 // TODO: dvmCallMethod(self, method, NULL, &unused);
Elliott Hughes53b61312011-08-12 18:28:20 -0700874 // UNIMPLEMENTED(FATAL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700875 }
876
877 {
878 ObjectLock lock(klass);
879
880 if (self->IsExceptionPending()) {
881 klass->SetStatus(Class::kStatusError);
882 } else {
883 klass->SetStatus(Class::kStatusInitialized);
884 }
885 lock.NotifyAll();
886 }
887
888 return true;
889}
890
891bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
892 if (klass->IsInterface()) {
893 return true;
894 }
895 // begin with the methods local to the superclass
896 if (klass->HasSuperClass() &&
897 klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
898 const Class* super = klass->GetSuperClass();
899 for (int i = super->NumVirtualMethods() - 1; i >= 0; --i) {
900 const Method* method = klass->GetVirtualMethod(i);
901 if (method != super->GetVirtualMethod(i) &&
902 !HasSameMethodDescriptorClasses(method, super, klass)) {
903 LG << "Classes resolve differently in superclass";
904 return false;
905 }
906 }
907 }
908 for (size_t i = 0; i < klass->iftable_count_; ++i) {
909 const InterfaceEntry* iftable = &klass->iftable_[i];
910 Class* interface = iftable->GetClass();
911 if (klass->GetClassLoader() != interface->GetClassLoader()) {
912 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
913 uint32_t vtable_index = iftable->method_index_array_[j];
914 const Method* method = klass->GetVirtualMethod(vtable_index);
915 if (!HasSameMethodDescriptorClasses(method, interface,
916 method->GetClass())) {
917 LG << "Classes resolve differently in interface"; // TODO: LinkageError
918 return false;
919 }
920 }
921 }
922 }
923 return true;
924}
925
926bool ClassLinker::HasSameMethodDescriptorClasses(const Method* method,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700927 const Class* klass1,
928 const Class* klass2) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700929 const DexFile& dex_file = FindDexFile(method->GetClass()->GetDexCache());
930 const DexFile::ProtoId& proto_id = dex_file.GetProtoId(method->proto_idx_);
Brian Carlstromf615a612011-07-23 12:50:34 -0700931 DexFile::ParameterIterator *it;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700932 for (it = dex_file.GetParameterIterator(proto_id); it->HasNext(); it->Next()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700933 const char* descriptor = it->GetDescriptor();
934 if (descriptor == NULL) {
935 break;
936 }
937 if (descriptor[0] == 'L' || descriptor[0] == '[') {
938 // Found a non-primitive type.
939 if (!HasSameDescriptorClasses(descriptor, klass1, klass2)) {
940 return false;
941 }
942 }
943 }
944 // Check the return type
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700945 const char* descriptor = dex_file.GetReturnTypeDescriptor(proto_id);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700946 if (descriptor[0] == 'L' || descriptor[0] == '[') {
947 if (HasSameDescriptorClasses(descriptor, klass1, klass2)) {
948 return false;
949 }
950 }
951 return true;
952}
953
954// Returns true if classes referenced by the descriptor are the
955// same classes in klass1 as they are in klass2.
956bool ClassLinker::HasSameDescriptorClasses(const char* descriptor,
Brian Carlstrom934486c2011-07-12 23:42:50 -0700957 const Class* klass1,
958 const Class* klass2) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700959 CHECK(descriptor != NULL);
960 CHECK(klass1 != NULL);
961 CHECK(klass2 != NULL);
962#if 0
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700963 Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700964 // TODO: found1 == NULL
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700965 Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700966 // TODO: found2 == NULL
967 // TODO: lookup found1 in initiating loader list
968 if (found1 == NULL || found2 == NULL) {
Carl Shapirob5573532011-07-12 18:22:59 -0700969 Thread::Current()->ClearException();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700970 if (found1 == found2) {
971 return true;
972 } else {
973 return false;
974 }
975 }
976#endif
977 return true;
978}
979
980bool ClassLinker::InitializeSuperClass(Class* klass) {
981 CHECK(klass != NULL);
Brian Carlstrom7e93b502011-08-04 14:16:22 -0700982 MutexLock mu(classes_lock_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700983 if (!klass->IsInterface() && klass->HasSuperClass()) {
984 Class* super_class = klass->GetSuperClass();
985 if (super_class->GetStatus() != Class::kStatusInitialized) {
986 CHECK(!super_class->IsInterface());
987 klass->MonitorExit();
988 bool super_initialized = InitializeClass(super_class);
989 klass->MonitorEnter();
990 // TODO: check for a pending exception
991 if (!super_initialized) {
992 klass->SetStatus(Class::kStatusError);
993 klass->NotifyAll();
994 return false;
995 }
996 }
997 }
998 return true;
999}
1000
1001void ClassLinker::InitializeStaticFields(Class* klass) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001002 size_t num_static_fields = klass->NumStaticFields();
1003 if (num_static_fields == 0) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001004 return;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001005 }
Brian Carlstromf615a612011-07-23 12:50:34 -07001006 DexCache* dex_cache = klass->GetDexCache();
1007 if (dex_cache == NULL) {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001008 return;
1009 }
Brian Carlstrom6cc18452011-07-18 15:10:33 -07001010 const StringPiece& descriptor = klass->GetDescriptor();
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001011 const DexFile& dex_file = FindDexFile(dex_cache);
1012 const DexFile::ClassDef* dex_class_def = dex_file.FindClassDef(descriptor);
Brian Carlstromf615a612011-07-23 12:50:34 -07001013 CHECK(dex_class_def != NULL);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001014 const byte* addr = dex_file.GetEncodedArray(*dex_class_def);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001015 size_t array_size = DecodeUnsignedLeb128(&addr);
1016 for (size_t i = 0; i < array_size; ++i) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001017 Field* field = klass->GetStaticField(i);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001018 JValue value;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001019 DexFile::ValueType type = dex_file.ReadEncodedValue(&addr, &value);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001020 switch (type) {
Brian Carlstromf615a612011-07-23 12:50:34 -07001021 case DexFile::kByte:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001022 field->SetByte(value.b);
1023 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001024 case DexFile::kShort:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001025 field->SetShort(value.s);
1026 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001027 case DexFile::kChar:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001028 field->SetChar(value.c);
1029 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001030 case DexFile::kInt:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001031 field->SetInt(value.i);
1032 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001033 case DexFile::kLong:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001034 field->SetLong(value.j);
1035 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001036 case DexFile::kFloat:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001037 field->SetFloat(value.f);
1038 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001039 case DexFile::kDouble:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001040 field->SetDouble(value.d);
1041 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001042 case DexFile::kString: {
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001043 uint32_t string_idx = value.i;
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001044 String* resolved = ResolveString(klass, string_idx, dex_file);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001045 field->SetObject(resolved);
1046 break;
1047 }
Brian Carlstromf615a612011-07-23 12:50:34 -07001048 case DexFile::kBoolean:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001049 field->SetBoolean(value.z);
1050 break;
Brian Carlstromf615a612011-07-23 12:50:34 -07001051 case DexFile::kNull:
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001052 field->SetObject(value.l);
1053 break;
1054 default:
Carl Shapiro606258b2011-07-09 16:09:09 -07001055 LOG(FATAL) << "Unknown type " << static_cast<int>(type);
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001056 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001057 }
1058}
1059
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001060bool ClassLinker::LinkClass(Class* klass, const DexFile& dex_file) {
1061 CHECK_EQ(Class::kStatusLoaded, klass->status_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001062 if (!LinkSuperClass(klass)) {
1063 return false;
1064 }
1065 if (!LinkMethods(klass)) {
1066 return false;
1067 }
Jesse Wilson7833bd22011-08-09 18:31:44 -04001068 if (!LinkStaticFields(klass)) {
1069 return false;
1070 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001071 if (!LinkInstanceFields(klass)) {
1072 return false;
1073 }
1074 CreateReferenceOffsets(klass);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001075 CHECK_EQ(Class::kStatusLoaded, klass->status_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001076 klass->status_ = Class::kStatusResolved;
1077 return true;
1078}
1079
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001080bool ClassLinker::LoadSuperAndInterfaces(Class* klass, const DexFile& dex_file) {
1081 CHECK_EQ(Class::kStatusIdx, klass->status_);
Brian Carlstromf615a612011-07-23 12:50:34 -07001082 if (klass->super_class_idx_ != DexFile::kDexNoIndex) {
1083 Class* super_class = ResolveClass(klass, klass->super_class_idx_, dex_file);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001084 if (super_class == NULL) {
1085 LG << "Failed to resolve superclass";
1086 return false;
1087 }
1088 klass->super_class_ = super_class; // TODO: write barrier
1089 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001090 if (klass->NumInterfaces() > 0) {
1091 for (size_t i = 0; i < klass->NumInterfaces(); ++i) {
1092 uint32_t idx = klass->interfaces_idx_[i];
1093 klass->SetInterface(i, ResolveClass(klass, idx, dex_file));
1094 if (klass->GetInterface(i) == NULL) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001095 LG << "Failed to resolve interface";
1096 return false;
1097 }
1098 // Verify
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001099 if (!klass->CanAccess(klass->GetInterface(i))) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001100 LG << "Inaccessible interface";
1101 return false;
1102 }
1103 }
1104 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001105 // Mark the class as loaded.
1106 klass->status_ = Class::kStatusLoaded;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001107 return true;
1108}
1109
1110bool ClassLinker::LinkSuperClass(Class* klass) {
1111 CHECK(!klass->IsPrimitive());
1112 const Class* super = klass->GetSuperClass();
1113 if (klass->GetDescriptor() == "Ljava/lang/Object;") {
1114 if (super != NULL) {
1115 LG << "Superclass must not be defined"; // TODO: ClassFormatError
1116 return false;
1117 }
1118 // TODO: clear finalize attribute
1119 return true;
1120 }
1121 if (super == NULL) {
1122 LG << "No superclass defined"; // TODO: LinkageError
1123 return false;
1124 }
1125 // Verify
1126 if (super->IsFinal()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001127 LG << "Superclass " << super->descriptor_ << " is declared final"; // TODO: IncompatibleClassChangeError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001128 return false;
1129 }
1130 if (super->IsInterface()) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001131 LG << "Superclass " << super->descriptor_ << " is an interface"; // TODO: IncompatibleClassChangeError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001132 return false;
1133 }
1134 if (!klass->CanAccess(super)) {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001135 LG << "Superclass " << super->descriptor_ << " is inaccessible"; // TODO: IllegalAccessError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001136 return false;
1137 }
1138 return true;
1139}
1140
1141// Populate the class vtable and itable.
1142bool ClassLinker::LinkMethods(Class* klass) {
1143 if (klass->IsInterface()) {
1144 // No vtable.
1145 size_t count = klass->NumVirtualMethods();
1146 if (!IsUint(16, count)) {
1147 LG << "Too many methods on interface"; // TODO: VirtualMachineError
1148 return false;
1149 }
Carl Shapiro565f5072011-07-10 13:39:43 -07001150 for (size_t i = 0; i < count; ++i) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001151 klass->GetVirtualMethod(i)->method_index_ = i;
1152 }
1153 } else {
1154 // Link virtual method tables
1155 LinkVirtualMethods(klass);
1156
1157 // Link interface method tables
1158 LinkInterfaceMethods(klass);
1159
1160 // Insert stubs.
1161 LinkAbstractMethods(klass);
1162 }
1163 return true;
1164}
1165
1166bool ClassLinker::LinkVirtualMethods(Class* klass) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001167 if (klass->HasSuperClass()) {
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001168 uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->vtable_->GetLength();
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001169 size_t actual_count = klass->GetSuperClass()->vtable_->GetLength();
1170 CHECK_LE(actual_count, max_count);
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001171 // TODO: do not assign to the vtable field until it is fully constructed.
1172 klass->vtable_ = klass->GetSuperClass()->vtable_->CopyOf(max_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001173 // See if any of our virtual methods override the superclass.
1174 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
1175 Method* local_method = klass->GetVirtualMethod(i);
1176 size_t j = 0;
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001177 for (; j < actual_count; ++j) {
1178 Method* super_method = klass->vtable_->Get(j);
Carl Shapiro8860c0e2011-08-04 17:36:16 -07001179 if (local_method->HasSameNameAndDescriptor(super_method)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001180 // Verify
1181 if (super_method->IsFinal()) {
Brian Carlstrombe977852011-07-19 14:54:54 -07001182 LG << "Method overrides final method"; // TODO: VirtualMachineError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001183 return false;
1184 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001185 klass->vtable_->Set(j, local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001186 local_method->method_index_ = j;
1187 break;
1188 }
1189 }
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001190 if (j == actual_count) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001191 // Not overriding, append.
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001192 klass->vtable_->Set(actual_count, local_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001193 local_method->method_index_ = actual_count;
1194 actual_count += 1;
1195 }
1196 }
1197 if (!IsUint(16, actual_count)) {
1198 LG << "Too many methods defined on class"; // TODO: VirtualMachineError
1199 return false;
1200 }
1201 CHECK_LE(actual_count, max_count);
1202 if (actual_count < max_count) {
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001203 // TODO: do not assign to the vtable field until it is fully constructed.
1204 klass->vtable_ = klass->vtable_->CopyOf(actual_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001205 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001206 } else {
1207 CHECK(klass->GetDescriptor() == "Ljava/lang/Object;");
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001208 uint32_t num_virtual_methods = klass->NumVirtualMethods();
1209 CHECK(klass->GetDescriptor() == "Ljava/lang/Object;");
1210 if (!IsUint(16, num_virtual_methods)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001211 LG << "Too many methods"; // TODO: VirtualMachineError
1212 return false;
1213 }
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001214 // TODO: do not assign to the vtable field until it is fully constructed.
1215 klass->vtable_ = AllocObjectArray<Method>(num_virtual_methods);
1216 for (size_t i = 0; i < num_virtual_methods; ++i) {
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001217 klass->vtable_->Set(i, klass->GetVirtualMethod(i));
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001218 klass->GetVirtualMethod(i)->method_index_ = i & 0xFFFF;
1219 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001220 }
1221 return true;
1222}
1223
1224bool ClassLinker::LinkInterfaceMethods(Class* klass) {
1225 int pool_offset = 0;
1226 int pool_size = 0;
1227 int miranda_count = 0;
1228 int miranda_alloc = 0;
1229 size_t super_ifcount;
1230 if (klass->HasSuperClass()) {
1231 super_ifcount = klass->GetSuperClass()->iftable_count_;
1232 } else {
1233 super_ifcount = 0;
1234 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001235 size_t ifcount = super_ifcount;
1236 ifcount += klass->NumInterfaces();
1237 for (size_t i = 0; i < klass->NumInterfaces(); i++) {
1238 ifcount += klass->GetInterface(i)->iftable_count_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001239 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001240 if (ifcount == 0) {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001241 DCHECK(klass->iftable_count_ == 0);
1242 DCHECK(klass->iftable_ == NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001243 return true;
1244 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001245 klass->iftable_ = new InterfaceEntry[ifcount * sizeof(InterfaceEntry)];
1246 memset(klass->iftable_, 0x00, sizeof(InterfaceEntry) * ifcount);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001247 if (super_ifcount != 0) {
1248 memcpy(klass->iftable_, klass->GetSuperClass()->iftable_,
1249 sizeof(InterfaceEntry) * super_ifcount);
1250 }
1251 // Flatten the interface inheritance hierarchy.
1252 size_t idx = super_ifcount;
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001253 for (size_t i = 0; i < klass->NumInterfaces(); i++) {
1254 Class* interf = klass->GetInterface(i);
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001255 DCHECK(interf != NULL);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001256 if (!interf->IsInterface()) {
1257 LG << "Class implements non-interface class"; // TODO: IncompatibleClassChangeError
1258 return false;
1259 }
1260 klass->iftable_[idx++].SetClass(interf);
1261 for (size_t j = 0; j < interf->iftable_count_; j++) {
1262 klass->iftable_[idx++].SetClass(interf->iftable_[j].GetClass());
1263 }
1264 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001265 CHECK_EQ(idx, ifcount);
1266 klass->iftable_count_ = ifcount;
1267 if (klass->IsInterface() || super_ifcount == ifcount) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001268 return true;
1269 }
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001270 for (size_t i = super_ifcount; i < ifcount; i++) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001271 pool_size += klass->iftable_[i].GetClass()->NumVirtualMethods();
1272 }
1273 if (pool_size == 0) {
1274 return true;
1275 }
1276 klass->ifvi_pool_count_ = pool_size;
1277 klass->ifvi_pool_ = new uint32_t[pool_size];
1278 std::vector<Method*> miranda_list;
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001279 for (size_t i = super_ifcount; i < ifcount; ++i) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001280 klass->iftable_[i].method_index_array_ = klass->ifvi_pool_ + pool_offset;
1281 Class* interface = klass->iftable_[i].GetClass();
1282 pool_offset += interface->NumVirtualMethods(); // end here
1283 for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
1284 Method* interface_method = interface->GetVirtualMethod(j);
1285 int k; // must be signed
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001286 for (k = klass->vtable_->GetLength() - 1; k >= 0; --k) {
Carl Shapiro8860c0e2011-08-04 17:36:16 -07001287 Method* vtable_method = klass->vtable_->Get(k);
1288 if (interface_method->HasSameNameAndDescriptor(vtable_method)) {
1289 if (!vtable_method->IsPublic()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001290 LG << "Implementation not public";
1291 return false;
1292 }
1293 klass->iftable_[i].method_index_array_[j] = k;
1294 break;
1295 }
1296 }
1297 if (k < 0) {
1298 if (miranda_count == miranda_alloc) {
1299 miranda_alloc += 8;
1300 if (miranda_list.empty()) {
1301 miranda_list.resize(miranda_alloc);
1302 } else {
1303 miranda_list.resize(miranda_alloc);
1304 }
1305 }
1306 int mir;
1307 for (mir = 0; mir < miranda_count; mir++) {
Carl Shapiro8860c0e2011-08-04 17:36:16 -07001308 Method* miranda_method = miranda_list[mir];
1309 if (miranda_method->HasSameNameAndDescriptor(interface_method)) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001310 break;
1311 }
1312 }
1313 // point the interface table at a phantom slot index
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001314 klass->iftable_[i].method_index_array_[j] = klass->vtable_->GetLength() + mir;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001315 if (mir == miranda_count) {
1316 miranda_list[miranda_count++] = interface_method;
1317 }
1318 }
1319 }
1320 }
1321 if (miranda_count != 0) {
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001322 int old_method_count = klass->NumVirtualMethods();
1323 int new_method_count = old_method_count + miranda_count;
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001324 klass->virtual_methods_ = klass->virtual_methods_->CopyOf(new_method_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001325
1326 CHECK(klass->vtable_ != NULL);
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001327 int old_vtable_count = klass->vtable_->GetLength();
1328 int new_vtable_count = old_vtable_count + miranda_count;
Brian Carlstroma40f9bc2011-07-26 21:26:07 -07001329 // TODO: do not assign to the vtable field until it is fully constructed.
1330 klass->vtable_ = klass->vtable_->CopyOf(new_vtable_count);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001331
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001332 for (int i = 0; i < miranda_count; i++) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001333 Method* meth = AllocMethod();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001334 memcpy(meth, miranda_list[i], sizeof(Method));
1335 meth->klass_ = klass;
1336 meth->access_flags_ |= kAccMiranda;
Brian Carlstrom913af1b2011-07-23 21:41:13 -07001337 meth->method_index_ = 0xFFFF & (old_vtable_count + i);
1338 klass->SetVirtualMethod(old_method_count + i, meth);
Brian Carlstrom4a96b602011-07-26 16:40:23 -07001339 klass->vtable_->Set(old_vtable_count + i, meth);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001340 }
1341 }
1342 return true;
1343}
1344
1345void ClassLinker::LinkAbstractMethods(Class* klass) {
1346 for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
1347 Method* method = klass->GetVirtualMethod(i);
1348 if (method->IsAbstract()) {
Shih-wei Liao2fb97532011-08-11 16:17:23 -07001349 LG << "AbstractMethodError";
1350 method->code_off_ = 0xFFFFFFFF;
1351 // TODO: throw AbstractMethodError
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001352 }
1353 }
1354}
1355
Jesse Wilson7833bd22011-08-09 18:31:44 -04001356// Each static field will be stored in one of three arrays: static_references_,
1357// static_32bit_primitives_, or static_64bit_primitives_. This assigns each
1358// field a slot in its array and create the arrays.
1359bool ClassLinker::LinkStaticFields(Class* klass) {
1360 size_t next_reference_slot = 0;
1361 size_t next_32bit_primitive_slot = 0;
1362 size_t next_64bit_primitive_slot = 0;
1363
1364 for (size_t i = 0; i < klass->NumStaticFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001365 Field* field = klass->GetStaticField(i);
Jesse Wilson7833bd22011-08-09 18:31:44 -04001366 char type = field->GetType();
1367 if (type == '[' || type == 'L') {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001368 field->offset_ = next_reference_slot++;
Jesse Wilson7833bd22011-08-09 18:31:44 -04001369 } else if (type == 'J' || type == 'D') {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001370 field->offset_ = next_64bit_primitive_slot++;
Jesse Wilson7833bd22011-08-09 18:31:44 -04001371 } else {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001372 field->offset_ = next_32bit_primitive_slot++;
Jesse Wilson7833bd22011-08-09 18:31:44 -04001373 }
1374 }
1375
1376 if (next_reference_slot > 0) {
1377 Class* array_class = GetClassRoot(kObjectArrayClass);
1378 klass->static_references_ = ObjectArray<Object>::Alloc(array_class, next_reference_slot);
1379 }
1380 if (next_32bit_primitive_slot > 0) {
1381 Class* array_class = GetClassRoot(kIntArrayClass);
1382 klass->static_32bit_primitives_ = IntArray::Alloc(array_class, next_32bit_primitive_slot);
1383 }
1384 if (next_64bit_primitive_slot > 0) {
1385 Class* array_class = GetClassRoot(kLongArrayClass);
1386 klass->static_64bit_primitives_ = LongArray::Alloc(array_class, next_64bit_primitive_slot);
1387 }
1388
1389 return true;
1390}
1391
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001392bool ClassLinker::LinkInstanceFields(Class* klass) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001393 int field_offset;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001394 if (klass->GetSuperClass() != NULL) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001395 field_offset = klass->GetSuperClass()->object_size_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001396 } else {
Brian Carlstroma0808032011-07-18 00:39:23 -07001397 field_offset = OFFSETOF_MEMBER(DataObject, fields_);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001398 }
1399 // Move references to the front.
Carl Shapiro69759ea2011-07-21 18:13:35 -07001400 klass->num_reference_instance_fields_ = 0;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001401 size_t i = 0;
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001402 for ( ; i < klass->NumInstanceFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001403 Field* pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001404 char c = pField->GetType();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001405 if (c != '[' && c != 'L') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001406 for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001407 Field* refField = klass->GetInstanceField(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001408 char rc = refField->GetType();
1409 if (rc == '[' || rc == 'L') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001410 klass->SetInstanceField(i, refField);
1411 klass->SetInstanceField(j, pField);
1412 pField = refField;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001413 c = rc;
Carl Shapiro69759ea2011-07-21 18:13:35 -07001414 klass->num_reference_instance_fields_++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001415 break;
1416 }
1417 }
1418 } else {
Carl Shapiro69759ea2011-07-21 18:13:35 -07001419 klass->num_reference_instance_fields_++;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001420 }
1421 if (c != '[' && c != 'L') {
1422 break;
1423 }
Brian Carlstroma0808032011-07-18 00:39:23 -07001424 pField->SetOffset(field_offset);
1425 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001426 }
1427
1428 // Now we want to pack all of the double-wide fields together. If
1429 // we're not aligned, though, we want to shuffle one 32-bit field
1430 // into place. If we can't find one, we'll have to pad it.
Brian Carlstroma0808032011-07-18 00:39:23 -07001431 if (i != klass->NumInstanceFields() && (field_offset & 0x04) != 0) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001432 Field* pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001433 char c = pField->GetType();
1434
1435 if (c != 'J' && c != 'D') {
1436 // The field that comes next is 32-bit, so just advance past it.
Brian Carlstrombe977852011-07-19 14:54:54 -07001437 DCHECK(c != '[');
1438 DCHECK(c != 'L');
Brian Carlstroma0808032011-07-18 00:39:23 -07001439 pField->SetOffset(field_offset);
1440 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001441 i++;
1442 } else {
1443 // Next field is 64-bit, so search for a 32-bit field we can
1444 // swap into it.
1445 bool found = false;
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001446 for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001447 Field* singleField = klass->GetInstanceField(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001448 char rc = singleField->GetType();
1449 if (rc != 'J' && rc != 'D') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001450 klass->SetInstanceField(i, singleField);
1451 klass->SetInstanceField(j, pField);
1452 pField = singleField;
Brian Carlstroma0808032011-07-18 00:39:23 -07001453 pField->SetOffset(field_offset);
1454 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001455 found = true;
1456 i++;
1457 break;
1458 }
1459 }
1460 if (!found) {
Brian Carlstroma0808032011-07-18 00:39:23 -07001461 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001462 }
1463 }
1464 }
1465
1466 // Alignment is good, shuffle any double-wide fields forward, and
1467 // finish assigning field offsets to all fields.
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001468 DCHECK(i == klass->NumInstanceFields() || (field_offset & 0x04) == 0);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001469 for ( ; i < klass->NumInstanceFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001470 Field* pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001471 char c = pField->GetType();
1472 if (c != 'D' && c != 'J') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001473 for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001474 Field* doubleField = klass->GetInstanceField(j);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001475 char rc = doubleField->GetType();
1476 if (rc == 'D' || rc == 'J') {
Brian Carlstroma7f4f482011-07-17 17:01:34 -07001477 klass->SetInstanceField(i, doubleField);
1478 klass->SetInstanceField(j, pField);
1479 pField = doubleField;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001480 c = rc;
1481 break;
1482 }
1483 }
1484 } else {
1485 // This is a double-wide field, leave it be.
1486 }
1487
Brian Carlstroma0808032011-07-18 00:39:23 -07001488 pField->SetOffset(field_offset);
1489 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001490 if (c == 'J' || c == 'D')
Brian Carlstroma0808032011-07-18 00:39:23 -07001491 field_offset += sizeof(uint32_t);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001492 }
1493
1494#ifndef NDEBUG
Brian Carlstrombe977852011-07-19 14:54:54 -07001495 // Make sure that all reference fields appear before
1496 // non-reference fields, and all double-wide fields are aligned.
1497 bool seen_non_ref = false;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001498 for (i = 0; i < klass->NumInstanceFields(); i++) {
Jesse Wilson35baaab2011-08-10 16:18:03 -04001499 Field *pField = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001500 char c = pField->GetType();
1501
1502 if (c == 'D' || c == 'J') {
Brian Carlstrombe977852011-07-19 14:54:54 -07001503 DCHECK_EQ(0U, pField->GetOffset() & 0x07);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001504 }
1505
1506 if (c != '[' && c != 'L') {
Brian Carlstrombe977852011-07-19 14:54:54 -07001507 if (!seen_non_ref) {
1508 seen_non_ref = true;
Brian Carlstrom07d579f2011-07-27 13:31:51 -07001509 DCHECK_EQ(klass->NumReferenceInstanceFields(), i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001510 }
Brian Carlstrombe977852011-07-19 14:54:54 -07001511 } else {
1512 DCHECK(!seen_non_ref);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001513 }
1514 }
Brian Carlstrombe977852011-07-19 14:54:54 -07001515 if (!seen_non_ref) {
Brian Carlstrom07d579f2011-07-27 13:31:51 -07001516 DCHECK_EQ(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001517 }
1518#endif
Brian Carlstrom75cb3b42011-07-28 02:13:36 -07001519 klass->object_size_ = field_offset;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001520 return true;
1521}
1522
1523// Set the bitmap of reference offsets, refOffsets, from the ifields
1524// list.
1525void ClassLinker::CreateReferenceOffsets(Class* klass) {
1526 uint32_t reference_offsets = 0;
1527 if (klass->HasSuperClass()) {
1528 reference_offsets = klass->GetSuperClass()->GetReferenceOffsets();
1529 }
1530 // If our superclass overflowed, we don't stand a chance.
1531 if (reference_offsets != CLASS_WALK_SUPER) {
1532 // All of the fields that contain object references are guaranteed
1533 // to be at the beginning of the ifields list.
1534 for (size_t i = 0; i < klass->NumReferenceInstanceFields(); ++i) {
1535 // Note that, per the comment on struct InstField, f->byteOffset
1536 // is the offset from the beginning of obj, not the offset into
1537 // obj->instanceData.
Jesse Wilson35baaab2011-08-10 16:18:03 -04001538 const Field* field = klass->GetInstanceField(i);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001539 size_t byte_offset = field->GetOffset();
1540 CHECK_GE(byte_offset, CLASS_SMALLEST_OFFSET);
Elliott Hughes1f359b02011-07-17 14:27:17 -07001541 CHECK_EQ(byte_offset & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001542 if (CLASS_CAN_ENCODE_OFFSET(byte_offset)) {
1543 uint32_t new_bit = CLASS_BIT_FROM_OFFSET(byte_offset);
Elliott Hughes1f359b02011-07-17 14:27:17 -07001544 CHECK_NE(new_bit, 0U);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001545 reference_offsets |= new_bit;
1546 } else {
1547 reference_offsets = CLASS_WALK_SUPER;
1548 break;
1549 }
1550 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001551 }
Brian Carlstromae3ac012011-07-27 01:30:28 -07001552 klass->SetReferenceOffsets(reference_offsets);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001553}
1554
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07001555Class* ClassLinker::ResolveClass(const Class* referrer,
1556 uint32_t class_idx,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001557 const DexFile& dex_file) {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001558 DexCache* dex_cache = referrer->GetDexCache();
1559 Class* resolved = dex_cache->GetResolvedClass(class_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001560 if (resolved != NULL) {
1561 return resolved;
1562 }
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001563 const char* descriptor = dex_file.dexStringByTypeIdx(class_idx);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001564 if (descriptor[0] != '\0' && descriptor[1] == '\0') {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001565 resolved = FindPrimitiveClass(descriptor[0]);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001566 } else {
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001567 resolved = FindClass(descriptor, referrer->GetClassLoader());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001568 }
1569 if (resolved != NULL) {
1570 Class* check = resolved->IsArray() ? resolved->component_type_ : resolved;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001571 if (referrer->GetDexCache() != check->GetDexCache()) {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001572 if (check->GetClassLoader() != NULL) {
1573 LG << "Class resolved by unexpected DEX"; // TODO: IllegalAccessError
1574 return NULL;
1575 }
1576 }
Brian Carlstrom7e49dca2011-07-22 18:07:34 -07001577 dex_cache->SetResolvedClass(class_idx, resolved);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001578 } else {
Brian Carlstroma331b3c2011-07-18 17:47:56 -07001579 DCHECK(Thread::Current()->IsExceptionPending());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001580 }
1581 return resolved;
1582}
1583
1584Method* ResolveMethod(const Class* referrer, uint32_t method_idx,
1585 /*MethodType*/ int method_type) {
1586 CHECK(false);
1587 return NULL;
1588}
1589
Carl Shapiro69759ea2011-07-21 18:13:35 -07001590String* ClassLinker::ResolveString(const Class* referring,
Brian Carlstrom74eb46a2011-08-02 20:10:14 -07001591 uint32_t string_idx,
1592 const DexFile& dex_file) {
1593 const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
1594 int32_t utf16_length = dex_file.GetStringLength(string_id);
1595 const char* utf8_data = dex_file.GetStringData(string_id);
Brian Carlstrom7e93b502011-08-04 14:16:22 -07001596 String* string = intern_table_.Intern(utf16_length, utf8_data);
1597 referring->GetDexCache()->SetResolvedString(string_idx, string);
1598 return string;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -07001599}
1600
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001601} // namespace art