[vmkit-commits] [PATCH] Add NYI'd implementations of all JVM_* methods
Nicolas Geoffray
nicolas.geoffray at gmail.com
Thu Oct 27 09:40:51 PDT 2011
Please commit modulo one comment :)
> From 289714c204fb704079d915bfcb800242c63069ad Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Wed, 26 Oct 2011 19:52:31 -0500
> Subject: [PATCH 1/3] Add NYI'd implementations of JVM_* in new file
> OpenJDK.inc
> ---
> lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp | 1 +
> lib/J3/ClassLib/OpenJDK/OpenJDK.inc | 1466
> +++++++++++++++++++++++++++++++
> 2 files changed, 1467 insertions(+), 0 deletions(-)
> create mode 100644 lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> index 9030fb6..99bcce5 100644
> --- a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> +++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
> @@ -1073,3 +1073,4 @@ void Classpath::initialiseClasspath(JnjvmClassLoader*
> loader) {
> #include "Classpath.inc"
> #include "ClasspathField.inc"
> #include "ClasspathMethod.inc"
> +#include "OpenJDK.inc"
> diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> new file mode 100644
> index 0000000..ae64e32
> --- /dev/null
> +++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
> @@ -0,0 +1,1466 @@
> +// vim: set ft=cpp:
> +// TODO: Add comment header like the rest of VMKit
>
Please fix the TODO :)
> +
> +#include <jvm.h>
> +
> +#define NYI() \
> + do{ assert(0 && "Not yet implemented!"); abort(); } while(0)
> +
> +
> +JNIEXPORT jint JNICALL
> +JVM_GetInterfaceVersion(void) {
> + NYI();
> +}
> +
> +jint JVM_CreateJavaVM(JavaVM **pvm, void **penv, void *args) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_IHashCode(JNIEnv *env, jobject _obj) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_MonitorNotify(JNIEnv *env, jobject obj) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_MonitorNotifyAll(JNIEnv *env, jobject obj) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_Clone(JNIEnv *env, jobject obj) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.String
> + */
> +JNIEXPORT jstring JNICALL
> +JVM_InternString(JNIEnv *env, jstring _str) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.System
> + */
> +JNIEXPORT jlong JNICALL
> +JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored) {
> + NYI();
> +}
> +
> +JNIEXPORT jlong JNICALL
> +JVM_NanoTime(JNIEnv *env, jclass ignored) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject jsrc, jint sstart,
> + jobject jdst, jint dstart, jint len) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_InitProperties(JNIEnv *env, jobject p) {
> + NYI();
> +}
> +
> +/*
> + * java.io.File
> + */
> +JNIEXPORT void JNICALL
> +JVM_OnExit(void (*func)(void)) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.Runtime
> + */
> +JNIEXPORT void JNICALL
> +JVM_Exit(jint code) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_Halt(jint code) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_GC(void) {
> + NYI();
> +}
> +
> +/* Returns the number of real-time milliseconds that have elapsed since
> the
> + * least-recently-inspected heap object was last inspected by the garbage
> + * collector.
> + *
> + * For simple stop-the-world collectors this value is just the time
> + * since the most recent collection. For generational collectors it is
> the
> + * time since the oldest generation was most recently collected. Other
> + * collectors are free to return a pessimistic estimate of the elapsed
> time, or
> + * simply the time since the last full collection was performed.
> + *
> + * Note that in the presence of reference objects, a given object that is
> no
> + * longer strongly reachable may have to be inspected multiple times
> before it
> + * can be reclaimed.
> + */
> +JNIEXPORT jlong JNICALL
> +JVM_MaxObjectInspectionAge(void) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_TraceInstructions(jboolean on) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_TraceMethodCalls(jboolean on) {
> + NYI();
> +}
> +
> +JNIEXPORT jlong JNICALL
> +JVM_TotalMemory(void) {
> + NYI();
> +}
> +
> +JNIEXPORT jlong JNICALL
> +JVM_FreeMemory(void) {
> + NYI();
> +}
> +
> +JNIEXPORT jlong JNICALL
> +JVM_MaxMemory(void) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_ActiveProcessorCount(void) {
> + NYI();
> +}
> +
> +JNIEXPORT void * JNICALL
> +JVM_LoadLibrary(const char *name) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_UnloadLibrary(void * handle) {
> + NYI();
> +}
> +
> +JNIEXPORT void * JNICALL
> +JVM_FindLibraryEntry(void *handle, const char *name) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_IsSupportedJNIVersion(jint version) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.Float and java.lang.Double
> + */
> +JNIEXPORT jboolean JNICALL
> +JVM_IsNaN(jdouble d) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.Throwable
> + */
> +JNIEXPORT void JNICALL
> +JVM_FillInStackTrace(JNIEnv *env, jobject throwable) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_PrintStackTrace(JNIEnv *env, jobject throwable, jobject printable) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.Compiler
> + */
> +JNIEXPORT void JNICALL
> +JVM_InitializeCompiler (JNIEnv *env, jclass compCls) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_IsSilentCompiler(JNIEnv *env, jclass compCls) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_EnableCompiler(JNIEnv *env, jclass compCls) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_DisableCompiler(JNIEnv *env, jclass compCls) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.Thread
> + */
> +JNIEXPORT void JNICALL
> +JVM_StartThread(JNIEnv *env, jobject _thread) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_StopThread(JNIEnv *env, jobject thread, jobject exception) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_IsThreadAlive(JNIEnv *env, jobject _thread) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_SuspendThread(JNIEnv *env, jobject thread) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_ResumeThread(JNIEnv *env, jobject thread) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_Yield(JNIEnv *env, jclass threadClass) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_CurrentThread(JNIEnv *env, jclass threadClass) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_CountStackFrames(JNIEnv *env, jobject thread) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_Interrupt(JNIEnv *env, jobject thread) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted)
> {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_DumpAllStacks(JNIEnv *env, jclass unused) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetAllThreads(JNIEnv *env, jclass dummy) {
> + NYI();
> +}
> +
> +/* getStackTrace() and getAllStackTraces() method */
> +JNIEXPORT jobjectArray JNICALL
> +JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.SecurityManager
> + */
> +JNIEXPORT jclass JNICALL
> +JVM_CurrentLoadedClass(JNIEnv *env) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_CurrentClassLoader(JNIEnv *env) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassContext(JNIEnv *env) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_ClassDepth(JNIEnv *env, jstring name) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_ClassLoaderDepth(JNIEnv *env) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.Package
> + */
> +JNIEXPORT jstring JNICALL
> +JVM_GetSystemPackage(JNIEnv *env, jstring name) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetSystemPackages(JNIEnv *env) {
> + NYI();
> +}
> +
> +/*
> + * java.io.ObjectInputStream
> + */
> +JNIEXPORT jobject JNICALL
> +JVM_AllocateNewObject(JNIEnv *env, jobject obj, jclass currClass,
> + jclass initClass) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass,
> + jint length) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_LatestUserDefinedLoader(JNIEnv *env) {
> + NYI();
> +}
> +
> +/*
> + * This function has been deprecated and should not be considered
> + * part of the specified JVM interface.
> + */
> +JNIEXPORT jclass JNICALL
> +JVM_LoadClass0(JNIEnv *env, jobject obj, jclass currClass,
> + jstring currClassName) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.reflect.Array
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetArrayLength(JNIEnv *env, jobject arr) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jvalue JNICALL
> +JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint
> wCode) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue
> v,
> + unsigned char vCode) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_NewArray(JNIEnv *env, jclass eltClass, jint length) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.Class and java.lang.ClassLoader
> + */
> +/*
> + * Returns the class in which the code invoking the native method
> + * belongs.
> + *
> + * Note that in JDK 1.1, native methods did not create a frame.
> + * In 1.2, they do. Therefore native methods like Class.forName
> + * can no longer look at the current frame for the caller class.
> + */
> +JNIEXPORT jclass JNICALL
> +JVM_GetCallerClass(JNIEnv *env, int n) {
> + NYI();
> +}
> +
> +/*
> + * Find primitive classes
> + * utf: class name
> + */
> +
> +JNIEXPORT jclass JNICALL
> +JVM_FindPrimitiveClass(JNIEnv *env, const char *utf) {
> + NYI();
> +}
> +
> +/*
> + * Link the class
> + */
> +JNIEXPORT void JNICALL
> +JVM_ResolveClass(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +/*
> + * Find a class from a given class loader. Throw ClassNotFoundException
> + * or NoClassDefFoundError depending on the value of the last
> + * argument.
> + */
> +JNIEXPORT jclass JNICALL
> +JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,
> + jobject _loader, jboolean throwError) {
> + NYI();
> +}
> +
> +JNIEXPORT jclass JNICALL
> +JVM_FindClassFromBootLoader(JNIEnv *env, const char *name) {
> + NYI();
> +}
> +
> +/*
> + * Find a class from a given class.
> + */
> +JNIEXPORT jclass JNICALL
> +JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,
> + jclass from) {
> + NYI();
> +}
> +
> +/* Find a loaded class cached by the VM */
> +JNIEXPORT jclass JNICALL
> +JVM_FindLoadedClass(JNIEnv *env, jobject _loader, jstring name) {
> + NYI();
> +}
> +
> +/* Define a class */
> +JNIEXPORT jclass JNICALL
> +JVM_DefineClass(JNIEnv *env, const char *name, jobject _loader, const
> jbyte *buf,
> + jsize len, jobject pd) {
> + NYI();
> +}
> +
> +/* Define a class with a source (added in JDK1.5) */
> +JNIEXPORT jclass JNICALL
> +JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
> + const jbyte *buf, jsize len, jobject pd,
> + const char *source) {
> + NYI();
> +}
> +
> +/* Define a class with a source with conditional verification (added HSX
> 14)
> + * -Xverify:all will verify anyway, -Xverify:none will not verify,
> + * -Xverify:remote (default) will obey this conditional
> + * i.e. true = should_verify_class
> + */
> +JNIEXPORT jclass JNICALL
> +JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name, jobject
> loader,
> + const jbyte *buf, jsize len, jobject pd,
> + const char *source, jboolean verify) {
> + NYI();
> +}
> +
> +/*
> + * Reflection support functions
> + */
> +
> +JNIEXPORT jstring JNICALL
> +JVM_GetClassName(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_GetClassLoader(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_IsInterface(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassSigners(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_GetProtectionDomain(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject
> protection_domain) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_IsArrayClass(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_IsPrimitiveClass(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jclass JNICALL
> +JVM_GetComponentType(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
> + NYI();
> +}
> +
> +JNIEXPORT jclass JNICALL
> +JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
> + NYI();
> +}
> +
> +/* Generics support (JDK 1.5) */
> +JNIEXPORT jstring JNICALL
> +JVM_GetClassSignature(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +/* Annotations support (JDK 1.5) */
> +JNIEXPORT jbyteArray JNICALL
> +JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +/*
> + * New (JDK 1.4) reflection implementation
> + */
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean
> publicOnly) {
> + NYI();
> +}
> +
> +/* Differs from JVM_GetClassModifiers in treatment of inner classes.
> + This returns the access flags for the class as specified in the
> + class file rather than searching the InnerClasses attribute (if
> + present) to find the source-level access flags. Only the values of
> + the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
> + valid. */
> +JNIEXPORT jint JNICALL
> +JVM_GetClassAccessFlags(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +/* The following two reflection routines are still needed due to startup
> time issues */
> +/*
> + * java.lang.reflect.Method
> + */
> +JNIEXPORT jobject JNICALL
> +JVM_InvokeMethod(JNIEnv *env, jobject method, jobject _obj, jobjectArray
> args0) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.reflect.Constructor
> + */
> +JNIEXPORT jobject JNICALL
> +JVM_NewInstanceFromConstructor(JNIEnv *env, jobject _c, jobjectArray
> args0) {
> + NYI();
> +}
> +
> +/*
> + * Constant pool access; currently used to implement reflective access to
> annotations (JDK 1.5
> + */
> +
> +JNIEXPORT jobject JNICALL
> +JVM_GetClassConstantPool(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize
> +(JNIEnv *env, jobject unused, jobject jcpool) {
> + NYI();
> +}
> +
> +JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
> +(JNIEnv *env, jobject unused, jobject jcpool, jint index) {
> + NYI();
> +}
> +
> +/*
> + * java.security.*
> + */
> +
> +JNIEXPORT jobject JNICALL
> +JVM_DoPrivileged(JNIEnv *env, jclass cls,
> + jobject action, jobject context, jboolean wrapException)
> {
> + NYI();
> +}
> +
> +JNIEXPORT jobject JNICALL
> +JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +
> +JNIEXPORT jobject JNICALL
> +JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls) {
> + NYI();
> +}
> +
> +/*
> + * Signal support, used to implement the shutdown sequence. Every VM must
> + * support JVM_SIGINT and JVM_SIGTERM, raising the former for user
> interrupts
> + * (^C) and the latter for external termination (kill, system shutdown,
> etc.).
> + * Other platform-dependent signal values may also be supported.
> + */
> +
> +JNIEXPORT void * JNICALL
> +JVM_RegisterSignal(jint sig, void *handler) {
> + NYI();
> +}
> +
> +JNIEXPORT jboolean JNICALL
> +JVM_RaiseSignal(jint sig) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_FindSignal(const char *name) {
> + NYI();
> +}
> +
> +/*
> + * Retrieve the assertion directives for the specified class.
> + */
> +JNIEXPORT jboolean JNICALL
> +JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls) {
> + NYI();
> +}
> +
> +/*
> + * Retrieve the assertion directives from the VM.
> + */
> +JNIEXPORT jobject JNICALL
> +JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused) {
> + NYI();
> +}
> +
> +/*
> + * java.util.concurrent.AtomicLong
> + */
> +JNIEXPORT jboolean JNICALL
> +JVM_SupportsCX8(void) {
> + NYI();
> +}
> +
> +/*************************************************************************
> + PART 2: Support for the Verifier and Class File Format Checker
> + ************************************************************************/
> +/*
> + * Return the class name in UTF format. The result is valid
> + * until JVM_ReleaseUTf is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetClassNameUTF(JNIEnv *env, jclass cb) {
> + NYI();
> +}
> +
> +/*
> + * Returns the constant pool types in the buffer provided by "types."
> + */
> +JNIEXPORT void JNICALL
> +JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types) {
> + NYI();
> +}
> +
> +/*
> + * Returns the number of Constant Pool entries.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb) {
> + NYI();
> +}
> +
> +/*
> + * Returns the number of *declared* fields or methods.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetClassFieldsCount(JNIEnv *env, jclass cb) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_GetClassMethodsCount(JNIEnv *env, jclass cb) {
> + NYI();
> +}
> +
> +/*
> + * Returns the CP indexes of exceptions raised by a given method.
> + * Places the result in the given buffer.
> + *
> + * The method is identified by method_index.
> + */
> +JNIEXPORT void JNICALL
> +JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,
> + unsigned short *exceptions) {
> + NYI();
> +}
> +
> +/*
> + * Returns the number of exceptions raised by a given method.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index)
> {
> + NYI();
> +}
> +
> +/*
> + * Returns the byte code sequence of a given method.
> + * Places the result in the given buffer.
> + *
> + * The method is identified by method_index.
> + */
> +JNIEXPORT void JNICALL
> +JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,
> + unsigned char *code) {
> + NYI();
> +}
> +
> +/*
> + * Returns the length of the byte code sequence of a given method.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the exception table entry at entry_index of a given method.
> + * Places the result in the given buffer.
> + *
> + * The method is identified by method_index.
> + */
> +JNIEXPORT void JNICALL
> +JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint
> method_index,
> + jint entry_index,
> + JVM_ExceptionTableEntryType *entry) {
> + NYI();
> +}
> +
> +/*
> + * Returns the length of the exception table of a given method.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the modifiers of a given field.
> + * The field is identified by field_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the modifiers of a given method.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the number of local variables of a given method.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the number of arguments (including this pointer) of a given
> method.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the maximum amount of stack (in words) used by a given method.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index) {
> + NYI();
> +}
> +
> +/*
> + * Is a given method a constructor.
> + * The method is identified by method_index.
> + */
> +JNIEXPORT jboolean JNICALL
> +JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the name of a given method in UTF format.
> + * The result remains valid until JVM_ReleaseUTF is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the signature of a given method in UTF format.
> + * The result remains valid until JVM_ReleaseUTF is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the name of the field refered to at a given constant pool
> + * index.
> + *
> + * The result is in UTF format and remains valid until JVM_ReleaseUTF
> + * is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the name of the method refered to at a given constant pool
> + * index.
> + *
> + * The result is in UTF format and remains valid until JVM_ReleaseUTF
> + * is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the signature of the method refered to at a given constant pool
> + * index.
> + *
> + * The result is in UTF format and remains valid until JVM_ReleaseUTF
> + * is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the signature of the field refered to at a given constant pool
> + * index.
> + *
> + * The result is in UTF format and remains valid until JVM_ReleaseUTF
> + * is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the class name refered to at a given constant pool index.
> + *
> + * The result is in UTF format and remains valid until JVM_ReleaseUTF
> + * is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the class name refered to at a given constant pool index.
> + *
> + * The constant pool entry must refer to a CONSTANT_Fieldref.
> + *
> + * The result is in UTF format and remains valid until JVM_ReleaseUTF
> + * is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the class name refered to at a given constant pool index.
> + *
> + * The constant pool entry must refer to CONSTANT_Methodref or
> + * CONSTANT_InterfaceMethodref.
> + *
> + * The result is in UTF format and remains valid until JVM_ReleaseUTF
> + * is called.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + */
> +JNIEXPORT const char * JNICALL
> +JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index) {
> + NYI();
> +}
> +
> +/*
> + * Returns the modifiers of a field in calledClass. The field is
> + * referred to in class cb at constant pool entry index.
> + *
> + * The caller must treat the string as a constant and not modify it
> + * in any way.
> + *
> + * Returns -1 if the field does not exist in calledClass.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass
> calledClass) {
> + NYI();
> +}
> +
> +/*
> + * Returns the modifiers of a method in calledClass. The method is
> + * referred to in class cb at constant pool entry index.
> + *
> + * Returns -1 if the method does not exist in calledClass.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass
> calledClass) {
> + NYI();
> +}
> +
> +/*
> + * Releases the UTF string obtained from the VM.
> + */
> +JNIEXPORT void JNICALL
> +JVM_ReleaseUTF(const char *utf) {
> + NYI();
> +}
> +
> +/*
> + * Compare if two classes are in the same package.
> + */
> +JNIEXPORT jboolean JNICALL
> +JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2) {
> + NYI();
> +}
> +
> +/* Write a string into the given buffer, in the platform's local encoding,
> + * that describes the most recent system-level error to occur in this
> thread.
> + * Return the length of the string or zero if no error occurred.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_GetLastErrorString(char *buf, int len) {
> + NYI();
> +}
> +
> +/*
> + * Convert a pathname into native format. This function does syntactic
> + * cleanup, such as removing redundant separator characters. It modifies
> + * the given pathname string in place.
> + */
> +JNIEXPORT char * JNICALL
> +JVM_NativePath(char * path) {
> + NYI();
> +}
> +
> +/*
> + * Open a file descriptor. This function returns a negative error code
> + * on error, and a non-negative integer that is the file descriptor on
> + * success.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_Open(const char *fname, jint flags, jint mode) {
> + NYI();
> +}
> +
> +/*
> + * Close a file descriptor. This function returns -1 on error, and 0
> + * on success.
> + *
> + * fd the file descriptor to close.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_Close(jint fd) {
> + NYI();
> +}
> +
> +/*
> + * Read data from a file decriptor into a char array.
> + *
> + * fd the file descriptor to read from.
> + * buf the buffer where to put the read data.
> + * nbytes the number of bytes to read.
> + *
> + * This function returns -1 on error, and 0 on success.
> + * (WDTZ: If I return '0' on success, things die. Returning
> + * number of bytes read instead for now)
> + */
> +JNIEXPORT jint JNICALL
> +JVM_Read(jint fd, char *buf, jint nbytes) {
> + NYI();
> +}
> +
> +/*
> + * Write data from a char array to a file decriptor.
> + *
> + * fd the file descriptor to read from.
> + * buf the buffer from which to fetch the data.
> + * nbytes the number of bytes to write.
> + *
> + * This function returns -1 on error, and 0 on success.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_Write(jint fd, char *buf, jint nbytes) {
> + NYI();
> +}
> +
> +/*
> + * Returns the number of bytes available for reading from a given file
> + * descriptor
> + */
> +JNIEXPORT jint JNICALL
> +JVM_Available(jint fd, jlong *pbytes) {
> + NYI();
> +}
> +
> +/*
> + * Move the file descriptor pointer from whence by offset.
> + *
> + * fd the file descriptor to move.
> + * offset the number of bytes to move it by.
> + * whence the start from where to move it.
> + *
> + * This function returns the resulting pointer location.
> + */
> +JNIEXPORT jlong JNICALL
> +JVM_Lseek(jint fd, jlong offset, jint whence) {
> + NYI();
> +}
> +
> +/*
> + * Set the length of the file associated with the given descriptor to the
> given
> + * length. If the new length is longer than the current length then the
> file
> + * is extended; the contents of the extended portion are not defined. Th
> {
> +NYI();
> +}
> + * value of the file pointer is undefined after this procedure returns.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_SetLength(jint fd, jlong length) {
> + NYI();
> +}
> +
> +/*
> + * Synchronize the file descriptor's in memory state with that of the
> + * physical device. Return of -1 is an error, 0 is OK.
> + */
> +JNIEXPORT jint JNICALL
> +JVM_Sync(jint fd) {
> + NYI();
> +}
> +
> +/*
> + * Networking library support
> + */
> +
> +JNIEXPORT jint JNICALL
> +JVM_InitializeSocketLibrary(void) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Socket(jint domain, jint type, jint protocol) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_SocketClose(jint fd) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_SocketShutdown(jint fd, jint howto) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Recv(jint fd, char *buf, jint nBytes, jint flags) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Send(jint fd, char *buf, jint nBytes, jint flags) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Timeout(int fd, long timeout) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Listen(jint fd, jint count) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Connect(jint fd, struct sockaddr *him, jint len) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Bind(jint fd, struct sockaddr *him, jint len) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_Accept(jint fd, struct sockaddr *him, jint *len) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_RecvFrom(jint fd, char *buf, int nBytes,
> + int flags, struct sockaddr *from, int *fromlen) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_SendTo(jint fd, char *buf, int len,
> + int flags, struct sockaddr *to, int tolen) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_SocketAvailable(jint fd, jint *result) {
> + NYI();
> +}
> +
> +
> +JNIEXPORT jint JNICALL
> +JVM_GetSockName(jint fd, struct sockaddr *him, int *len) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen)
> {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int
> optlen) {
> + NYI();
> +}
> +
> +/*
> + * These routines are only reentrant on Windows
> + */
> +
> +JNIEXPORT int JNICALL
> +JVM_GetHostName(char* name, int namelen) {
> + NYI();
> +}
> +
> +/*
> + * The standard printing functions supported by the Java VM. (Should they
> + * be renamed to JVM_* in the future?
> + */
> +
> +/*
> + * BE CAREFUL! The following functions do not implement the
> + * full feature set of standard C printf formats.
> + */
> +int
> +jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {
> + NYI();
> +}
> +
> +int
> +jio_snprintf(char *str, size_t count, const char *fmt, ...) {
> + NYI();
> +}
> +
> +int
> +jio_fprintf(FILE *, const char *fmt, ...) {
> + NYI();
> +}
> +
> +int
> +jio_vfprintf(FILE *, const char *fmt, va_list args) {
> + NYI();
> +}
> +
> +typedef pthread_mutex_t Lock;
> +JNIEXPORT void * JNICALL
> +JVM_RawMonitorCreate(void) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_RawMonitorDestroy(void *mon) {
> + NYI();
> +}
> +
> +JNIEXPORT jint JNICALL
> +JVM_RawMonitorEnter(void *mon) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_RawMonitorExit(void *mon) {
> + NYI();
> +}
> +
> +/*
> + * java.lang.management support
> + */
> +JNIEXPORT void* JNICALL
> +JVM_GetManagement(jint version) {
> + NYI();
> +}
> +
> +/*
> + * com.sun.tools.attach.VirtualMachine support
> + *
> + * Initialize the agent properties with the properties maintained in the
> VM.
> + */
> +JNIEXPORT jobject JNICALL
> +JVM_InitAgentProperties(JNIEnv *env, jobject agent_props) {
> + NYI();
> +}
> +
> +/* Generics reflection support.
> + *
> + * Returns information about the given class's EnclosingMethod
> + * attribute, if present, or null if the class had no enclosing
> + * method.
> + *
> + * If non-null, the returned array contains three elements. Element 0
> + * is the java.lang.Class of which the enclosing method is a member,
> + * and elements 1 and 2 are the java.lang.Strings for the enclosing
> + * method's name and descriptor, respectively.
> + */
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass) {
> + NYI();
> +}
> +
> +/*
> + * Returns an array of the threadStatus values representing the
> + * given Java thread state. Returns NULL if the VM version is
> + * incompatible with the JDK or doesn't support the given
> + * Java thread state.
> + */
> +JNIEXPORT jintArray JNICALL
> +JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState) {
> + NYI();
> +}
> +
> +/*
> + * Returns an array of the substate names representing the
> + * given Java thread state. Returns NULL if the VM version is
> + * incompatible with the JDK or the VM doesn't support
> + * the given Java thread state.
> + * values must be the jintArray returned from JVM_GetThreadStateValues
> + * and javaThreadState.
> + */
> +JNIEXPORT jobjectArray JNICALL
> +JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray
> values) {
> + NYI();
> +}
> +
> +JNIEXPORT void JNICALL
> +JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size)
> {
> + NYI();
> +}
> --
> 1.7.5.1
>
> On Thu, Oct 27, 2011 at 3:10 AM, Will Dietz <wdietz2 at illinois.edu> wrote:
> ~Will
>
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
> ~Will
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
Attached (it's just a large file with all the methods defined to NYI()).
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111027/0197d0fa/attachment.html>
More information about the vmkit-commits
mailing list