/*

 * Copyright (c) 1997, 2014, 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.

 *

 * 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 SHARE_VM_PRIMS_JVM_H

#define SHARE_VM_PRIMS_JVM_H

#include "prims/jni.h"

#ifdef TARGET_OS_FAMILY_linux

# include "jvm_linux.h"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "jvm_solaris.h"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "jvm_windows.h"

#endif

#ifdef TARGET_OS_FAMILY_aix

# include "jvm_aix.h"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "jvm_bsd.h"

#endif

#ifndef _JAVASOFT_JVM_H_

#define _JAVASOFT_JVM_H_

// HotSpot integration note:

//

// This file and jvm.h used with the JDK are identical,

// except for the three includes removed below

// #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 jobjectArray JNICALL

JVM_GetMethodParameters(JNIEnv *env, jobject method);

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

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 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.Throwable

 */

JNIEXPORT void JNICALL

JVM_FillInStackTrace(JNIEnv *env, jobject throwable);

JNIEXPORT jint JNICALL

JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable);

JNIEXPORT jobject JNICALL

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

/*

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

JNIEXPORT void JNICALL

JVM_SetNativeThreadName(JNIEnv *env, jobject jthread, jstring name);

/* 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_LatestUserDefinedLoader(JNIEnv *env);

/*

 * 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

 */

#define JVM_CALLER_DEPTH -1

/*

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

/*

 * 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 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.  Throws ClassNotFoundException.

 *  name:   name of class

 *  init:   whether initialization is done

 *  loader: class loader to look up the class. This may not be the same as the caller's

 *          class loader.

 *  caller: initiating class. The initiating class may be null when a security

 *          manager is not installed.

 */

JNIEXPORT jclass JNICALL

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

                        jobject loader, jclass caller);

/*

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

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

/*

 * Reflection support functions

 */

JNIEXPORT jstring JNICALL

JVM_GetClassName(JNIEnv *env, jclass cls);

JNIEXPORT jobjectArray JNICALL

JVM_GetClassInterfaces(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 jboolean JNICALL

JVM_IsArrayClass(JNIEnv *env, jclass cls);

JNIEXPORT jboolean JNICALL

JVM_IsPrimitiveClass(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);

/* Annotations support (JDK 1.6) */

/* Type use annotations support (JDK 1.8) */

JNIEXPORT jbyteArray JNICALL

JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls);

// field is a handle to a java.lang.reflect.Field object

JNIEXPORT jbyteArray JNICALL

JVM_GetFieldTypeAnnotations(JNIEnv *env, jobject field);

// method is a handle to a java.lang.reflect.Method object

JNIEXPORT jbyteArray JNICALL

JVM_GetMethodTypeAnnotations(JNIEnv *env, jobject method);

/*

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

/*

 * 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 obj, jobject unused);

JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt

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

JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded

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

JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt

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

JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded

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

JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt

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

JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded

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

JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt

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

JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt

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

JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt

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

JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt

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