1 /*

     2  * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "classfile/classFileStream.hpp"

    27 #include "classfile/classLoader.hpp"

    28 #include "classfile/classLoaderData.inline.hpp"

    29 #include "classfile/javaAssertions.hpp"

    30 #include "classfile/javaClasses.inline.hpp"

    31 #include "classfile/moduleEntry.hpp"

    32 #include "classfile/modules.hpp"

    33 #include "classfile/packageEntry.hpp"

    34 #include "classfile/stringTable.hpp"

    35 #include "classfile/systemDictionary.hpp"

    36 #include "classfile/vmSymbols.hpp"

    37 #include "gc/shared/barrierSet.inline.hpp"

    38 #include "gc/shared/collectedHeap.inline.hpp"

    39 #include "interpreter/bytecode.hpp"

    40 #include "memory/oopFactory.hpp"

    41 #include "memory/resourceArea.hpp"

    42 #include "memory/universe.inline.hpp"

    43 #include "oops/fieldStreams.hpp"

    44 #include "oops/instanceKlass.hpp"

    45 #include "oops/method.hpp"

    46 #include "oops/objArrayKlass.hpp"

    47 #include "oops/objArrayOop.inline.hpp"

    48 #include "oops/oop.inline.hpp"

    49 #include "prims/jvm.h"

    50 #include "prims/jvm_misc.hpp"

    51 #include "prims/jvmtiExport.hpp"

    52 #include "prims/jvmtiThreadState.hpp"

    53 #include "prims/nativeLookup.hpp"

    54 #include "prims/privilegedStack.hpp"

    55 #include "prims/stackwalk.hpp"

    56 #include "runtime/arguments.hpp"

    57 #include "runtime/atomic.hpp"

    58 #include "runtime/handles.inline.hpp"

    59 #include "runtime/init.hpp"

    60 #include "runtime/interfaceSupport.hpp"

    61 #include "runtime/java.hpp"

    62 #include "runtime/javaCalls.hpp"

    63 #include "runtime/jfieldIDWorkaround.hpp"

    64 #include "runtime/orderAccess.inline.hpp"

    65 #include "runtime/os.inline.hpp"

    66 #include "runtime/perfData.hpp"

    67 #include "runtime/reflection.hpp"

    68 #include "runtime/thread.inline.hpp"

    69 #include "runtime/vframe.hpp"

    70 #include "runtime/vm_operations.hpp"

    71 #include "runtime/vm_version.hpp"

    72 #include "services/attachListener.hpp"

    73 #include "services/management.hpp"

    74 #include "services/threadService.hpp"

    75 #include "trace/tracing.hpp"

    76 #include "utilities/copy.hpp"

    77 #include "utilities/defaultStream.hpp"

    78 #include "utilities/dtrace.hpp"

    79 #include "utilities/events.hpp"

    80 #include "utilities/histogram.hpp"

    81 #include "utilities/macros.hpp"

    82 #include "utilities/utf8.hpp"

    83 #if INCLUDE_CDS

    84 #include "classfile/sharedClassUtil.hpp"

    85 #include "classfile/systemDictionaryShared.hpp"

    86 #endif

    87 

    88 #include <errno.h>

    89 

    90 /*

    91   NOTE about use of any ctor or function call that can trigger a safepoint/GC:

    92   such ctors and calls MUST NOT come between an oop declaration/init and its

    93   usage because if objects are move this may cause various memory stomps, bus

    94   errors and segfaults. Here is a cookbook for causing so called "naked oop

    95   failures":

    96 

    97       JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> {

    98           JVMWrapper("JVM_GetClassDeclaredFields");

    99 

   100           // Object address to be held directly in mirror & not visible to GC

   101           oop mirror = JNIHandles::resolve_non_null(ofClass);

   102 

   103           // If this ctor can hit a safepoint, moving objects around, then

   104           ComplexConstructor foo;

   105 

   106           // Boom! mirror may point to JUNK instead of the intended object

   107           (some dereference of mirror)

   108 

   109           // Here's another call that may block for GC, making mirror stale

   110           MutexLocker ml(some_lock);

   111 

   112           // And here's an initializer that can result in a stale oop

   113           // all in one step.

   114           oop o = call_that_can_throw_exception(TRAPS);

   115 

   116 

   117   The solution is to keep the oop declaration BELOW the ctor or function

   118   call that might cause a GC, do another resolve to reassign the oop, or

   119   consider use of a Handle instead of an oop so there is immunity from object

   120   motion. But note that the "QUICK" entries below do not have a handlemark

   121   and thus can only support use of handles passed in.

   122 */

   123 

   124 static void trace_class_resolution_impl(Klass* to_class, TRAPS) {

   125   ResourceMark rm;

   126   int line_number = -1;

   127   const char * source_file = NULL;

   128   const char * trace = "explicit";

   129   InstanceKlass* caller = NULL;

   130   JavaThread* jthread = JavaThread::current();

   131   if (jthread->has_last_Java_frame()) {

   132     vframeStream vfst(jthread);

   133 

   134     // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames

   135     TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK);

   136     Klass* access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);

   137     TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK);

   138     Klass* privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);

   139 

   140     Method* last_caller = NULL;

   141 

   142     while (!vfst.at_end()) {

   143       Method* m = vfst.method();

   144       if (!vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&

   145           !vfst.method()->method_holder()->is_subclass_of(access_controller_klass) &&

   146           !vfst.method()->method_holder()->is_subclass_of(privileged_action_klass)) {

   147         break;

   148       }

   149       last_caller = m;

   150       vfst.next();

   151     }

   152     // if this is called from Class.forName0 and that is called from Class.forName,

   153     // then print the caller of Class.forName.  If this is Class.loadClass, then print

   154     // that caller, otherwise keep quiet since this should be picked up elsewhere.

   155     bool found_it = false;

   156     if (!vfst.at_end() &&

   157         vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&

   158         vfst.method()->name() == vmSymbols::forName0_name()) {

   159       vfst.next();

   160       if (!vfst.at_end() &&

   161           vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&

   162           vfst.method()->name() == vmSymbols::forName_name()) {

   163         vfst.next();

   164         found_it = true;

   165       }

   166     } else if (last_caller != NULL &&

   167                last_caller->method_holder()->name() ==

   168                vmSymbols::java_lang_ClassLoader() &&

   169                (last_caller->name() == vmSymbols::loadClassInternal_name() ||

   170                 last_caller->name() == vmSymbols::loadClass_name())) {

   171       found_it = true;

   172     } else if (!vfst.at_end()) {

   173       if (vfst.method()->is_native()) {

   174         // JNI call

   175         found_it = true;

   176       }

   177     }

   178     if (found_it && !vfst.at_end()) {

   179       // found the caller

   180       caller = vfst.method()->method_holder();

   181       line_number = vfst.method()->line_number_from_bci(vfst.bci());

   182       if (line_number == -1) {

   183         // show method name if it's a native method

   184         trace = vfst.method()->name_and_sig_as_C_string();

   185       }

   186       Symbol* s = caller->source_file_name();

   187       if (s != NULL) {

   188         source_file = s->as_C_string();

   189       }

   190     }

   191   }

   192   if (caller != NULL) {

   193     if (to_class != caller) {

   194       const char * from = caller->external_name();

   195       const char * to = to_class->external_name();

   196       // print in a single call to reduce interleaving between threads

   197       if (source_file != NULL) {

   198         log_debug(class, resolve)("%s %s %s:%d (%s)", from, to, source_file, line_number, trace);

   199       } else {

   200         log_debug(class, resolve)("%s %s (%s)", from, to, trace);

   201       }

   202     }

   203   }

   204 }

   205 

   206 void trace_class_resolution(Klass* to_class) {

   207   EXCEPTION_MARK;

   208   trace_class_resolution_impl(to_class, THREAD);

   209   if (HAS_PENDING_EXCEPTION) {

   210     CLEAR_PENDING_EXCEPTION;

   211   }

   212 }

   213 

   214 // Wrapper to trace JVM functions

   215 

   216 #ifdef ASSERT

   217   Histogram* JVMHistogram;

   218   volatile jint JVMHistogram_lock = 0;

   219 

   220   class JVMHistogramElement : public HistogramElement {

   221     public:

   222      JVMHistogramElement(const char* name);

   223   };

   224 

   225   JVMHistogramElement::JVMHistogramElement(const char* elementName) {

   226     _name = elementName;

   227     uintx count = 0;

   228 

   229     while (Atomic::cmpxchg(1, &JVMHistogram_lock, 0) != 0) {

   230       while (OrderAccess::load_acquire(&JVMHistogram_lock) != 0) {

   231         count +=1;

   232         if ( (WarnOnStalledSpinLock > 0)

   233           && (count % WarnOnStalledSpinLock == 0)) {

   234           warning("JVMHistogram_lock seems to be stalled");

   235         }

   236       }

   237      }

   238 

   239     if(JVMHistogram == NULL)

   240       JVMHistogram = new Histogram("JVM Call Counts",100);

   241 

   242     JVMHistogram->add_element(this);

   243     Atomic::dec(&JVMHistogram_lock);

   244   }

   245 

   246   #define JVMCountWrapper(arg) \

   247       static JVMHistogramElement* e = new JVMHistogramElement(arg); \

   248       if (e != NULL) e->increment_count();  // Due to bug in VC++, we need a NULL check here eventhough it should never happen!

   249 

   250   #define JVMWrapper(arg) JVMCountWrapper(arg);

   251 #else

   252   #define JVMWrapper(arg)

   253 #endif

   254 

   255 

   256 // Interface version /////////////////////////////////////////////////////////////////////

   257 

   258 

   259 JVM_LEAF(jint, JVM_GetInterfaceVersion())

   260   return JVM_INTERFACE_VERSION;

   261 JVM_END

   262 

   263 

   264 // java.lang.System //////////////////////////////////////////////////////////////////////

   265 

   266 

   267 JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored))

   268   JVMWrapper("JVM_CurrentTimeMillis");

   269   return os::javaTimeMillis();

   270 JVM_END

   271 

   272 JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored))

   273   JVMWrapper("JVM_NanoTime");

   274   return os::javaTimeNanos();

   275 JVM_END

   276 

   277 // The function below is actually exposed by jdk.internal.misc.VM and not

   278 // java.lang.System, but we choose to keep it here so that it stays next

   279 // to JVM_CurrentTimeMillis and JVM_NanoTime

   280 

   281 const jlong MAX_DIFF_SECS = CONST64(0x0100000000); //  2^32

   282 const jlong MIN_DIFF_SECS = -MAX_DIFF_SECS; // -2^32

   283 

   284 JVM_LEAF(jlong, JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs))

   285   JVMWrapper("JVM_GetNanoTimeAdjustment");

   286   jlong seconds;

   287   jlong nanos;

   288 

   289   os::javaTimeSystemUTC(seconds, nanos);

   290 

   291   // We're going to verify that the result can fit in a long.

   292   // For that we need the difference in seconds between 'seconds'

   293   // and 'offset_secs' to be such that:

   294   //     |seconds - offset_secs| < (2^63/10^9)

   295   // We're going to approximate 10^9 ~< 2^30 (1000^3 ~< 1024^3)

   296   // which makes |seconds - offset_secs| < 2^33

   297   // and we will prefer +/- 2^32 as the maximum acceptable diff

   298   // as 2^32 has a more natural feel than 2^33...

   299   //

   300   // So if |seconds - offset_secs| >= 2^32 - we return a special

   301   // sentinel value (-1) which the caller should take as an

   302   // exception value indicating that the offset given to us is

   303   // too far from range of the current time - leading to too big

   304   // a nano adjustment. The caller is expected to recover by

   305   // computing a more accurate offset and calling this method

   306   // again. (For the record 2^32 secs is ~136 years, so that

   307   // should rarely happen)

   308   //

   309   jlong diff = seconds - offset_secs;

   310   if (diff >= MAX_DIFF_SECS || diff <= MIN_DIFF_SECS) {

   311      return -1; // sentinel value: the offset is too far off the target

   312   }

   313 

   314   // return the adjustment. If you compute a time by adding

   315   // this number of nanoseconds along with the number of seconds

   316   // in the offset you should get the current UTC time.

   317   return (diff * (jlong)1000000000) + nanos;

   318 JVM_END

   319 

   320 JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,

   321                                jobject dst, jint dst_pos, jint length))

   322   JVMWrapper("JVM_ArrayCopy");

   323   // Check if we have null pointers

   324   if (src == NULL || dst == NULL) {

   325     THROW(vmSymbols::java_lang_NullPointerException());

   326   }

   327   arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));

   328   arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));

   329   assert(oopDesc::is_oop(s), "JVM_ArrayCopy: src not an oop");

   330   assert(oopDesc::is_oop(d), "JVM_ArrayCopy: dst not an oop");

   331   // Do copy

   332   s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread);

   333 JVM_END

   334 

   335 

   336 static void set_property(Handle props, const char* key, const char* value, TRAPS) {

   337   JavaValue r(T_OBJECT);

   338   // public synchronized Object put(Object key, Object value);

   339   HandleMark hm(THREAD);

   340   Handle key_str    = java_lang_String::create_from_platform_dependent_str(key, CHECK);

   341   Handle value_str  = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);

   342   JavaCalls::call_virtual(&r,

   343                           props,

   344                           SystemDictionary::Properties_klass(),

   345                           vmSymbols::put_name(),

   346                           vmSymbols::object_object_object_signature(),

   347                           key_str,

   348                           value_str,

   349                           THREAD);

   350 }

   351 

   352 

   353 #define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties));

   354 

   355 

   356 JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties))

   357   JVMWrapper("JVM_InitProperties");

   358   ResourceMark rm;

   359 

   360   Handle props(THREAD, JNIHandles::resolve_non_null(properties));

   361 

   362   // System property list includes both user set via -D option and

   363   // jvm system specific properties.

   364   for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) {

   365     PUTPROP(props, p->key(), p->value());

   366   }

   367 

   368   // Convert the -XX:MaxDirectMemorySize= command line flag

   369   // to the sun.nio.MaxDirectMemorySize property.

   370   // Do this after setting user properties to prevent people

   371   // from setting the value with a -D option, as requested.

   372   {

   373     if (FLAG_IS_DEFAULT(MaxDirectMemorySize)) {

   374       PUTPROP(props, "sun.nio.MaxDirectMemorySize", "-1");

   375     } else {

   376       char as_chars[256];

   377       jio_snprintf(as_chars, sizeof(as_chars), JULONG_FORMAT, MaxDirectMemorySize);

   378       PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars);

   379     }

   380   }

   381 

   382   // JVM monitoring and management support

   383   // Add the sun.management.compiler property for the compiler's name

   384   {

   385 #undef CSIZE

   386 #if defined(_LP64) || defined(_WIN64)

   387   #define CSIZE "64-Bit "

   388 #else

   389   #define CSIZE

   390 #endif // 64bit

   391 

   392 #ifdef TIERED

   393     const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers";

   394 #else

   395 #if defined(COMPILER1)

   396     const char* compiler_name = "HotSpot " CSIZE "Client Compiler";

   397 #elif defined(COMPILER2)

   398     const char* compiler_name = "HotSpot " CSIZE "Server Compiler";

   399 #elif INCLUDE_JVMCI

   400     #error "INCLUDE_JVMCI should imply TIERED"

   401 #else

   402     const char* compiler_name = "";

   403 #endif // compilers

   404 #endif // TIERED

   405 

   406     if (*compiler_name != '\0' &&

   407         (Arguments::mode() != Arguments::_int)) {

   408       PUTPROP(props, "sun.management.compiler", compiler_name);

   409     }

   410   }

   411 

   412   return properties;

   413 JVM_END

   414 

   415 

   416 /*

   417  * Return the temporary directory that the VM uses for the attach

   418  * and perf data files.

   419  *

   420  * It is important that this directory is well-known and the

   421  * same for all VM instances. It cannot be affected by configuration

   422  * variables such as java.io.tmpdir.

   423  */

   424 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))

   425   JVMWrapper("JVM_GetTemporaryDirectory");

   426   HandleMark hm(THREAD);

   427   const char* temp_dir = os::get_temp_directory();

   428   Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);

   429   return (jstring) JNIHandles::make_local(env, h());

   430 JVM_END

   431 

   432 

   433 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////

   434 

   435 extern volatile jint vm_created;

   436 

   437 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))

   438   before_exit(thread);

   439   vm_exit(code);

   440 JVM_END

   441 

   442 

   443 JVM_ENTRY_NO_ENV(void, JVM_GC(void))

   444   JVMWrapper("JVM_GC");

   445   if (!DisableExplicitGC) {

   446     Universe::heap()->collect(GCCause::_java_lang_system_gc);

   447   }

   448 JVM_END

   449 

   450 

   451 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))

   452   JVMWrapper("JVM_MaxObjectInspectionAge");

   453   return Universe::heap()->millis_since_last_gc();

   454 JVM_END

   455 

   456 

   457 static inline jlong convert_size_t_to_jlong(size_t val) {

   458   // In the 64-bit vm, a size_t can overflow a jlong (which is signed).

   459   NOT_LP64 (return (jlong)val;)

   460   LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)

   461 }

   462 

   463 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))

   464   JVMWrapper("JVM_TotalMemory");

   465   size_t n = Universe::heap()->capacity();

   466   return convert_size_t_to_jlong(n);

   467 JVM_END

   468 

   469 

   470 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))

   471   JVMWrapper("JVM_FreeMemory");

   472   CollectedHeap* ch = Universe::heap();

   473   size_t n;

   474   {

   475      MutexLocker x(Heap_lock);

   476      n = ch->capacity() - ch->used();

   477   }

   478   return convert_size_t_to_jlong(n);

   479 JVM_END

   480 

   481 

   482 JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))

   483   JVMWrapper("JVM_MaxMemory");

   484   size_t n = Universe::heap()->max_capacity();

   485   return convert_size_t_to_jlong(n);

   486 JVM_END

   487 

   488 

   489 JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))

   490   JVMWrapper("JVM_ActiveProcessorCount");

   491   return os::active_processor_count();

   492 JVM_END

   493 

   494 

   495 

   496 // java.lang.Throwable //////////////////////////////////////////////////////

   497 

   498 

   499 JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver))

   500   JVMWrapper("JVM_FillInStackTrace");

   501   Handle exception(thread, JNIHandles::resolve_non_null(receiver));

   502   java_lang_Throwable::fill_in_stack_trace(exception);

   503 JVM_END

   504 

   505 

   506 // java.lang.StackTraceElement //////////////////////////////////////////////

   507 

   508 

   509 JVM_ENTRY(void, JVM_InitStackTraceElementArray(JNIEnv *env, jobjectArray elements, jobject throwable))

   510   JVMWrapper("JVM_InitStackTraceElementArray");

   511   Handle exception(THREAD, JNIHandles::resolve(throwable));

   512   objArrayOop st = objArrayOop(JNIHandles::resolve(elements));

   513   objArrayHandle stack_trace(THREAD, st);

   514   // Fill in the allocated stack trace

   515   java_lang_Throwable::get_stack_trace_elements(exception, stack_trace, CHECK);

   516 JVM_END

   517 

   518 

   519 JVM_ENTRY(void, JVM_InitStackTraceElement(JNIEnv* env, jobject element, jobject stackFrameInfo))

   520   JVMWrapper("JVM_InitStackTraceElement");

   521   Handle stack_frame_info(THREAD, JNIHandles::resolve_non_null(stackFrameInfo));

   522   Handle stack_trace_element(THREAD, JNIHandles::resolve_non_null(element));

   523   java_lang_StackFrameInfo::to_stack_trace_element(stack_frame_info, stack_trace_element, THREAD);

   524 JVM_END

   525 

   526 

   527 // java.lang.StackWalker //////////////////////////////////////////////////////

   528 

   529 

   530 JVM_ENTRY(jobject, JVM_CallStackWalk(JNIEnv *env, jobject stackStream, jlong mode,

   531                                      jint skip_frames, jint frame_count, jint start_index,

   532                                      jobjectArray frames))

   533   JVMWrapper("JVM_CallStackWalk");

   534   JavaThread* jt = (JavaThread*) THREAD;

   535   if (!jt->is_Java_thread() || !jt->has_last_Java_frame()) {

   536     THROW_MSG_(vmSymbols::java_lang_InternalError(), "doStackWalk: no stack trace", NULL);

   537   }

   538 

   539   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));

   540 

   541   // frames array is a Class<?>[] array when only getting caller reference,

   542   // and a StackFrameInfo[] array (or derivative) otherwise. It should never

   543   // be null.

   544   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));

   545   objArrayHandle frames_array_h(THREAD, fa);

   546 

   547   int limit = start_index + frame_count;

   548   if (frames_array_h->length() < limit) {

   549     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers", NULL);

   550   }

   551 

   552   oop result = StackWalk::walk(stackStream_h, mode, skip_frames, frame_count,

   553                                start_index, frames_array_h, CHECK_NULL);

   554   return JNIHandles::make_local(env, result);

   555 JVM_END

   556 

   557 

   558 JVM_ENTRY(jint, JVM_MoreStackWalk(JNIEnv *env, jobject stackStream, jlong mode, jlong anchor,

   559                                   jint frame_count, jint start_index,

   560                                   jobjectArray frames))

   561   JVMWrapper("JVM_MoreStackWalk");

   562   JavaThread* jt = (JavaThread*) THREAD;

   563 

   564   // frames array is a Class<?>[] array when only getting caller reference,

   565   // and a StackFrameInfo[] array (or derivative) otherwise. It should never

   566   // be null.

   567   objArrayOop fa = objArrayOop(JNIHandles::resolve_non_null(frames));

   568   objArrayHandle frames_array_h(THREAD, fa);

   569 

   570   int limit = start_index+frame_count;

   571   if (frames_array_h->length() < limit) {

   572     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "not enough space in buffers");

   573   }

   574 

   575   Handle stackStream_h(THREAD, JNIHandles::resolve_non_null(stackStream));

   576   return StackWalk::fetchNextBatch(stackStream_h, mode, anchor, frame_count,

   577                                    start_index, frames_array_h, THREAD);

   578 JVM_END

   579 

   580 // java.lang.Object ///////////////////////////////////////////////

   581 

   582 

   583 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))

   584   JVMWrapper("JVM_IHashCode");

   585   // as implemented in the classic virtual machine; return 0 if object is NULL

   586   return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;

   587 JVM_END

   588 

   589 

   590 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))

   591   JVMWrapper("JVM_MonitorWait");

   592   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

   593   JavaThreadInObjectWaitState jtiows(thread, ms != 0);

   594   if (JvmtiExport::should_post_monitor_wait()) {

   595     JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);

   596 

   597     // The current thread already owns the monitor and it has not yet

   598     // been added to the wait queue so the current thread cannot be

   599     // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT

   600     // event handler cannot accidentally consume an unpark() meant for

   601     // the ParkEvent associated with this ObjectMonitor.

   602   }

   603   ObjectSynchronizer::wait(obj, ms, CHECK);

   604 JVM_END

   605 

   606 

   607 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))

   608   JVMWrapper("JVM_MonitorNotify");

   609   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

   610   ObjectSynchronizer::notify(obj, CHECK);

   611 JVM_END

   612 

   613 

   614 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))

   615   JVMWrapper("JVM_MonitorNotifyAll");

   616   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

   617   ObjectSynchronizer::notifyall(obj, CHECK);

   618 JVM_END

   619 

   620 

   621 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))

   622   JVMWrapper("JVM_Clone");

   623   Handle obj(THREAD, JNIHandles::resolve_non_null(handle));

   624   Klass* klass = obj->klass();

   625   JvmtiVMObjectAllocEventCollector oam;

   626 

   627 #ifdef ASSERT

   628   // Just checking that the cloneable flag is set correct

   629   if (obj->is_array()) {

   630     guarantee(klass->is_cloneable(), "all arrays are cloneable");

   631   } else {

   632     guarantee(obj->is_instance(), "should be instanceOop");

   633     bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());

   634     guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");

   635   }

   636 #endif

   637 

   638   // Check if class of obj supports the Cloneable interface.

   639   // All arrays are considered to be cloneable (See JLS 20.1.5)

   640   if (!klass->is_cloneable()) {

   641     ResourceMark rm(THREAD);

   642     THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());

   643   }

   644 

   645   // Make shallow object copy

   646   const int size = obj->size();

   647   oop new_obj_oop = NULL;

   648   if (obj->is_array()) {

   649     const int length = ((arrayOop)obj())->length();

   650     new_obj_oop = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);

   651   } else {

   652     new_obj_oop = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);

   653   }

   654 

   655   // 4839641 (4840070): We must do an oop-atomic copy, because if another thread

   656   // is modifying a reference field in the clonee, a non-oop-atomic copy might

   657   // be suspended in the middle of copying the pointer and end up with parts

   658   // of two different pointers in the field.  Subsequent dereferences will crash.

   659   // 4846409: an oop-copy of objects with long or double fields or arrays of same

   660   // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead

   661   // of oops.  We know objects are aligned on a minimum of an jlong boundary.

   662   // The same is true of StubRoutines::object_copy and the various oop_copy

   663   // variants, and of the code generated by the inline_native_clone intrinsic.

   664   assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");

   665   Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj_oop,

   666                                align_object_size(size) / HeapWordsPerLong);

   667   // Clear the header

   668   new_obj_oop->init_mark();

   669 

   670   // Store check (mark entire object and let gc sort it out)

   671   BarrierSet* bs = Universe::heap()->barrier_set();

   672   assert(bs->has_write_region_opt(), "Barrier set does not have write_region");

   673   bs->write_region(MemRegion((HeapWord*)new_obj_oop, size));

   674 

   675   Handle new_obj(THREAD, new_obj_oop);

   676   // Caution: this involves a java upcall, so the clone should be

   677   // "gc-robust" by this stage.

   678   if (klass->has_finalizer()) {

   679     assert(obj->is_instance(), "should be instanceOop");

   680     new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);

   681     new_obj = Handle(THREAD, new_obj_oop);

   682   }

   683 

   684   return JNIHandles::make_local(env, new_obj());

   685 JVM_END

   686 

   687 // java.io.File ///////////////////////////////////////////////////////////////

   688 

   689 JVM_LEAF(char*, JVM_NativePath(char* path))

   690   JVMWrapper("JVM_NativePath");

   691   return os::native_path(path);

   692 JVM_END

   693 

   694 

   695 // Misc. class handling ///////////////////////////////////////////////////////////

   696 

   697 

   698 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))

   699   JVMWrapper("JVM_GetCallerClass");

   700 

   701   // Pre-JDK 8 and early builds of JDK 8 don't have a CallerSensitive annotation; or

   702   // sun.reflect.Reflection.getCallerClass with a depth parameter is provided

   703   // temporarily for existing code to use until a replacement API is defined.

   704   if (SystemDictionary::reflect_CallerSensitive_klass() == NULL || depth != JVM_CALLER_DEPTH) {

   705     Klass* k = thread->security_get_caller_class(depth);

   706     return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror());

   707   }

   708 

   709   // Getting the class of the caller frame.

   710   //

   711   // The call stack at this point looks something like this:

   712   //

   713   // [0] [ @CallerSensitive public sun.reflect.Reflection.getCallerClass ]

   714   // [1] [ @CallerSensitive API.method                                   ]

   715   // [.] [ (skipped intermediate frames)                                 ]

   716   // [n] [ caller                                                        ]

   717   vframeStream vfst(thread);

   718   // Cf. LibraryCallKit::inline_native_Reflection_getCallerClass

   719   for (int n = 0; !vfst.at_end(); vfst.security_next(), n++) {

   720     Method* m = vfst.method();

   721     assert(m != NULL, "sanity");

   722     switch (n) {

   723     case 0:

   724       // This must only be called from Reflection.getCallerClass

   725       if (m->intrinsic_id() != vmIntrinsics::_getCallerClass) {

   726         THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetCallerClass must only be called from Reflection.getCallerClass");

   727       }

   728       // fall-through

   729     case 1:

   730       // Frame 0 and 1 must be caller sensitive.

   731       if (!m->caller_sensitive()) {

   732         THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), err_msg("CallerSensitive annotation expected at frame %d", n));

   733       }

   734       break;

   735     default:

   736       if (!m->is_ignored_by_security_stack_walk()) {

   737         // We have reached the desired frame; return the holder class.

   738         return (jclass) JNIHandles::make_local(env, m->method_holder()->java_mirror());

   739       }

   740       break;

   741     }

   742   }

   743   return NULL;

   744 JVM_END

   745 

   746 

   747 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))

   748   JVMWrapper("JVM_FindPrimitiveClass");

   749   oop mirror = NULL;

   750   BasicType t = name2type(utf);

   751   if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) {

   752     mirror = Universe::java_mirror(t);

   753   }

   754   if (mirror == NULL) {

   755     THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf);

   756   } else {

   757     return (jclass) JNIHandles::make_local(env, mirror);

   758   }

   759 JVM_END

   760 

   761 

   762 // Returns a class loaded by the bootstrap class loader; or null

   763 // if not found.  ClassNotFoundException is not thrown.

   764 // FindClassFromBootLoader is exported to the launcher for windows.

   765 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,

   766                                               const char* name))

   767   JVMWrapper("JVM_FindClassFromBootLoader");

   768 

   769   // Java libraries should ensure that name is never null...

   770   if (name == NULL || (int)strlen(name) > Symbol::max_length()) {

   771     // It's impossible to create this class;  the name cannot fit

   772     // into the constant pool.

   773     return NULL;

   774   }

   775 

   776   TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);

   777   Klass* k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);

   778   if (k == NULL) {

   779     return NULL;

   780   }

   781 

   782   if (log_is_enabled(Debug, class, resolve)) {

   783     trace_class_resolution(k);

   784   }

   785   return (jclass) JNIHandles::make_local(env, k->java_mirror());

   786 JVM_END

   787 

   788 // Find a class with this name in this loader, using the caller's protection domain.

   789 JVM_ENTRY(jclass, JVM_FindClassFromCaller(JNIEnv* env, const char* name,

   790                                           jboolean init, jobject loader,

   791                                           jclass caller))

   792   JVMWrapper("JVM_FindClassFromCaller throws ClassNotFoundException");

   793   // Java libraries should ensure that name is never null...

   794   if (name == NULL || (int)strlen(name) > Symbol::max_length()) {

   795     // It's impossible to create this class;  the name cannot fit

   796     // into the constant pool.

   797     THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), name);

   798   }

   799 

   800   TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);

   801 

   802   oop loader_oop = JNIHandles::resolve(loader);

   803   oop from_class = JNIHandles::resolve(caller);

   804   oop protection_domain = NULL;

   805   // If loader is null, shouldn't call ClassLoader.checkPackageAccess; otherwise get

   806   // NPE. Put it in another way, the bootstrap class loader has all permission and

   807   // thus no checkPackageAccess equivalence in the VM class loader.

   808   // The caller is also passed as NULL by the java code if there is no security

   809   // manager to avoid the performance cost of getting the calling class.

   810   if (from_class != NULL && loader_oop != NULL) {

   811     protection_domain = java_lang_Class::as_Klass(from_class)->protection_domain();

   812   }

   813 

   814   Handle h_loader(THREAD, loader_oop);

   815   Handle h_prot(THREAD, protection_domain);

   816   jclass result = find_class_from_class_loader(env, h_name, init, h_loader,

   817                                                h_prot, false, THREAD);

   818 

   819   if (log_is_enabled(Debug, class, resolve) && result != NULL) {

   820     trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));

   821   }

   822   return result;

   823 JVM_END

   824 

   825 // Currently only called from the old verifier.

   826 JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name,

   827                                          jboolean init, jclass from))

   828   JVMWrapper("JVM_FindClassFromClass");

   829   if (name == NULL) {

   830     THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), "No class name given");

   831   }

   832   if ((int)strlen(name) > Symbol::max_length()) {

   833     // It's impossible to create this class;  the name cannot fit

   834     // into the constant pool.

   835     Exceptions::fthrow(THREAD_AND_LOCATION,

   836                        vmSymbols::java_lang_NoClassDefFoundError(),

   837                        "Class name exceeds maximum length of %d: %s",

   838                        Symbol::max_length(),

   839                        name);

   840     return 0;

   841   }

   842   TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);

   843   oop from_class_oop = JNIHandles::resolve(from);

   844   Klass* from_class = (from_class_oop == NULL)

   845                            ? (Klass*)NULL

   846                            : java_lang_Class::as_Klass(from_class_oop);

   847   oop class_loader = NULL;

   848   oop protection_domain = NULL;

   849   if (from_class != NULL) {

   850     class_loader = from_class->class_loader();

   851     protection_domain = from_class->protection_domain();

   852   }

   853   Handle h_loader(THREAD, class_loader);

   854   Handle h_prot  (THREAD, protection_domain);

   855   jclass result = find_class_from_class_loader(env, h_name, init, h_loader,

   856                                                h_prot, true, thread);

   857 

   858   if (log_is_enabled(Debug, class, resolve) && result != NULL) {

   859     // this function is generally only used for class loading during verification.

   860     ResourceMark rm;

   861     oop from_mirror = JNIHandles::resolve_non_null(from);

   862     Klass* from_class = java_lang_Class::as_Klass(from_mirror);

   863     const char * from_name = from_class->external_name();

   864 

   865     oop mirror = JNIHandles::resolve_non_null(result);

   866     Klass* to_class = java_lang_Class::as_Klass(mirror);

   867     const char * to = to_class->external_name();

   868     log_debug(class, resolve)("%s %s (verification)", from_name, to);

   869   }

   870 

   871   return result;

   872 JVM_END

   873 

   874 static void is_lock_held_by_thread(Handle loader, PerfCounter* counter, TRAPS) {

   875   if (loader.is_null()) {

   876     return;

   877   }

   878 

   879   // check whether the current caller thread holds the lock or not.

   880   // If not, increment the corresponding counter

   881   if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader) !=

   882       ObjectSynchronizer::owner_self) {

   883     counter->inc();

   884   }

   885 }

   886 

   887 // common code for JVM_DefineClass() and JVM_DefineClassWithSource()

   888 static jclass jvm_define_class_common(JNIEnv *env, const char *name,

   889                                       jobject loader, const jbyte *buf,

   890                                       jsize len, jobject pd, const char *source,

   891                                       TRAPS) {

   892   if (source == NULL)  source = "__JVM_DefineClass__";

   893 

   894   assert(THREAD->is_Java_thread(), "must be a JavaThread");

   895   JavaThread* jt = (JavaThread*) THREAD;

   896 

   897   PerfClassTraceTime vmtimer(ClassLoader::perf_define_appclass_time(),

   898                              ClassLoader::perf_define_appclass_selftime(),

   899                              ClassLoader::perf_define_appclasses(),

   900                              jt->get_thread_stat()->perf_recursion_counts_addr(),

   901                              jt->get_thread_stat()->perf_timers_addr(),

   902                              PerfClassTraceTime::DEFINE_CLASS);

   903 

   904   if (UsePerfData) {

   905     ClassLoader::perf_app_classfile_bytes_read()->inc(len);

   906   }

   907 

   908   // Since exceptions can be thrown, class initialization can take place

   909   // if name is NULL no check for class name in .class stream has to be made.

   910   TempNewSymbol class_name = NULL;

   911   if (name != NULL) {

   912     const int str_len = (int)strlen(name);

   913     if (str_len > Symbol::max_length()) {

   914       // It's impossible to create this class;  the name cannot fit

   915       // into the constant pool.

   916       Exceptions::fthrow(THREAD_AND_LOCATION,

   917                          vmSymbols::java_lang_NoClassDefFoundError(),

   918                          "Class name exceeds maximum length of %d: %s",

   919                          Symbol::max_length(),

   920                          name);

   921       return 0;

   922     }

   923     class_name = SymbolTable::new_symbol(name, str_len, CHECK_NULL);

   924   }

   925 

   926   ResourceMark rm(THREAD);

   927   ClassFileStream st((u1*)buf, len, source, ClassFileStream::verify);

   928   Handle class_loader (THREAD, JNIHandles::resolve(loader));

   929   if (UsePerfData) {

   930     is_lock_held_by_thread(class_loader,

   931                            ClassLoader::sync_JVMDefineClassLockFreeCounter(),

   932                            THREAD);

   933   }

   934   Handle protection_domain (THREAD, JNIHandles::resolve(pd));

   935   Klass* k = SystemDictionary::resolve_from_stream(class_name,

   936                                                    class_loader,

   937                                                    protection_domain,

   938                                                    &st,

   939                                                    CHECK_NULL);

   940 

   941   if (log_is_enabled(Debug, class, resolve) && k != NULL) {

   942     trace_class_resolution(k);

   943   }

   944 

   945   return (jclass) JNIHandles::make_local(env, k->java_mirror());

   946 }

   947 

   948 

   949 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))

   950   JVMWrapper("JVM_DefineClass");

   951 

   952   return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, THREAD);

   953 JVM_END

   954 

   955 

   956 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))

   957   JVMWrapper("JVM_DefineClassWithSource");

   958 

   959   return jvm_define_class_common(env, name, loader, buf, len, pd, source, THREAD);

   960 JVM_END

   961 

   962 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))

   963   JVMWrapper("JVM_FindLoadedClass");

   964   ResourceMark rm(THREAD);

   965 

   966   Handle h_name (THREAD, JNIHandles::resolve_non_null(name));

   967   Handle string = java_lang_String::internalize_classname(h_name, CHECK_NULL);

   968 

   969   const char* str   = java_lang_String::as_utf8_string(string());

   970   // Sanity check, don't expect null

   971   if (str == NULL) return NULL;

   972 

   973   const int str_len = (int)strlen(str);

   974   if (str_len > Symbol::max_length()) {

   975     // It's impossible to create this class;  the name cannot fit

   976     // into the constant pool.

   977     return NULL;

   978   }

   979   TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len, CHECK_NULL);

   980 

   981   // Security Note:

   982   //   The Java level wrapper will perform the necessary security check allowing

   983   //   us to pass the NULL as the initiating class loader.

   984   Handle h_loader(THREAD, JNIHandles::resolve(loader));

   985   if (UsePerfData) {

   986     is_lock_held_by_thread(h_loader,

   987                            ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(),

   988                            THREAD);

   989   }

   990 

   991   Klass* k = SystemDictionary::find_instance_or_array_klass(klass_name,

   992                                                               h_loader,

   993                                                               Handle(),

   994                                                               CHECK_NULL);

   995 #if INCLUDE_CDS

   996   if (k == NULL) {

   997     // If the class is not already loaded, try to see if it's in the shared

   998     // archive for the current classloader (h_loader).

   999     k = SystemDictionaryShared::find_or_load_shared_class(klass_name, h_loader, CHECK_NULL);

  1000   }

  1001 #endif

  1002   return (k == NULL) ? NULL :

  1003             (jclass) JNIHandles::make_local(env, k->java_mirror());

  1004 JVM_END

  1005 

  1006 // Module support //////////////////////////////////////////////////////////////////////////////

  1007 

  1008 JVM_ENTRY(void, JVM_DefineModule(JNIEnv *env, jobject module, jboolean is_open, jstring version,

  1009                                  jstring location, const char* const* packages, jsize num_packages))

  1010   JVMWrapper("JVM_DefineModule");

  1011   Modules::define_module(module, is_open, version, location, packages, num_packages, CHECK);

  1012 JVM_END

  1013 

  1014 JVM_ENTRY(void, JVM_SetBootLoaderUnnamedModule(JNIEnv *env, jobject module))

  1015   JVMWrapper("JVM_SetBootLoaderUnnamedModule");

  1016   Modules::set_bootloader_unnamed_module(module, CHECK);

  1017 JVM_END

  1018 

  1019 JVM_ENTRY(void, JVM_AddModuleExports(JNIEnv *env, jobject from_module, const char* package, jobject to_module))

  1020   JVMWrapper("JVM_AddModuleExports");

  1021   Modules::add_module_exports_qualified(from_module, package, to_module, CHECK);

  1022 JVM_END

  1023 

  1024 JVM_ENTRY(void, JVM_AddModuleExportsToAllUnnamed(JNIEnv *env, jobject from_module, const char* package))

  1025   JVMWrapper("JVM_AddModuleExportsToAllUnnamed");

  1026   Modules::add_module_exports_to_all_unnamed(from_module, package, CHECK);

  1027 JVM_END

  1028 

  1029 JVM_ENTRY(void, JVM_AddModuleExportsToAll(JNIEnv *env, jobject from_module, const char* package))

  1030   JVMWrapper("JVM_AddModuleExportsToAll");

  1031   Modules::add_module_exports(from_module, package, NULL, CHECK);

  1032 JVM_END

  1033 

  1034 JVM_ENTRY (void, JVM_AddReadsModule(JNIEnv *env, jobject from_module, jobject source_module))

  1035   JVMWrapper("JVM_AddReadsModule");

  1036   Modules::add_reads_module(from_module, source_module, CHECK);

  1037 JVM_END

  1038 

  1039 // Reflection support //////////////////////////////////////////////////////////////////////////////

  1040 

  1041 JVM_ENTRY(jstring, JVM_GetClassName(JNIEnv *env, jclass cls))

  1042   assert (cls != NULL, "illegal class");

  1043   JVMWrapper("JVM_GetClassName");

  1044   JvmtiVMObjectAllocEventCollector oam;

  1045   ResourceMark rm(THREAD);

  1046   const char* name;

  1047   if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {

  1048     name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls)));

  1049   } else {

  1050     // Consider caching interned string in Klass

  1051     Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));

  1052     assert(k->is_klass(), "just checking");

  1053     name = k->external_name();

  1054   }

  1055   oop result = StringTable::intern((char*) name, CHECK_NULL);

  1056   return (jstring) JNIHandles::make_local(env, result);

  1057 JVM_END

  1058 

  1059 

  1060 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))

  1061   JVMWrapper("JVM_GetClassInterfaces");

  1062   JvmtiVMObjectAllocEventCollector oam;

  1063   oop mirror = JNIHandles::resolve_non_null(cls);

  1064 

  1065   // Special handling for primitive objects

  1066   if (java_lang_Class::is_primitive(mirror)) {

  1067     // Primitive objects does not have any interfaces

  1068     objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);

  1069     return (jobjectArray) JNIHandles::make_local(env, r);

  1070   }

  1071 

  1072   Klass* klass = java_lang_Class::as_Klass(mirror);

  1073   // Figure size of result array

  1074   int size;

  1075   if (klass->is_instance_klass()) {

  1076     size = InstanceKlass::cast(klass)->local_interfaces()->length();

  1077   } else {

  1078     assert(klass->is_objArray_klass() || klass->is_typeArray_klass(), "Illegal mirror klass");

  1079     size = 2;

  1080   }

  1081 

  1082   // Allocate result array

  1083   objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), size, CHECK_NULL);

  1084   objArrayHandle result (THREAD, r);

  1085   // Fill in result

  1086   if (klass->is_instance_klass()) {

  1087     // Regular instance klass, fill in all local interfaces

  1088     for (int index = 0; index < size; index++) {

  1089       Klass* k = InstanceKlass::cast(klass)->local_interfaces()->at(index);

  1090       result->obj_at_put(index, k->java_mirror());

  1091     }

  1092   } else {

  1093     // All arrays implement java.lang.Cloneable and java.io.Serializable

  1094     result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror());

  1095     result->obj_at_put(1, SystemDictionary::Serializable_klass()->java_mirror());

  1096   }

  1097   return (jobjectArray) JNIHandles::make_local(env, result());

  1098 JVM_END

  1099 

  1100 

  1101 JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))

  1102   JVMWrapper("JVM_IsInterface");

  1103   oop mirror = JNIHandles::resolve_non_null(cls);

  1104   if (java_lang_Class::is_primitive(mirror)) {

  1105     return JNI_FALSE;

  1106   }

  1107   Klass* k = java_lang_Class::as_Klass(mirror);

  1108   jboolean result = k->is_interface();

  1109   assert(!result || k->is_instance_klass(),

  1110          "all interfaces are instance types");

  1111   // The compiler intrinsic for isInterface tests the

  1112   // Klass::_access_flags bits in the same way.

  1113   return result;

  1114 JVM_END

  1115 

  1116 

  1117 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))

  1118   JVMWrapper("JVM_GetClassSigners");

  1119   JvmtiVMObjectAllocEventCollector oam;

  1120   if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {

  1121     // There are no signers for primitive types

  1122     return NULL;

  1123   }

  1124 

  1125   objArrayOop signers = java_lang_Class::signers(JNIHandles::resolve_non_null(cls));

  1126 

  1127   // If there are no signers set in the class, or if the class

  1128   // is an array, return NULL.

  1129   if (signers == NULL) return NULL;

  1130 

  1131   // copy of the signers array

  1132   Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();

  1133   objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);

  1134   for (int index = 0; index < signers->length(); index++) {