| //===--------------- JavaTypes.h - Java primitives ------------------------===// |
| // |
| // JnJVM |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef JNJVM_JAVA_TYPES_H |
| #define JNJVM_JAVA_TYPES_H |
| |
| #include "types.h" |
| |
| #include "mvm/JIT.h" |
| #include "mvm/Object.h" |
| |
| namespace jnjvm { |
| |
| class Classpath; |
| class ClassArray; |
| class CommonClass; |
| class JavaArray; |
| class JavaJIT; |
| class JavaObject; |
| class Jnjvm; |
| class JnjvmBootstrapLoader; |
| class JnjvmClassLoader; |
| class UserClassArray; |
| class UserClassPrimitive; |
| class UserCommonClass; |
| class UTF8; |
| class UTF8Map; |
| |
| #define VOID_ID 0 |
| #define BOOL_ID 1 |
| #define BYTE_ID 2 |
| #define CHAR_ID 3 |
| #define SHORT_ID 4 |
| #define INT_ID 5 |
| #define FLOAT_ID 6 |
| #define LONG_ID 7 |
| #define DOUBLE_ID 8 |
| #define OBJECT_ID 9 |
| #define ARRAY_ID 10 |
| #define NUM_ASSESSORS 11 |
| |
| static const char I_TAB = '['; |
| static const char I_END_REF = ';'; |
| static const char I_PARG = '('; |
| static const char I_PARD = ')'; |
| static const char I_BYTE = 'B'; |
| static const char I_CHAR = 'C'; |
| static const char I_DOUBLE = 'D'; |
| static const char I_FLOAT = 'F'; |
| static const char I_INT = 'I'; |
| static const char I_LONG = 'J'; |
| static const char I_REF = 'L'; |
| static const char I_SHORT = 'S'; |
| static const char I_VOID = 'V'; |
| static const char I_BOOL = 'Z'; |
| static const char I_SEP = '/'; |
| |
| /// Typedef - Each class has a Typedef representation. A Typedef is also a class |
| /// which has not been loaded yet. Typedefs are hashed on the name of the class. |
| /// Hashing is for memory purposes, not for comparison. |
| /// |
| class Typedef { |
| public: |
| |
| /// keyName - The name of the Typedef. It is the representation of a class |
| /// in a Java signature, e.g. "Ljava/lang/Object;". |
| /// |
| const UTF8* keyName; |
| |
| /// humanPrintArgs - Prints the list of typedef in a human readable form. |
| /// |
| static void humanPrintArgs(const std::vector<Typedef*>*, |
| mvm::PrintBuffer* buf); |
| |
| /// tPrintBuf - Prints the name of the class this Typedef represents. |
| /// |
| virtual void tPrintBuf(mvm::PrintBuffer* buf) const = 0; |
| |
| /// printString - Print the Typedef for debugging purposes. |
| /// |
| const char* printString() const; |
| |
| /// assocClass - Given the loaded, try to load the class represented by this |
| /// Typedef. |
| /// |
| virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const = 0; |
| |
| /// Typedef - Create a new Typedef. |
| /// |
| static Typedef* constructType(const UTF8* name, UTF8Map* map, Jnjvm* vm); |
| |
| virtual bool trace() const = 0; |
| |
| virtual bool isPrimitive() const { |
| return false; |
| } |
| |
| virtual bool isReference() const { |
| return true; |
| } |
| |
| virtual bool isUnsigned() const { |
| return false; |
| } |
| |
| virtual const UTF8* getName() const { |
| return keyName; |
| } |
| |
| const UTF8* getKey() const { |
| return keyName; |
| } |
| |
| }; |
| |
| class PrimitiveTypedef : public Typedef { |
| private: |
| UserClassPrimitive* prim; |
| bool unsign; |
| char charId; |
| |
| public: |
| |
| /// tPrintBuf - Prints the name of the class this Typedef represents. |
| /// |
| virtual void tPrintBuf(mvm::PrintBuffer* buf) const; |
| |
| |
| virtual bool trace() const { |
| return false; |
| } |
| |
| virtual bool isPrimitive() const { |
| return true; |
| } |
| |
| virtual bool isReference() const { |
| return false; |
| } |
| |
| virtual bool isUnsigned() const { |
| return unsign; |
| } |
| |
| virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const { |
| return (UserCommonClass*)prim; |
| } |
| |
| PrimitiveTypedef(const UTF8* name, UserClassPrimitive* cl, bool u, char i) { |
| keyName = name; |
| prim = cl; |
| unsign = u; |
| charId = i; |
| } |
| |
| bool isVoid() const { |
| return charId == I_VOID; |
| } |
| |
| bool isLong() const { |
| return charId == I_LONG; |
| } |
| |
| bool isInt() const { |
| return charId == I_INT; |
| } |
| |
| bool isChar() const { |
| return charId == I_CHAR; |
| } |
| |
| bool isShort() const { |
| return charId == I_SHORT; |
| } |
| |
| bool isByte() const { |
| return charId == I_BYTE; |
| } |
| |
| bool isBool() const { |
| return charId == I_BOOL; |
| } |
| |
| bool isFloat() const { |
| return charId == I_FLOAT; |
| } |
| |
| bool isDouble() const { |
| return charId == I_DOUBLE; |
| } |
| |
| /// JInfo - Holds info useful for the JIT. |
| /// |
| mvm::JITInfo* JInfo; |
| |
| /// getInfo - Get the JIT info of this signature. The info is created lazely. |
| /// |
| template<typename Ty> |
| Ty *getInfo() { |
| if (!JInfo) { |
| JInfo = new Ty(this); |
| } |
| |
| assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo && |
| "Invalid concrete type or multiple inheritence for getInfo"); |
| return static_cast<Ty*>(JInfo); |
| } |
| }; |
| |
| class ArrayTypedef : public Typedef { |
| public: |
| /// tPrintBuf - Prints the name of the class this Typedef represents. |
| /// |
| virtual void tPrintBuf(mvm::PrintBuffer* buf) const; |
| |
| |
| virtual bool trace() const { |
| return true; |
| } |
| |
| virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const; |
| |
| ArrayTypedef(const UTF8* name) { |
| keyName = name; |
| } |
| }; |
| |
| class ObjectTypedef : public Typedef { |
| private: |
| /// pseudoAssocClassName - The real name of the class this Typedef |
| /// represents, e.g. "java/lang/Object" |
| /// |
| const UTF8* pseudoAssocClassName; |
| |
| public: |
| /// tPrintBuf - Prints the name of the class this Typedef represents. |
| /// |
| virtual void tPrintBuf(mvm::PrintBuffer* buf) const; |
| |
| virtual bool trace() const { |
| return true; |
| } |
| |
| virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const; |
| |
| ObjectTypedef(const UTF8*name, UTF8Map* map); |
| |
| virtual const UTF8* getName() const { |
| return pseudoAssocClassName; |
| } |
| |
| }; |
| |
| |
| /// Signdef - This class represents a Java signature. Each Java method has a |
| /// Java signature. Signdefs are hashed for memory purposes, not equality |
| /// purposes. |
| /// |
| class Signdef { |
| private: |
| |
| /// _staticCallBuf - A dynamically generated method which calls a static Java |
| /// function with the specific signature and receive the arguments in a |
| /// buffer. |
| /// |
| intptr_t _staticCallBuf; |
| intptr_t staticCallBuf(); |
| |
| /// _virtualCallBuf - A dynamically generated method which calls a virtual |
| /// Java function with the specific signature and receive the arguments in a |
| /// buffer. |
| /// |
| intptr_t _virtualCallBuf; |
| intptr_t virtualCallBuf(); |
| |
| /// _staticCallAP - A dynamically generated method which calls a static Java |
| /// function with the specific signature and receive the arguments in a |
| /// variable argument handle. |
| /// |
| intptr_t _staticCallAP; |
| intptr_t staticCallAP(); |
| |
| /// _virtualCallBuf - A dynamically generated method which calls a virtual |
| /// Java function with the specific signature and receive the arguments in a |
| /// variable argument handle. |
| /// |
| intptr_t _virtualCallAP; |
| intptr_t virtualCallAP(); |
| |
| public: |
| |
| /// args - The arguments as Typedef of this signature. |
| /// |
| std::vector<Typedef*> args; |
| |
| /// ret - The Typedef return of this signature. |
| /// |
| Typedef* ret; |
| |
| /// initialLoader - The loader that first loaded this typedef. |
| /// |
| JnjvmClassLoader* initialLoader; |
| |
| /// keyName - The Java name of the signature, e.g. "()V". |
| /// |
| const UTF8* keyName; |
| |
| /// printString - Print the signature for debugging purposes. |
| /// |
| const char* printString() const; |
| |
| /// printWithSign - Print the signature of a method with the method's class |
| /// and name. |
| /// |
| void printWithSign(CommonClass* cl, const UTF8* name, mvm::PrintBuffer* buf); |
| |
| /// Signdef - Create a new Signdef. |
| /// |
| Signdef(const UTF8* name, JnjvmClassLoader* loader); |
| |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // Inline calls to get the dynamically generated functions to call Java |
| // functions. Note that this calls the JIT. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| intptr_t getStaticCallBuf() { |
| if(!_staticCallBuf) return staticCallBuf(); |
| return _staticCallBuf; |
| } |
| |
| intptr_t getVirtualCallBuf() { |
| if(!_virtualCallBuf) return virtualCallBuf(); |
| return _virtualCallBuf; |
| } |
| |
| intptr_t getStaticCallAP() { |
| if (!_staticCallAP) return staticCallAP(); |
| return _staticCallAP; |
| } |
| |
| intptr_t getVirtualCallAP() { |
| if (!_virtualCallAP) return virtualCallAP(); |
| return _virtualCallAP; |
| } |
| |
| void setStaticCallBuf(intptr_t code) { |
| _staticCallBuf = code; |
| } |
| |
| void setVirtualCallBuf(intptr_t code) { |
| _virtualCallBuf = code; |
| } |
| |
| void setStaticCallAP(intptr_t code) { |
| _staticCallAP = code; |
| } |
| |
| void setVirtualCallAP(intptr_t code) { |
| _virtualCallAP = code; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // End of inlined methods of getting dynamically generated functions. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| |
| /// JInfo - Holds info useful for the JIT. |
| /// |
| mvm::JITInfo* JInfo; |
| |
| /// getInfo - Get the JIT info of this signature. The info is created lazely. |
| /// |
| template<typename Ty> |
| Ty *getInfo() { |
| if (!JInfo) { |
| JInfo = new Ty(this); |
| } |
| |
| assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo && |
| "Invalid concrete type or multiple inheritence for getInfo"); |
| return static_cast<Ty*>(JInfo); |
| } |
| |
| }; |
| |
| |
| } // end namespace jnjvm |
| |
| #endif |