vmkit/lib/J3/Isolate/IsolateCommonClass.h

//===---- IsolateCommonClass.h - User visible classes with isolates -------===//
//
//                              JnJVM
//
// This file is distributed under the University of Illinois Open Source 
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef JNJVM_JAVA_CLASS_H
#error "Never use <IsolateCommonClass.h> directly, but include <JavaClass.h>"
#endif

#ifndef ISOLATE_COMMON_CLASS_H
#define ISOLATE_COMMON_CLASS_H

#include "mvm/Object.h"

#include "JavaConstantPool.h"

namespace jnjvm {

class ArrayUInt8;
class AssessorDesc;
class CommonClass;
class Class;
class ClassArray;
class ClassPrimitive;
class JavaConstantPool;
class JavaField;
class JavaMethod;
class JavaObject;
class Jnjvm;
class JnjvmClassLoader;
class UserClass;
class UserClassArray;
class UserConstantPool;
class UTF8;
enum JavaState;

class UserCommonClass : public mvm::Object {
public:
  
 //===----------------------------------------------------------------------===//
//
// Do not reorder these fields or add new ones! the LLVM runtime assumes that
// classes have the following beginning layout.
//
//===----------------------------------------------------------------------===//

  
  /// virtualSize - The size of instances of this class. Array classes do
  /// not need this information, but to simplify accessing this field in
  /// the JIT, we put this in here.
  /// 
  uint32 virtualSize;

  /// virtualVT - The virtual table of instances of this class. Like the
  /// virtualSize field, array classes do not need this information. But we
  /// simplify JIT generation to set it here.
  ///
  VirtualTable* virtualVT;
  
  /// display - The class hierarchy of supers for this class. Array classes
  /// do not need it.
  ///
  UserCommonClass** display;
  
  /// depth - The depth of this class in its class hierarchy. 
  /// display[depth] contains the class. Array classes do not need it.
  ///
  uint32 depth;

  /// status - The loading/resolve/initialization state of the class.
  ///
  JavaState status;
  
  /// ctpInfo - The private constant pool of this class.
  ///
  UserConstantPool* ctpInfo;
  
  JavaObject* staticInstance;

//===----------------------------------------------------------------------===//
//
// New fields can be added from now, or reordered.
//
//===----------------------------------------------------------------------===// 

  JnjvmClassLoader* classLoader;
  JavaObject* delegatee;
  CommonClass* classDef;
  UserClass* super;
  std::vector<UserClass*> interfaces;

  bool inheritName(const UTF8* Tname);
  bool isOfTypeName(const UTF8* name);
  bool isAssignableFrom(UserCommonClass* cl);
  
  /// subclassOf - If this class is a regular class, is it a subclass of the
  /// given class?
  ///
  bool subclassOf(UserCommonClass* cl);

  bool isArray() {
    return classDef->isArray();
  }
  bool isPrimitive() {
    return classDef->isPrimitive();
  }

  bool isInterface() {
    return classDef->isInterface();
  }

  bool isReady() {
    return status >= inClinit;
  }
  
  bool isResolved() {
    return status >= resolved;
  }

  uint8 getAccess() {
    return classDef->access;
  }

  const UTF8* getName() {
    return classDef->name;
  }

  void getDeclaredConstructors(std::vector<JavaMethod*>& res, bool publicOnly) {
    classDef->getDeclaredConstructors(res, publicOnly);
  }

  void getDeclaredFields(std::vector<JavaField*>& res, bool publicOnly) {
    classDef->getDeclaredFields(res, publicOnly);
  }

  void getDeclaredMethods(std::vector<JavaMethod*>& res, bool publicOnly) {
    classDef->getDeclaredMethods(res, publicOnly);
  }
  
  void initialiseClass(Jnjvm* vm);
  JavaObject* getClassDelegatee(Jnjvm* vm, JavaObject* pd = 0);

  void resolveClass();

