Move DexFiles to be allocated on the heap

Removed pointer from DexFile to RawDexfile to allow heap allocation of
DexFile. DexFile is now an ObjectArray of ObjectArrays. Removing the
pointer from DexFile to RawDexfile meant adding arguments to pass the
RawDexfile along to ClassLinker::LoadClass, LoadInterfaces, LoadField,
LoadMethod, LinkClass, LinkInterfaces, ResolveClass to avoid the need
to look a RawDexfile up from a DexFile. ClassLinker::CreateArrayClass
now takes the raw_dex_file to assist in looking up the component class
from the proper source. Moved Method::HasSame* methods to ClassLinker
since for access to the RawDexfile (and tests of HasSame from
ObjectTest to ClassLinkerTest.

	src/dex_file.cc
	src/dex_file.h
	src/class_linker.cc
	src/class_linker.h
	src/object.h

RunTime::Create/RunTime::Init/ClassLinker::Create/ClassLinker::Init
now take the boot class path. A boot class path with
Ljava/lang/Object; must be provided to initalize [Ljava/lang/Object;
during startup in order to heap allocate DexFiles.

	src/class_linker.cc
	src/class_linker.h
	src/runtime.cc
	src/runtime.h

Restored FindClass to load from a specific dex file. This is for use
by class loaders, otherwise it is assumed the caller wants to use the
boot classpath. We now distinguish and track the boot classpath as
separate from other dex files known to the class linker. Renamed
AppendToClassPath to AppendToBootClassPath and FindInClassPath to
FindInBootClassPath to clarify.

	src/class_linker.cc
	src/class_linker.h

Cleaned up AllocCharArray to generic AllocArray and added
AllocObjectArray. Added a functional ObjectArray implementation and a
ObjectTest to cover it.

	src/heap.h
	src/object.h
	src/object_test.cc

Switched more Object* downcasting to down_cast

	src/class_linker.cc

Switched order of arguments for DexFile::SetResolved to follow more
conventional collection ordering ( "(index, value)" vs "(value, index)" )

	src/dex_file.h
	src/class_linker.cc
	src/class_linker.h

Added class_linker_ and java_lang_raw_dex_file_ to RuntimeTest as
convenience to test subclasses. ClassLinkerTest now can use these to
simplify its ::Assert* methods. JniCompilerTest now uses it for
setting up its boot class path. Removed now unneeded
OpenDexFileBase64.

	src/common_test.h
	src/class_linker_test.cc
	src/jni_compiler_test.cc

Add external/gtest/include to non-test include path so FRIEND_TEST can be used.
Add src to include path to remove the need of using in in art/src files.

	build/Android.libart.host.mk
	build/Android.libart.mk
	src/assembler.cc
	src/assembler.h
	src/assembler_arm.cc
	src/assembler_arm.h
	src/assembler_x86.cc
	src/assembler_x86.h
	src/assembler_x86_test.cc
	src/base64.cc
	src/base64.h
	src/calling_convention.cc
	src/calling_convention.h
	src/calling_convention_arm.cc
	src/calling_convention_x86.cc
	src/casts.h
	src/class_linker.h
	src/class_linker_test.cc
	src/common_test.h
	src/constants.h
	src/constants_arm.h
	src/constants_x86.h
	src/dex_file.cc
	src/dex_file.h
	src/dex_file_test.cc
	src/dex_instruction.cc
	src/dex_instruction.h
	src/dex_instruction_visitor.h
	src/dex_instruction_visitor_test.cc
	src/dex_verifier.cc
	src/dex_verifier.h
	src/heap.cc
	src/heap.h
	src/jni_compiler.cc
	src/jni_compiler_test.cc
	src/jni_internal.cc
	src/jni_internal.h
	src/leb128.h
	src/managed_register.h
	src/managed_register_arm.cc
	src/managed_register_arm.h
	src/managed_register_arm_test.cc
	src/managed_register_x86.cc
	src/managed_register_x86.h
	src/managed_register_x86_test.cc
	src/mark_stack.cc
	src/mark_stack.h
	src/mark_sweep.cc
	src/mark_sweep.h
	src/memory_region.cc
	src/memory_region.h
	src/monitor.h
	src/object.cc
	src/object.h
	src/object_bitmap.cc
	src/object_bitmap.h
	src/object_test.cc
	src/offsets.cc
	src/offsets.h
	src/raw_dex_file.cc
	src/raw_dex_file.h
	src/raw_dex_file_test.cc
	src/runtime.cc
	src/runtime.h
	src/scoped_ptr.h
	src/space.cc
	src/space.h
	src/space_test.cc
	src/stringpiece.cc
	src/thread.cc
	src/thread.h
	src/thread_arm.cc
	src/thread_x86.cc
	src/utils.h

Change-Id: Ib633cea878c36921e9037b0464cb903aec318c3e

1 files changed, 72 insertions, 23 deletions

diff --git a/src/class_linker.h b/src/class_linker.h
index 47f8c24017..d7bb1916c0 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -7,64 +7,90 @@
 #include <utility>
 #include <vector>
 
-#include "src/macros.h"
-#include "src/thread.h"
-#include "src/object.h"
+#include "macros.h"
+#include "raw_dex_file.h"
+#include "thread.h"
+#include "object.h"
+#include "gtest/gtest.h"
 
 namespace art {
 
 class ClassLinker {
  public:
   // Initializes the class linker.
-  static ClassLinker* Create();
+  static ClassLinker* Create(std::vector<RawDexFile*> boot_class_path);
 
   ~ClassLinker() {}
 
+  DexFile* AllocDexFile();
   Class* AllocClass(DexFile* dex_file);
   StaticField* AllocStaticField();
   InstanceField* AllocInstanceField();
   Method* AllocMethod();
+  ObjectArray* AllocObjectArray(size_t length);
 
   // Finds a class by its descriptor name.
+  // If raw_dex_file is null, searches boot_class_path_.
   Class* FindClass(const StringPiece& descriptor,
-                   Object* class_loader);
+                   Object* class_loader,
+                   const RawDexFile* raw_dex_file);
 
   Class* FindSystemClass(const StringPiece& descriptor) {
-    return FindClass(descriptor, NULL);
+    return FindClass(descriptor, NULL, NULL);
   }
 
-  Class* FindPrimitiveClass(char type);
-
   bool InitializeClass(Class* klass);
 
   Class* LookupClass(const StringPiece& descriptor, Object* class_loader);
 
-  Class* ResolveClass(const Class* referring, uint32_t class_idx);
+  Class* ResolveClass(const Class* referring,
+                      uint32_t class_idx,
+                      const RawDexFile* raw_dex_file);
 
   String* ResolveString(const Class* referring, uint32_t string_idx);
 
-  typedef std::pair<DexFile*, const RawDexFile::ClassDef*> ClassPathEntry;
-
-  ClassPathEntry FindInClassPath(const StringPiece& descriptor);
-
-  void AppendToClassPath(DexFile* dex_file);
+  void RegisterDexFile(RawDexFile* raw_dex_file);
 
  private:
   ClassLinker() {}
 
-  void Init();
+  void Init(std::vector<RawDexFile*> boot_class_path_);
 
   Class* CreatePrimitiveClass(const StringPiece& descriptor);
 
-  Class* CreateArrayClass(const StringPiece& descriptor, Object* class_loader);
+  Class* CreateArrayClass(const StringPiece& descriptor,
+                          Object* class_loader,
+                          const RawDexFile* raw_dex_file);
+
+  Class* FindPrimitiveClass(char type);
+
+  const RawDexFile* FindRawDexFile(const DexFile* dex_file) const;
+
+  DexFile* FindDexFile(const RawDexFile* raw_dex_file) const;
+
+  typedef std::pair<const RawDexFile*, const RawDexFile::ClassDef*> ClassPathEntry;
+
+  void AppendToBootClassPath(RawDexFile* raw_dex_file);
+
+  ClassPathEntry FindInBootClassPath(const StringPiece& descriptor);
 
-  void LoadClass(const RawDexFile::ClassDef& class_def, Class* klass);
+  void LoadClass(const RawDexFile& raw_dex_file,
+                 const RawDexFile::ClassDef& class_def,
+                 Class* klass);
 
-  void LoadInterfaces(const RawDexFile::ClassDef& class_def, Class *klass);
+  void LoadInterfaces(const RawDexFile& raw_dex_file,
+                      const RawDexFile::ClassDef& class_def,
+                      Class *klass);
 
-  void LoadField(Class* klass, const RawDexFile::Field& src, Field* dst);
+  void LoadField(const RawDexFile& raw_dex_file,
+                 const RawDexFile::Field& src,
+                 Class* klass,
+                 Field* dst);
 
-  void LoadMethod(Class* klass, const RawDexFile::Method& src, Method* dst);
+  void LoadMethod(const RawDexFile& raw_dex_file,
+                  const RawDexFile::Method& src,
+                  Class* klass,
+                  Method* dst);
 
   // Inserts a class into the class table.  Returns true if the class
   // was inserted.
@@ -84,11 +110,27 @@ class ClassLinker {
                                       const Class* klass1,
                                       const Class* klass2);
 
-  bool LinkClass(Class* klass);
+  bool HasSameNameAndPrototype(const Method* m1, const Method* m2) const {
+    return HasSameName(m1, m2) && HasSamePrototype(m1, m2);
+  }
+
+  bool HasSameName(const Method* m1, const Method* m2) const {
+    return m1->GetName() == m2->GetName();
+  }
+
+  bool HasSamePrototype(const Method* m1, const Method* m2) const {
+    return HasSameReturnType(m1, m2) && HasSameArgumentTypes(m1, m2);
+  }
+
+  bool HasSameReturnType(const Method* m1, const Method* m2) const;
+
+  bool HasSameArgumentTypes(const Method* m1, const Method* m2) const;
+
+  bool LinkClass(Class* klass, const RawDexFile* raw_dex_file);
 
   bool LinkSuperClass(Class* klass);
 
-  bool LinkInterfaces(Class* klass);
+  bool LinkInterfaces(Class* klass, const RawDexFile* raw_dex_file);
 
   bool LinkMethods(Class* klass);
 
@@ -102,7 +144,11 @@ class ClassLinker {
 
   void CreateReferenceOffsets(Class* klass);
 
-  std::vector<DexFile*> class_path_;
+  std::vector<RawDexFile*> boot_class_path_;
+
+  std::vector<RawDexFile*> raw_dex_files_;
+
+  std::vector<DexFile*> dex_files_;
 
   // TODO: multimap
   typedef std::map<const StringPiece, Class*> Table;
@@ -131,8 +177,11 @@ class ClassLinker {
   Class* primitive_long_;
   Class* primitive_void_;
 
+  Class* object_array_class_;
   Class* char_array_class_;
 
+  FRIEND_TEST(ClassLinkerTest, ProtoCompare);
+  FRIEND_TEST(ClassLinkerTest, ProtoCompare2);
   DISALLOW_COPY_AND_ASSIGN(ClassLinker);
 };