398 * Return the temporary directory that the VM uses for the attach
399 * and perf data files.
400 *
401 * It is important that this directory is well-known and the
402 * same for all VM instances. It cannot be affected by configuration
403 * variables such as java.io.tmpdir.
404 */
405 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
406 JVMWrapper("JVM_GetTemporaryDirectory");
407 HandleMark hm(THREAD);
408 const char* temp_dir = os::get_temp_directory();
409 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
410 return (jstring) JNIHandles::make_local(env, h());
411 JVM_END
412
413
414 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
415
416 extern volatile jint vm_created;
417
418 JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code))
419 if (vm_created != 0 && (code == 0)) {
420 // The VM is about to exit. We call back into Java to check whether finalizers should be run
421 Universe::run_finalizers_on_exit();
422 }
423 before_exit(thread);
424 vm_exit(code);
425 JVM_END
426
427
428 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
429 before_exit(thread);
430 vm_exit(code);
431 JVM_END
432
433
434 JVM_LEAF(void, JVM_OnExit(void (*func)(void)))
435 register_on_exit_function(func);
436 JVM_END
437
438
439 JVM_ENTRY_NO_ENV(void, JVM_GC(void))
440 JVMWrapper("JVM_GC");
441 if (!DisableExplicitGC) {
442 Universe::heap()->collect(GCCause::_java_lang_system_gc);
443 }
444 JVM_END
445
446
447 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))
448 JVMWrapper("JVM_MaxObjectInspectionAge");
449 return Universe::heap()->millis_since_last_gc();
450 JVM_END
451
452
453 JVM_LEAF(void, JVM_TraceInstructions(jboolean on))
454 if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported");
455 JVM_END
456
457
458 JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on))
459 if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported");
460 JVM_END
461
462 static inline jlong convert_size_t_to_jlong(size_t val) {
463 // In the 64-bit vm, a size_t can overflow a jlong (which is signed).
464 NOT_LP64 (return (jlong)val;)
465 LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)
466 }
467
468 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))
469 JVMWrapper("JVM_TotalMemory");
470 size_t n = Universe::heap()->capacity();
471 return convert_size_t_to_jlong(n);
472 JVM_END
473
474
475 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))
476 JVMWrapper("JVM_FreeMemory");
477 CollectedHeap* ch = Universe::heap();
478 size_t n;
479 {
480 MutexLocker x(Heap_lock);
481 n = ch->capacity() - ch->used();
611 Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,
612 (size_t)align_object_size(size) / HeapWordsPerLong);
613 // Clear the header
614 new_obj->init_mark();
615
616 // Store check (mark entire object and let gc sort it out)
617 BarrierSet* bs = Universe::heap()->barrier_set();
618 assert(bs->has_write_region_opt(), "Barrier set does not have write_region");
619 bs->write_region(MemRegion((HeapWord*)new_obj, size));
620
621 // Caution: this involves a java upcall, so the clone should be
622 // "gc-robust" by this stage.
623 if (klass->has_finalizer()) {
624 assert(obj->is_instance(), "should be instanceOop");
625 new_obj = InstanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);
626 }
627
628 return JNIHandles::make_local(env, oop(new_obj));
629 JVM_END
630
631 // java.lang.Compiler ////////////////////////////////////////////////////
632
633 // The initial cuts of the HotSpot VM will not support JITs, and all existing
634 // JITs would need extensive changes to work with HotSpot. The JIT-related JVM
635 // functions are all silently ignored unless JVM warnings are printed.
636
637 JVM_LEAF(void, JVM_InitializeCompiler (JNIEnv *env, jclass compCls))
638 if (PrintJVMWarnings) warning("JVM_InitializeCompiler not supported");
639 JVM_END
640
641
642 JVM_LEAF(jboolean, JVM_IsSilentCompiler(JNIEnv *env, jclass compCls))
643 if (PrintJVMWarnings) warning("JVM_IsSilentCompiler not supported");
644 return JNI_FALSE;
645 JVM_END
646
647
648 JVM_LEAF(jboolean, JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls))
649 if (PrintJVMWarnings) warning("JVM_CompileClass not supported");
650 return JNI_FALSE;
651 JVM_END
652
653
654 JVM_LEAF(jboolean, JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname))
655 if (PrintJVMWarnings) warning("JVM_CompileClasses not supported");
656 return JNI_FALSE;
657 JVM_END
658
659
660 JVM_LEAF(jobject, JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg))
661 if (PrintJVMWarnings) warning("JVM_CompilerCommand not supported");
662 return NULL;
663 JVM_END
664
665
666 JVM_LEAF(void, JVM_EnableCompiler(JNIEnv *env, jclass compCls))
667 if (PrintJVMWarnings) warning("JVM_EnableCompiler not supported");
668 JVM_END
669
670
671 JVM_LEAF(void, JVM_DisableCompiler(JNIEnv *env, jclass compCls))
672 if (PrintJVMWarnings) warning("JVM_DisableCompiler not supported");
673 JVM_END
674
675
676
677 // Error message support //////////////////////////////////////////////////////
678
679 JVM_LEAF(jint, JVM_GetLastErrorString(char *buf, int len))
680 JVMWrapper("JVM_GetLastErrorString");
681 return (jint)os::lasterror(buf, len);
682 JVM_END
683
684
685 // java.io.File ///////////////////////////////////////////////////////////////
686
687 JVM_LEAF(char*, JVM_NativePath(char* path))
688 JVMWrapper2("JVM_NativePath (%s)", path);
689 return os::native_path(path);
690 JVM_END
691
692
693 // Misc. class handling ///////////////////////////////////////////////////////////
694
695
696 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))
697 JVMWrapper("JVM_GetCallerClass");
698
699 // Pre-JDK 8 and early builds of JDK 8 don't have a CallerSensitive annotation; or
700 // sun.reflect.Reflection.getCallerClass with a depth parameter is provided
701 // temporarily for existing code to use until a replacement API is defined.
702 if (SystemDictionary::reflect_CallerSensitive_klass() == NULL || depth != JVM_CALLER_DEPTH) {
703 Klass* k = thread->security_get_caller_class(depth);
704 return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror());
740 }
741 return NULL;
742 JVM_END
743
744
745 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
746 JVMWrapper("JVM_FindPrimitiveClass");
747 oop mirror = NULL;
748 BasicType t = name2type(utf);
749 if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) {
750 mirror = Universe::java_mirror(t);
751 }
752 if (mirror == NULL) {
753 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf);
754 } else {
755 return (jclass) JNIHandles::make_local(env, mirror);
756 }
757 JVM_END
758
759
760 JVM_ENTRY(void, JVM_ResolveClass(JNIEnv* env, jclass cls))
761 JVMWrapper("JVM_ResolveClass");
762 if (PrintJVMWarnings) warning("JVM_ResolveClass not implemented");
763 JVM_END
764
765
766 // Returns a class loaded by the bootstrap class loader; or null
767 // if not found. ClassNotFoundException is not thrown.
768 //
769 // Rationale behind JVM_FindClassFromBootLoader
770 // a> JVM_FindClassFromClassLoader was never exported in the export tables.
771 // b> because of (a) java.dll has a direct dependecy on the unexported
772 // private symbol "_JVM_FindClassFromClassLoader@20".
773 // c> the launcher cannot use the private symbol as it dynamically opens
774 // the entry point, so if something changes, the launcher will fail
775 // unexpectedly at runtime, it is safest for the launcher to dlopen a
776 // stable exported interface.
777 // d> re-exporting JVM_FindClassFromClassLoader as public, will cause its
778 // signature to change from _JVM_FindClassFromClassLoader@20 to
779 // JVM_FindClassFromClassLoader and will not be backward compatible
780 // with older JDKs.
781 // Thus a public/stable exported entry point is the right solution,
782 // public here means public in linker semantics, and is exported only
783 // to the JDK, and is not intended to be a public API.
784
785 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,
1597 KlassHandle kh(THREAD, k);
1598 intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot);
1599
1600 if (modifiers & JVM_ACC_STATIC) {
1601 // for static fields we only look in the current class
1602 if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) {
1603 assert(false, "cannot find static field");
1604 return false;
1605 }
1606 } else {
1607 // for instance fields we start with the current class and work
1608 // our way up through the superclass chain
1609 if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) {
1610 assert(false, "cannot find instance field");
1611 return false;
1612 }
1613 }
1614 return true;
1615 }
1616
1617 JVM_ENTRY(jbyteArray, JVM_GetFieldAnnotations(JNIEnv *env, jobject field))
1618 // field is a handle to a java.lang.reflect.Field object
1619 assert(field != NULL, "illegal field");
1620 JVMWrapper("JVM_GetFieldAnnotations");
1621
1622 fieldDescriptor fd;
1623 bool gotFd = jvm_get_field_common(field, fd, CHECK_NULL);
1624 if (!gotFd) {
1625 return NULL;
1626 }
1627
1628 return (jbyteArray) JNIHandles::make_local(env, Annotations::make_java_array(fd.annotations(), THREAD));
1629 JVM_END
1630
1631
1632 static Method* jvm_get_method_common(jobject method) {
1633 // some of this code was adapted from from jni_FromReflectedMethod
1634
1635 oop reflected = JNIHandles::resolve_non_null(method);
1636 oop mirror = NULL;
1637 int slot = 0;
1638
1639 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
1640 mirror = java_lang_reflect_Constructor::clazz(reflected);
1641 slot = java_lang_reflect_Constructor::slot(reflected);
1642 } else {
1643 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(),
1644 "wrong type");
1645 mirror = java_lang_reflect_Method::clazz(reflected);
1646 slot = java_lang_reflect_Method::slot(reflected);
1647 }
1648 Klass* k = java_lang_Class::as_Klass(mirror);
1649
1650 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
1651 assert(m != NULL, "cannot find method");
1652 return m; // caller has to deal with NULL in product mode
1653 }
1654
1655
1656 JVM_ENTRY(jbyteArray, JVM_GetMethodAnnotations(JNIEnv *env, jobject method))
1657 JVMWrapper("JVM_GetMethodAnnotations");
1658
1659 // method is a handle to a java.lang.reflect.Method object
1660 Method* m = jvm_get_method_common(method);
1661 if (m == NULL) {
1662 return NULL;
1663 }
1664
1665 return (jbyteArray) JNIHandles::make_local(env,
1666 Annotations::make_java_array(m->annotations(), THREAD));
1667 JVM_END
1668
1669
1670 JVM_ENTRY(jbyteArray, JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method))
1671 JVMWrapper("JVM_GetMethodDefaultAnnotationValue");
1672
1673 // method is a handle to a java.lang.reflect.Method object
1674 Method* m = jvm_get_method_common(method);
1675 if (m == NULL) {
1676 return NULL;
1677 }
1678
1679 return (jbyteArray) JNIHandles::make_local(env,
1680 Annotations::make_java_array(m->annotation_default(), THREAD));
1681 JVM_END
1682
1683
1684 JVM_ENTRY(jbyteArray, JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method))
1685 JVMWrapper("JVM_GetMethodParameterAnnotations");
1686
1687 // method is a handle to a java.lang.reflect.Method object
1688 Method* m = jvm_get_method_common(method);
1689 if (m == NULL) {
1690 return NULL;
1691 }
1692
1693 return (jbyteArray) JNIHandles::make_local(env,
1694 Annotations::make_java_array(m->parameter_annotations(), THREAD));
1695 JVM_END
1696
1697 /* Type use annotations support (JDK 1.8) */
1698
1699 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls))
1700 assert (cls != NULL, "illegal class");
1701 JVMWrapper("JVM_GetClassTypeAnnotations");
1702 ResourceMark rm(THREAD);
1703 // Return null for arrays and primitives
1704 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1705 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1706 if (k->oop_is_instance()) {
1707 AnnotationArray* type_annotations = InstanceKlass::cast(k)->class_type_annotations();
1708 if (type_annotations != NULL) {
1709 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
1710 return (jbyteArray) JNIHandles::make_local(env, a);
1711 }
1712 }
1713 }
1714 return NULL;
1715 JVM_END
1716
2663 return 0;
2664 JVM_END
2665
2666
2667 // Misc //////////////////////////////////////////////////////////////////////////////////////////////
2668
2669 JVM_LEAF(void, JVM_ReleaseUTF(const char *utf))
2670 // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything
2671 JVM_END
2672
2673
2674 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2))
2675 JVMWrapper("JVM_IsSameClassPackage");
2676 oop class1_mirror = JNIHandles::resolve_non_null(class1);
2677 oop class2_mirror = JNIHandles::resolve_non_null(class2);
2678 Klass* klass1 = java_lang_Class::as_Klass(class1_mirror);
2679 Klass* klass2 = java_lang_Class::as_Klass(class2_mirror);
2680 return (jboolean) Reflection::is_same_class_package(klass1, klass2);
2681 JVM_END
2682
2683
2684 // IO functions ////////////////////////////////////////////////////////////////////////////////////////
2685
2686 JVM_LEAF(jint, JVM_Open(const char *fname, jint flags, jint mode))
2687 JVMWrapper2("JVM_Open (%s)", fname);
2688
2689 //%note jvm_r6
2690 int result = os::open(fname, flags, mode);
2691 if (result >= 0) {
2692 return result;
2693 } else {
2694 switch(errno) {
2695 case EEXIST:
2696 return JVM_EEXIST;
2697 default:
2698 return -1;
2699 }
2700 }
2701 JVM_END
2702
2703
2704 JVM_LEAF(jint, JVM_Close(jint fd))
2705 JVMWrapper2("JVM_Close (0x%x)", fd);
2706 //%note jvm_r6
2707 return os::close(fd);
2708 JVM_END
2709
2710
2711 JVM_LEAF(jint, JVM_Read(jint fd, char *buf, jint nbytes))
2712 JVMWrapper2("JVM_Read (0x%x)", fd);
2713
2714 //%note jvm_r6
2715 return (jint)os::restartable_read(fd, buf, nbytes);
2716 JVM_END
2717
2718
2719 JVM_LEAF(jint, JVM_Write(jint fd, char *buf, jint nbytes))
2720 JVMWrapper2("JVM_Write (0x%x)", fd);
2721
2722 //%note jvm_r6
2723 return (jint)os::write(fd, buf, nbytes);
2724 JVM_END
2725
2726
2727 JVM_LEAF(jint, JVM_Available(jint fd, jlong *pbytes))
2728 JVMWrapper2("JVM_Available (0x%x)", fd);
2729 //%note jvm_r6
2730 return os::available(fd, pbytes);
2731 JVM_END
2732
2733
2734 JVM_LEAF(jlong, JVM_Lseek(jint fd, jlong offset, jint whence))
2735 JVMWrapper4("JVM_Lseek (0x%x, " INT64_FORMAT ", %d)", fd, (int64_t) offset, whence);
2736 //%note jvm_r6
2737 return os::lseek(fd, offset, whence);
2738 JVM_END
2739
2740
2741 JVM_LEAF(jint, JVM_SetLength(jint fd, jlong length))
2742 JVMWrapper3("JVM_SetLength (0x%x, " INT64_FORMAT ")", fd, (int64_t) length);
2743 return os::ftruncate(fd, length);
2744 JVM_END
2745
2746
2747 JVM_LEAF(jint, JVM_Sync(jint fd))
2748 JVMWrapper2("JVM_Sync (0x%x)", fd);
2749 //%note jvm_r6
2750 return os::fsync(fd);
2751 JVM_END
2752
2753
2754 // Printing support //////////////////////////////////////////////////
2755 extern "C" {
2756
2757 ATTRIBUTE_PRINTF(3, 0)
2758 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {
2759 // see bug 4399518, 4417214
2760 if ((intptr_t)count <= 0) return -1;
2761 return vsnprintf(str, count, fmt, args);
2762 }
2763
2764 ATTRIBUTE_PRINTF(3, 0)
2765 int jio_snprintf(char *str, size_t count, const char *fmt, ...) {
2766 va_list args;
2767 int len;
2768 va_start(args, fmt);
2769 len = jio_vsnprintf(str, count, fmt, args);
2770 va_end(args);
2771 return len;
2772 }
2773
3405 // ObjectInputStream ///////////////////////////////////////////////////////////////
3406
3407 bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessFlags access, bool classloader_only) {
3408 if (current_class == NULL) {
3409 return true;
3410 }
3411 if ((current_class == field_class) || access.is_public()) {
3412 return true;
3413 }
3414
3415 if (access.is_protected()) {
3416 // See if current_class is a subclass of field_class
3417 if (current_class->is_subclass_of(field_class)) {
3418 return true;
3419 }
3420 }
3421
3422 return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class));
3423 }
3424
3425
3426 // JVM_AllocateNewObject and JVM_AllocateNewArray are unused as of 1.4
3427 JVM_ENTRY(jobject, JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass))
3428 JVMWrapper("JVM_AllocateNewObject");
3429 JvmtiVMObjectAllocEventCollector oam;
3430 // Receiver is not used
3431 oop curr_mirror = JNIHandles::resolve_non_null(currClass);
3432 oop init_mirror = JNIHandles::resolve_non_null(initClass);
3433
3434 // Cannot instantiate primitive types
3435 if (java_lang_Class::is_primitive(curr_mirror) || java_lang_Class::is_primitive(init_mirror)) {
3436 ResourceMark rm(THREAD);
3437 THROW_0(vmSymbols::java_lang_InvalidClassException());
3438 }
3439
3440 // Arrays not allowed here, must use JVM_AllocateNewArray
3441 if (java_lang_Class::as_Klass(curr_mirror)->oop_is_array() ||
3442 java_lang_Class::as_Klass(init_mirror)->oop_is_array()) {
3443 ResourceMark rm(THREAD);
3444 THROW_0(vmSymbols::java_lang_InvalidClassException());
3445 }
3446
3447 instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_Klass(curr_mirror));
3448 instanceKlassHandle init_klass (THREAD, java_lang_Class::as_Klass(init_mirror));
3449
3450 assert(curr_klass->is_subclass_of(init_klass()), "just checking");
3451
3452 // Interfaces, abstract classes, and java.lang.Class classes cannot be instantiated directly.
3453 curr_klass->check_valid_for_instantiation(false, CHECK_NULL);
3454
3455 // Make sure klass is initialized, since we are about to instantiate one of them.
3456 curr_klass->initialize(CHECK_NULL);
3457
3458 methodHandle m (THREAD,
3459 init_klass->find_method(vmSymbols::object_initializer_name(),
3460 vmSymbols::void_method_signature()));
3461 if (m.is_null()) {
3462 ResourceMark rm(THREAD);
3463 THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(),
3464 Method::name_and_sig_as_C_string(init_klass(),
3465 vmSymbols::object_initializer_name(),
3466 vmSymbols::void_method_signature()));
3467 }
3468
3469 if (curr_klass == init_klass && !m->is_public()) {
3470 // Calling the constructor for class 'curr_klass'.
3471 // Only allow calls to a public no-arg constructor.
3472 // This path corresponds to creating an Externalizable object.
3473 THROW_0(vmSymbols::java_lang_IllegalAccessException());
3474 }
3475
3476 if (!force_verify_field_access(curr_klass(), init_klass(), m->access_flags(), false)) {
3477 // subclass 'curr_klass' does not have access to no-arg constructor of 'initcb'
3478 THROW_0(vmSymbols::java_lang_IllegalAccessException());
3479 }
3480
3481 Handle obj = curr_klass->allocate_instance_handle(CHECK_NULL);
3482 // Call constructor m. This might call a constructor higher up in the hierachy
3483 JavaCalls::call_default_constructor(thread, m, obj, CHECK_NULL);
3484
3485 return JNIHandles::make_local(obj());
3486 JVM_END
3487
3488
3489 JVM_ENTRY(jobject, JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currClass, jint length))
3490 JVMWrapper("JVM_AllocateNewArray");
3491 JvmtiVMObjectAllocEventCollector oam;
3492 oop mirror = JNIHandles::resolve_non_null(currClass);
3493
3494 if (java_lang_Class::is_primitive(mirror)) {
3495 THROW_0(vmSymbols::java_lang_InvalidClassException());
3496 }
3497 Klass* k = java_lang_Class::as_Klass(mirror);
3498 oop result;
3499
3500 if (k->oop_is_typeArray()) {
3501 // typeArray
3502 result = TypeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
3503 } else if (k->oop_is_objArray()) {
3504 // objArray
3505 ObjArrayKlass* oak = ObjArrayKlass::cast(k);
3506 oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior)
3507 result = oak->allocate(length, CHECK_NULL);
3508 } else {
3509 THROW_0(vmSymbols::java_lang_InvalidClassException());
3510 }
3511 return JNIHandles::make_local(env, result);
3512 JVM_END
3513
3514
3515 // Return the first non-null class loader up the execution stack, or null
3516 // if only code from the null class loader is on the stack.
3517
3518 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
3519 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3520 vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
3521 oop loader = vfst.method()->method_holder()->class_loader();
3522 if (loader != NULL) {
3523 return JNIHandles::make_local(env, loader);
3524 }
3525 }
3526 return NULL;
3527 JVM_END
3528
3529
3530 // Load a class relative to the most recent class on the stack with a non-null
3531 // classloader.
3532 // This function has been deprecated and should not be considered part of the
3533 // specified JVM interface.
3534
3535 JVM_ENTRY(jclass, JVM_LoadClass0(JNIEnv *env, jobject receiver,
3536 jclass currClass, jstring currClassName))
3537 JVMWrapper("JVM_LoadClass0");
3538 // Receiver is not used
3539 ResourceMark rm(THREAD);
3540
3541 // Class name argument is not guaranteed to be in internal format
3542 Handle classname (THREAD, JNIHandles::resolve_non_null(currClassName));
3543 Handle string = java_lang_String::internalize_classname(classname, CHECK_NULL);
3544
3545 const char* str = java_lang_String::as_utf8_string(string());
3546
3547 if (str == NULL || (int)strlen(str) > Symbol::max_length()) {
3548 // It's impossible to create this class; the name cannot fit
3549 // into the constant pool.
3550 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), str);
3551 }
3552
3553 TempNewSymbol name = SymbolTable::new_symbol(str, CHECK_NULL);
3554 Handle curr_klass (THREAD, JNIHandles::resolve(currClass));
3555 // Find the most recent class on the stack with a non-null classloader
3556 oop loader = NULL;
3557 oop protection_domain = NULL;
3558 if (curr_klass.is_null()) {
3559 for (vframeStream vfst(thread);
3560 !vfst.at_end() && loader == NULL;
3561 vfst.next()) {
3562 if (!vfst.method()->is_native()) {
3563 InstanceKlass* holder = vfst.method()->method_holder();
3564 loader = holder->class_loader();
3565 protection_domain = holder->protection_domain();
3566 }
3567 }
3568 } else {
3569 Klass* curr_klass_oop = java_lang_Class::as_Klass(curr_klass());
3570 loader = InstanceKlass::cast(curr_klass_oop)->class_loader();
3571 protection_domain = InstanceKlass::cast(curr_klass_oop)->protection_domain();
3572 }
3573 Handle h_loader(THREAD, loader);
3574 Handle h_prot (THREAD, protection_domain);
3575 jclass result = find_class_from_class_loader(env, name, true, h_loader, h_prot,
3576 false, thread);
3577 if (TraceClassResolution && result != NULL) {
3578 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
3579 }
3580 return result;
3581 JVM_END
3582
3583
3584 // Array ///////////////////////////////////////////////////////////////////////////////////////////
3585
3586
3587 // resolve array handle and check arguments
3588 static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) {
3589 if (arr == NULL) {
3590 THROW_0(vmSymbols::java_lang_NullPointerException());
3591 }
3592 oop a = JNIHandles::resolve_non_null(arr);
3593 if (!a->is_array() || (type_array_only && !a->is_typeArray())) {
3594 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array");
3595 }
3596 return arrayOop(a);
3597 }
3598
3599
3600 JVM_ENTRY(jint, JVM_GetArrayLength(JNIEnv *env, jobject arr))
3601 JVMWrapper("JVM_GetArrayLength");
3602 arrayOop a = check_array(env, arr, false, CHECK_0);
3603 return a->length();
3659 JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length))
3660 JVMWrapper("JVM_NewArray");
3661 JvmtiVMObjectAllocEventCollector oam;
3662 oop element_mirror = JNIHandles::resolve(eltClass);
3663 oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL);
3664 return JNIHandles::make_local(env, result);
3665 JVM_END
3666
3667
3668 JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim))
3669 JVMWrapper("JVM_NewMultiArray");
3670 JvmtiVMObjectAllocEventCollector oam;
3671 arrayOop dim_array = check_array(env, dim, true, CHECK_NULL);
3672 oop element_mirror = JNIHandles::resolve(eltClass);
3673 assert(dim_array->is_typeArray(), "just checking");
3674 oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL);
3675 return JNIHandles::make_local(env, result);
3676 JVM_END
3677
3678
3679 // Networking library support ////////////////////////////////////////////////////////////////////
3680
3681 JVM_LEAF(jint, JVM_InitializeSocketLibrary())
3682 JVMWrapper("JVM_InitializeSocketLibrary");
3683 return 0;
3684 JVM_END
3685
3686
3687 JVM_LEAF(jint, JVM_Socket(jint domain, jint type, jint protocol))
3688 JVMWrapper("JVM_Socket");
3689 return os::socket(domain, type, protocol);
3690 JVM_END
3691
3692
3693 JVM_LEAF(jint, JVM_SocketClose(jint fd))
3694 JVMWrapper2("JVM_SocketClose (0x%x)", fd);
3695 //%note jvm_r6
3696 return os::socket_close(fd);
3697 JVM_END
3698
3699
3700 JVM_LEAF(jint, JVM_SocketShutdown(jint fd, jint howto))
3701 JVMWrapper2("JVM_SocketShutdown (0x%x)", fd);
3702 //%note jvm_r6
3703 return os::socket_shutdown(fd, howto);
3704 JVM_END
3705
3706
3707 JVM_LEAF(jint, JVM_Recv(jint fd, char *buf, jint nBytes, jint flags))
3708 JVMWrapper2("JVM_Recv (0x%x)", fd);
3709 //%note jvm_r6
3710 return os::recv(fd, buf, (size_t)nBytes, (uint)flags);
3711 JVM_END
3712
3713
3714 JVM_LEAF(jint, JVM_Send(jint fd, char *buf, jint nBytes, jint flags))
3715 JVMWrapper2("JVM_Send (0x%x)", fd);
3716 //%note jvm_r6
3717 return os::send(fd, buf, (size_t)nBytes, (uint)flags);
3718 JVM_END
3719
3720
3721 JVM_LEAF(jint, JVM_Timeout(int fd, long timeout))
3722 JVMWrapper2("JVM_Timeout (0x%x)", fd);
3723 //%note jvm_r6
3724 return os::timeout(fd, timeout);
3725 JVM_END
3726
3727
3728 JVM_LEAF(jint, JVM_Listen(jint fd, jint count))
3729 JVMWrapper2("JVM_Listen (0x%x)", fd);
3730 //%note jvm_r6
3731 return os::listen(fd, count);
3732 JVM_END
3733
3734
3735 JVM_LEAF(jint, JVM_Connect(jint fd, struct sockaddr *him, jint len))
3736 JVMWrapper2("JVM_Connect (0x%x)", fd);
3737 //%note jvm_r6
3738 return os::connect(fd, him, (socklen_t)len);
3739 JVM_END
3740
3741
3742 JVM_LEAF(jint, JVM_Bind(jint fd, struct sockaddr *him, jint len))
3743 JVMWrapper2("JVM_Bind (0x%x)", fd);
3744 //%note jvm_r6
3745 return os::bind(fd, him, (socklen_t)len);
3746 JVM_END
3747
3748
3749 JVM_LEAF(jint, JVM_Accept(jint fd, struct sockaddr *him, jint *len))
3750 JVMWrapper2("JVM_Accept (0x%x)", fd);
3751 //%note jvm_r6
3752 socklen_t socklen = (socklen_t)(*len);
3753 jint result = os::accept(fd, him, &socklen);
3754 *len = (jint)socklen;
3755 return result;
3756 JVM_END
3757
3758
3759 JVM_LEAF(jint, JVM_RecvFrom(jint fd, char *buf, int nBytes, int flags, struct sockaddr *from, int *fromlen))
3760 JVMWrapper2("JVM_RecvFrom (0x%x)", fd);
3761 //%note jvm_r6
3762 socklen_t socklen = (socklen_t)(*fromlen);
3763 jint result = os::recvfrom(fd, buf, (size_t)nBytes, (uint)flags, from, &socklen);
3764 *fromlen = (int)socklen;
3765 return result;
3766 JVM_END
3767
3768
3769 JVM_LEAF(jint, JVM_GetSockName(jint fd, struct sockaddr *him, int *len))
3770 JVMWrapper2("JVM_GetSockName (0x%x)", fd);
3771 //%note jvm_r6
3772 socklen_t socklen = (socklen_t)(*len);
3773 jint result = os::get_sock_name(fd, him, &socklen);
3774 *len = (int)socklen;
3775 return result;
3776 JVM_END
3777
3778
3779 JVM_LEAF(jint, JVM_SendTo(jint fd, char *buf, int len, int flags, struct sockaddr *to, int tolen))
3780 JVMWrapper2("JVM_SendTo (0x%x)", fd);
3781 //%note jvm_r6
3782 return os::sendto(fd, buf, (size_t)len, (uint)flags, to, (socklen_t)tolen);
3783 JVM_END
3784
3785
3786 JVM_LEAF(jint, JVM_SocketAvailable(jint fd, jint *pbytes))
3787 JVMWrapper2("JVM_SocketAvailable (0x%x)", fd);
3788 //%note jvm_r6
3789 return os::socket_available(fd, pbytes);
3790 JVM_END
3791
3792
3793 JVM_LEAF(jint, JVM_GetSockOpt(jint fd, int level, int optname, char *optval, int *optlen))
3794 JVMWrapper2("JVM_GetSockOpt (0x%x)", fd);
3795 //%note jvm_r6
3796 socklen_t socklen = (socklen_t)(*optlen);
3797 jint result = os::get_sock_opt(fd, level, optname, optval, &socklen);
3798 *optlen = (int)socklen;
3799 return result;
3800 JVM_END
3801
3802
3803 JVM_LEAF(jint, JVM_SetSockOpt(jint fd, int level, int optname, const char *optval, int optlen))
3804 JVMWrapper2("JVM_GetSockOpt (0x%x)", fd);
3805 //%note jvm_r6
3806 return os::set_sock_opt(fd, level, optname, optval, (socklen_t)optlen);
3807 JVM_END
3808
3809
3810 JVM_LEAF(int, JVM_GetHostName(char* name, int namelen))
3811 JVMWrapper("JVM_GetHostName");
3812 return os::get_host_name(name, namelen);
3813 JVM_END
3814
3815
3816 // Library support ///////////////////////////////////////////////////////////////////////////
3817
3818 JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name))
3819 //%note jvm_ct
3820 JVMWrapper2("JVM_LoadLibrary (%s)", name);
3821 char ebuf[1024];
3822 void *load_result;
3823 {
3824 ThreadToNativeFromVM ttnfvm(thread);
3825 load_result = os::dll_load(name, ebuf, sizeof ebuf);
3826 }
3827 if (load_result == NULL) {
3828 char msg[1024];
3829 jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf);
3830 // Since 'ebuf' may contain a string encoded using
3831 // platform encoding scheme, we need to pass
3832 // Exceptions::unsafe_to_utf8 to the new_exception method
3833 // as the last argument. See bug 6367357.
3834 Handle h_exception =
3835 Exceptions::new_exception(thread,
3837 msg, Exceptions::unsafe_to_utf8);
3838
3839 THROW_HANDLE_0(h_exception);
3840 }
3841 return load_result;
3842 JVM_END
3843
3844
3845 JVM_LEAF(void, JVM_UnloadLibrary(void* handle))
3846 JVMWrapper("JVM_UnloadLibrary");
3847 os::dll_unload(handle);
3848 JVM_END
3849
3850
3851 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3852 JVMWrapper2("JVM_FindLibraryEntry (%s)", name);
3853 return os::dll_lookup(handle, name);
3854 JVM_END
3855
3856
3857 // Floating point support ////////////////////////////////////////////////////////////////////
3858
3859 JVM_LEAF(jboolean, JVM_IsNaN(jdouble a))
3860 JVMWrapper("JVM_IsNaN");
3861 return g_isnan(a);
3862 JVM_END
3863
3864
3865 // JNI version ///////////////////////////////////////////////////////////////////////////////
3866
3867 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3868 JVMWrapper2("JVM_IsSupportedJNIVersion (%d)", version);
3869 return Threads::is_supported_jni_version_including_1_1(version);
3870 JVM_END
3871
3872
3873 // String support ///////////////////////////////////////////////////////////////////////////
3874
3875 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3876 JVMWrapper("JVM_InternString");
3877 JvmtiVMObjectAllocEventCollector oam;
3878 if (str == NULL) return NULL;
3879 oop string = JNIHandles::resolve_non_null(str);
3880 oop result = StringTable::intern(string, CHECK_NULL);
3881 return (jstring) JNIHandles::make_local(env, result);
3882 JVM_END
3883
3884
3965
3966 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3967 JVMWrapper("JVM_NewInstanceFromConstructor");
3968 oop constructor_mirror = JNIHandles::resolve(c);
3969 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3970 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3971 jobject res = JNIHandles::make_local(env, result);
3972 if (JvmtiExport::should_post_vm_object_alloc()) {
3973 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
3974 }
3975 return res;
3976 JVM_END
3977
3978 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3979
3980 JVM_LEAF(jboolean, JVM_SupportsCX8())
3981 JVMWrapper("JVM_SupportsCX8");
3982 return VM_Version::supports_cx8();
3983 JVM_END
3984
3985
3986 JVM_ENTRY(jboolean, JVM_CX8Field(JNIEnv *env, jobject obj, jfieldID fid, jlong oldVal, jlong newVal))
3987 JVMWrapper("JVM_CX8Field");
3988 jlong res;
3989 oop o = JNIHandles::resolve(obj);
3990 intptr_t fldOffs = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid);
3991 volatile jlong* addr = (volatile jlong*)((address)o + fldOffs);
3992
3993 assert(VM_Version::supports_cx8(), "cx8 not supported");
3994 res = Atomic::cmpxchg(newVal, addr, oldVal);
3995
3996 return res == oldVal;
3997 JVM_END
3998
3999 // DTrace ///////////////////////////////////////////////////////////////////
4000
4001 JVM_ENTRY(jint, JVM_DTraceGetVersion(JNIEnv* env))
4002 JVMWrapper("JVM_DTraceGetVersion");
4003 return (jint)JVM_TRACING_DTRACE_VERSION;
4004 JVM_END
4005
4006 JVM_ENTRY(jlong,JVM_DTraceActivate(
4007 JNIEnv* env, jint version, jstring module_name, jint providers_count,
4008 JVM_DTraceProvider* providers))
4009 JVMWrapper("JVM_DTraceActivate");
4010 return DTraceJSDT::activate(
4011 version, module_name, providers_count, providers, CHECK_0);
4012 JVM_END
4013
4014 JVM_ENTRY(jboolean,JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method))
4015 JVMWrapper("JVM_DTraceIsProbeEnabled");
4016 return DTraceJSDT::is_probe_enabled(method);
4017 JVM_END
4018
4133 objArrayHandle dest(THREAD, dest_o);
4134 Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
4135 dest->obj_at_put(0, enc_k->java_mirror());
4136 int encl_method_method_idx = ik_h->enclosing_method_method_index();
4137 if (encl_method_method_idx != 0) {
4138 Symbol* sym = ik_h->constants()->symbol_at(
4139 extract_low_short_from_int(
4140 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
4141 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
4142 dest->obj_at_put(1, str());
4143 sym = ik_h->constants()->symbol_at(
4144 extract_high_short_from_int(
4145 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
4146 str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
4147 dest->obj_at_put(2, str());
4148 }
4149 return (jobjectArray) JNIHandles::make_local(dest());
4150 }
4151 JVM_END
4152
4153 JVM_ENTRY(jintArray, JVM_GetThreadStateValues(JNIEnv* env,
4154 jint javaThreadState))
4155 {
4156 // If new thread states are added in future JDK and VM versions,
4157 // this should check if the JDK version is compatible with thread
4158 // states supported by the VM. Return NULL if not compatible.
4159 //
4160 // This function must map the VM java_lang_Thread::ThreadStatus
4161 // to the Java thread state that the JDK supports.
4162 //
4163
4164 typeArrayHandle values_h;
4165 switch (javaThreadState) {
4166 case JAVA_THREAD_STATE_NEW : {
4167 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
4168 values_h = typeArrayHandle(THREAD, r);
4169 values_h->int_at_put(0, java_lang_Thread::NEW);
4170 break;
4171 }
4172 case JAVA_THREAD_STATE_RUNNABLE : {
4173 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
4174 values_h = typeArrayHandle(THREAD, r);
4175 values_h->int_at_put(0, java_lang_Thread::RUNNABLE);
4176 break;
4177 }
4178 case JAVA_THREAD_STATE_BLOCKED : {
4179 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
4180 values_h = typeArrayHandle(THREAD, r);
4181 values_h->int_at_put(0, java_lang_Thread::BLOCKED_ON_MONITOR_ENTER);
4182 break;
4183 }
4184 case JAVA_THREAD_STATE_WAITING : {
4185 typeArrayOop r = oopFactory::new_typeArray(T_INT, 2, CHECK_NULL);
4186 values_h = typeArrayHandle(THREAD, r);
4187 values_h->int_at_put(0, java_lang_Thread::IN_OBJECT_WAIT);
4188 values_h->int_at_put(1, java_lang_Thread::PARKED);
4189 break;
4190 }
4191 case JAVA_THREAD_STATE_TIMED_WAITING : {
4192 typeArrayOop r = oopFactory::new_typeArray(T_INT, 3, CHECK_NULL);
4193 values_h = typeArrayHandle(THREAD, r);
4194 values_h->int_at_put(0, java_lang_Thread::SLEEPING);
4195 values_h->int_at_put(1, java_lang_Thread::IN_OBJECT_WAIT_TIMED);
4196 values_h->int_at_put(2, java_lang_Thread::PARKED_TIMED);
4197 break;
4198 }
4199 case JAVA_THREAD_STATE_TERMINATED : {
4200 typeArrayOop r = oopFactory::new_typeArray(T_INT, 1, CHECK_NULL);
4201 values_h = typeArrayHandle(THREAD, r);
4202 values_h->int_at_put(0, java_lang_Thread::TERMINATED);
4203 break;
4204 }
4205 default:
4206 // Unknown state - probably incompatible JDK version
4207 return NULL;
4208 }
4209
4210 return (jintArray) JNIHandles::make_local(env, values_h());
4211 }
4212 JVM_END
4213
4214
4215 JVM_ENTRY(jobjectArray, JVM_GetThreadStateNames(JNIEnv* env,
4216 jint javaThreadState,
4217 jintArray values))
4218 {
4219 // If new thread states are added in future JDK and VM versions,
4220 // this should check if the JDK version is compatible with thread
4221 // states supported by the VM. Return NULL if not compatible.
4222 //
4223 // This function must map the VM java_lang_Thread::ThreadStatus
4224 // to the Java thread state that the JDK supports.
4225 //
4226
4227 ResourceMark rm;
4228
4229 // Check if threads is null
4230 if (values == NULL) {
4231 THROW_(vmSymbols::java_lang_NullPointerException(), 0);
4232 }
4233
4234 typeArrayOop v = typeArrayOop(JNIHandles::resolve_non_null(values));
4235 typeArrayHandle values_h(THREAD, v);
4236
4237 objArrayHandle names_h;
4238 switch (javaThreadState) {
4239 case JAVA_THREAD_STATE_NEW : {
4240 assert(values_h->length() == 1 &&
4241 values_h->int_at(0) == java_lang_Thread::NEW,
4242 "Invalid threadStatus value");
4243
4244 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
4245 1, /* only 1 substate */
4246 CHECK_NULL);
4247 names_h = objArrayHandle(THREAD, r);
4248 Handle name = java_lang_String::create_from_str("NEW", CHECK_NULL);
4249 names_h->obj_at_put(0, name());
4250 break;
4251 }
4252 case JAVA_THREAD_STATE_RUNNABLE : {
4253 assert(values_h->length() == 1 &&
4254 values_h->int_at(0) == java_lang_Thread::RUNNABLE,
4255 "Invalid threadStatus value");
4256
4257 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
4258 1, /* only 1 substate */
4259 CHECK_NULL);
4260 names_h = objArrayHandle(THREAD, r);
4261 Handle name = java_lang_String::create_from_str("RUNNABLE", CHECK_NULL);
4262 names_h->obj_at_put(0, name());
4263 break;
4264 }
4265 case JAVA_THREAD_STATE_BLOCKED : {
4266 assert(values_h->length() == 1 &&
4267 values_h->int_at(0) == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER,
4268 "Invalid threadStatus value");
4269
4270 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
4271 1, /* only 1 substate */
4272 CHECK_NULL);
4273 names_h = objArrayHandle(THREAD, r);
4274 Handle name = java_lang_String::create_from_str("BLOCKED", CHECK_NULL);
4275 names_h->obj_at_put(0, name());
4276 break;
4277 }
4278 case JAVA_THREAD_STATE_WAITING : {
4279 assert(values_h->length() == 2 &&
4280 values_h->int_at(0) == java_lang_Thread::IN_OBJECT_WAIT &&
4281 values_h->int_at(1) == java_lang_Thread::PARKED,
4282 "Invalid threadStatus value");
4283 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
4284 2, /* number of substates */
4285 CHECK_NULL);
4286 names_h = objArrayHandle(THREAD, r);
4287 Handle name0 = java_lang_String::create_from_str("WAITING.OBJECT_WAIT",
4288 CHECK_NULL);
4289 Handle name1 = java_lang_String::create_from_str("WAITING.PARKED",
4290 CHECK_NULL);
4291 names_h->obj_at_put(0, name0());
4292 names_h->obj_at_put(1, name1());
4293 break;
4294 }
4295 case JAVA_THREAD_STATE_TIMED_WAITING : {
4296 assert(values_h->length() == 3 &&
4297 values_h->int_at(0) == java_lang_Thread::SLEEPING &&
4298 values_h->int_at(1) == java_lang_Thread::IN_OBJECT_WAIT_TIMED &&
4299 values_h->int_at(2) == java_lang_Thread::PARKED_TIMED,
4300 "Invalid threadStatus value");
4301 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
4302 3, /* number of substates */
4303 CHECK_NULL);
4304 names_h = objArrayHandle(THREAD, r);
4305 Handle name0 = java_lang_String::create_from_str("TIMED_WAITING.SLEEPING",
4306 CHECK_NULL);
4307 Handle name1 = java_lang_String::create_from_str("TIMED_WAITING.OBJECT_WAIT",
4308 CHECK_NULL);
4309 Handle name2 = java_lang_String::create_from_str("TIMED_WAITING.PARKED",
4310 CHECK_NULL);
4311 names_h->obj_at_put(0, name0());
4312 names_h->obj_at_put(1, name1());
4313 names_h->obj_at_put(2, name2());
4314 break;
4315 }
4316 case JAVA_THREAD_STATE_TERMINATED : {
4317 assert(values_h->length() == 1 &&
4318 values_h->int_at(0) == java_lang_Thread::TERMINATED,
4319 "Invalid threadStatus value");
4320 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
4321 1, /* only 1 substate */
4322 CHECK_NULL);
4323 names_h = objArrayHandle(THREAD, r);
4324 Handle name = java_lang_String::create_from_str("TERMINATED", CHECK_NULL);
4325 names_h->obj_at_put(0, name());
4326 break;
4327 }
4328 default:
4329 // Unknown state - probably incompatible JDK version
4330 return NULL;
4331 }
4332 return (jobjectArray) JNIHandles::make_local(env, names_h());
4333 }
4334 JVM_END
4335
4336 JVM_ENTRY(void, JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size))
4337 {
4338 memset(info, 0, info_size);
4339
4340 info->jvm_version = Abstract_VM_Version::jvm_version();
4341 info->update_version = 0; /* 0 in HotSpot Express VM */
4342 info->special_update_version = 0; /* 0 in HotSpot Express VM */
4343
4344 // when we add a new capability in the jvm_version_info struct, we should also
4345 // consider to expose this new capability in the sun.rt.jvmCapabilities jvmstat
4346 // counter defined in runtimeService.cpp.
4347 info->is_attachable = AttachListener::is_attach_supported();
4348 }
4349 JVM_END
|
398 * Return the temporary directory that the VM uses for the attach
399 * and perf data files.
400 *
401 * It is important that this directory is well-known and the
402 * same for all VM instances. It cannot be affected by configuration
403 * variables such as java.io.tmpdir.
404 */
405 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
406 JVMWrapper("JVM_GetTemporaryDirectory");
407 HandleMark hm(THREAD);
408 const char* temp_dir = os::get_temp_directory();
409 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
410 return (jstring) JNIHandles::make_local(env, h());
411 JVM_END
412
413
414 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
415
416 extern volatile jint vm_created;
417
418 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
419 before_exit(thread);
420 vm_exit(code);
421 JVM_END
422
423
424 JVM_ENTRY_NO_ENV(void, JVM_GC(void))
425 JVMWrapper("JVM_GC");
426 if (!DisableExplicitGC) {
427 Universe::heap()->collect(GCCause::_java_lang_system_gc);
428 }
429 JVM_END
430
431
432 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))
433 JVMWrapper("JVM_MaxObjectInspectionAge");
434 return Universe::heap()->millis_since_last_gc();
435 JVM_END
436
437
438 static inline jlong convert_size_t_to_jlong(size_t val) {
439 // In the 64-bit vm, a size_t can overflow a jlong (which is signed).
440 NOT_LP64 (return (jlong)val;)
441 LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)
442 }
443
444 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))
445 JVMWrapper("JVM_TotalMemory");
446 size_t n = Universe::heap()->capacity();
447 return convert_size_t_to_jlong(n);
448 JVM_END
449
450
451 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))
452 JVMWrapper("JVM_FreeMemory");
453 CollectedHeap* ch = Universe::heap();
454 size_t n;
455 {
456 MutexLocker x(Heap_lock);
457 n = ch->capacity() - ch->used();
587 Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,
588 (size_t)align_object_size(size) / HeapWordsPerLong);
589 // Clear the header
590 new_obj->init_mark();
591
592 // Store check (mark entire object and let gc sort it out)
593 BarrierSet* bs = Universe::heap()->barrier_set();
594 assert(bs->has_write_region_opt(), "Barrier set does not have write_region");
595 bs->write_region(MemRegion((HeapWord*)new_obj, size));
596
597 // Caution: this involves a java upcall, so the clone should be
598 // "gc-robust" by this stage.
599 if (klass->has_finalizer()) {
600 assert(obj->is_instance(), "should be instanceOop");
601 new_obj = InstanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);
602 }
603
604 return JNIHandles::make_local(env, oop(new_obj));
605 JVM_END
606
607 // java.io.File ///////////////////////////////////////////////////////////////
608
609 JVM_LEAF(char*, JVM_NativePath(char* path))
610 JVMWrapper2("JVM_NativePath (%s)", path);
611 return os::native_path(path);
612 JVM_END
613
614
615 // Misc. class handling ///////////////////////////////////////////////////////////
616
617
618 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))
619 JVMWrapper("JVM_GetCallerClass");
620
621 // Pre-JDK 8 and early builds of JDK 8 don't have a CallerSensitive annotation; or
622 // sun.reflect.Reflection.getCallerClass with a depth parameter is provided
623 // temporarily for existing code to use until a replacement API is defined.
624 if (SystemDictionary::reflect_CallerSensitive_klass() == NULL || depth != JVM_CALLER_DEPTH) {
625 Klass* k = thread->security_get_caller_class(depth);
626 return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror());
662 }
663 return NULL;
664 JVM_END
665
666
667 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
668 JVMWrapper("JVM_FindPrimitiveClass");
669 oop mirror = NULL;
670 BasicType t = name2type(utf);
671 if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) {
672 mirror = Universe::java_mirror(t);
673 }
674 if (mirror == NULL) {
675 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf);
676 } else {
677 return (jclass) JNIHandles::make_local(env, mirror);
678 }
679 JVM_END
680
681
682 // Returns a class loaded by the bootstrap class loader; or null
683 // if not found. ClassNotFoundException is not thrown.
684 //
685 // Rationale behind JVM_FindClassFromBootLoader
686 // a> JVM_FindClassFromClassLoader was never exported in the export tables.
687 // b> because of (a) java.dll has a direct dependecy on the unexported
688 // private symbol "_JVM_FindClassFromClassLoader@20".
689 // c> the launcher cannot use the private symbol as it dynamically opens
690 // the entry point, so if something changes, the launcher will fail
691 // unexpectedly at runtime, it is safest for the launcher to dlopen a
692 // stable exported interface.
693 // d> re-exporting JVM_FindClassFromClassLoader as public, will cause its
694 // signature to change from _JVM_FindClassFromClassLoader@20 to
695 // JVM_FindClassFromClassLoader and will not be backward compatible
696 // with older JDKs.
697 // Thus a public/stable exported entry point is the right solution,
698 // public here means public in linker semantics, and is exported only
699 // to the JDK, and is not intended to be a public API.
700
701 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,
1513 KlassHandle kh(THREAD, k);
1514 intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot);
1515
1516 if (modifiers & JVM_ACC_STATIC) {
1517 // for static fields we only look in the current class
1518 if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) {
1519 assert(false, "cannot find static field");
1520 return false;
1521 }
1522 } else {
1523 // for instance fields we start with the current class and work
1524 // our way up through the superclass chain
1525 if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) {
1526 assert(false, "cannot find instance field");
1527 return false;
1528 }
1529 }
1530 return true;
1531 }
1532
1533 static Method* jvm_get_method_common(jobject method) {
1534 // some of this code was adapted from from jni_FromReflectedMethod
1535
1536 oop reflected = JNIHandles::resolve_non_null(method);
1537 oop mirror = NULL;
1538 int slot = 0;
1539
1540 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
1541 mirror = java_lang_reflect_Constructor::clazz(reflected);
1542 slot = java_lang_reflect_Constructor::slot(reflected);
1543 } else {
1544 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(),
1545 "wrong type");
1546 mirror = java_lang_reflect_Method::clazz(reflected);
1547 slot = java_lang_reflect_Method::slot(reflected);
1548 }
1549 Klass* k = java_lang_Class::as_Klass(mirror);
1550
1551 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
1552 assert(m != NULL, "cannot find method");
1553 return m; // caller has to deal with NULL in product mode
1554 }
1555
1556 /* Type use annotations support (JDK 1.8) */
1557
1558 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls))
1559 assert (cls != NULL, "illegal class");
1560 JVMWrapper("JVM_GetClassTypeAnnotations");
1561 ResourceMark rm(THREAD);
1562 // Return null for arrays and primitives
1563 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1564 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1565 if (k->oop_is_instance()) {
1566 AnnotationArray* type_annotations = InstanceKlass::cast(k)->class_type_annotations();
1567 if (type_annotations != NULL) {
1568 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
1569 return (jbyteArray) JNIHandles::make_local(env, a);
1570 }
1571 }
1572 }
1573 return NULL;
1574 JVM_END
1575
2522 return 0;
2523 JVM_END
2524
2525
2526 // Misc //////////////////////////////////////////////////////////////////////////////////////////////
2527
2528 JVM_LEAF(void, JVM_ReleaseUTF(const char *utf))
2529 // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything
2530 JVM_END
2531
2532
2533 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2))
2534 JVMWrapper("JVM_IsSameClassPackage");
2535 oop class1_mirror = JNIHandles::resolve_non_null(class1);
2536 oop class2_mirror = JNIHandles::resolve_non_null(class2);
2537 Klass* klass1 = java_lang_Class::as_Klass(class1_mirror);
2538 Klass* klass2 = java_lang_Class::as_Klass(class2_mirror);
2539 return (jboolean) Reflection::is_same_class_package(klass1, klass2);
2540 JVM_END
2541
2542 // Printing support //////////////////////////////////////////////////
2543 extern "C" {
2544
2545 ATTRIBUTE_PRINTF(3, 0)
2546 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {
2547 // see bug 4399518, 4417214
2548 if ((intptr_t)count <= 0) return -1;
2549 return vsnprintf(str, count, fmt, args);
2550 }
2551
2552 ATTRIBUTE_PRINTF(3, 0)
2553 int jio_snprintf(char *str, size_t count, const char *fmt, ...) {
2554 va_list args;
2555 int len;
2556 va_start(args, fmt);
2557 len = jio_vsnprintf(str, count, fmt, args);
2558 va_end(args);
2559 return len;
2560 }
2561
3193 // ObjectInputStream ///////////////////////////////////////////////////////////////
3194
3195 bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessFlags access, bool classloader_only) {
3196 if (current_class == NULL) {
3197 return true;
3198 }
3199 if ((current_class == field_class) || access.is_public()) {
3200 return true;
3201 }
3202
3203 if (access.is_protected()) {
3204 // See if current_class is a subclass of field_class
3205 if (current_class->is_subclass_of(field_class)) {
3206 return true;
3207 }
3208 }
3209
3210 return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class));
3211 }
3212
3213 // Return the first non-null class loader up the execution stack, or null
3214 // if only code from the null class loader is on the stack.
3215
3216 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
3217 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3218 vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
3219 oop loader = vfst.method()->method_holder()->class_loader();
3220 if (loader != NULL) {
3221 return JNIHandles::make_local(env, loader);
3222 }
3223 }
3224 return NULL;
3225 JVM_END
3226
3227
3228 // Array ///////////////////////////////////////////////////////////////////////////////////////////
3229
3230
3231 // resolve array handle and check arguments
3232 static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) {
3233 if (arr == NULL) {
3234 THROW_0(vmSymbols::java_lang_NullPointerException());
3235 }
3236 oop a = JNIHandles::resolve_non_null(arr);
3237 if (!a->is_array() || (type_array_only && !a->is_typeArray())) {
3238 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array");
3239 }
3240 return arrayOop(a);
3241 }
3242
3243
3244 JVM_ENTRY(jint, JVM_GetArrayLength(JNIEnv *env, jobject arr))
3245 JVMWrapper("JVM_GetArrayLength");
3246 arrayOop a = check_array(env, arr, false, CHECK_0);
3247 return a->length();
3303 JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length))
3304 JVMWrapper("JVM_NewArray");
3305 JvmtiVMObjectAllocEventCollector oam;
3306 oop element_mirror = JNIHandles::resolve(eltClass);
3307 oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL);
3308 return JNIHandles::make_local(env, result);
3309 JVM_END
3310
3311
3312 JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim))
3313 JVMWrapper("JVM_NewMultiArray");
3314 JvmtiVMObjectAllocEventCollector oam;
3315 arrayOop dim_array = check_array(env, dim, true, CHECK_NULL);
3316 oop element_mirror = JNIHandles::resolve(eltClass);
3317 assert(dim_array->is_typeArray(), "just checking");
3318 oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL);
3319 return JNIHandles::make_local(env, result);
3320 JVM_END
3321
3322
3323 // Library support ///////////////////////////////////////////////////////////////////////////
3324
3325 JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name))
3326 //%note jvm_ct
3327 JVMWrapper2("JVM_LoadLibrary (%s)", name);
3328 char ebuf[1024];
3329 void *load_result;
3330 {
3331 ThreadToNativeFromVM ttnfvm(thread);
3332 load_result = os::dll_load(name, ebuf, sizeof ebuf);
3333 }
3334 if (load_result == NULL) {
3335 char msg[1024];
3336 jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf);
3337 // Since 'ebuf' may contain a string encoded using
3338 // platform encoding scheme, we need to pass
3339 // Exceptions::unsafe_to_utf8 to the new_exception method
3340 // as the last argument. See bug 6367357.
3341 Handle h_exception =
3342 Exceptions::new_exception(thread,
3344 msg, Exceptions::unsafe_to_utf8);
3345
3346 THROW_HANDLE_0(h_exception);
3347 }
3348 return load_result;
3349 JVM_END
3350
3351
3352 JVM_LEAF(void, JVM_UnloadLibrary(void* handle))
3353 JVMWrapper("JVM_UnloadLibrary");
3354 os::dll_unload(handle);
3355 JVM_END
3356
3357
3358 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3359 JVMWrapper2("JVM_FindLibraryEntry (%s)", name);
3360 return os::dll_lookup(handle, name);
3361 JVM_END
3362
3363
3364 // JNI version ///////////////////////////////////////////////////////////////////////////////
3365
3366 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3367 JVMWrapper2("JVM_IsSupportedJNIVersion (%d)", version);
3368 return Threads::is_supported_jni_version_including_1_1(version);
3369 JVM_END
3370
3371
3372 // String support ///////////////////////////////////////////////////////////////////////////
3373
3374 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3375 JVMWrapper("JVM_InternString");
3376 JvmtiVMObjectAllocEventCollector oam;
3377 if (str == NULL) return NULL;
3378 oop string = JNIHandles::resolve_non_null(str);
3379 oop result = StringTable::intern(string, CHECK_NULL);
3380 return (jstring) JNIHandles::make_local(env, result);
3381 JVM_END
3382
3383
3464
3465 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3466 JVMWrapper("JVM_NewInstanceFromConstructor");
3467 oop constructor_mirror = JNIHandles::resolve(c);
3468 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3469 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3470 jobject res = JNIHandles::make_local(env, result);
3471 if (JvmtiExport::should_post_vm_object_alloc()) {
3472 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
3473 }
3474 return res;
3475 JVM_END
3476
3477 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3478
3479 JVM_LEAF(jboolean, JVM_SupportsCX8())
3480 JVMWrapper("JVM_SupportsCX8");
3481 return VM_Version::supports_cx8();
3482 JVM_END
3483
3484 // DTrace ///////////////////////////////////////////////////////////////////
3485
3486 JVM_ENTRY(jint, JVM_DTraceGetVersion(JNIEnv* env))
3487 JVMWrapper("JVM_DTraceGetVersion");
3488 return (jint)JVM_TRACING_DTRACE_VERSION;
3489 JVM_END
3490
3491 JVM_ENTRY(jlong,JVM_DTraceActivate(
3492 JNIEnv* env, jint version, jstring module_name, jint providers_count,
3493 JVM_DTraceProvider* providers))
3494 JVMWrapper("JVM_DTraceActivate");
3495 return DTraceJSDT::activate(
3496 version, module_name, providers_count, providers, CHECK_0);
3497 JVM_END
3498
3499 JVM_ENTRY(jboolean,JVM_DTraceIsProbeEnabled(JNIEnv* env, jmethodID method))
3500 JVMWrapper("JVM_DTraceIsProbeEnabled");
3501 return DTraceJSDT::is_probe_enabled(method);
3502 JVM_END
3503
3618 objArrayHandle dest(THREAD, dest_o);
3619 Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
3620 dest->obj_at_put(0, enc_k->java_mirror());
3621 int encl_method_method_idx = ik_h->enclosing_method_method_index();
3622 if (encl_method_method_idx != 0) {
3623 Symbol* sym = ik_h->constants()->symbol_at(
3624 extract_low_short_from_int(
3625 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
3626 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
3627 dest->obj_at_put(1, str());
3628 sym = ik_h->constants()->symbol_at(
3629 extract_high_short_from_int(
3630 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
3631 str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
3632 dest->obj_at_put(2, str());
3633 }
3634 return (jobjectArray) JNIHandles::make_local(dest());
3635 }
3636 JVM_END
3637
3638 JVM_ENTRY(void, JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size))
3639 {
3640 memset(info, 0, info_size);
3641
3642 info->jvm_version = Abstract_VM_Version::jvm_version();
3643 info->update_version = 0; /* 0 in HotSpot Express VM */
3644 info->special_update_version = 0; /* 0 in HotSpot Express VM */
3645
3646 // when we add a new capability in the jvm_version_info struct, we should also
3647 // consider to expose this new capability in the sun.rt.jvmCapabilities jvmstat
3648 // counter defined in runtimeService.cpp.
3649 info->is_attachable = AttachListener::is_attach_supported();
3650 }
3651 JVM_END
|