  UserClass* getSuper() {
    return super;
  }

  std::vector<UserClass*>* getInterfaces() {
    return &interfaces;
  }

  CommonClass::field_map* getStaticFields() {
    return classDef->getStaticFields();
  }
  
  CommonClass::field_map* getVirtualFields() {
    return classDef->getVirtualFields();
  }
  
  CommonClass::method_map* getStaticMethods() {
    return classDef->getStaticMethods();
  }
  
  CommonClass::method_map* getVirtualMethods() {
    return classDef->getVirtualMethods();
  }
  
  void resolveStaticClass() {
    ((Class*)classDef)->resolveStaticClass();
  }


  JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type,
                                    bool isStatic, bool recurse,
                                    UserClass*& methodCl);

  JavaMethod* lookupMethod(const UTF8* name, const UTF8* type,
                           bool isStatic, bool recurse, UserClass*& methodCl);

  JavaField* lookupField(const UTF8* name, const UTF8* type,
                         bool isStatic, bool recurse,
                         UserCommonClass*& fieldCl);
  
  JavaField* lookupFieldDontThrow(const UTF8* name, const UTF8* type,
                                  bool isStatic, bool recurse,
                                  UserCommonClass*& fieldCl);
  
  
  uint32 getVirtualSize() {
    return virtualSize;
  }

  VirtualTable* getVirtualVT() {
    return virtualVT;
  }

  void setInterfaces(std::vector<UserClass*> Is) {
    interfaces = Is;
  }

  void setSuper(UserClass* S) {
    super = S;
  }

  bool instantiationOfArray(UserClassArray* cl);
  bool implements(UserCommonClass* cl);

  /// constructMethod - Add a new method in this class method map.
  ///
  JavaMethod* constructMethod(const UTF8* name, const UTF8* type,
                              uint32 access) {
    return classDef->constructMethod(name, type, access);
  }
  
  /// constructField - Add a new field in this class field map.
  ///
  JavaField* constructField(const UTF8* name, const UTF8* type,
                            uint32 access) {
    return classDef->constructField(name, type, access);
  }


  UserClass* lookupClassFromMethod(JavaMethod* meth);
  UserCommonClass* getUserClass(CommonClass* cl);
  
  /// lockVar - When multiple threads want to initialize a class,
  /// they must be synchronized so that it is only performed once
  /// for a given class.
  mvm::Lock* lockVar;

  /// condVar - Used to wake threads waiting on the initialization
  /// process of this class, done by another thread.
  mvm::Cond* condVar;

  /// acquire - Acquire this class lock.
  ///
  void acquire() {
    lockVar->lock();
  }
  
  /// release - Release this class lock.
  ///
  void release() {
    lockVar->unlock();  
  }
  
    /// waitClass - Wait for the class to be loaded/initialized/resolved.
  ///
  void waitClass() {
    condVar->wait(lockVar);
  }
  
  /// broadcastClass - Unblock threads that were waiting on the class being
  /// loaded/initialized/resolved.
  ///
  void broadcastClass() {
    condVar->broadcast();  
  }

  /// ownerClass - Is the current thread the owner of this thread?
  ///
  bool ownerClass() {
    return mvm::Lock::selfOwner(lockVar);    
  }

  const UTF8* getSuperUTF8(){
    return classDef->superUTF8;
  }

  std::vector<const UTF8*>* getInterfacesUTF8(){
    return &classDef->interfacesUTF8;
  }
  
  UserCommonClass();
  
  virtual void print(mvm::PrintBuffer *buf) const;
};

class UserClass : public UserCommonClass {
public:
  static VirtualTable* VT;
  
  virtual void TRACER;

  UserClass(JnjvmClassLoader* JCL, const UTF8* name, ArrayUInt8* bytes);
  UserClass() {}

  JavaObject* doNew(Jnjvm* vm);
  
  std::vector<UserClass*> innerClasses;
  UserClass* outerClass;

  std::vector<UserClass*>* getInnerClasses() {
    return &innerClasses;
  }

  UserClass* getOuterClass() {
    return outerClass;
  }
  
  bool innerOuterResolved;

  void resolveInnerOuterClasses();
  
  void setInnerAccess(uint32 access) {
    ((Class*)classDef)->setInnerAccess(access);
  }

  JavaObject* getStaticInstance() {
    return staticInstance;
  }

  void setStaticInstance(JavaObject* obj) {
    staticInstance = obj;
  }
  
  UserConstantPool* getConstantPool() {
    return ctpInfo;
  }

  uint32 getStaticSize() {
    return ((Class*)classDef)->getStaticSize();
  }

  VirtualTable* getStaticVT() {
    return ((Class*)classDef)->getStaticVT();
  }
  
  /// loadParents - Loads and resolves the parents, i.e. super and interfarces,
  /// of the class.
  ///
  void loadParents();

  Attribut* lookupAttribut(const UTF8* Att) {
    return ((Class*)classDef)->lookupAttribut(Att);
  }

  ArrayUInt8* getBytes() {
    return ((Class*)classDef)->bytes;
  }
};

class UserClassArray : public UserCommonClass {
public:
  static VirtualTable* VT;
  UserCommonClass* _baseClass;
  AssessorDesc* _funcs;

  virtual void TRACER;
  UserClassArray(JnjvmClassLoader* JCL, const UTF8* name);
  UserClassArray() {}
  
  void resolveComponent();

  UserCommonClass* baseClass() {
    if (_baseClass == 0)
      resolveComponent();
    return _baseClass;
  }

  AssessorDesc* funcs() {
    if (_funcs == 0)
      resolveComponent();
    return _funcs;
  }
};

class UserClassPrimitive : public UserCommonClass {
  static VirtualTable* VT;
public:
  
  virtual void TRACER;
  UserClassPrimitive(JnjvmClassLoader* JCL, const UTF8* name, uint32 nb);
};

class UserConstantPool : public mvm::Object {
public:
  
  static VirtualTable* VT;
  /// ctpRes - Objects resolved dynamically, e.g. UTF8s, classes, methods,
  /// fields, strings.
  ///
  void*  ctpRes[1]; 
  
  /// resolveMethod - Resolve the class and the signature of the method. May
  /// perform class loading. This function is called just in time, ie when
  /// the method call is actually made and not yet resolved.
  ///
  void resolveMethod(uint32 index, UserCommonClass*& cl,
                     const UTF8*& utf8, Signdef*& sign);
  
  /// resolveField - Resolve the class and signature of the field. May
  /// perform class loading. This function is called just in time, ie when
  /// the field is accessed and not yet resolved.
  ///
  void resolveField(uint32 index, UserCommonClass*& cl, const UTF8*& utf8,
                    Typedef*& sign);
  
  UserClass* getClass() const {
    return (UserClass*)ctpRes[0];
  }

  JavaConstantPool* getSharedPool() const {
    return ((Class*)(getClass()->classDef))->ctpInfo;
  }

  /// UTF8At - Get the UTF8 referenced from this string entry.
  ///
  const UTF8* UTF8AtForString(uint32 entry) const {
    return getSharedPool()->UTF8AtForString(entry);
  }

  /// loadClass - Loads the class and returns it. This is called just in time, 
  /// ie when the class will be used and not yet resolved.
  ///
  UserCommonClass* loadClass(uint32 index);

  void* operator new(size_t sz, JavaAllocator* alloc, uint32 size);
  
  UserConstantPool(){}

  UserConstantPool(UserClass* cl) {
    ctpRes[0] = cl;
  }

  UserCommonClass* isClassLoaded(uint32 entry);

  virtual void print(mvm::PrintBuffer *buf) const;

};

} // end namespace jnjvm

#endif // JNJVM_CLASS_ISOLATE_H