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