Mercurial > jdk8-mips64-public > hotspot / annotate

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

src/share/vm/prims/jvm.h

Wed, 02 Jul 2008 12:55:16 -0700

author
xdono
date
Wed, 02 Jul 2008 12:55:16 -0700
changeset 631
d1605aabd0a1
parent 551
018d5b58dd4f
child 670
9c2ecc2ffb12
permissions
-rw-r--r--

6719955: Update copyright year
Summary: Update copyright year for files that have been modified in 2008
Reviewed-by: ohair, tbell

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

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial