Add class loading infrastructure.
Change-Id: I94bdabcefdf1030ee1827d9219eaf60e4dc818ca
diff --git a/src/object.h b/src/object.h
new file mode 100644
index 0000000..b7d3a50
--- /dev/null
+++ b/src/object.h
@@ -0,0 +1,214 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+#ifndef ART_SRC_OBJECT_H_
+#define ART_SRC_OBJECT_H_
+
+#include "src/globals.h"
+
+namespace art {
+
+class Array;
+class Class;
+class DexFile;
+class IField;
+class InterfaceEntry;
+class Monitor;
+class Method;
+class SField;
+
+class Object {
+ Class* klass_;
+ Monitor* lock_;
+};
+
+class Field {
+ Class* klass_;
+};
+
+// Instance fields.
+class IField : Field {
+ // TODO
+};
+
+// Static fields.
+class SField : Field {
+ // TODO
+};
+
+// Class objects.
+class Class : Object {
+ public:
+ enum ClassStatus {
+ kClassError = -1,
+ kClassNotReady = 0,
+ kClassIdx = 1, // loaded, DEX idx in super or ifaces
+ kClassLoaded = 2, // DEX idx values resolved
+ kClassResolved = 3, // part of linking
+ kClassVerifying = 4, // in the process of being verified
+ kClassVerified = 5, // logically part of linking; done pre-init
+ kClassInitializing = 6, // class init in progress
+ kClassInitialized = 7, // ready to go
+ };
+
+ enum PrimitiveType {
+ kPrimNot = -1
+ };
+
+ // Returns the size in bytes of a class object instance with the
+ // given number of static fields.
+ static size_t Size(size_t num_sfields) {
+ return OFFSETOF_MEMBER(Class, sfields_) + sizeof(SField) * num_sfields;
+ }
+
+ public: // TODO: private
+ // leave space for instance data; we could access fields directly if
+ // we freeze the definition of java/lang/Class
+#define CLASS_FIELD_SLOTS 4
+ uint32_t instance_data_[CLASS_FIELD_SLOTS];
+#undef CLASS_FIELD_SLOTS
+
+ // UTF-8 descriptor for the class from constant pool
+ // ("Ljava/lang/Class;"), or on heap if generated ("[C")
+ const char* descriptor_;
+
+ // Proxy classes have their descriptor allocated on the native heap.
+ // When this field is non-NULL it must be explicitly freed.
+ char* descriptor_alloc_;
+
+ // access flags; low 16 bits are defined by VM spec
+ uint32_t access_flags_;
+
+ // VM-unique class serial number, nonzero, set very early
+ //uint32_t serial_number_;
+
+ // DexFile from which we came; needed to resolve constant pool entries
+ // (will be NULL for VM-generated, e.g. arrays and primitive classes)
+ DexFile* dex_file_;
+
+ // state of class initialization
+ ClassStatus status_;
+
+ // if class verify fails, we must return same error on subsequent tries
+ Class* verify_error_class_;
+
+ // threadId, used to check for recursive <clinit> invocation
+ uint32_t clinit_thread_id_;
+
+ // Total object size; used when allocating storage on gc heap. (For
+ // interfaces and abstract classes this will be zero.)
+ uint32_t object_size_;
+
+ // For array classes, the class object for base element, for
+ // instanceof/checkcast (for String[][][], this will be String).
+ // Otherwise, NULL.
+ Class* array_element_class_;
+
+ // For array classes, the number of array dimensions, e.g. int[][]
+ // is 2. Otherwise 0.
+ int32_t array_rank_;
+
+ // primitive type index, or PRIM_NOT (-1); set for generated prim classes
+ PrimitiveType primitive_type_;
+
+ // The superclass, or NULL if this is java.lang.Object or a
+ // primitive type.
+ Class* super_;
+
+ // defining class loader, or NULL for the "bootstrap" system loader
+ Object* class_loader_;
+
+ // initiating class loader list
+ // NOTE: for classes with low serialNumber, these are unused, and the
+ // values are kept in a table in gDvm.
+ //InitiatingLoaderList initiating_loader_list_;
+
+ // array of interfaces this class implements directly
+ int interface_count_;
+ Class** interfaces_;
+
+ // static, private, and <init> methods
+ int direct_method_count_;
+ Method* direct_methods_;
+
+ // virtual methods defined in this class; invoked through vtable
+ int virtual_method_count_;
+ Method* virtual_methods_;
+
+ // Virtual method table (vtable), for use by "invoke-virtual". The
+ // vtable from the superclass is copied in, and virtual methods from
+ // our class either replace those from the super or are appended.
+ int32_t vtable_count_;
+ Method** vtable_;
+
+ // Interface table (iftable), one entry per interface supported by
+ // this class. That means one entry for each interface we support
+ // directly, indirectly via superclass, or indirectly via
+ // superinterface. This will be null if neither we nor our
+ // superclass implement any interfaces.
+ //
+ // Why we need this: given "class Foo implements Face", declare
+ // "Face faceObj = new Foo()". Invoke faceObj.blah(), where "blah"
+ // is part of the Face interface. We can't easily use a single
+ // vtable.
+ //
+ // For every interface a concrete class implements, we create a list
+ // of virtualMethod indices for the methods in the interface.
+ int iftable_count_;
+ InterfaceEntry* iftable_;
+
+ // The interface vtable indices for iftable get stored here. By
+ // placing them all in a single pool for each class that implements
+ // interfaces, we decrease the number of allocations.
+ int ifvipool_count;
+ int* ifvipool_;
+
+ // instance fields
+ //
+ // These describe the layout of the contents of a
+ // DataObject-compatible Object. Note that only the fields directly
+ // declared by this class are listed in ifields; fields declared by
+ // a superclass are listed in the superclass's ClassObject.ifields.
+ //
+ // All instance fields that refer to objects are guaranteed to be at
+ // the beginning of the field list. ifieldRefCount specifies the
+ // number of reference fields.
+ int ifield_count_;
+ int ifield_ref_count_; // number of fields that are object refs
+ IField* ifields_;
+
+ // bitmap of offsets of ifields
+ uint32_t ref_offsets_;
+
+ // source file name, if known. Otherwise, NULL.
+ const char* source_file_;
+
+ // Static fields
+ uint16_t num_sfields_;
+ SField sfields_[]; // MUST be last item
+};
+
+class String : Object {
+ public:
+ Array* array_;
+
+ uint32_t hash_code_;
+
+ uint32_t offset_;
+
+ uint32_t count_;
+};
+
+class Array : Object {
+ public:
+ // The number of array elements.
+ uint32_t length_;
+};
+
+class Method {
+ public:
+ Class* klass;
+};
+
+} // namespace art
+
+#endif // ART_SRC_OBJECT_H_