Mercurial > jdk8-mips64-public > hotspot / annotate

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

src/share/vm/prims/jvm.h

Tue, 01 Feb 2011 11:23:19 -0500

author
coleenp
date
Tue, 01 Feb 2011 11:23:19 -0500
changeset 2507
d70fe6ab4436
parent 2449
8f8dfba37802
child 2742
ed69575596ac
permissions
-rw-r--r--

6588413: Use -fvisibility=hidden for gcc compiles
Summary: Add option for gcc 4 and above, define JNIEXPORT and JNIIMPORT to visibility=default, add for jio_snprintf and others since -fvisibility=hidden overrides --version-script definitions.
Reviewed-by: kamg, never

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

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial