/*

 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#ifndef _JAVASOFT_JVM_H_

#define _JAVASOFT_JVM_H_

#include <sys/stat.h>

#include "jni.h"

#include "jvm_md.h"

#ifdef __cplusplus

extern "C" {

#endif

/*

 * This file contains additional functions exported from the VM.

 * These functions are complementary to the standard JNI support.

 * There are three parts to this file:

 *

 * First, this file contains the VM-related functions needed by native

 * libraries in the standard Java API. For example, the java.lang.Object

 * class needs VM-level functions that wait for and notify monitors.

 *

 * Second, this file contains the functions and constant definitions

 * needed by the byte code verifier and class file format checker.

 * These functions allow the verifier and format checker to be written

 * in a VM-independent way.

 *

 * Third, this file contains various I/O and nerwork operations needed

 * by the standard Java I/O and network APIs.

 */

/*

 * Bump the version number when either of the following happens:

 *

 * 1. There is a change in JVM_* functions.

 *

 * 2. There is a change in the contract between VM and Java classes.

 *    For example, if the VM relies on a new private field in Thread

 *    class.

 */

#define JVM_INTERFACE_VERSION 4

JNIEXPORT jint JNICALL

JVM_GetInterfaceVersion(void);

/*************************************************************************

 PART 1: Functions for Native Libraries

 ************************************************************************/

/*

 * java.lang.Object

 */

JNIEXPORT jint JNICALL

JVM_IHashCode(JNIEnv *env, jobject obj);

JNIEXPORT void JNICALL

JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms);

JNIEXPORT void JNICALL

JVM_MonitorNotify(JNIEnv *env, jobject obj);

JNIEXPORT void JNICALL

JVM_MonitorNotifyAll(JNIEnv *env, jobject obj);

JNIEXPORT jobject JNICALL

JVM_Clone(JNIEnv *env, jobject obj);

/*

 * java.lang.String

 */

JNIEXPORT jstring JNICALL

JVM_InternString(JNIEnv *env, jstring str);

/*

 * java.lang.System

 */

JNIEXPORT jlong JNICALL

JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored);

JNIEXPORT jlong JNICALL

JVM_NanoTime(JNIEnv *env, jclass ignored);

JNIEXPORT void JNICALL

JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,

              jobject dst, jint dst_pos, jint length);

JNIEXPORT jobject JNICALL

JVM_InitProperties(JNIEnv *env, jobject p);

/*

 * java.io.File

 */

JNIEXPORT void JNICALL

JVM_OnExit(void (*func)(void));

/*

 * java.lang.Runtime

 */

JNIEXPORT void JNICALL

JVM_Exit(jint code);

JNIEXPORT void JNICALL

JVM_Halt(jint code);

JNIEXPORT void JNICALL

JVM_GC(void);

/* 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);

JNIEXPORT void JNICALL

JVM_TraceInstructions(jboolean on);

JNIEXPORT void JNICALL

JVM_TraceMethodCalls(jboolean on);

JNIEXPORT jlong JNICALL

JVM_TotalMemory(void);

JNIEXPORT jlong JNICALL

JVM_FreeMemory(void);

JNIEXPORT jlong JNICALL

JVM_MaxMemory(void);

JNIEXPORT jint JNICALL

JVM_ActiveProcessorCount(void);

JNIEXPORT void * JNICALL

JVM_LoadLibrary(const char *name);

JNIEXPORT void JNICALL

JVM_UnloadLibrary(void * handle);

JNIEXPORT void * JNICALL

JVM_FindLibraryEntry(void *handle, const char *name);

JNIEXPORT jboolean JNICALL

JVM_IsSupportedJNIVersion(jint version);

/*

 * java.lang.Float and java.lang.Double

 */

JNIEXPORT jboolean JNICALL

JVM_IsNaN(jdouble d);

/*

 * java.lang.Throwable

 */

JNIEXPORT void JNICALL

JVM_FillInStackTrace(JNIEnv *env, jobject throwable);

JNIEXPORT void JNICALL

JVM_PrintStackTrace(JNIEnv *env, jobject throwable, jobject printable);

JNIEXPORT jint JNICALL

JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable);

JNIEXPORT jobject JNICALL

JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index);

/*

 * java.lang.Compiler

 */

JNIEXPORT void JNICALL

JVM_InitializeCompiler (JNIEnv *env, jclass compCls);

JNIEXPORT jboolean JNICALL

JVM_IsSilentCompiler(JNIEnv *env, jclass compCls);

JNIEXPORT jboolean JNICALL

JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls);

JNIEXPORT jboolean JNICALL

JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname);

JNIEXPORT jobject JNICALL

JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg);

JNIEXPORT void JNICALL

JVM_EnableCompiler(JNIEnv *env, jclass compCls);

JNIEXPORT void JNICALL

JVM_DisableCompiler(JNIEnv *env, jclass compCls);

/*

 * java.lang.Thread

 */

JNIEXPORT void JNICALL

JVM_StartThread(JNIEnv *env, jobject thread);

JNIEXPORT void JNICALL

JVM_StopThread(JNIEnv *env, jobject thread, jobject exception);

JNIEXPORT jboolean JNICALL

JVM_IsThreadAlive(JNIEnv *env, jobject thread);

JNIEXPORT void JNICALL

JVM_SuspendThread(JNIEnv *env, jobject thread);

JNIEXPORT void JNICALL

JVM_ResumeThread(JNIEnv *env, jobject thread);

JNIEXPORT void JNICALL

JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio);

JNIEXPORT void JNICALL

JVM_Yield(JNIEnv *env, jclass threadClass);

JNIEXPORT void JNICALL

JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis);

JNIEXPORT jobject JNICALL

JVM_CurrentThread(JNIEnv *env, jclass threadClass);

JNIEXPORT jint JNICALL

JVM_CountStackFrames(JNIEnv *env, jobject thread);

JNIEXPORT void JNICALL

JVM_Interrupt(JNIEnv *env, jobject thread);

JNIEXPORT jboolean JNICALL

JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted);

JNIEXPORT jboolean JNICALL

JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj);

JNIEXPORT void JNICALL

JVM_DumpAllStacks(JNIEnv *env, jclass unused);

JNIEXPORT jobjectArray JNICALL

JVM_GetAllThreads(JNIEnv *env, jclass dummy);

/* getStackTrace() and getAllStackTraces() method */

JNIEXPORT jobjectArray JNICALL

JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);

/*

 * java.lang.SecurityManager

 */

JNIEXPORT jclass JNICALL

JVM_CurrentLoadedClass(JNIEnv *env);

JNIEXPORT jobject JNICALL

JVM_CurrentClassLoader(JNIEnv *env);

JNIEXPORT jobjectArray JNICALL

JVM_GetClassContext(JNIEnv *env);

JNIEXPORT jint JNICALL

JVM_ClassDepth(JNIEnv *env, jstring name);

JNIEXPORT jint JNICALL

JVM_ClassLoaderDepth(JNIEnv *env);

/*

 * java.lang.Package

 */

JNIEXPORT jstring JNICALL

JVM_GetSystemPackage(JNIEnv *env, jstring name);

JNIEXPORT jobjectArray JNICALL

JVM_GetSystemPackages(JNIEnv *env);

/*

 * java.io.ObjectInputStream

 */

JNIEXPORT jobject JNICALL

JVM_AllocateNewObject(JNIEnv *env, jobject obj, jclass currClass,

                      jclass initClass);

JNIEXPORT jobject JNICALL

JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass,

                     jint length);

JNIEXPORT jobject JNICALL

JVM_LatestUserDefinedLoader(JNIEnv *env);

/*

 * 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);

/*

 * java.lang.reflect.Array

 */

JNIEXPORT jint JNICALL

JVM_GetArrayLength(JNIEnv *env, jobject arr);

JNIEXPORT jobject JNICALL

JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index);

JNIEXPORT jvalue JNICALL

JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode);

JNIEXPORT void JNICALL

JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val);

JNIEXPORT void JNICALL

JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v,

                             unsigned char vCode);

JNIEXPORT jobject JNICALL

JVM_NewArray(JNIEnv *env, jclass eltClass, jint length);

JNIEXPORT jobject JNICALL

JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim);

/*

 * 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);

/*

 * Find primitive classes

 * utf: class name

 */

JNIEXPORT jclass JNICALL

JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);

/*

 * Link the class

 */

JNIEXPORT void JNICALL

JVM_ResolveClass(JNIEnv *env, jclass cls);

/*

 * Find a class from a boot class loader. Returns NULL if class not found.

 */

JNIEXPORT jclass JNICALL

JVM_FindClassFromBootLoader(JNIEnv *env, const char *name);

/*

 * 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);

/*

 * Find a class from a given class.

 */

JNIEXPORT jclass JNICALL

JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,

                             jclass from);

/* Find a loaded class cached by the VM */

JNIEXPORT jclass JNICALL

JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);

/* Define a class */

JNIEXPORT jclass JNICALL

JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,

                jsize len, jobject pd);

/* 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);

/*

 * Reflection support functions

 */

JNIEXPORT jstring JNICALL

JVM_GetClassName(JNIEnv *env, jclass cls);

JNIEXPORT jobjectArray JNICALL

JVM_GetClassInterfaces(JNIEnv *env, jclass cls);

JNIEXPORT jobject JNICALL

JVM_GetClassLoader(JNIEnv *env, jclass cls);

JNIEXPORT jboolean JNICALL

JVM_IsInterface(JNIEnv *env, jclass cls);

JNIEXPORT jobjectArray JNICALL

JVM_GetClassSigners(JNIEnv *env, jclass cls);

JNIEXPORT void JNICALL

JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);

JNIEXPORT jobject JNICALL

JVM_GetProtectionDomain(JNIEnv *env, jclass cls);

JNIEXPORT void JNICALL

JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain);

JNIEXPORT jboolean JNICALL

JVM_IsArrayClass(JNIEnv *env, jclass cls);

JNIEXPORT jboolean JNICALL

JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);

JNIEXPORT jclass JNICALL

JVM_GetComponentType(JNIEnv *env, jclass cls);

JNIEXPORT jint JNICALL

JVM_GetClassModifiers(JNIEnv *env, jclass cls);

JNIEXPORT jobjectArray JNICALL

JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);

JNIEXPORT jclass JNICALL

JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);

/* Generics support (JDK 1.5) */

JNIEXPORT jstring JNICALL

JVM_GetClassSignature(JNIEnv *env, jclass cls);

/* Annotations support (JDK 1.5) */

JNIEXPORT jbyteArray JNICALL

JVM_GetClassAnnotations(JNIEnv *env, jclass cls);

/*

 * New (JDK 1.4) reflection implementation

 */

JNIEXPORT jobjectArray JNICALL

JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);

JNIEXPORT jobjectArray JNICALL

JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);

JNIEXPORT jobjectArray JNICALL

JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);

/* 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);

/* 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);

/*

 * java.lang.reflect.Constructor

 */

JNIEXPORT jobject JNICALL

JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);

/*

 * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)

 */

JNIEXPORT jobject JNICALL

JVM_GetClassConstantPool(JNIEnv *env, jclass cls);

JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize

(JNIEnv *env, jobject unused, jobject jcpool);

JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt

(JNIEnv *env, jobject unused, jobject jcpool, jint index);

JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded

(JNIEnv *env, jobject unused, jobject jcpool, jint index);

JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt

(JNIEnv *env, jobject unused, jobject jcpool, jint index);

JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded

(JNIEnv *env, jobject unused, jobject jcpool, jint index);

JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt

(JNIEnv *env, jobject unused, jobject jcpool, jint index);