hotspot/src/share/vm/prims/jvm.h
author jrose
Wed, 12 Nov 2008 22:33:26 -0800
changeset 1550 be2fc37a817f
parent 781 e1baa9c8f16f
child 3578 411436f0a4a2
permissions -rw-r--r--
6653858: dynamic languages need to be able to load anonymous classes Summary: low-level privileged sun.misc.Unsafe.defineAnonymousClass Reviewed-by: kvn
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
670
ddf3e9583f2f 6719955: Update copyright year
xdono
parents: 363
diff changeset
     2
 * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#ifndef _JAVASOFT_JVM_H_
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#define _JAVASOFT_JVM_H_
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// HotSpot integration note:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// This file and jvm.h used with the JDK are identical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// except for the three includes removed below and the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
// SUPPORT_OLD_REFLECTION sections cut out of the JDK's jvm.h.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// #include <sys/stat.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// #include "jni.h"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// #include "jvm_md.h"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
#ifdef __cplusplus
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
 * This file contains additional functions exported from the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
 * These functions are complementary to the standard JNI support.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
 * There are three parts to this file:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
 * First, this file contains the VM-related functions needed by native
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
 * libraries in the standard Java API. For example, the java.lang.Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
 * class needs VM-level functions that wait for and notify monitors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
 * Second, this file contains the functions and constant definitions
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
 * needed by the byte code verifier and class file format checker.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
 * These functions allow the verifier and format checker to be written
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
 * in a VM-independent way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
 * Third, this file contains various I/O and nerwork operations needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
 * by the standard Java I/O and network APIs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
 * Bump the version number when either of the following happens:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
 * 1. There is a change in JVM_* functions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
 * 2. There is a change in the contract between VM and Java classes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
 *    For example, if the VM relies on a new private field in Thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
 *    class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
#define JVM_INTERFACE_VERSION 4
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
JVM_GetInterfaceVersion(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
/*************************************************************************
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
 PART 1: Functions for Native Libraries
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
 ************************************************************************/
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
 * java.lang.Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
JVM_IHashCode(JNIEnv *env, jobject obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
JVM_MonitorWait(JNIEnv *env, jobject obj, jlong ms);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
JVM_MonitorNotify(JNIEnv *env, jobject obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
JVM_MonitorNotifyAll(JNIEnv *env, jobject obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
JVM_Clone(JNIEnv *env, jobject obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
 * java.lang.String
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
JNIEXPORT jstring JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
JVM_InternString(JNIEnv *env, jstring str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
 * java.lang.System
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
JNIEXPORT jlong JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
JNIEXPORT jlong JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
JVM_NanoTime(JNIEnv *env, jclass ignored);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
              jobject dst, jint dst_pos, jint length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
JVM_InitProperties(JNIEnv *env, jobject p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
 * java.io.File
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
JVM_OnExit(void (*func)(void));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
 * java.lang.Runtime
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
JVM_Exit(jint code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
JVM_Halt(jint code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
JVM_GC(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
/* Returns the number of real-time milliseconds that have elapsed since the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
 * least-recently-inspected heap object was last inspected by the garbage
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
 * collector.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
 * For simple stop-the-world collectors this value is just the time
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
 * since the most recent collection.  For generational collectors it is the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
 * time since the oldest generation was most recently collected.  Other
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
 * collectors are free to return a pessimistic estimate of the elapsed time, or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
 * simply the time since the last full collection was performed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
 * Note that in the presence of reference objects, a given object that is no
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
 * longer strongly reachable may have to be inspected multiple times before it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
 * can be reclaimed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
JNIEXPORT jlong JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
JVM_MaxObjectInspectionAge(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
JVM_TraceInstructions(jboolean on);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
JVM_TraceMethodCalls(jboolean on);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
JNIEXPORT jlong JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
JVM_TotalMemory(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
JNIEXPORT jlong JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
JVM_FreeMemory(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
JNIEXPORT jlong JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
JVM_MaxMemory(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
JVM_ActiveProcessorCount(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
JNIEXPORT void * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
JVM_LoadLibrary(const char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
JVM_UnloadLibrary(void * handle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
JNIEXPORT void * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
JVM_FindLibraryEntry(void *handle, const char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
JVM_IsSupportedJNIVersion(jint version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
 * java.lang.Float and java.lang.Double
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
JVM_IsNaN(jdouble d);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
 * java.lang.Throwable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
JVM_FillInStackTrace(JNIEnv *env, jobject throwable);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
JVM_PrintStackTrace(JNIEnv *env, jobject throwable, jobject printable);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
 * java.lang.Compiler
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
JVM_InitializeCompiler (JNIEnv *env, jclass compCls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
JVM_IsSilentCompiler(JNIEnv *env, jclass compCls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
JVM_EnableCompiler(JNIEnv *env, jclass compCls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
JVM_DisableCompiler(JNIEnv *env, jclass compCls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
 * java.lang.Thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
JVM_StartThread(JNIEnv *env, jobject thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
JVM_StopThread(JNIEnv *env, jobject thread, jobject exception);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
JVM_IsThreadAlive(JNIEnv *env, jobject thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
JVM_SuspendThread(JNIEnv *env, jobject thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
JVM_ResumeThread(JNIEnv *env, jobject thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
JVM_SetThreadPriority(JNIEnv *env, jobject thread, jint prio);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
JVM_Yield(JNIEnv *env, jclass threadClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
JVM_Sleep(JNIEnv *env, jclass threadClass, jlong millis);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
JVM_CurrentThread(JNIEnv *env, jclass threadClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
JVM_CountStackFrames(JNIEnv *env, jobject thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
JVM_Interrupt(JNIEnv *env, jobject thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
JVM_IsInterrupted(JNIEnv *env, jobject thread, jboolean clearInterrupted);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
JVM_HoldsLock(JNIEnv *env, jclass threadClass, jobject obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
JVM_DumpAllStacks(JNIEnv *env, jclass unused);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
JVM_GetAllThreads(JNIEnv *env, jclass dummy);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
/* getStackTrace() and getAllStackTraces() method */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
 * java.lang.SecurityManager
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
JVM_CurrentLoadedClass(JNIEnv *env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
JVM_CurrentClassLoader(JNIEnv *env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
JVM_GetClassContext(JNIEnv *env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
JVM_ClassDepth(JNIEnv *env, jstring name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
JVM_ClassLoaderDepth(JNIEnv *env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
 * java.lang.Package
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
JNIEXPORT jstring JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
JVM_GetSystemPackage(JNIEnv *env, jstring name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
JVM_GetSystemPackages(JNIEnv *env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
 * java.io.ObjectInputStream
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
JVM_AllocateNewObject(JNIEnv *env, jobject obj, jclass currClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
                      jclass initClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
                     jint length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
JVM_LatestUserDefinedLoader(JNIEnv *env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
 * This function has been deprecated and should not be considered
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
 * part of the specified JVM interface.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
JVM_LoadClass0(JNIEnv *env, jobject obj, jclass currClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
               jstring currClassName);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
 * java.lang.reflect.Array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
JVM_GetArrayLength(JNIEnv *env, jobject arr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
JNIEXPORT jvalue JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
                             unsigned char vCode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
JVM_NewArray(JNIEnv *env, jclass eltClass, jint length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
 * java.lang.Class and java.lang.ClassLoader
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
 * Returns the class in which the code invoking the native method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
 * belongs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
 * Note that in JDK 1.1, native methods did not create a frame.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
 * In 1.2, they do. Therefore native methods like Class.forName
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
 * can no longer look at the current frame for the caller class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
JVM_GetCallerClass(JNIEnv *env, int n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
 * Find primitive classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
 * utf: class name
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
JVM_FindPrimitiveClass(JNIEnv *env, const char *utf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
 * Link the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
JVM_ResolveClass(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
 * Find a class from a given class loader. Throw ClassNotFoundException
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
 * or NoClassDefFoundError depending on the value of the last
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
 * argument.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
JVM_FindClassFromClassLoader(JNIEnv *env, const char *name, jboolean init,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
                             jobject loader, jboolean throwError);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
/*
772
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   393
 * Find a class from a boot class loader. Throw ClassNotFoundException
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   394
 * or NoClassDefFoundError depending on the value of the last
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   395
 * argument. This is the same as FindClassFromClassLoader but provided
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   396
 * as a convenience method exported correctly on all platforms for
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   397
 * JSR 277 launcher class loading.
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   398
 */
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   399
JNIEXPORT jclass JNICALL
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   400
JVM_FindClassFromBootLoader(JNIEnv *env, const char *name,
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   401
                            jboolean throwError);
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   402
96110c02b165 6714758: hotspot: provide an entry point to the BootStrap Class loader[dholmes,acorn]
ksrini
parents: 363
diff changeset
   403
/*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
 * Find a class from a given class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
                             jclass from);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
/* Find a loaded class cached by the VM */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
/* Define a class */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
                jsize len, jobject pd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
/* Define a class with a source (added in JDK1.5) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
                          const jbyte *buf, jsize len, jobject pd,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
                          const char *source);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   425
/* Define a class with a source (MLVM) */
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   426
JNIEXPORT jclass JNICALL
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   427
JVM_DefineClassWithCP(JNIEnv *env, const char *name, jobject loader,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   428
                      const jbyte *buf, jsize len, jobject pd,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   429
                      const char *source,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   430
                      // same args as JVM_DefineClassWithSource to this point
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   431
                      jobjectArray constants);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 781
diff changeset
   432
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
 * Reflection support functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
JNIEXPORT jstring JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
JVM_GetClassName(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
JVM_GetClassInterfaces(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
JVM_GetClassLoader(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
JVM_IsInterface(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
JVM_GetClassSigners(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
JVM_GetProtectionDomain(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
JVM_IsArrayClass(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
JVM_GetComponentType(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
JVM_GetClassModifiers(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
JNIEXPORT jclass JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
/* Generics support (JDK 1.5) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
JNIEXPORT jstring JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
JVM_GetClassSignature(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
/* Annotations support (JDK 1.5) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
JNIEXPORT jbyteArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
JVM_GetClassAnnotations(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
/* Annotations support (JDK 1.6) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
// field is a handle to a java.lang.reflect.Field object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
JNIEXPORT jbyteArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
JVM_GetFieldAnnotations(JNIEnv *env, jobject field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
// method is a handle to a java.lang.reflect.Method object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
JNIEXPORT jbyteArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
JVM_GetMethodAnnotations(JNIEnv *env, jobject method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
// method is a handle to a java.lang.reflect.Method object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
JNIEXPORT jbyteArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
// method is a handle to a java.lang.reflect.Method object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
JNIEXPORT jbyteArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
 * New (JDK 1.4) reflection implementation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
/* Differs from JVM_GetClassModifiers in treatment of inner classes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
   This returns the access flags for the class as specified in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
   class file rather than searching the InnerClasses attribute (if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
   present) to find the source-level access flags. Only the values of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
   the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
   valid. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
 * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
JVM_GetClassConstantPool(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
(JNIEnv *env, jobject unused, jobject jcpool);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
(JNIEnv *env, jobject unused, jobject jcpool, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
 * java.security.*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
JVM_DoPrivileged(JNIEnv *env, jclass cls,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
                 jobject action, jobject context, jboolean wrapException);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
 * Signal support, used to implement the shutdown sequence.  Every VM must
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
 * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
 * (^C) and the latter for external termination (kill, system shutdown, etc.).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
 * Other platform-dependent signal values may also be supported.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
JNIEXPORT void * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
JVM_RegisterSignal(jint sig, void *handler);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
JVM_RaiseSignal(jint sig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
JVM_FindSignal(const char *name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
 * Retrieve the assertion directives for the specified class.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
 * Retrieve the assertion directives from the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
 * sun.misc.AtomicLong
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
JVM_SupportsCX8(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fldID, jlong oldVal, jlong newVal);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
363
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   628
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   629
 * com.sun.dtrace.jsdt support
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   630
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   631
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   632
#define JVM_TRACING_DTRACE_VERSION 1
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   633
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   634
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   635
 * Structure to pass one probe description to JVM.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   636
 *
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   637
 * The VM will overwrite the definition of the referenced method with
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   638
 * code that will fire the probe.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   639
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   640
typedef struct {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   641
    jmethodID method;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   642
    jstring   function;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   643
    jstring   name;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   644
    void*     reserved[4];     // for future use
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   645
} JVM_DTraceProbe;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   646
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   647
/**
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   648
 * Encapsulates the stability ratings for a DTrace provider field
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   649
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   650
typedef struct {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   651
    jint nameStability;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   652
    jint dataStability;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   653
    jint dependencyClass;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   654
} JVM_DTraceInterfaceAttributes;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   655
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   656
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   657
 * Structure to pass one provider description to JVM
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   658
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   659
typedef struct {
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   660
    jstring                       name;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   661
    JVM_DTraceProbe*              probes;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   662
    jint                          probe_count;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   663
    JVM_DTraceInterfaceAttributes providerAttributes;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   664
    JVM_DTraceInterfaceAttributes moduleAttributes;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   665
    JVM_DTraceInterfaceAttributes functionAttributes;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   666
    JVM_DTraceInterfaceAttributes nameAttributes;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   667
    JVM_DTraceInterfaceAttributes argsAttributes;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   668
    void*                         reserved[4]; // for future use
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   669
} JVM_DTraceProvider;
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   670
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   671
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   672
 * Get the version number the JVM was built with
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   673
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   674
JNIEXPORT jint JNICALL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   675
JVM_DTraceGetVersion(JNIEnv* env);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   676
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   677
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   678
 * Register new probe with given signature, return global handle
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   679
 *
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   680
 * The version passed in is the version that the library code was
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   681
 * built with.
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   682
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   683
JNIEXPORT jlong JNICALL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   684
JVM_DTraceActivate(JNIEnv* env, jint version, jstring module_name,
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   685
  jint providers_count, JVM_DTraceProvider* providers);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   686
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   687
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   688
 * Check JSDT probe
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   689
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   690
JNIEXPORT jboolean JNICALL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   691
JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   692
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   693
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   694
 * Destroy custom DOF
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   695
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   696
JNIEXPORT void JNICALL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   697
JVM_DTraceDispose(JNIEnv* env, jlong handle);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   698
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   699
/*
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   700
 * Check to see if DTrace is supported by OS
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   701
 */
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   702
JNIEXPORT jboolean JNICALL
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   703
JVM_DTraceIsSupported(JNIEnv* env);
99d43e8a76ad 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents: 1
diff changeset
   704
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
/*************************************************************************
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
 PART 2: Support for the Verifier and Class File Format Checker
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
 ************************************************************************/
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
 * Return the class name in UTF format. The result is valid
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
 * until JVM_ReleaseUTf is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
JVM_GetClassNameUTF(JNIEnv *env, jclass cb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
 * Returns the constant pool types in the buffer provided by "types."
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
 * Returns the number of Constant Pool entries.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
 * Returns the number of *declared* fields or methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
 * Returns the CP indexes of exceptions raised by a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
 * Places the result in the given buffer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
                                unsigned short *exceptions);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
 * Returns the number of exceptions raised by a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
 * Returns the byte code sequence of a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
 * Places the result in the given buffer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
                        unsigned char *code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
 * Returns the length of the byte code sequence of a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
 * A structure used to a capture exception table entry in a Java method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
typedef struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
    jint start_pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    jint end_pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    jint handler_pc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    jint catchType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
} JVM_ExceptionTableEntryType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
 * Returns the exception table entry at entry_index of a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
 * Places the result in the given buffer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
                                   jint entry_index,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
                                   JVM_ExceptionTableEntryType *entry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
 * Returns the length of the exception table of a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
 * Returns the modifiers of a given field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
 * The field is identified by field_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
 * Returns the modifiers of a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
 * Returns the number of local variables of a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
 * Returns the number of arguments (including this pointer) of a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
 * Returns the maximum amount of stack (in words) used by a given method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
 * Is a given method a constructor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
 * The method is identified by method_index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
 * Returns the name of a given method in UTF format.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
 * The result remains valid until JVM_ReleaseUTF is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
 * Returns the signature of a given method in UTF format.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
 * The result remains valid until JVM_ReleaseUTF is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
 * Returns the name of the field refered to at a given constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
 * index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
 * The result is in UTF format and remains valid until JVM_ReleaseUTF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
 * is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
 * Returns the name of the method refered to at a given constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
 * index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
 * The result is in UTF format and remains valid until JVM_ReleaseUTF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
 * is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
 * Returns the signature of the method refered to at a given constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
 * index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
 * The result is in UTF format and remains valid until JVM_ReleaseUTF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
 * is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
 * Returns the signature of the field refered to at a given constant pool
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
 * index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
 * The result is in UTF format and remains valid until JVM_ReleaseUTF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
 * is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
 * Returns the class name refered to at a given constant pool index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
 * The result is in UTF format and remains valid until JVM_ReleaseUTF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
 * is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
JVM_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
 * Returns the class name refered to at a given constant pool index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
 * The constant pool entry must refer to a CONSTANT_Fieldref.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
 * The result is in UTF format and remains valid until JVM_ReleaseUTF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
 * is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
 * Returns the class name refered to at a given constant pool index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
 * The constant pool entry must refer to CONSTANT_Methodref or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
 * CONSTANT_InterfaceMethodref.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
 * The result is in UTF format and remains valid until JVM_ReleaseUTF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
 * is called.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
JNIEXPORT const char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
 * Returns the modifiers of a field in calledClass. The field is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
 * referred to in class cb at constant pool entry index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
 * The caller must treat the string as a constant and not modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
 * in any way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
 * Returns -1 if the field does not exist in calledClass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
 * Returns the modifiers of a method in calledClass. The method is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
 * referred to in class cb at constant pool entry index.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
 * Returns -1 if the method does not exist in calledClass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
 * Releases the UTF string obtained from the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
JVM_ReleaseUTF(const char *utf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
 * Compare if two classes are in the same package.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
JNIEXPORT jboolean JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
/* Constants in class files */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
#define JVM_ACC_PUBLIC        0x0001  /* visible to everyone */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
#define JVM_ACC_PRIVATE       0x0002  /* visible only to the defining class */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
#define JVM_ACC_PROTECTED     0x0004  /* visible to subclasses */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
#define JVM_ACC_STATIC        0x0008  /* instance variable is static */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
#define JVM_ACC_FINAL         0x0010  /* no further subclassing, overriding */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
#define JVM_ACC_SYNCHRONIZED  0x0020  /* wrap method call in monitor lock */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
#define JVM_ACC_SUPER         0x0020  /* funky handling of invokespecial */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
#define JVM_ACC_VOLATILE      0x0040  /* can not cache in registers */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
#define JVM_ACC_BRIDGE        0x0040  /* bridge method generated by compiler */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
#define JVM_ACC_TRANSIENT     0x0080  /* not persistent */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
#define JVM_ACC_VARARGS       0x0080  /* method declared with variable number of args */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
#define JVM_ACC_NATIVE        0x0100  /* implemented in C */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
#define JVM_ACC_INTERFACE     0x0200  /* class is an interface */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
#define JVM_ACC_ABSTRACT      0x0400  /* no definition provided */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
#define JVM_ACC_STRICT        0x0800  /* strict floating point */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
#define JVM_ACC_SYNTHETIC     0x1000  /* compiler-generated class, method or field */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
#define JVM_ACC_ANNOTATION    0x2000  /* annotation type */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
#define JVM_ACC_ENUM          0x4000  /* field is declared as element of enum */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
#define JVM_ACC_PUBLIC_BIT        0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
#define JVM_ACC_PRIVATE_BIT       1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
#define JVM_ACC_PROTECTED_BIT     2
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
#define JVM_ACC_STATIC_BIT        3
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
#define JVM_ACC_FINAL_BIT         4
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
#define JVM_ACC_SYNCHRONIZED_BIT  5
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
#define JVM_ACC_SUPER_BIT         5
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
#define JVM_ACC_VOLATILE_BIT      6
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
#define JVM_ACC_BRIDGE_BIT        6
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
#define JVM_ACC_TRANSIENT_BIT     7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
#define JVM_ACC_VARARGS_BIT       7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
#define JVM_ACC_NATIVE_BIT        8
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
#define JVM_ACC_INTERFACE_BIT     9
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
#define JVM_ACC_ABSTRACT_BIT      10
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
#define JVM_ACC_STRICT_BIT        11
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
#define JVM_ACC_SYNTHETIC_BIT     12
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
#define JVM_ACC_ANNOTATION_BIT    13
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
#define JVM_ACC_ENUM_BIT          14
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
// NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/utilities/ConstantTag.java
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
    JVM_CONSTANT_Utf8 = 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
    JVM_CONSTANT_Unicode,               /* unused */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
    JVM_CONSTANT_Integer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
    JVM_CONSTANT_Float,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
    JVM_CONSTANT_Long,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
    JVM_CONSTANT_Double,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
    JVM_CONSTANT_Class,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
    JVM_CONSTANT_String,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
    JVM_CONSTANT_Fieldref,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
    JVM_CONSTANT_Methodref,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
    JVM_CONSTANT_InterfaceMethodref,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
    JVM_CONSTANT_NameAndType
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
/* Used in the newarray instruction. */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
#define JVM_T_BOOLEAN 4
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
#define JVM_T_CHAR    5
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
#define JVM_T_FLOAT   6
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
#define JVM_T_DOUBLE  7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
#define JVM_T_BYTE    8
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
#define JVM_T_SHORT   9
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
#define JVM_T_INT    10
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
#define JVM_T_LONG   11
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
/* JVM method signatures */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
#define JVM_SIGNATURE_ARRAY             '['
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
#define JVM_SIGNATURE_BYTE              'B'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
#define JVM_SIGNATURE_CHAR              'C'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
#define JVM_SIGNATURE_CLASS             'L'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
#define JVM_SIGNATURE_ENDCLASS          ';'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
#define JVM_SIGNATURE_ENUM              'E'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
#define JVM_SIGNATURE_FLOAT             'F'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
#define JVM_SIGNATURE_DOUBLE            'D'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
#define JVM_SIGNATURE_FUNC              '('
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
#define JVM_SIGNATURE_ENDFUNC           ')'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
#define JVM_SIGNATURE_INT               'I'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
#define JVM_SIGNATURE_LONG              'J'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
#define JVM_SIGNATURE_SHORT             'S'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
#define JVM_SIGNATURE_VOID              'V'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
#define JVM_SIGNATURE_BOOLEAN           'Z'
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
 * A function defined by the byte-code verifier and called by the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
 * This is not a function implemented in the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
 * Returns JNI_FALSE if verification fails. A detailed error message
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
 * will be places in msg_buf, whose length is specified by buf_len.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
typedef jboolean (*verifier_fn_t)(JNIEnv *env,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
                                  jclass cb,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
                                  char * msg_buf,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
                                  jint buf_len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
 * Support for a VM-independent class format checker.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
typedef struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
    unsigned long code;    /* byte code */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
    unsigned long excs;    /* exceptions */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
    unsigned long etab;    /* catch table */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
    unsigned long lnum;    /* line number */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
    unsigned long lvar;    /* local vars */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
} method_size_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
typedef struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
    unsigned int constants;    /* constant pool */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
    unsigned int fields;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
    unsigned int methods;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
    unsigned int interfaces;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
    unsigned int fields2;      /* number of static 2-word fields */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
    unsigned int innerclasses; /* # of records in InnerClasses attr */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
    method_size_info clinit;   /* memory used in clinit */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
    method_size_info main;     /* used everywhere else */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
} class_size_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
 * Functions defined in libjava.so to perform string conversions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
typedef jstring (*to_java_string_fn_t)(JNIEnv *env, char *str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
typedef char *(*to_c_string_fn_t)(JNIEnv *env, jstring s, jboolean *b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
/* This is the function defined in libjava.so that performs class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
 * format checks. This functions fills in size information about
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
 * the class file and returns:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
 *   0: good
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
 *  -1: out of memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
 *  -2: bad format
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
 *  -3: unsupported version
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
 *  -4: bad class name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
typedef jint (*check_format_fn_t)(char *class_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
                                  unsigned char *data,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
                                  unsigned int data_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
                                  class_size_info *class_size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
                                  char *message_buffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
                                  jint buffer_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
                                  jboolean measure_only,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
                                  jboolean check_relaxed);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
#define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
                                        JVM_ACC_FINAL | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
                                        JVM_ACC_SUPER | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
                                        JVM_ACC_INTERFACE | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
                                        JVM_ACC_ABSTRACT | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
                                        JVM_ACC_ANNOTATION | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
                                        JVM_ACC_ENUM | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
                                        JVM_ACC_SYNTHETIC)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
#define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
                                        JVM_ACC_PRIVATE | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
                                        JVM_ACC_PROTECTED | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
                                        JVM_ACC_STATIC | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
                                        JVM_ACC_FINAL | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
                                        JVM_ACC_VOLATILE | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
                                        JVM_ACC_TRANSIENT | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
                                        JVM_ACC_ENUM | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
                                        JVM_ACC_SYNTHETIC)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
#define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
                                         JVM_ACC_PRIVATE | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
                                         JVM_ACC_PROTECTED | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
                                         JVM_ACC_STATIC | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
                                         JVM_ACC_FINAL | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
                                         JVM_ACC_SYNCHRONIZED | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
                                         JVM_ACC_BRIDGE | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
                                         JVM_ACC_VARARGS | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
                                         JVM_ACC_NATIVE | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
                                         JVM_ACC_ABSTRACT | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
                                         JVM_ACC_STRICT | \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
                                         JVM_ACC_SYNTHETIC)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
 * This is the function defined in libjava.so to perform path
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
 * canonicalization. VM call this function before opening jar files
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
 * to load system classes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
/*************************************************************************
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
 PART 3: I/O and Network Support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
 ************************************************************************/
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
/* Note that the JVM IO functions are expected to return JVM_IO_ERR
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
 * when there is any kind of error. The caller can then use the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
 * platform specific support (e.g., errno) to get the detailed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
 * error info.  The JVM_GetLastErrorString procedure may also be used
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
 * to obtain a descriptive error string.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
#define JVM_IO_ERR  (-1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
/* For interruptible IO. Returning JVM_IO_INTR indicates that an IO
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
 * operation has been disrupted by Thread.interrupt. There are a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
 * number of technical difficulties related to interruptible IO that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
 * need to be solved. For example, most existing programs do not handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
 * InterruptedIOExceptions specially, they simply treat those as any
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
 * IOExceptions, which typically indicate fatal errors.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
 * There are also two modes of operation for interruptible IO. In the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
 * resumption mode, an interrupted IO operation is guaranteed not to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
 * have any side-effects, and can be restarted. In the termination mode,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
 * an interrupted IO operation corrupts the underlying IO stream, so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
 * that the only reasonable operation on an interrupted stream is to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
 * close that stream. The resumption mode seems to be impossible to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
 * implement on Win32 and Solaris. Implementing the termination mode is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
 * easier, but it's not clear that's the right semantics.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
 * Interruptible IO is not supported on Win32.It can be enabled/disabled
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
 * using a compile-time flag on Solaris. Third-party JVM ports do not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
 * need to implement interruptible IO.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
#define JVM_IO_INTR (-2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
/* Write a string into the given buffer, in the platform's local encoding,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
 * that describes the most recent system-level error to occur in this thread.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
 * Return the length of the string or zero if no error occurred.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
JVM_GetLastErrorString(char *buf, int len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
 * Convert a pathname into native format.  This function does syntactic
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
 * cleanup, such as removing redundant separator characters.  It modifies
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
 * the given pathname string in place.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
JNIEXPORT char * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
JVM_NativePath(char *);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
 * JVM I/O error codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
#define JVM_EEXIST       -100
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
 * Open a file descriptor. This function returns a negative error code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
 * on error, and a non-negative integer that is the file descriptor on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
 * success.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
JVM_Open(const char *fname, jint flags, jint mode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
 * Close a file descriptor. This function returns -1 on error, and 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
 * on success.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
 * fd        the file descriptor to close.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
JVM_Close(jint fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
 * Read data from a file decriptor into a char array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
 * fd        the file descriptor to read from.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
 * buf       the buffer where to put the read data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
 * nbytes    the number of bytes to read.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
 * This function returns -1 on error, and 0 on success.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
JVM_Read(jint fd, char *buf, jint nbytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
 * Write data from a char array to a file decriptor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
 * fd        the file descriptor to read from.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
 * buf       the buffer from which to fetch the data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
 * nbytes    the number of bytes to write.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
 * This function returns -1 on error, and 0 on success.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
JVM_Write(jint fd, char *buf, jint nbytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
 * Returns the number of bytes available for reading from a given file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
 * descriptor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
JVM_Available(jint fd, jlong *pbytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
 * Move the file descriptor pointer from whence by offset.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
 * fd        the file descriptor to move.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
 * offset    the number of bytes to move it by.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
 * whence    the start from where to move it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
 * This function returns the resulting pointer location.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
JNIEXPORT jlong JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
JVM_Lseek(jint fd, jlong offset, jint whence);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
 * Set the length of the file associated with the given descriptor to the given
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
 * length.  If the new length is longer than the current length then the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
 * is extended; the contents of the extended portion are not defined.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
 * value of the file pointer is undefined after this procedure returns.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
JVM_SetLength(jint fd, jlong length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
 * Synchronize the file descriptor's in memory state with that of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
 * physical device.  Return of -1 is an error, 0 is OK.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
JVM_Sync(jint fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
 * Networking library support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
JVM_InitializeSocketLibrary(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
struct sockaddr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
JVM_Socket(jint domain, jint type, jint protocol);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
JVM_SocketClose(jint fd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
JVM_SocketShutdown(jint fd, jint howto);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
JVM_Recv(jint fd, char *buf, jint nBytes, jint flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
JVM_Send(jint fd, char *buf, jint nBytes, jint flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
JVM_Timeout(int fd, long timeout);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
JVM_Listen(jint fd, jint count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
JVM_Connect(jint fd, struct sockaddr *him, jint len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
JVM_Bind(jint fd, struct sockaddr *him, jint len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
JVM_Accept(jint fd, struct sockaddr *him, jint *len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
JVM_RecvFrom(jint fd, char *buf, int nBytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
                  int flags, struct sockaddr *from, int *fromlen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
JVM_SendTo(jint fd, char *buf, int len,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
                int flags, struct sockaddr *to, int tolen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
JVM_SocketAvailable(jint fd, jint *result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
JVM_GetSockName(jint fd, struct sockaddr *him, int *len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
 * These routines are only reentrant on Windows
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
#ifdef _WINDOWS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
JNIEXPORT struct protoent * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
JVM_GetProtoByName(char* name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
JNIEXPORT struct hostent* JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
JVM_GetHostByAddr(const char* name, int len, int type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
JNIEXPORT struct hostent* JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
JVM_GetHostByName(char* name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
#endif /* _WINDOWS */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
JNIEXPORT int JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
JVM_GetHostName(char* name, int namelen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
 * The standard printing functions supported by the Java VM. (Should they
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
 * be renamed to JVM_* in the future?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
 * BE CAREFUL! The following functions do not implement the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
 * full feature set of standard C printf formats.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
jio_snprintf(char *str, size_t count, const char *fmt, ...);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
jio_fprintf(FILE *, const char *fmt, ...);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
int
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
jio_vfprintf(FILE *, const char *fmt, va_list args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
JNIEXPORT void * JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
JVM_RawMonitorCreate(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
JVM_RawMonitorDestroy(void *mon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
JNIEXPORT jint JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
JVM_RawMonitorEnter(void *mon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
JVM_RawMonitorExit(void *mon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
#ifdef SUPPORT_OLD_REFLECTION
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
 * Support for old native code-based (pre-JDK 1.4) reflection implementation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
 * Disabled by default in the product build.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
 * See reflection.hpp for information on SUPPORT_OLD_REFLECTION
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
 * reflecting fields and methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
 * which: 0 --- MEMBER_PUBLIC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
 *        1 --- MEMBER_DECLARED
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
 * NOTE: absent in product build by default
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
JVM_GetClassFields(JNIEnv *env, jclass cls, jint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1454
                   jint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
                        jint which);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
 * Implements Class.newInstance
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
JVM_NewInstance(JNIEnv *env, jclass cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
 * java.lang.reflect.Field
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1467
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
JVM_GetField(JNIEnv *env, jobject field, jobject obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
JNIEXPORT jvalue JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
                      unsigned char wCode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1477
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1478
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1479
JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1480
                      unsigned char vCode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
 * java.lang.reflect.Method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
 * java.lang.reflect.Constructor
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
#endif /* SUPPORT_OLD_REFLECTION */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
 * java.lang.management support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1498
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1499
JNIEXPORT void* JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1500
JVM_GetManagement(jint version);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1502
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
 * com.sun.tools.attach.VirtualMachine support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
 * Initialize the agent properties with the properties maintained in the VM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
JNIEXPORT jobject JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
JVM_InitAgentProperties(JNIEnv *env, jobject agent_props);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
/* Generics reflection support.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
 * Returns information about the given class's EnclosingMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
 * attribute, if present, or null if the class had no enclosing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
 * method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
 * If non-null, the returned array contains three elements. Element 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
 * is the java.lang.Class of which the enclosing method is a member,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
 * and elements 1 and 2 are the java.lang.Strings for the enclosing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
 * method's name and descriptor, respectively.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
 * Java thread state support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
enum {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    JAVA_THREAD_STATE_NEW           = 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
    JAVA_THREAD_STATE_RUNNABLE      = 1,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
    JAVA_THREAD_STATE_BLOCKED       = 2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
    JAVA_THREAD_STATE_WAITING       = 3,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    JAVA_THREAD_STATE_TIMED_WAITING = 4,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
    JAVA_THREAD_STATE_TERMINATED    = 5,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
    JAVA_THREAD_STATE_COUNT         = 6
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
 * Returns an array of the threadStatus values representing the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
 * given Java thread state.  Returns NULL if the VM version is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
 * incompatible with the JDK or doesn't support the given
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
 * Java thread state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
JNIEXPORT jintArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
 * Returns an array of the substate names representing the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
 * given Java thread state.  Returns NULL if the VM version is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
 * incompatible with the JDK or the VM doesn't support
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
 * the given Java thread state.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
 * values must be the jintArray returned from JVM_GetThreadStateValues
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
 * and javaThreadState.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
JNIEXPORT jobjectArray JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
/* =========================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
 * The following defines a private JVM interface that the JDK can query
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
 * for the JVM version and capabilities.  sun.misc.Version defines
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
 * the methods for getting the VM version and its capabilities.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
 * When a new bit is added, the following should be updated to provide
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
 * access to the new capability:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
 *    HS:   JVM_GetVersionInfo and Abstract_VM_Version class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
 *    SDK:  Version class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
 * Similary, a private JDK interface JDK_GetVersionInfo0 is defined for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
 * JVM to query for the JDK version and capabilities.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
 * When a new bit is added, the following should be updated to provide
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
 * access to the new capability:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
 *    HS:   JDK_Version class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
 *    SDK:  JDK_GetVersionInfo0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
 * ==========================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
typedef struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
    /* HotSpot Express VM version string:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
     * <major>.<minor>-bxx[-<identifier>][-<debug_flavor>]
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
     */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
    unsigned int jvm_version; /* Consists of major.minor.0.build */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
    unsigned int update_version : 8;         /* 0 in HotSpot Express VM */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
    unsigned int special_update_version : 8; /* 0 in HotSpot Express VM */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1584
    unsigned int reserved1 : 16;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
    unsigned int reserved2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
    /* The following bits represents JVM supports that JDK has dependency on.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
     * JDK can use these bits to determine which JVM version
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
     * and support it has to maintain runtime compatibility.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
     *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
     * When a new bit is added in a minor or update release, make sure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
     * the new bit is also added in the main/baseline.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
     */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
    unsigned int is_attachable : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
    unsigned int is_kernel_jvm : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
    unsigned int : 30;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
    unsigned int : 32;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
    unsigned int : 32;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
} jvm_version_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
#define JVM_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
#define JVM_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
// Micro version is 0 in HotSpot Express VM (set in jvm.cpp).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
#define JVM_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
/* Build number is available in all HotSpot Express VM builds.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
 * It is defined in make/hotspot_version file.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
#define JVM_VERSION_BUILD(version) ((version & 0x000000FF))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
JNIEXPORT void JNICALL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
typedef struct {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
    // Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
    unsigned int jdk_version;   /* Consists of major, minor, micro (n.n.n) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
                                /* and build number (xx) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
    unsigned int update_version : 8;         /* Update release version (uu) */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
    unsigned int special_update_version : 8; /* Special update release version (c)*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
    unsigned int reserved1 : 16;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
    unsigned int reserved2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
    /* The following bits represents new JDK supports that VM has dependency on.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
     * VM implementation can use these bits to determine which JDK version
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
     * and support it has to maintain runtime compatibility.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
     *
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
     * When a new bit is added in a minor or update release, make sure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
     * the new bit is also added in the main/baseline.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
     */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
    unsigned int thread_park_blocker : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
    unsigned int : 31;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
    unsigned int : 32;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
    unsigned int : 32;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
} jdk_version_info;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
#define JDK_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
#define JDK_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
#define JDK_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
/* Build number is available only for RE build (i.e. JDK_BUILD_NUMBER is set to bNN)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
 * It will be zero for internal builds.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
#define JDK_VERSION_BUILD(version) ((version & 0x000000FF))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
 * This is the function JDK_GetVersionInfo0 defined in libjava.so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
 * that is dynamically looked up by JVM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
typedef void (*jdk_version_info_fn_t)(jdk_version_info* info, size_t info_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
 * This structure is used by the launcher to get the default thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
 * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
 * version of 1.1.  As it is not supported otherwise, it has been removed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
 * from jni.h
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
typedef struct JDK1_1InitArgs {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
    jint version;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
    char **properties;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
    jint checkSource;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
    jint nativeStackSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
    jint javaStackSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
    jint minHeapSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
    jint maxHeapSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
    jint verifyMode;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
    char *classpath;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
    jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
    void (JNICALL *exit)(jint code);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
    void (JNICALL *abort)(void);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
    jint enableClassGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
    jint enableVerboseGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
    jint disableAsyncGC;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
    jint verbose;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
    jboolean debugging;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
    jint debugPort;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
} JDK1_1InitArgs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
#ifdef __cplusplus
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
} /* extern "C" */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
#endif /* __cplusplus */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
#endif /* !_JAVASOFT_JVM_H_ */