Mercurial > jdk8-mips64-public > hotspot / annotate

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

src/share/vm/prims/jvm.h

Tue, 22 Sep 2009 14:06:10 -0700

author
xdono
date
Tue, 22 Sep 2009 14:06:10 -0700
changeset 1383
89e0543e1737
parent 1313
abe076e3636f
child 1417
7a102acc9f17
permissions
-rw-r--r--

6884624: Update copyright year
Summary: Update copyright for files that have been modified in 2009 through Septermber
Reviewed-by: tbell, ohair

duke@435 1 /*
xdono@1383 2 * Copyright 1997-2009 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 /*
mchung@1313 393 * Find a class from a boot class loader. Returns NULL if class not found.
ksrini@661 394 */
ksrini@661 395 JNIEXPORT jclass JNICALL
mchung@1313 396 JVM_FindClassFromBootLoader(JNIEnv *env, const char *name);
ksrini@661 397
ksrini@661 398 /*
duke@435 399 * Find a class from a given class.
duke@435 400 */
duke@435 401 JNIEXPORT jclass JNICALL
duke@435 402 JVM_FindClassFromClass(JNIEnv *env, const char *name, jboolean init,
duke@435 403 jclass from);
duke@435 404
duke@435 405 /* Find a loaded class cached by the VM */
duke@435 406 JNIEXPORT jclass JNICALL
duke@435 407 JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name);
duke@435 408
duke@435 409 /* Define a class */
duke@435 410 JNIEXPORT jclass JNICALL
duke@435 411 JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
duke@435 412 jsize len, jobject pd);
duke@435 413
duke@435 414 /* Define a class with a source (added in JDK1.5) */
duke@435 415 JNIEXPORT jclass JNICALL
duke@435 416 JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader,
duke@435 417 const jbyte *buf, jsize len, jobject pd,
duke@435 418 const char *source);
duke@435 419
jrose@866 420 /* Define a class with a source (MLVM) */
jrose@866 421 JNIEXPORT jclass JNICALL
jrose@866 422 JVM_DefineClassWithCP(JNIEnv *env, const char *name, jobject loader,
jrose@866 423 const jbyte *buf, jsize len, jobject pd,
jrose@866 424 const char *source,
jrose@866 425 // same args as JVM_DefineClassWithSource to this point
jrose@866 426 jobjectArray constants);
jrose@866 427
duke@435 428 /*
duke@435 429 * Reflection support functions
duke@435 430 */
duke@435 431
duke@435 432 JNIEXPORT jstring JNICALL
duke@435 433 JVM_GetClassName(JNIEnv *env, jclass cls);
duke@435 434
duke@435 435 JNIEXPORT jobjectArray JNICALL
duke@435 436 JVM_GetClassInterfaces(JNIEnv *env, jclass cls);
duke@435 437
duke@435 438 JNIEXPORT jobject JNICALL
duke@435 439 JVM_GetClassLoader(JNIEnv *env, jclass cls);
duke@435 440
duke@435 441 JNIEXPORT jboolean JNICALL
duke@435 442 JVM_IsInterface(JNIEnv *env, jclass cls);
duke@435 443
duke@435 444 JNIEXPORT jobjectArray JNICALL
duke@435 445 JVM_GetClassSigners(JNIEnv *env, jclass cls);
duke@435 446
duke@435 447 JNIEXPORT void JNICALL
duke@435 448 JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers);
duke@435 449
duke@435 450 JNIEXPORT jobject JNICALL
duke@435 451 JVM_GetProtectionDomain(JNIEnv *env, jclass cls);
duke@435 452
duke@435 453 JNIEXPORT void JNICALL
duke@435 454 JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain);
duke@435 455
duke@435 456 JNIEXPORT jboolean JNICALL
duke@435 457 JVM_IsArrayClass(JNIEnv *env, jclass cls);
duke@435 458
duke@435 459 JNIEXPORT jboolean JNICALL
duke@435 460 JVM_IsPrimitiveClass(JNIEnv *env, jclass cls);
duke@435 461
duke@435 462 JNIEXPORT jclass JNICALL
duke@435 463 JVM_GetComponentType(JNIEnv *env, jclass cls);
duke@435 464
duke@435 465 JNIEXPORT jint JNICALL
duke@435 466 JVM_GetClassModifiers(JNIEnv *env, jclass cls);
duke@435 467
duke@435 468 JNIEXPORT jobjectArray JNICALL
duke@435 469 JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass);
duke@435 470
duke@435 471 JNIEXPORT jclass JNICALL
duke@435 472 JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass);
duke@435 473
duke@435 474 /* Generics support (JDK 1.5) */
duke@435 475 JNIEXPORT jstring JNICALL
duke@435 476 JVM_GetClassSignature(JNIEnv *env, jclass cls);
duke@435 477
duke@435 478 /* Annotations support (JDK 1.5) */
duke@435 479 JNIEXPORT jbyteArray JNICALL
duke@435 480 JVM_GetClassAnnotations(JNIEnv *env, jclass cls);
duke@435 481
duke@435 482 /* Annotations support (JDK 1.6) */
duke@435 483
duke@435 484 // field is a handle to a java.lang.reflect.Field object
duke@435 485 JNIEXPORT jbyteArray JNICALL
duke@435 486 JVM_GetFieldAnnotations(JNIEnv *env, jobject field);
duke@435 487
duke@435 488 // method is a handle to a java.lang.reflect.Method object
duke@435 489 JNIEXPORT jbyteArray JNICALL
duke@435 490 JVM_GetMethodAnnotations(JNIEnv *env, jobject method);
duke@435 491
duke@435 492 // method is a handle to a java.lang.reflect.Method object
duke@435 493 JNIEXPORT jbyteArray JNICALL
duke@435 494 JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method);
duke@435 495
duke@435 496 // method is a handle to a java.lang.reflect.Method object
duke@435 497 JNIEXPORT jbyteArray JNICALL
duke@435 498 JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method);
duke@435 499
duke@435 500
duke@435 501 /*
duke@435 502 * New (JDK 1.4) reflection implementation
duke@435 503 */
duke@435 504
duke@435 505 JNIEXPORT jobjectArray JNICALL
duke@435 506 JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly);
duke@435 507
duke@435 508 JNIEXPORT jobjectArray JNICALL
duke@435 509 JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly);
duke@435 510
duke@435 511 JNIEXPORT jobjectArray JNICALL
duke@435 512 JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly);
duke@435 513
duke@435 514 /* Differs from JVM_GetClassModifiers in treatment of inner classes.
duke@435 515 This returns the access flags for the class as specified in the
duke@435 516 class file rather than searching the InnerClasses attribute (if
duke@435 517 present) to find the source-level access flags. Only the values of
duke@435 518 the low 13 bits (i.e., a mask of 0x1FFF) are guaranteed to be
duke@435 519 valid. */
duke@435 520 JNIEXPORT jint JNICALL
duke@435 521 JVM_GetClassAccessFlags(JNIEnv *env, jclass cls);
duke@435 522
duke@435 523 /*
duke@435 524 * Constant pool access; currently used to implement reflective access to annotations (JDK 1.5)
duke@435 525 */
duke@435 526
duke@435 527 JNIEXPORT jobject JNICALL
duke@435 528 JVM_GetClassConstantPool(JNIEnv *env, jclass cls);
duke@435 529
duke@435 530 JNIEXPORT jint JNICALL JVM_ConstantPoolGetSize
duke@435 531 (JNIEnv *env, jobject unused, jobject jcpool);
duke@435 532
duke@435 533 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAt
duke@435 534 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 535
duke@435 536 JNIEXPORT jclass JNICALL JVM_ConstantPoolGetClassAtIfLoaded
duke@435 537 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 538
duke@435 539 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAt
duke@435 540 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 541
duke@435 542 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetMethodAtIfLoaded
duke@435 543 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 544
duke@435 545 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAt
duke@435 546 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 547
duke@435 548 JNIEXPORT jobject JNICALL JVM_ConstantPoolGetFieldAtIfLoaded
duke@435 549 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 550
duke@435 551 JNIEXPORT jobjectArray JNICALL JVM_ConstantPoolGetMemberRefInfoAt
duke@435 552 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 553
duke@435 554 JNIEXPORT jint JNICALL JVM_ConstantPoolGetIntAt
duke@435 555 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 556
duke@435 557 JNIEXPORT jlong JNICALL JVM_ConstantPoolGetLongAt
duke@435 558 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 559
duke@435 560 JNIEXPORT jfloat JNICALL JVM_ConstantPoolGetFloatAt
duke@435 561 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 562
duke@435 563 JNIEXPORT jdouble JNICALL JVM_ConstantPoolGetDoubleAt
duke@435 564 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 565
duke@435 566 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetStringAt
duke@435 567 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 568
duke@435 569 JNIEXPORT jstring JNICALL JVM_ConstantPoolGetUTF8At
duke@435 570 (JNIEnv *env, jobject unused, jobject jcpool, jint index);
duke@435 571
duke@435 572 /*
duke@435 573 * java.security.*
duke@435 574 */
duke@435 575
duke@435 576 JNIEXPORT jobject JNICALL
duke@435 577 JVM_DoPrivileged(JNIEnv *env, jclass cls,
duke@435 578 jobject action, jobject context, jboolean wrapException);
duke@435 579
duke@435 580 JNIEXPORT jobject JNICALL
duke@435 581 JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls);
duke@435 582
duke@435 583 JNIEXPORT jobject JNICALL
duke@435 584 JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls);
duke@435 585
duke@435 586 /*
duke@435 587 * Signal support, used to implement the shutdown sequence. Every VM must
duke@435 588 * support JVM_SIGINT and JVM_SIGTERM, raising the former for user interrupts
duke@435 589 * (^C) and the latter for external termination (kill, system shutdown, etc.).
duke@435 590 * Other platform-dependent signal values may also be supported.
duke@435 591 */
duke@435 592
duke@435 593 JNIEXPORT void * JNICALL
duke@435 594 JVM_RegisterSignal(jint sig, void *handler);
duke@435 595
duke@435 596 JNIEXPORT jboolean JNICALL
duke@435 597 JVM_RaiseSignal(jint sig);
duke@435 598
duke@435 599 JNIEXPORT jint JNICALL
duke@435 600 JVM_FindSignal(const char *name);
duke@435 601
duke@435 602 /*
duke@435 603 * Retrieve the assertion directives for the specified class.
duke@435 604 */
duke@435 605 JNIEXPORT jboolean JNICALL
duke@435 606 JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls);
duke@435 607
duke@435 608 /*
duke@435 609 * Retrieve the assertion directives from the VM.
duke@435 610 */
duke@435 611 JNIEXPORT jobject JNICALL
duke@435 612 JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused);
duke@435 613
duke@435 614 /*
duke@435 615 * sun.misc.AtomicLong
duke@435 616 */
duke@435 617 JNIEXPORT jboolean JNICALL
duke@435 618 JVM_SupportsCX8(void);
duke@435 619
duke@435 620 JNIEXPORT jboolean JNICALL
duke@435 621 JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fldID, jlong oldVal, jlong newVal);
duke@435 622
kamg@551 623 /*
kamg@551 624 * com.sun.dtrace.jsdt support
kamg@551 625 */
kamg@551 626
kamg@551 627 #define JVM_TRACING_DTRACE_VERSION 1
kamg@551 628
kamg@551 629 /*
kamg@551 630 * Structure to pass one probe description to JVM.
kamg@551 631 *
kamg@551 632 * The VM will overwrite the definition of the referenced method with
kamg@551 633 * code that will fire the probe.
kamg@551 634 */
kamg@551 635 typedef struct {
kamg@551 636 jmethodID method;
kamg@551 637 jstring function;
kamg@551 638 jstring name;
kamg@551 639 void* reserved[4]; // for future use
kamg@551 640 } JVM_DTraceProbe;
kamg@551 641
kamg@551 642 /**
kamg@551 643 * Encapsulates the stability ratings for a DTrace provider field
kamg@551 644 */
kamg@551 645 typedef struct {
kamg@551 646 jint nameStability;
kamg@551 647 jint dataStability;
kamg@551 648 jint dependencyClass;
kamg@551 649 } JVM_DTraceInterfaceAttributes;
kamg@551 650
kamg@551 651 /*
kamg@551 652 * Structure to pass one provider description to JVM
kamg@551 653 */
kamg@551 654 typedef struct {
kamg@551 655 jstring name;
kamg@551 656 JVM_DTraceProbe* probes;
kamg@551 657 jint probe_count;
kamg@551 658 JVM_DTraceInterfaceAttributes providerAttributes;
kamg@551 659 JVM_DTraceInterfaceAttributes moduleAttributes;
kamg@551 660 JVM_DTraceInterfaceAttributes functionAttributes;
kamg@551 661 JVM_DTraceInterfaceAttributes nameAttributes;
kamg@551 662 JVM_DTraceInterfaceAttributes argsAttributes;
kamg@551 663 void* reserved[4]; // for future use
kamg@551 664 } JVM_DTraceProvider;
kamg@551 665
kamg@551 666 /*
kamg@551 667 * Get the version number the JVM was built with
kamg@551 668 */
kamg@551 669 JNIEXPORT jint JNICALL
kamg@551 670 JVM_DTraceGetVersion(JNIEnv* env);
kamg@551 671
kamg@551 672 /*
kamg@551 673 * Register new probe with given signature, return global handle
kamg@551 674 *
kamg@551 675 * The version passed in is the version that the library code was
kamg@551 676 * built with.
kamg@551 677 */
kamg@551 678 JNIEXPORT jlong JNICALL
kamg@551 679 JVM_DTraceActivate(JNIEnv* env, jint version, jstring module_name,
kamg@551 680 jint providers_count, JVM_DTraceProvider* providers);
kamg@551 681
kamg@551 682 /*
kamg@551 683 * Check JSDT probe
kamg@551 684 */
kamg@551 685 JNIEXPORT jboolean JNICALL
kamg@551 686 JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method);
kamg@551 687
kamg@551 688 /*
kamg@551 689 * Destroy custom DOF
kamg@551 690 */
kamg@551 691 JNIEXPORT void JNICALL
kamg@551 692 JVM_DTraceDispose(JNIEnv* env, jlong handle);
kamg@551 693
kamg@551 694 /*
kamg@551 695 * Check to see if DTrace is supported by OS
kamg@551 696 */
kamg@551 697 JNIEXPORT jboolean JNICALL
kamg@551 698 JVM_DTraceIsSupported(JNIEnv* env);
kamg@551 699
duke@435 700 /*************************************************************************
duke@435 701 PART 2: Support for the Verifier and Class File Format Checker
duke@435 702 ************************************************************************/
duke@435 703 /*
duke@435 704 * Return the class name in UTF format. The result is valid
duke@435 705 * until JVM_ReleaseUTf is called.
duke@435 706 *
duke@435 707 * The caller must treat the string as a constant and not modify it
duke@435 708 * in any way.
duke@435 709 */
duke@435 710 JNIEXPORT const char * JNICALL
duke@435 711 JVM_GetClassNameUTF(JNIEnv *env, jclass cb);
duke@435 712
duke@435 713 /*
duke@435 714 * Returns the constant pool types in the buffer provided by "types."
duke@435 715 */
duke@435 716 JNIEXPORT void JNICALL
duke@435 717 JVM_GetClassCPTypes(JNIEnv *env, jclass cb, unsigned char *types);
duke@435 718
duke@435 719 /*
duke@435 720 * Returns the number of Constant Pool entries.
duke@435 721 */
duke@435 722 JNIEXPORT jint JNICALL
duke@435 723 JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cb);
duke@435 724
duke@435 725 /*
duke@435 726 * Returns the number of *declared* fields or methods.
duke@435 727 */
duke@435 728 JNIEXPORT jint JNICALL
duke@435 729 JVM_GetClassFieldsCount(JNIEnv *env, jclass cb);
duke@435 730
duke@435 731 JNIEXPORT jint JNICALL
duke@435 732 JVM_GetClassMethodsCount(JNIEnv *env, jclass cb);
duke@435 733
duke@435 734 /*
duke@435 735 * Returns the CP indexes of exceptions raised by a given method.
duke@435 736 * Places the result in the given buffer.
duke@435 737 *
duke@435 738 * The method is identified by method_index.
duke@435 739 */
duke@435 740 JNIEXPORT void JNICALL
duke@435 741 JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cb, jint method_index,
duke@435 742 unsigned short *exceptions);
duke@435 743 /*
duke@435 744 * Returns the number of exceptions raised by a given method.
duke@435 745 * The method is identified by method_index.
duke@435 746 */
duke@435 747 JNIEXPORT jint JNICALL
duke@435 748 JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cb, jint method_index);
duke@435 749
duke@435 750 /*
duke@435 751 * Returns the byte code sequence of a given method.
duke@435 752 * Places the result in the given buffer.
duke@435 753 *
duke@435 754 * The method is identified by method_index.
duke@435 755 */
duke@435 756 JNIEXPORT void JNICALL
duke@435 757 JVM_GetMethodIxByteCode(JNIEnv *env, jclass cb, jint method_index,
duke@435 758 unsigned char *code);
duke@435 759
duke@435 760 /*
duke@435 761 * Returns the length of the byte code sequence of a given method.
duke@435 762 * The method is identified by method_index.
duke@435 763 */
duke@435 764 JNIEXPORT jint JNICALL
duke@435 765 JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cb, jint method_index);
duke@435 766
duke@435 767 /*
duke@435 768 * A structure used to a capture exception table entry in a Java method.
duke@435 769 */
duke@435 770 typedef struct {
duke@435 771 jint start_pc;
duke@435 772 jint end_pc;
duke@435 773 jint handler_pc;
duke@435 774 jint catchType;
duke@435 775 } JVM_ExceptionTableEntryType;
duke@435 776
duke@435 777 /*
duke@435 778 * Returns the exception table entry at entry_index of a given method.
duke@435 779 * Places the result in the given buffer.
duke@435 780 *
duke@435 781 * The method is identified by method_index.
duke@435 782 */
duke@435 783 JNIEXPORT void JNICALL
duke@435 784 JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cb, jint method_index,
duke@435 785 jint entry_index,
duke@435 786 JVM_ExceptionTableEntryType *entry);
duke@435 787
duke@435 788 /*
duke@435 789 * Returns the length of the exception table of a given method.
duke@435 790 * The method is identified by method_index.
duke@435 791 */
duke@435 792 JNIEXPORT jint JNICALL
duke@435 793 JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cb, int index);
duke@435 794
duke@435 795 /*
duke@435 796 * Returns the modifiers of a given field.
duke@435 797 * The field is identified by field_index.
duke@435 798 */
duke@435 799 JNIEXPORT jint JNICALL
duke@435 800 JVM_GetFieldIxModifiers(JNIEnv *env, jclass cb, int index);
duke@435 801
duke@435 802 /*
duke@435 803 * Returns the modifiers of a given method.
duke@435 804 * The method is identified by method_index.
duke@435 805 */
duke@435 806 JNIEXPORT jint JNICALL
duke@435 807 JVM_GetMethodIxModifiers(JNIEnv *env, jclass cb, int index);
duke@435 808
duke@435 809 /*
duke@435 810 * Returns the number of local variables of a given method.
duke@435 811 * The method is identified by method_index.
duke@435 812 */
duke@435 813 JNIEXPORT jint JNICALL
duke@435 814 JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cb, int index);
duke@435 815
duke@435 816 /*
duke@435 817 * Returns the number of arguments (including this pointer) of a given method.
duke@435 818 * The method is identified by method_index.
duke@435 819 */
duke@435 820 JNIEXPORT jint JNICALL
duke@435 821 JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cb, int index);
duke@435 822
duke@435 823 /*
duke@435 824 * Returns the maximum amount of stack (in words) used by a given method.
duke@435 825 * The method is identified by method_index.
duke@435 826 */
duke@435 827 JNIEXPORT jint JNICALL
duke@435 828 JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cb, int index);
duke@435 829
duke@435 830 /*
duke@435 831 * Is a given method a constructor.
duke@435 832 * The method is identified by method_index.
duke@435 833 */
duke@435 834 JNIEXPORT jboolean JNICALL
duke@435 835 JVM_IsConstructorIx(JNIEnv *env, jclass cb, int index);
duke@435 836
duke@435 837 /*
duke@435 838 * Returns the name of a given method in UTF format.
duke@435 839 * The result remains valid until JVM_ReleaseUTF is called.
duke@435 840 *
duke@435 841 * The caller must treat the string as a constant and not modify it
duke@435 842 * in any way.
duke@435 843 */
duke@435 844 JNIEXPORT const char * JNICALL
duke@435 845 JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cb, jint index);
duke@435 846
duke@435 847 /*
duke@435 848 * Returns the signature of a given method in UTF format.
duke@435 849 * The result remains valid until JVM_ReleaseUTF is called.
duke@435 850 *
duke@435 851 * The caller must treat the string as a constant and not modify it
duke@435 852 * in any way.
duke@435 853 */
duke@435 854 JNIEXPORT const char * JNICALL
duke@435 855 JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cb, jint index);
duke@435 856
duke@435 857 /*
duke@435 858 * Returns the name of the field refered to at a given constant pool
duke@435 859 * index.
duke@435 860 *
duke@435 861 * The result is in UTF format and remains valid until JVM_ReleaseUTF
duke@435 862 * is called.
duke@435 863 *
duke@435 864 * The caller must treat the string as a constant and not modify it
duke@435 865 * in any way.
duke@435 866 */
duke@435 867 JNIEXPORT const char * JNICALL
duke@435 868 JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cb, jint index);
duke@435 869
duke@435 870 /*
duke@435 871 * Returns the name of the method refered to at a given constant pool
duke@435 872 * index.
duke@435 873 *
duke@435 874 * The result is in UTF format and remains valid until JVM_ReleaseUTF
duke@435 875 * is called.
duke@435 876 *
duke@435 877 * The caller must treat the string as a constant and not modify it
duke@435 878 * in any way.
duke@435 879 */
duke@435 880 JNIEXPORT const char * JNICALL
duke@435 881 JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cb, jint index);
duke@435 882
duke@435 883 /*
duke@435 884 * Returns the signature of the method refered to at a given constant pool
duke@435 885 * index.
duke@435 886 *
duke@435 887 * The result is in UTF format and remains valid until JVM_ReleaseUTF
duke@435 888 * is called.
duke@435 889 *
duke@435 890 * The caller must treat the string as a constant and not modify it
duke@435 891 * in any way.
duke@435 892 */
duke@435 893 JNIEXPORT const char * JNICALL
duke@435 894 JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cb, jint index);
duke@435 895
duke@435 896 /*
duke@435 897 * Returns the signature of the field refered to at a given constant pool
duke@435 898 * index.
duke@435 899 *
duke@435 900 * The result is in UTF format and remains valid until JVM_ReleaseUTF
duke@435 901 * is called.
duke@435 902 *
duke@435 903 * The caller must treat the string as a constant and not modify it
duke@435 904 * in any way.
duke@435 905 */
duke@435 906 JNIEXPORT const char * JNICALL
duke@435 907 JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cb, jint index);
duke@435 908
duke@435 909 /*
duke@435 910 * Returns the class name refered to at a given constant pool index.
duke@435 911 *
duke@435 912 * The result is in UTF format and remains valid until JVM_ReleaseUTF
duke@435 913 * is called.
duke@435 914 *
duke@435 915 * The caller must treat the string as a constant and not modify it
duke@435 916 * in any way.
duke@435 917 */
duke@435 918 JNIEXPORT const char * JNICALL
duke@435 919 JVM_GetCPClassNameUTF(JNIEnv *env, jclass cb, jint index);
duke@435 920
duke@435 921 /*
duke@435 922 * Returns the class name refered to at a given constant pool index.
duke@435 923 *
duke@435 924 * The constant pool entry must refer to a CONSTANT_Fieldref.
duke@435 925 *
duke@435 926 * The result is in UTF format and remains valid until JVM_ReleaseUTF
duke@435 927 * is called.
duke@435 928 *
duke@435 929 * The caller must treat the string as a constant and not modify it
duke@435 930 * in any way.
duke@435 931 */
duke@435 932 JNIEXPORT const char * JNICALL
duke@435 933 JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cb, jint index);
duke@435 934
duke@435 935 /*
duke@435 936 * Returns the class name refered to at a given constant pool index.
duke@435 937 *
duke@435 938 * The constant pool entry must refer to CONSTANT_Methodref or
duke@435 939 * CONSTANT_InterfaceMethodref.
duke@435 940 *
duke@435 941 * The result is in UTF format and remains valid until JVM_ReleaseUTF
duke@435 942 * is called.
duke@435 943 *
duke@435 944 * The caller must treat the string as a constant and not modify it
duke@435 945 * in any way.
duke@435 946 */
duke@435 947 JNIEXPORT const char * JNICALL
duke@435 948 JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cb, jint index);
duke@435 949
duke@435 950 /*
duke@435 951 * Returns the modifiers of a field in calledClass. The field is
duke@435 952 * referred to in class cb at constant pool entry index.
duke@435 953 *
duke@435 954 * The caller must treat the string as a constant and not modify it
duke@435 955 * in any way.
duke@435 956 *
duke@435 957 * Returns -1 if the field does not exist in calledClass.
duke@435 958 */
duke@435 959 JNIEXPORT jint JNICALL
duke@435 960 JVM_GetCPFieldModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
duke@435 961
duke@435 962 /*
duke@435 963 * Returns the modifiers of a method in calledClass. The method is
duke@435 964 * referred to in class cb at constant pool entry index.
duke@435 965 *
duke@435 966 * Returns -1 if the method does not exist in calledClass.
duke@435 967 */
duke@435 968 JNIEXPORT jint JNICALL
duke@435 969 JVM_GetCPMethodModifiers(JNIEnv *env, jclass cb, int index, jclass calledClass);
duke@435 970
duke@435 971 /*
duke@435 972 * Releases the UTF string obtained from the VM.
duke@435 973 */
duke@435 974 JNIEXPORT void JNICALL
duke@435 975 JVM_ReleaseUTF(const char *utf);
duke@435 976
duke@435 977 /*
duke@435 978 * Compare if two classes are in the same package.
duke@435 979 */
duke@435 980 JNIEXPORT jboolean JNICALL
duke@435 981 JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2);
duke@435 982
duke@435 983 /* Constants in class files */
duke@435 984
duke@435 985 #define JVM_ACC_PUBLIC 0x0001 /* visible to everyone */
duke@435 986 #define JVM_ACC_PRIVATE 0x0002 /* visible only to the defining class */
duke@435 987 #define JVM_ACC_PROTECTED 0x0004 /* visible to subclasses */
duke@435 988 #define JVM_ACC_STATIC 0x0008 /* instance variable is static */
duke@435 989 #define JVM_ACC_FINAL 0x0010 /* no further subclassing, overriding */
duke@435 990 #define JVM_ACC_SYNCHRONIZED 0x0020 /* wrap method call in monitor lock */
duke@435 991 #define JVM_ACC_SUPER 0x0020 /* funky handling of invokespecial */
duke@435 992 #define JVM_ACC_VOLATILE 0x0040 /* can not cache in registers */
duke@435 993 #define JVM_ACC_BRIDGE 0x0040 /* bridge method generated by compiler */
duke@435 994 #define JVM_ACC_TRANSIENT 0x0080 /* not persistent */
duke@435 995 #define JVM_ACC_VARARGS 0x0080 /* method declared with variable number of args */
duke@435 996 #define JVM_ACC_NATIVE 0x0100 /* implemented in C */
duke@435 997 #define JVM_ACC_INTERFACE 0x0200 /* class is an interface */
duke@435 998 #define JVM_ACC_ABSTRACT 0x0400 /* no definition provided */
duke@435 999 #define JVM_ACC_STRICT 0x0800 /* strict floating point */
duke@435 1000 #define JVM_ACC_SYNTHETIC 0x1000 /* compiler-generated class, method or field */
duke@435 1001 #define JVM_ACC_ANNOTATION 0x2000 /* annotation type */
duke@435 1002 #define JVM_ACC_ENUM 0x4000 /* field is declared as element of enum */
duke@435 1003
duke@435 1004 #define JVM_ACC_PUBLIC_BIT 0
duke@435 1005 #define JVM_ACC_PRIVATE_BIT 1
duke@435 1006 #define JVM_ACC_PROTECTED_BIT 2
duke@435 1007 #define JVM_ACC_STATIC_BIT 3
duke@435 1008 #define JVM_ACC_FINAL_BIT 4
duke@435 1009 #define JVM_ACC_SYNCHRONIZED_BIT 5
duke@435 1010 #define JVM_ACC_SUPER_BIT 5
duke@435 1011 #define JVM_ACC_VOLATILE_BIT 6
duke@435 1012 #define JVM_ACC_BRIDGE_BIT 6
duke@435 1013 #define JVM_ACC_TRANSIENT_BIT 7
duke@435 1014 #define JVM_ACC_VARARGS_BIT 7
duke@435 1015 #define JVM_ACC_NATIVE_BIT 8
duke@435 1016 #define JVM_ACC_INTERFACE_BIT 9
duke@435 1017 #define JVM_ACC_ABSTRACT_BIT 10
duke@435 1018 #define JVM_ACC_STRICT_BIT 11
duke@435 1019 #define JVM_ACC_SYNTHETIC_BIT 12
duke@435 1020 #define JVM_ACC_ANNOTATION_BIT 13
duke@435 1021 #define JVM_ACC_ENUM_BIT 14
duke@435 1022
duke@435 1023 // NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/utilities/ConstantTag.java
duke@435 1024 enum {
duke@435 1025 JVM_CONSTANT_Utf8 = 1,
duke@435 1026 JVM_CONSTANT_Unicode, /* unused */
duke@435 1027 JVM_CONSTANT_Integer,
duke@435 1028 JVM_CONSTANT_Float,
duke@435 1029 JVM_CONSTANT_Long,
duke@435 1030 JVM_CONSTANT_Double,
duke@435 1031 JVM_CONSTANT_Class,
duke@435 1032 JVM_CONSTANT_String,
duke@435 1033 JVM_CONSTANT_Fieldref,
duke@435 1034 JVM_CONSTANT_Methodref,
duke@435 1035 JVM_CONSTANT_InterfaceMethodref,
duke@435 1036 JVM_CONSTANT_NameAndType
duke@435 1037 };
duke@435 1038
duke@435 1039 /* Used in the newarray instruction. */
duke@435 1040
duke@435 1041 #define JVM_T_BOOLEAN 4
duke@435 1042 #define JVM_T_CHAR 5
duke@435 1043 #define JVM_T_FLOAT 6
duke@435 1044 #define JVM_T_DOUBLE 7
duke@435 1045 #define JVM_T_BYTE 8
duke@435 1046 #define JVM_T_SHORT 9
duke@435 1047 #define JVM_T_INT 10
duke@435 1048 #define JVM_T_LONG 11
duke@435 1049
duke@435 1050 /* JVM method signatures */
duke@435 1051
duke@435 1052 #define JVM_SIGNATURE_ARRAY '['
duke@435 1053 #define JVM_SIGNATURE_BYTE 'B'
duke@435 1054 #define JVM_SIGNATURE_CHAR 'C'
duke@435 1055 #define JVM_SIGNATURE_CLASS 'L'
duke@435 1056 #define JVM_SIGNATURE_ENDCLASS ';'
duke@435 1057 #define JVM_SIGNATURE_ENUM 'E'
duke@435 1058 #define JVM_SIGNATURE_FLOAT 'F'
duke@435 1059 #define JVM_SIGNATURE_DOUBLE 'D'
duke@435 1060 #define JVM_SIGNATURE_FUNC '('
duke@435 1061 #define JVM_SIGNATURE_ENDFUNC ')'
duke@435 1062 #define JVM_SIGNATURE_INT 'I'
duke@435 1063 #define JVM_SIGNATURE_LONG 'J'
duke@435 1064 #define JVM_SIGNATURE_SHORT 'S'
duke@435 1065 #define JVM_SIGNATURE_VOID 'V'
duke@435 1066 #define JVM_SIGNATURE_BOOLEAN 'Z'
duke@435 1067
duke@435 1068 /*
duke@435 1069 * A function defined by the byte-code verifier and called by the VM.
duke@435 1070 * This is not a function implemented in the VM.
duke@435 1071 *
duke@435 1072 * Returns JNI_FALSE if verification fails. A detailed error message
duke@435 1073 * will be places in msg_buf, whose length is specified by buf_len.
duke@435 1074 */
duke@435 1075 typedef jboolean (*verifier_fn_t)(JNIEnv *env,
duke@435 1076 jclass cb,
duke@435 1077 char * msg_buf,
duke@435 1078 jint buf_len);
duke@435 1079
duke@435 1080
duke@435 1081 /*
duke@435 1082 * Support for a VM-independent class format checker.
duke@435 1083 */
duke@435 1084 typedef struct {
duke@435 1085 unsigned long code; /* byte code */
duke@435 1086 unsigned long excs; /* exceptions */
duke@435 1087 unsigned long etab; /* catch table */
duke@435 1088 unsigned long lnum; /* line number */
duke@435 1089 unsigned long lvar; /* local vars */
duke@435 1090 } method_size_info;
duke@435 1091
duke@435 1092 typedef struct {
duke@435 1093 unsigned int constants; /* constant pool */
duke@435 1094 unsigned int fields;
duke@435 1095 unsigned int methods;
duke@435 1096 unsigned int interfaces;
duke@435 1097 unsigned int fields2; /* number of static 2-word fields */
duke@435 1098 unsigned int innerclasses; /* # of records in InnerClasses attr */
duke@435 1099
duke@435 1100 method_size_info clinit; /* memory used in clinit */
duke@435 1101 method_size_info main; /* used everywhere else */
duke@435 1102 } class_size_info;
duke@435 1103
duke@435 1104 /*
duke@435 1105 * Functions defined in libjava.so to perform string conversions.
duke@435 1106 *
duke@435 1107 */
duke@435 1108
duke@435 1109 typedef jstring (*to_java_string_fn_t)(JNIEnv *env, char *str);
duke@435 1110
duke@435 1111 typedef char *(*to_c_string_fn_t)(JNIEnv *env, jstring s, jboolean *b);
duke@435 1112
duke@435 1113 /* This is the function defined in libjava.so that performs class
duke@435 1114 * format checks. This functions fills in size information about
duke@435 1115 * the class file and returns:
duke@435 1116 *
duke@435 1117 * 0: good
duke@435 1118 * -1: out of memory
duke@435 1119 * -2: bad format
duke@435 1120 * -3: unsupported version
duke@435 1121 * -4: bad class name
duke@435 1122 */
duke@435 1123
duke@435 1124 typedef jint (*check_format_fn_t)(char *class_name,
duke@435 1125 unsigned char *data,
duke@435 1126 unsigned int data_size,
duke@435 1127 class_size_info *class_size,
duke@435 1128 char *message_buffer,
duke@435 1129 jint buffer_length,
duke@435 1130 jboolean measure_only,
duke@435 1131 jboolean check_relaxed);
duke@435 1132
duke@435 1133 #define JVM_RECOGNIZED_CLASS_MODIFIERS (JVM_ACC_PUBLIC | \
duke@435 1134 JVM_ACC_FINAL | \
duke@435 1135 JVM_ACC_SUPER | \
duke@435 1136 JVM_ACC_INTERFACE | \
duke@435 1137 JVM_ACC_ABSTRACT | \
duke@435 1138 JVM_ACC_ANNOTATION | \
duke@435 1139 JVM_ACC_ENUM | \
duke@435 1140 JVM_ACC_SYNTHETIC)
duke@435 1141
duke@435 1142 #define JVM_RECOGNIZED_FIELD_MODIFIERS (JVM_ACC_PUBLIC | \
duke@435 1143 JVM_ACC_PRIVATE | \
duke@435 1144 JVM_ACC_PROTECTED | \
duke@435 1145 JVM_ACC_STATIC | \
duke@435 1146 JVM_ACC_FINAL | \
duke@435 1147 JVM_ACC_VOLATILE | \
duke@435 1148 JVM_ACC_TRANSIENT | \
duke@435 1149 JVM_ACC_ENUM | \
duke@435 1150 JVM_ACC_SYNTHETIC)
duke@435 1151
duke@435 1152 #define JVM_RECOGNIZED_METHOD_MODIFIERS (JVM_ACC_PUBLIC | \
duke@435 1153 JVM_ACC_PRIVATE | \
duke@435 1154 JVM_ACC_PROTECTED | \
duke@435 1155 JVM_ACC_STATIC | \
duke@435 1156 JVM_ACC_FINAL | \
duke@435 1157 JVM_ACC_SYNCHRONIZED | \
duke@435 1158 JVM_ACC_BRIDGE | \
duke@435 1159 JVM_ACC_VARARGS | \
duke@435 1160 JVM_ACC_NATIVE | \
duke@435 1161 JVM_ACC_ABSTRACT | \
duke@435 1162 JVM_ACC_STRICT | \
duke@435 1163 JVM_ACC_SYNTHETIC)
duke@435 1164
duke@435 1165 /*
duke@435 1166 * This is the function defined in libjava.so to perform path
duke@435 1167 * canonicalization. VM call this function before opening jar files
duke@435 1168 * to load system classes.
duke@435 1169 *
duke@435 1170 */
duke@435 1171
duke@435 1172 typedef int (*canonicalize_fn_t)(JNIEnv *env, char *orig, char *out, int len);
duke@435 1173
duke@435 1174 /*************************************************************************
duke@435 1175 PART 3: I/O and Network Support
duke@435 1176 ************************************************************************/
duke@435 1177
duke@435 1178 /* Note that the JVM IO functions are expected to return JVM_IO_ERR
duke@435 1179 * when there is any kind of error. The caller can then use the
duke@435 1180 * platform specific support (e.g., errno) to get the detailed
duke@435 1181 * error info. The JVM_GetLastErrorString procedure may also be used
duke@435 1182 * to obtain a descriptive error string.
duke@435 1183 */
duke@435 1184 #define JVM_IO_ERR (-1)
duke@435 1185
duke@435 1186 /* For interruptible IO. Returning JVM_IO_INTR indicates that an IO
duke@435 1187 * operation has been disrupted by Thread.interrupt. There are a
duke@435 1188 * number of technical difficulties related to interruptible IO that
duke@435 1189 * need to be solved. For example, most existing programs do not handle
duke@435 1190 * InterruptedIOExceptions specially, they simply treat those as any
duke@435 1191 * IOExceptions, which typically indicate fatal errors.
duke@435 1192 *
duke@435 1193 * There are also two modes of operation for interruptible IO. In the
duke@435 1194 * resumption mode, an interrupted IO operation is guaranteed not to
duke@435 1195 * have any side-effects, and can be restarted. In the termination mode,
duke@435 1196 * an interrupted IO operation corrupts the underlying IO stream, so
duke@435 1197 * that the only reasonable operation on an interrupted stream is to
duke@435 1198 * close that stream. The resumption mode seems to be impossible to
duke@435 1199 * implement on Win32 and Solaris. Implementing the termination mode is
duke@435 1200 * easier, but it's not clear that's the right semantics.
duke@435 1201 *
duke@435 1202 * Interruptible IO is not supported on Win32.It can be enabled/disabled
duke@435 1203 * using a compile-time flag on Solaris. Third-party JVM ports do not
duke@435 1204 * need to implement interruptible IO.
duke@435 1205 */
duke@435 1206 #define JVM_IO_INTR (-2)
duke@435 1207
duke@435 1208 /* Write a string into the given buffer, in the platform's local encoding,
duke@435 1209 * that describes the most recent system-level error to occur in this thread.
duke@435 1210 * Return the length of the string or zero if no error occurred.
duke@435 1211 */
duke@435 1212 JNIEXPORT jint JNICALL
duke@435 1213 JVM_GetLastErrorString(char *buf, int len);
duke@435 1214
duke@435 1215 /*
duke@435 1216 * Convert a pathname into native format. This function does syntactic
duke@435 1217 * cleanup, such as removing redundant separator characters. It modifies
duke@435 1218 * the given pathname string in place.
duke@435 1219 */
duke@435 1220 JNIEXPORT char * JNICALL
duke@435 1221 JVM_NativePath(char *);
duke@435 1222
duke@435 1223 /*
duke@435 1224 * JVM I/O error codes
duke@435 1225 */
duke@435 1226 #define JVM_EEXIST -100
duke@435 1227
duke@435 1228 /*
duke@435 1229 * Open a file descriptor. This function returns a negative error code
duke@435 1230 * on error, and a non-negative integer that is the file descriptor on
duke@435 1231 * success.
duke@435 1232 */
duke@435 1233 JNIEXPORT jint JNICALL
duke@435 1234 JVM_Open(const char *fname, jint flags, jint mode);
duke@435 1235
duke@435 1236 /*
duke@435 1237 * Close a file descriptor. This function returns -1 on error, and 0
duke@435 1238 * on success.
duke@435 1239 *
duke@435 1240 * fd the file descriptor to close.
duke@435 1241 */
duke@435 1242 JNIEXPORT jint JNICALL
duke@435 1243 JVM_Close(jint fd);
duke@435 1244
duke@435 1245 /*
duke@435 1246 * Read data from a file decriptor into a char array.
duke@435 1247 *
duke@435 1248 * fd the file descriptor to read from.
duke@435 1249 * buf the buffer where to put the read data.
duke@435 1250 * nbytes the number of bytes to read.
duke@435 1251 *
duke@435 1252 * This function returns -1 on error, and 0 on success.
duke@435 1253 */
duke@435 1254 JNIEXPORT jint JNICALL
duke@435 1255 JVM_Read(jint fd, char *buf, jint nbytes);
duke@435 1256
duke@435 1257 /*
duke@435 1258 * Write data from a char array to a file decriptor.
duke@435 1259 *
duke@435 1260 * fd the file descriptor to read from.
duke@435 1261 * buf the buffer from which to fetch the data.
duke@435 1262 * nbytes the number of bytes to write.
duke@435 1263 *
duke@435 1264 * This function returns -1 on error, and 0 on success.
duke@435 1265 */
duke@435 1266 JNIEXPORT jint JNICALL
duke@435 1267 JVM_Write(jint fd, char *buf, jint nbytes);
duke@435 1268
duke@435 1269 /*
duke@435 1270 * Returns the number of bytes available for reading from a given file
duke@435 1271 * descriptor
duke@435 1272 */
duke@435 1273 JNIEXPORT jint JNICALL
duke@435 1274 JVM_Available(jint fd, jlong *pbytes);
duke@435 1275
duke@435 1276 /*
duke@435 1277 * Move the file descriptor pointer from whence by offset.
duke@435 1278 *
duke@435 1279 * fd the file descriptor to move.
duke@435 1280 * offset the number of bytes to move it by.
duke@435 1281 * whence the start from where to move it.
duke@435 1282 *
duke@435 1283 * This function returns the resulting pointer location.
duke@435 1284 */
duke@435 1285 JNIEXPORT jlong JNICALL
duke@435 1286 JVM_Lseek(jint fd, jlong offset, jint whence);
duke@435 1287
duke@435 1288 /*
duke@435 1289 * Set the length of the file associated with the given descriptor to the given
duke@435 1290 * length. If the new length is longer than the current length then the file
duke@435 1291 * is extended; the contents of the extended portion are not defined. The
duke@435 1292 * value of the file pointer is undefined after this procedure returns.
duke@435 1293 */
duke@435 1294 JNIEXPORT jint JNICALL
duke@435 1295 JVM_SetLength(jint fd, jlong length);
duke@435 1296
duke@435 1297 /*
duke@435 1298 * Synchronize the file descriptor's in memory state with that of the
duke@435 1299 * physical device. Return of -1 is an error, 0 is OK.
duke@435 1300 */
duke@435 1301 JNIEXPORT jint JNICALL
duke@435 1302 JVM_Sync(jint fd);
duke@435 1303
duke@435 1304 /*
duke@435 1305 * Networking library support
duke@435 1306 */
duke@435 1307
duke@435 1308 JNIEXPORT jint JNICALL
duke@435 1309 JVM_InitializeSocketLibrary(void);
duke@435 1310
duke@435 1311 struct sockaddr;
duke@435 1312
duke@435 1313 JNIEXPORT jint JNICALL
duke@435 1314 JVM_Socket(jint domain, jint type, jint protocol);
duke@435 1315
duke@435 1316 JNIEXPORT jint JNICALL
duke@435 1317 JVM_SocketClose(jint fd);
duke@435 1318
duke@435 1319 JNIEXPORT jint JNICALL
duke@435 1320 JVM_SocketShutdown(jint fd, jint howto);
duke@435 1321
duke@435 1322 JNIEXPORT jint JNICALL
duke@435 1323 JVM_Recv(jint fd, char *buf, jint nBytes, jint flags);
duke@435 1324
duke@435 1325 JNIEXPORT jint JNICALL
duke@435 1326 JVM_Send(jint fd, char *buf, jint nBytes, jint flags);
duke@435 1327
duke@435 1328 JNIEXPORT jint JNICALL
duke@435 1329 JVM_Timeout(int fd, long timeout);
duke@435 1330
duke@435 1331 JNIEXPORT jint JNICALL
duke@435 1332 JVM_Listen(jint fd, jint count);
duke@435 1333
duke@435 1334 JNIEXPORT jint JNICALL
duke@435 1335 JVM_Connect(jint fd, struct sockaddr *him, jint len);
duke@435 1336
duke@435 1337 JNIEXPORT jint JNICALL
duke@435 1338 JVM_Bind(jint fd, struct sockaddr *him, jint len);
duke@435 1339
duke@435 1340 JNIEXPORT jint JNICALL
duke@435 1341 JVM_Accept(jint fd, struct sockaddr *him, jint *len);
duke@435 1342
duke@435 1343 JNIEXPORT jint JNICALL
duke@435 1344 JVM_RecvFrom(jint fd, char *buf, int nBytes,
duke@435 1345 int flags, struct sockaddr *from, int *fromlen);
duke@435 1346
duke@435 1347 JNIEXPORT jint JNICALL
duke@435 1348 JVM_SendTo(jint fd, char *buf, int len,
duke@435 1349 int flags, struct sockaddr *to, int tolen);
duke@435 1350
duke@435 1351 JNIEXPORT jint JNICALL
duke@435 1352 JVM_SocketAvailable(jint fd, jint *result);
duke@435 1353
duke@435 1354
duke@435 1355 JNIEXPORT jint JNICALL
duke@435 1356 JVM_GetSockName(jint fd, struct sockaddr *him, int *len);
duke@435 1357
duke@435 1358 JNIEXPORT jint JNICALL
duke@435 1359 JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen);
duke@435 1360
duke@435 1361 JNIEXPORT jint JNICALL
duke@435 1362 JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen);
duke@435 1363
duke@435 1364 /*
duke@435 1365 * These routines are only reentrant on Windows
duke@435 1366 */
duke@435 1367
duke@435 1368 #ifdef _WINDOWS
duke@435 1369
duke@435 1370 JNIEXPORT struct protoent * JNICALL
duke@435 1371 JVM_GetProtoByName(char* name);
duke@435 1372
duke@435 1373 JNIEXPORT struct hostent* JNICALL
duke@435 1374 JVM_GetHostByAddr(const char* name, int len, int type);
duke@435 1375
duke@435 1376 JNIEXPORT struct hostent* JNICALL
duke@435 1377 JVM_GetHostByName(char* name);
duke@435 1378
duke@435 1379 #endif /* _WINDOWS */
duke@435 1380
duke@435 1381 JNIEXPORT int JNICALL
duke@435 1382 JVM_GetHostName(char* name, int namelen);
duke@435 1383
duke@435 1384 /*
duke@435 1385 * The standard printing functions supported by the Java VM. (Should they
duke@435 1386 * be renamed to JVM_* in the future?
duke@435 1387 */
duke@435 1388
duke@435 1389 /*
duke@435 1390 * BE CAREFUL! The following functions do not implement the
duke@435 1391 * full feature set of standard C printf formats.
duke@435 1392 */
duke@435 1393 int
duke@435 1394 jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
duke@435 1395
duke@435 1396 int
duke@435 1397 jio_snprintf(char *str, size_t count, const char *fmt, ...);
duke@435 1398
duke@435 1399 int
duke@435 1400 jio_fprintf(FILE *, const char *fmt, ...);
duke@435 1401
duke@435 1402 int
duke@435 1403 jio_vfprintf(FILE *, const char *fmt, va_list args);
duke@435 1404
duke@435 1405
duke@435 1406 JNIEXPORT void * JNICALL
duke@435 1407 JVM_RawMonitorCreate(void);
duke@435 1408
duke@435 1409 JNIEXPORT void JNICALL
duke@435 1410 JVM_RawMonitorDestroy(void *mon);
duke@435 1411
duke@435 1412 JNIEXPORT jint JNICALL
duke@435 1413 JVM_RawMonitorEnter(void *mon);
duke@435 1414
duke@435 1415 JNIEXPORT void JNICALL
duke@435 1416 JVM_RawMonitorExit(void *mon);
duke@435 1417
duke@435 1418
duke@435 1419 #ifdef SUPPORT_OLD_REFLECTION
duke@435 1420
duke@435 1421 /*
duke@435 1422 * Support for old native code-based (pre-JDK 1.4) reflection implementation.
duke@435 1423 * Disabled by default in the product build.
duke@435 1424 *
duke@435 1425 * See reflection.hpp for information on SUPPORT_OLD_REFLECTION
duke@435 1426 */
duke@435 1427
duke@435 1428 /*
duke@435 1429 * reflecting fields and methods.
duke@435 1430 * which: 0 --- MEMBER_PUBLIC
duke@435 1431 * 1 --- MEMBER_DECLARED
duke@435 1432 * NOTE: absent in product build by default
duke@435 1433 */
duke@435 1434
duke@435 1435 JNIEXPORT jobjectArray JNICALL
duke@435 1436 JVM_GetClassFields(JNIEnv *env, jclass cls, jint which);
duke@435 1437
duke@435 1438 JNIEXPORT jobjectArray JNICALL
duke@435 1439 JVM_GetClassMethods(JNIEnv *env, jclass cls, jint which);
duke@435 1440
duke@435 1441 JNIEXPORT jobjectArray JNICALL
duke@435 1442 JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which);
duke@435 1443
duke@435 1444 JNIEXPORT jobject JNICALL
duke@435 1445 JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which);
duke@435 1446
duke@435 1447 JNIEXPORT jobject JNICALL
duke@435 1448 JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types,
duke@435 1449 jint which);
duke@435 1450 JNIEXPORT jobject JNICALL
duke@435 1451 JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types,
duke@435 1452 jint which);
duke@435 1453
duke@435 1454 /*
duke@435 1455 * Implements Class.newInstance
duke@435 1456 */
duke@435 1457 JNIEXPORT jobject JNICALL
duke@435 1458 JVM_NewInstance(JNIEnv *env, jclass cls);
duke@435 1459
duke@435 1460 /*
duke@435 1461 * java.lang.reflect.Field
duke@435 1462 */
duke@435 1463 JNIEXPORT jobject JNICALL
duke@435 1464 JVM_GetField(JNIEnv *env, jobject field, jobject obj);
duke@435 1465
duke@435 1466 JNIEXPORT jvalue JNICALL
duke@435 1467 JVM_GetPrimitiveField(JNIEnv *env, jobject field, jobject obj,
duke@435 1468 unsigned char wCode);
duke@435 1469
duke@435 1470 JNIEXPORT void JNICALL
duke@435 1471 JVM_SetField(JNIEnv *env, jobject field, jobject obj, jobject val);
duke@435 1472
duke@435 1473 JNIEXPORT void JNICALL
duke@435 1474 JVM_SetPrimitiveField(JNIEnv *env, jobject field, jobject obj, jvalue v,
duke@435 1475 unsigned char vCode);
duke@435 1476
duke@435 1477 /*
duke@435 1478 * java.lang.reflect.Method
duke@435 1479 */
duke@435 1480 JNIEXPORT jobject JNICALL
duke@435 1481 JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0);
duke@435 1482
duke@435 1483 /*
duke@435 1484 * java.lang.reflect.Constructor
duke@435 1485 */
duke@435 1486 JNIEXPORT jobject JNICALL
duke@435 1487 JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0);
duke@435 1488
duke@435 1489 #endif /* SUPPORT_OLD_REFLECTION */
duke@435 1490
duke@435 1491 /*
duke@435 1492 * java.lang.management support
duke@435 1493 */
duke@435 1494 JNIEXPORT void* JNICALL
duke@435 1495 JVM_GetManagement(jint version);
duke@435 1496
duke@435 1497 /*
duke@435 1498 * com.sun.tools.attach.VirtualMachine support
duke@435 1499 *
duke@435 1500 * Initialize the agent properties with the properties maintained in the VM.
duke@435 1501 */
duke@435 1502 JNIEXPORT jobject JNICALL
duke@435 1503 JVM_InitAgentProperties(JNIEnv *env, jobject agent_props);
duke@435 1504
duke@435 1505 /* Generics reflection support.
duke@435 1506 *
duke@435 1507 * Returns information about the given class's EnclosingMethod
duke@435 1508 * attribute, if present, or null if the class had no enclosing
duke@435 1509 * method.
duke@435 1510 *
duke@435 1511 * If non-null, the returned array contains three elements. Element 0
duke@435 1512 * is the java.lang.Class of which the enclosing method is a member,
duke@435 1513 * and elements 1 and 2 are the java.lang.Strings for the enclosing
duke@435 1514 * method's name and descriptor, respectively.
duke@435 1515 */
duke@435 1516 JNIEXPORT jobjectArray JNICALL
duke@435 1517 JVM_GetEnclosingMethodInfo(JNIEnv* env, jclass ofClass);
duke@435 1518
duke@435 1519 /*
duke@435 1520 * Java thread state support
duke@435 1521 */
duke@435 1522 enum {
duke@435 1523 JAVA_THREAD_STATE_NEW = 0,
duke@435 1524 JAVA_THREAD_STATE_RUNNABLE = 1,
duke@435 1525 JAVA_THREAD_STATE_BLOCKED = 2,
duke@435 1526 JAVA_THREAD_STATE_WAITING = 3,
duke@435 1527 JAVA_THREAD_STATE_TIMED_WAITING = 4,
duke@435 1528 JAVA_THREAD_STATE_TERMINATED = 5,
duke@435 1529 JAVA_THREAD_STATE_COUNT = 6
duke@435 1530 };
duke@435 1531
duke@435 1532 /*
duke@435 1533 * Returns an array of the threadStatus values representing the
duke@435 1534 * given Java thread state. Returns NULL if the VM version is
duke@435 1535 * incompatible with the JDK or doesn't support the given
duke@435 1536 * Java thread state.
duke@435 1537 */
duke@435 1538 JNIEXPORT jintArray JNICALL
duke@435 1539 JVM_GetThreadStateValues(JNIEnv* env, jint javaThreadState);
duke@435 1540
duke@435 1541 /*
duke@435 1542 * Returns an array of the substate names representing the
duke@435 1543 * given Java thread state. Returns NULL if the VM version is
duke@435 1544 * incompatible with the JDK or the VM doesn't support
duke@435 1545 * the given Java thread state.
duke@435 1546 * values must be the jintArray returned from JVM_GetThreadStateValues
duke@435 1547 * and javaThreadState.
duke@435 1548 */
duke@435 1549 JNIEXPORT jobjectArray JNICALL
duke@435 1550 JVM_GetThreadStateNames(JNIEnv* env, jint javaThreadState, jintArray values);
duke@435 1551
duke@435 1552 /* =========================================================================
duke@435 1553 * The following defines a private JVM interface that the JDK can query
duke@435 1554 * for the JVM version and capabilities. sun.misc.Version defines
duke@435 1555 * the methods for getting the VM version and its capabilities.
duke@435 1556 *
duke@435 1557 * When a new bit is added, the following should be updated to provide
duke@435 1558 * access to the new capability:
duke@435 1559 * HS: JVM_GetVersionInfo and Abstract_VM_Version class
duke@435 1560 * SDK: Version class
duke@435 1561 *
duke@435 1562 * Similary, a private JDK interface JDK_GetVersionInfo0 is defined for
duke@435 1563 * JVM to query for the JDK version and capabilities.
duke@435 1564 *
duke@435 1565 * When a new bit is added, the following should be updated to provide
duke@435 1566 * access to the new capability:
duke@435 1567 * HS: JDK_Version class
duke@435 1568 * SDK: JDK_GetVersionInfo0
duke@435 1569 *
duke@435 1570 * ==========================================================================
duke@435 1571 */
duke@435 1572 typedef struct {
duke@435 1573 /* HotSpot Express VM version string:
duke@435 1574 * <major>.<minor>-bxx[-<identifier>][-<debug_flavor>]
duke@435 1575 */
duke@435 1576 unsigned int jvm_version; /* Consists of major.minor.0.build */
duke@435 1577 unsigned int update_version : 8; /* 0 in HotSpot Express VM */
duke@435 1578 unsigned int special_update_version : 8; /* 0 in HotSpot Express VM */
duke@435 1579 unsigned int reserved1 : 16;
duke@435 1580 unsigned int reserved2;
duke@435 1581
duke@435 1582 /* The following bits represents JVM supports that JDK has dependency on.
duke@435 1583 * JDK can use these bits to determine which JVM version
duke@435 1584 * and support it has to maintain runtime compatibility.
duke@435 1585 *
duke@435 1586 * When a new bit is added in a minor or update release, make sure
duke@435 1587 * the new bit is also added in the main/baseline.
duke@435 1588 */
duke@435 1589 unsigned int is_attachable : 1;
duke@435 1590 unsigned int is_kernel_jvm : 1;
duke@435 1591 unsigned int : 30;
duke@435 1592 unsigned int : 32;
duke@435 1593 unsigned int : 32;
duke@435 1594 } jvm_version_info;
duke@435 1595
duke@435 1596 #define JVM_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
duke@435 1597 #define JVM_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
duke@435 1598 // Micro version is 0 in HotSpot Express VM (set in jvm.cpp).
duke@435 1599 #define JVM_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
duke@435 1600 /* Build number is available in all HotSpot Express VM builds.
duke@435 1601 * It is defined in make/hotspot_version file.
duke@435 1602 */
duke@435 1603 #define JVM_VERSION_BUILD(version) ((version & 0x000000FF))
duke@435 1604
duke@435 1605 JNIEXPORT void JNICALL
duke@435 1606 JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size);
duke@435 1607
duke@435 1608 typedef struct {
duke@435 1609 // Naming convention of RE build version string: n.n.n[_uu[c]][-<identifier>]-bxx
duke@435 1610 unsigned int jdk_version; /* Consists of major, minor, micro (n.n.n) */
duke@435 1611 /* and build number (xx) */
duke@435 1612 unsigned int update_version : 8; /* Update release version (uu) */
duke@435 1613 unsigned int special_update_version : 8; /* Special update release version (c)*/
duke@435 1614 unsigned int reserved1 : 16;
duke@435 1615 unsigned int reserved2;
duke@435 1616
duke@435 1617 /* The following bits represents new JDK supports that VM has dependency on.
duke@435 1618 * VM implementation can use these bits to determine which JDK version
duke@435 1619 * and support it has to maintain runtime compatibility.
duke@435 1620 *
duke@435 1621 * When a new bit is added in a minor or update release, make sure
duke@435 1622 * the new bit is also added in the main/baseline.
duke@435 1623 */
duke@435 1624 unsigned int thread_park_blocker : 1;
duke@435 1625 unsigned int : 31;
duke@435 1626 unsigned int : 32;
duke@435 1627 unsigned int : 32;
duke@435 1628 } jdk_version_info;
duke@435 1629
duke@435 1630 #define JDK_VERSION_MAJOR(version) ((version & 0xFF000000) >> 24)
duke@435 1631 #define JDK_VERSION_MINOR(version) ((version & 0x00FF0000) >> 16)
duke@435 1632 #define JDK_VERSION_MICRO(version) ((version & 0x0000FF00) >> 8)
duke@435 1633
duke@435 1634 /* Build number is available only for RE build (i.e. JDK_BUILD_NUMBER is set to bNN)
duke@435 1635 * It will be zero for internal builds.
duke@435 1636 */
duke@435 1637 #define JDK_VERSION_BUILD(version) ((version & 0x000000FF))
duke@435 1638
duke@435 1639 /*
duke@435 1640 * This is the function JDK_GetVersionInfo0 defined in libjava.so
duke@435 1641 * that is dynamically looked up by JVM.
duke@435 1642 */
duke@435 1643 typedef void (*jdk_version_info_fn_t)(jdk_version_info* info, size_t info_size);
duke@435 1644
duke@435 1645 /*
duke@435 1646 * This structure is used by the launcher to get the default thread
duke@435 1647 * stack size from the VM using JNI_GetDefaultJavaVMInitArgs() with a
duke@435 1648 * version of 1.1. As it is not supported otherwise, it has been removed
duke@435 1649 * from jni.h
duke@435 1650 */
duke@435 1651 typedef struct JDK1_1InitArgs {
duke@435 1652 jint version;
duke@435 1653
duke@435 1654 char **properties;
duke@435 1655 jint checkSource;
duke@435 1656 jint nativeStackSize;
duke@435 1657 jint javaStackSize;
duke@435 1658 jint minHeapSize;
duke@435 1659 jint maxHeapSize;
duke@435 1660 jint verifyMode;
duke@435 1661 char *classpath;
duke@435 1662
duke@435 1663 jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
duke@435 1664 void (JNICALL *exit)(jint code);
duke@435 1665 void (JNICALL *abort)(void);
duke@435 1666
duke@435 1667 jint enableClassGC;
duke@435 1668 jint enableVerboseGC;
duke@435 1669 jint disableAsyncGC;
duke@435 1670 jint verbose;
duke@435 1671 jboolean debugging;
duke@435 1672 jint debugPort;
duke@435 1673 } JDK1_1InitArgs;
duke@435 1674
duke@435 1675 #ifdef __cplusplus
duke@435 1676 } /* extern "C" */
duke@435 1677 #endif /* __cplusplus */
duke@435 1678
duke@435 1679 #endif /* !_JAVASOFT_JVM_H_ */

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial