Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/prims/jvm.h@a45484ea312d (annotated)

src/share/vm/prims/jvm.h

Wed, 12 Nov 2008 22:33:26 -0800

author
jrose
date
Wed, 12 Nov 2008 22:33:26 -0800
changeset 866
a45484ea312d
parent 670
9c2ecc2ffb12
child 1313
abe076e3636f
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

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

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial