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