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