| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;; Type definitions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| ;;; A virtual table is an array of function pointers. |
| %VT = type [0 x i32 (...)*] |
| |
| ;;; The root of all Java Objects: a VT (and a lock moved into GC header). |
| %JavaObject = type { %VT* } |
| |
| ;;; Types for Java arrays. A size of 0 means an undefined size. |
| %JavaArray = type { %JavaObject, i8* } |
| %ArrayDouble = type { %JavaObject, i8*, [0 x double] } |
| %ArrayFloat = type { %JavaObject, i8*, [0 x float] } |
| %ArrayLong = type { %JavaObject, i8*, [0 x i64] } |
| %ArrayObject = type { %JavaObject, i8*, [0 x %JavaObject*] } |
| %ArraySInt16 = type { %JavaObject, i8*, [0 x i16] } |
| %ArraySInt32 = type { %JavaObject, i8*, [0 x i32] } |
| %ArraySInt8 = type { %JavaObject, i8*, [0 x i8] } |
| %ArrayUInt16 = type { %JavaObject, i8*, [0 x i16] } |
| %ArrayUInt32 = type { %JavaObject, i8*, [0 x i32] } |
| %ArrayUInt8 = type { %JavaObject, i8*, [0 x i8] } |
| |
| ;;; The task class mirror. |
| ;;; Field 0: The class state |
| ;;; Field 1: The initialization state |
| ;;; Field 2: The static instance |
| %TaskClassMirror = type { i8, i1, i8* } |
| |
| %CircularBase = type { %VT*, %CircularBase*, %CircularBase* } |
| |
| ;;; Field 0: the parent (circular base) |
| ;;; Field 1: size_t IsolateID |
| ;;; Field 2: void* MyVM |
| ;;; Field 3: void* baseSP |
| ;;; Field 4: bool doYield |
| ;;; Field 5: bool inRV |
| ;;; Field 6: bool joinedRV |
| ;;; Field 7: void* lastSP |
| ;;; Field 8: void* internalThreadID |
| ;;; field 9: void* routine |
| ;;; field 10: void* lastKnownFrame |
| ;;; field 11: void* lastExceptionBuffer |
| %Thread = type { %CircularBase, i32, i8*, i8*, i1, i1, i1, i8*, i8*, i8*, i8*, i8* } |
| |
| %JavaThread = type { %MutatorThread, i8*, %JavaObject* } |
| |
| %JavaConstantPool = type { %JavaClass*, i32, i8*, i32*, i8** } |
| |
| %Attribute = type { %UTF8*, i32, i32 } |
| |
| %UTF8 = type { i32, [0 x i16] } |
| |
| |
| %JavaField = type { i8*, i16, %UTF8*, %UTF8*, %Attribute*, i16, %JavaClass*, i32, |
| i16 } |
| |
| %JavaMethod = type { i8*, i16, %Attribute*, i16, %JavaClass*, |
| %UTF8*, %UTF8*, i8, i8*, i32 } |
| |
| %JavaClassPrimitive = type { %JavaCommonClass, i32 } |
| %JavaClassArray = type { %JavaCommonClass, %JavaCommonClass* } |
| |
| %J3DenseMap = type { i32, i8*, i32, i32, i1 } |
| |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;; Make sure all named types are emitted ;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| declare void @listAllTypes(%JavaObject, |
| %JavaArray, |
| %JavaCommonClass, |
| %JavaClassPrimitive, |
| %JavaClassArray, |
| %JavaClass, |
| %ClassBytes, |
| %JavaConstantPool, |
| %ArrayUInt8, |
| %ArraySInt8, |
| %ArrayUInt16, |
| %ArraySInt16, |
| %ArrayUInt32, |
| %ArraySInt32, |
| %ArrayLong, |
| %ArrayDouble, |
| %ArrayFloat, |
| %ArrayObject, |
| %JavaField, |
| %JavaMethod, |
| %UTF8, |
| %Attribute, |
| %JavaThread, |
| %MutatorThread, |
| %J3DenseMap); |
| |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;; Constant calls for J3 runtime internal objects field accesses ;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| ;;; j3RuntimeInitialiseClass - Initialises the class. |
| declare %JavaClass* @j3RuntimeInitialiseClass(%JavaClass*) |
| |
| ;;; arrayLength - Get the length of an array. |
| declare i32 @arrayLength(%JavaObject*) readnone |
| |
| ;;; getVT - Get the VT of the object. |
| declare %VT* @getVT(%JavaObject*) readnone |
| |
| ;;; getIMT - Get the IMT of the VT. |
| declare %VT* @getIMT(%VT*) readnone |
| |
| ;;; getClass - Get the class of an object. |
| declare %JavaCommonClass* @getClass(%JavaObject*) readnone |
| |
| ;;; getLock - Get the lock of an object. |
| ;;;declare i8* @getLock(%JavaObject*) |
| |
| ;;; getVTFromCommonClass - Get the VT of a class from its runtime |
| ;;; representation. |
| declare %VT* @getVTFromCommonClass(%JavaCommonClass*) readnone |
| |
| ;;; getVTFromClass - Get the VT of a class from its runtime representation. |
| declare %VT* @getVTFromClass(%JavaClass*) readnone |
| |
| ;;; getVTFromClassArray - Get the VT of an array class from its runtime |
| ;;; representation. |
| declare %VT* @getVTFromClassArray(%JavaClassArray*) readnone |
| |
| ;;; getObjectSizeFromClass - Get the size of a class from its runtime |
| ;;; representation. |
| declare i32 @getObjectSizeFromClass(%JavaClass*) readnone |
| |
| ;;; getBaseClassVTFromVT - Get the VT of the base class of an array, or the |
| ;;; VT of the array class of a regular class. |
| declare %VT* @getBaseClassVTFromVT(%VT*) readnone |
| |
| ;;; getDisplay - Get the display array of this VT. |
| declare %VT** @getDisplay(%VT*) readnone |
| |
| ;;; getVTInDisplay - Get the super class at the given offset. |
| declare %VT* @getVTInDisplay(%VT**, i32) readnone |
| |
| ;;; getDepth - Get the depth of the VT. |
| declare i32 @getDepth(%VT*) readnone |
| |
| ;;; getStaticInstance - Get the static instance of this class. |
| declare i8* @getStaticInstance(%JavaClass*) readnone |
| |
| |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;; Generic Runtime methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| ;;; j3InterfaceLookup - Used for interface calls. |
| declare i8* @j3InterfaceLookup(%JavaClass*, i32, ...) |
| |
| ;;; j3MultiCallNew - Allocate multi-dimensional arrays. This will go to |
| ;;; allocation specific methods. |
| declare %JavaObject* @j3MultiCallNew(%JavaCommonClass*, i32, ...) |
| |
| ;;; initialisationCheck - Checks if the class has been initialized and |
| ;;; initializes if not. This is used for initialization barriers in an isolate |
| ;;; environment, and in some specific scenario in a single environment. |
| declare %JavaClass* @initialisationCheck(%JavaClass*) readnone |
| |
| ;;; forceInitialisationCheck - Force to check initialization. The difference |
| ;;; between this function and the initialisationCheck function is that the |
| ;;; latter is readnone and can thus be removed. This function is removed |
| ;;; by J3 after the GVN pass, therefore it does not have an actual |
| ;;; implementation. |
| declare void @forceInitialisationCheck(%JavaClass*) |
| |
| ;;; forceLoadedCheck - Force to check if the class was loaded. Since we do |
| ;;; not want to run Java code in a callback, we have to make sure the class |
| ;;; of the method that we want to compile is loaded. This is used for |
| ;;; the invokespecial bytecode. |
| declare void @forceLoadedCheck(%JavaCommonClass*) |
| |
| ;;; getConstantPoolAt - Get the value in the constant pool of this class. |
| ;;; This function is removed by J3's LLVM pass, therefore it does |
| ;;; not have an actual implementation. |
| declare i8* @getConstantPoolAt(i8* (%JavaClass*, i32, ...)*, i8**, |
| %JavaClass*, i32, ...) |
| |
| ;;; j3VirtualTableLookup - Look up the offset in a virtual table of a |
| ;;; specific function. |
| declare i32 @j3VirtualTableLookup(%JavaClass*, i32, i32*, %JavaObject*) |
| |
| ;;; j3ClassLookup - Look up a specific class. The function takes a class and |
| ;;; an index to lookup in the constant pool and returns and stores it in the |
| ;;; constant pool cache. |
| declare i8* @j3ClassLookup(%JavaClass*, i32, ...) |
| |
| ;;; j3VirtualFieldLookup - Look up a specific virtual field. |
| declare i8* @j3VirtualFieldLookup(%JavaClass*, i32, ...) |
| |
| ;;; j3StaticFieldLookup - Look up a specific static field. |
| declare i8* @j3StaticFieldLookup(%JavaClass*, i32, ...) |
| |
| ;;; j3StringLookup - Get a pointer on a string. |
| declare i8* @j3StringLookup(%JavaClass*, i32, ...) readnone |
| |
| ;;; j3JavaObjectAquire - This function is called when starting a synchronized |
| ;;; block or method. |
| declare void @j3JavaObjectAquire(%JavaObject*) |
| |
| ;;; j3JavaObjectRelease - This function is called when leaving a synchronized |
| ;;; block or method. |
| declare void @j3JavaObjectRelease(%JavaObject*) |
| |
| ;;; isSubclassOf - Returns if a type is a subtype of another type. |
| declare i1 @isSubclassOf(%VT*, %VT*) readnone |
| |
| ;;; isSubclassOf - Returns if a type is a subtype of another type. |
| declare i1 @isSubclassOf_Inner(%VT*, %VT*) readnone |
| |
| ;;; isSubclassOf - Returns if a type is a subtype of another type. |
| declare i1 @checkIfObjectIsAssignableToArrayPosition(%JavaObject*, %JavaObject*) readnone |
| |
| ;;; isSecondaryClass - Returns if a type is a secondary super type of |
| ;;; another type. |
| declare i1 @isSecondaryClass(%VT*, %VT*) readnone |
| |
| ;;; isSecondaryClass_Inner - Returns if a type is a secondary super type of |
| ;;; another type. |
| declare i1 @isSecondaryClass_Inner(%VT*, %VT*) readnone |
| |
| ;;; getClassDelegatee - Returns the java/lang/Class representation of the |
| ;;; class. This method is lowered to the GEP to the class delegatee in |
| ;;; the common class. |
| declare %JavaObject* @getClassDelegatee(%JavaCommonClass*) |
| |
| ;;; j3RuntimeDelegatee - Returns the java/lang/Class representation of the |
| ;;; class. This method is called if the class delegatee has not been created |
| ;;; yet. |
| declare %JavaObject* @j3RuntimeDelegatee(%JavaCommonClass*) |
| |
| ;;; j3GetArrayClass - Get the array user class of the user class. |
| declare %VT* @j3GetArrayClass(%JavaClass*, i32, %VT**) readnone |
| |
| declare i8 @getFinalInt8Field(i8*) readnone |
| declare i16 @getFinalInt16Field(i16*) readnone |
| declare i32 @getFinalInt32Field(i32*) readnone |
| declare i64 @getFinalLongField(i64*) readnone |
| declare double @getFinalDoubleField(double*) readnone |
| declare float @getFinalFloatField(float*) readnone |
| |
| declare i8* @j3ResolveVirtualStub(%JavaObject*) |
| declare i8* @j3ResolveSpecialStub() |
| declare i8* @j3ResolveStaticStub() |
| declare i8* @j3ResolveInterface(%JavaObject*, %JavaMethod*, i32) |
| |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Exception methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| declare %JavaObject* @j3NullPointerException() |
| declare %JavaObject* @j3ClassCastException(%JavaObject*, %JavaCommonClass*) |
| declare %JavaObject* @j3IndexOutOfBoundsException(%JavaObject*, i32) |
| declare %JavaObject* @j3NegativeArraySizeException(i32) |
| declare %JavaObject* @j3OutOfMemoryError(i32) |
| declare %JavaObject* @j3StackOverflowError() |
| declare %JavaObject* @j3ArrayStoreException(%VT*, %VT*) |
| declare %JavaObject* @j3ArithmeticException() |
| declare void @j3ThrowException(%JavaObject*) |
| declare void @j3ThrowExceptionFromJIT() |
| |
| declare void @j3EndJNI(i32**) |
| declare void @j3StartJNI(i32*, i32**, i8*) |
| |
| |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Debugging methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| declare void @j3PrintExecution(i32, i32, %JavaMethod*) |
| declare void @j3PrintMethodStart(%JavaMethod*) |
| declare void @j3PrintMethodEnd(%JavaMethod*) |
