1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 #include "incls/_precompiled.incl"

    26 #include "incls/_jvm.cpp.incl"

    27 #include <errno.h>

    28 

    29 /*

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

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

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

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

    34   failures":

    35 

    36       JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> {

    37           JVMWrapper("JVM_GetClassDeclaredFields");

    38 

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

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

    41 

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

    43           ComplexConstructor foo;

    44 

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

    46           (some dereference of mirror)

    47 

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

    49           MutexLocker ml(some_lock);

    50 

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

    52           // all in one step.

    53           oop o = call_that_can_throw_exception(TRAPS);

    54 

    55 

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

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

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

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

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

    61 */

    62 

    63 static void trace_class_resolution_impl(klassOop to_class, TRAPS) {

    64   ResourceMark rm;

    65   int line_number = -1;

    66   const char * source_file = NULL;

    67   klassOop caller = NULL;

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

    69   if (jthread->has_last_Java_frame()) {

    70     vframeStream vfst(jthread);

    71 

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

    73     symbolHandle access_controller = oopFactory::new_symbol_handle("java/security/AccessController", CHECK);

    74     klassOop access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);

    75     symbolHandle privileged_action = oopFactory::new_symbol_handle("java/security/PrivilegedAction", CHECK);

    76     klassOop privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);

    77 

    78     methodOop last_caller = NULL;

    79 

    80     while (!vfst.at_end()) {

    81       methodOop m = vfst.method();

    82       if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::classloader_klass())&&

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

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

    85         break;

    86       }

    87       last_caller = m;

    88       vfst.next();

    89     }

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

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

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

    93     bool found_it = false;

    94     if (!vfst.at_end() &&

    95         instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&

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

    97       vfst.next();

    98       if (!vfst.at_end() &&

    99           instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&

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

   101         vfst.next();

   102         found_it = true;

   103       }

   104     } else if (last_caller != NULL &&

   105                instanceKlass::cast(last_caller->method_holder())->name() ==

   106                vmSymbols::java_lang_ClassLoader() &&

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

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

   109       found_it = true;

   110     }

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

   112       // found the caller

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

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

   115       symbolOop s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name();

   116       if (s != NULL) {

   117         source_file = s->as_C_string();

   118       }

   119     }

   120   }

   121   if (caller != NULL) {

   122     if (to_class != caller) {

   123       const char * from = Klass::cast(caller)->external_name();

   124       const char * to = Klass::cast(to_class)->external_name();

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

   126       if (source_file != NULL) {

   127         tty->print("RESOLVE %s %s %s:%d (explicit)\n", from, to, source_file, line_number);

   128       } else {

   129         tty->print("RESOLVE %s %s (explicit)\n", from, to);

   130       }

   131     }

   132   }

   133 }

   134 

   135 static void trace_class_resolution(klassOop to_class) {

   136   EXCEPTION_MARK;

   137   trace_class_resolution_impl(to_class, THREAD);

   138   if (HAS_PENDING_EXCEPTION) {

   139     CLEAR_PENDING_EXCEPTION;

   140   }

   141 }

   142 

   143 // Wrapper to trace JVM functions

   144 

   145 #ifdef ASSERT

   146   class JVMTraceWrapper : public StackObj {

   147    public:

   148     JVMTraceWrapper(const char* format, ...) {

   149       if (TraceJVMCalls) {

   150         va_list ap;

   151         va_start(ap, format);

   152         tty->print("JVM ");

   153         tty->vprint_cr(format, ap);

   154         va_end(ap);

   155       }

   156     }

   157   };

   158 

   159   Histogram* JVMHistogram;

   160   volatile jint JVMHistogram_lock = 0;

   161 

   162   class JVMHistogramElement : public HistogramElement {

   163     public:

   164      JVMHistogramElement(const char* name);

   165   };

   166 

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

   168     _name = elementName;

   169     uintx count = 0;

   170 

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

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

   173         count +=1;

   174         if ( (WarnOnStalledSpinLock > 0)

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

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

   177         }

   178       }

   179      }

   180 

   181     if(JVMHistogram == NULL)

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

   183 

   184     JVMHistogram->add_element(this);

   185     Atomic::dec(&JVMHistogram_lock);

   186   }

   187 

   188   #define JVMCountWrapper(arg) \

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

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

   191 

   192   #define JVMWrapper(arg1)                    JVMCountWrapper(arg1); JVMTraceWrapper(arg1)

   193   #define JVMWrapper2(arg1, arg2)             JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2)

   194   #define JVMWrapper3(arg1, arg2, arg3)       JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3)

   195   #define JVMWrapper4(arg1, arg2, arg3, arg4) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3, arg4)

   196 #else

   197   #define JVMWrapper(arg1)

   198   #define JVMWrapper2(arg1, arg2)

   199   #define JVMWrapper3(arg1, arg2, arg3)

   200   #define JVMWrapper4(arg1, arg2, arg3, arg4)

   201 #endif

   202 

   203 

   204 // Interface version /////////////////////////////////////////////////////////////////////

   205 

   206 

   207 JVM_LEAF(jint, JVM_GetInterfaceVersion())

   208   return JVM_INTERFACE_VERSION;

   209 JVM_END

   210 

   211 

   212 // java.lang.System //////////////////////////////////////////////////////////////////////

   213 

   214 

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

   216   JVMWrapper("JVM_CurrentTimeMillis");

   217   return os::javaTimeMillis();

   218 JVM_END

   219 

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

   221   JVMWrapper("JVM_NanoTime");

   222   return os::javaTimeNanos();

   223 JVM_END

   224 

   225 

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

   227                                jobject dst, jint dst_pos, jint length))

   228   JVMWrapper("JVM_ArrayCopy");

   229   // Check if we have null pointers

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

   231     THROW(vmSymbols::java_lang_NullPointerException());

   232   }

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

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

   235   assert(s->is_oop(), "JVM_ArrayCopy: src not an oop");

   236   assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop");

   237   // Do copy

   238   Klass::cast(s->klass())->copy_array(s, src_pos, d, dst_pos, length, thread);

   239 JVM_END

   240 

   241 

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

   243   JavaValue r(T_OBJECT);

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

   245   HandleMark hm(THREAD);

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

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

   248   JavaCalls::call_virtual(&r,

   249                           props,

   250                           KlassHandle(THREAD, SystemDictionary::properties_klass()),

   251                           vmSymbolHandles::put_name(),

   252                           vmSymbolHandles::object_object_object_signature(),

   253                           key_str,

   254                           value_str,

   255                           THREAD);

   256 }

   257 

   258 

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

   260 

   261 

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

   263   JVMWrapper("JVM_InitProperties");

   264   ResourceMark rm;

   265 

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

   267 

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

   269   // jvm system specific properties.

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

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

   272   }

   273 

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

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

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

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

   278   {

   279     char as_chars[256];

   280     jio_snprintf(as_chars, sizeof(as_chars), INTX_FORMAT, MaxDirectMemorySize);

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

   282   }

   283 

   284   // JVM monitoring and management support

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

   286   {

   287 #undef CSIZE

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

   289   #define CSIZE "64-Bit "

   290 #else

   291   #define CSIZE

   292 #endif // 64bit

   293 

   294 #ifdef TIERED

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

   296 #else

   297 #if defined(COMPILER1)

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

   299 #elif defined(COMPILER2)

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

   301 #else

   302     const char* compiler_name = "";

   303 #endif // compilers

   304 #endif // TIERED

   305 

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

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

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

   309     }

   310   }

   311 

   312   return properties;

   313 JVM_END

   314 

   315 

   316 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////

   317 

   318 extern volatile jint vm_created;

   319 

   320 JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code))

   321   if (vm_created != 0 && (code == 0)) {

   322     // The VM is about to exit. We call back into Java to check whether finalizers should be run

   323     Universe::run_finalizers_on_exit();

   324   }

   325   before_exit(thread);

   326   vm_exit(code);

   327 JVM_END

   328 

   329 

   330 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))

   331   before_exit(thread);

   332   vm_exit(code);

   333 JVM_END

   334 

   335 

   336 JVM_LEAF(void, JVM_OnExit(void (*func)(void)))

   337   register_on_exit_function(func);

   338 JVM_END

   339 

   340 

   341 JVM_ENTRY_NO_ENV(void, JVM_GC(void))

   342   JVMWrapper("JVM_GC");

   343   if (!DisableExplicitGC) {

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

   345   }

   346 JVM_END

   347 

   348 

   349 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))

   350   JVMWrapper("JVM_MaxObjectInspectionAge");

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

   352 JVM_END

   353 

   354 

   355 JVM_LEAF(void, JVM_TraceInstructions(jboolean on))

   356   if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported");

   357 JVM_END

   358 

   359 

   360 JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on))

   361   if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported");

   362 JVM_END

   363 

   364 static inline jlong convert_size_t_to_jlong(size_t val) {

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

   366   NOT_LP64 (return (jlong)val;)

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

   368 }

   369 

   370 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))

   371   JVMWrapper("JVM_TotalMemory");

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

   373   return convert_size_t_to_jlong(n);

   374 JVM_END

   375 

   376 

   377 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))

   378   JVMWrapper("JVM_FreeMemory");

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

   380   size_t n = ch->capacity() - ch->used();

   381   return convert_size_t_to_jlong(n);

   382 JVM_END

   383 

   384 

   385 JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))

   386   JVMWrapper("JVM_MaxMemory");

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

   388   return convert_size_t_to_jlong(n);

   389 JVM_END

   390 

   391 

   392 JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))

   393   JVMWrapper("JVM_ActiveProcessorCount");

   394   return os::active_processor_count();

   395 JVM_END

   396 

   397 

   398 

   399 // java.lang.Throwable //////////////////////////////////////////////////////

   400 

   401 

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

   403   JVMWrapper("JVM_FillInStackTrace");

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

   405   java_lang_Throwable::fill_in_stack_trace(exception);

   406 JVM_END

   407 

   408 

   409 JVM_ENTRY(void, JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable))

   410   JVMWrapper("JVM_PrintStackTrace");

   411   // Note: This is no longer used in Merlin, but we still support it for compatibility.

   412   oop exception = JNIHandles::resolve_non_null(receiver);

   413   oop stream    = JNIHandles::resolve_non_null(printable);

   414   java_lang_Throwable::print_stack_trace(exception, stream);

   415 JVM_END

   416 

   417 

   418 JVM_ENTRY(jint, JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable))

   419   JVMWrapper("JVM_GetStackTraceDepth");

   420   oop exception = JNIHandles::resolve(throwable);

   421   return java_lang_Throwable::get_stack_trace_depth(exception, THREAD);

   422 JVM_END

   423 

   424 

   425 JVM_ENTRY(jobject, JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index))

   426   JVMWrapper("JVM_GetStackTraceElement");

   427   JvmtiVMObjectAllocEventCollector oam; // This ctor (throughout this module) may trigger a safepoint/GC

   428   oop exception = JNIHandles::resolve(throwable);

   429   oop element = java_lang_Throwable::get_stack_trace_element(exception, index, CHECK_NULL);

   430   return JNIHandles::make_local(env, element);

   431 JVM_END

   432 

   433 

   434 // java.lang.Object ///////////////////////////////////////////////

   435 

   436 

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

   438   JVMWrapper("JVM_IHashCode");

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

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

   441 JVM_END

   442 

   443 

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

   445   JVMWrapper("JVM_MonitorWait");

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

   447   assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object");

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

   449   if (JvmtiExport::should_post_monitor_wait()) {

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

   451   }

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

   453 JVM_END

   454 

   455 

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

   457   JVMWrapper("JVM_MonitorNotify");

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

   459   assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotify must apply to an object");

   460   ObjectSynchronizer::notify(obj, CHECK);

   461 JVM_END

   462 

   463 

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

   465   JVMWrapper("JVM_MonitorNotifyAll");

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

   467   assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotifyAll must apply to an object");

   468   ObjectSynchronizer::notifyall(obj, CHECK);

   469 JVM_END

   470 

   471 

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

   473   JVMWrapper("JVM_Clone");

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

   475   const KlassHandle klass (THREAD, obj->klass());

   476   JvmtiVMObjectAllocEventCollector oam;

   477 

   478 #ifdef ASSERT

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

   480   if (obj->is_javaArray()) {

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

   482   } else {

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

   484     bool cloneable = klass->is_subtype_of(SystemDictionary::cloneable_klass());

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

   486   }

   487 #endif

   488 

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

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

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

   492     ResourceMark rm(THREAD);

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

   494   }

   495 

   496   // Make shallow object copy

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

   498   oop new_obj = NULL;

   499   if (obj->is_javaArray()) {

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

   501     new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);

   502   } else {

   503     new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);

   504   }

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

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

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

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

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

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

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

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

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

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

   515   Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj,

   516                                (size_t)align_object_size(size) / HeapWordsPerLong);

   517   // Clear the header

   518   new_obj->init_mark();

   519 

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

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

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

   523   bs->write_region(MemRegion((HeapWord*)new_obj, size));

   524 

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

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

   527   if (klass->has_finalizer()) {

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

   529     new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);

   530   }

   531 

   532   return JNIHandles::make_local(env, oop(new_obj));

   533 JVM_END

   534 

   535 // java.lang.Compiler ////////////////////////////////////////////////////

   536 

   537 // The initial cuts of the HotSpot VM will not support JITs, and all existing

   538 // JITs would need extensive changes to work with HotSpot.  The JIT-related JVM

   539 // functions are all silently ignored unless JVM warnings are printed.

   540 

   541 JVM_LEAF(void, JVM_InitializeCompiler (JNIEnv *env, jclass compCls))

   542   if (PrintJVMWarnings) warning("JVM_InitializeCompiler not supported");

   543 JVM_END

   544 

   545 

   546 JVM_LEAF(jboolean, JVM_IsSilentCompiler(JNIEnv *env, jclass compCls))

   547   if (PrintJVMWarnings) warning("JVM_IsSilentCompiler not supported");

   548   return JNI_FALSE;

   549 JVM_END

   550 

   551 

   552 JVM_LEAF(jboolean, JVM_CompileClass(JNIEnv *env, jclass compCls, jclass cls))

   553   if (PrintJVMWarnings) warning("JVM_CompileClass not supported");

   554   return JNI_FALSE;

   555 JVM_END

   556 

   557 

   558 JVM_LEAF(jboolean, JVM_CompileClasses(JNIEnv *env, jclass cls, jstring jname))

   559   if (PrintJVMWarnings) warning("JVM_CompileClasses not supported");

   560   return JNI_FALSE;

   561 JVM_END

   562 

   563 

   564 JVM_LEAF(jobject, JVM_CompilerCommand(JNIEnv *env, jclass compCls, jobject arg))

   565   if (PrintJVMWarnings) warning("JVM_CompilerCommand not supported");

   566   return NULL;

   567 JVM_END

   568 

   569 

   570 JVM_LEAF(void, JVM_EnableCompiler(JNIEnv *env, jclass compCls))

   571   if (PrintJVMWarnings) warning("JVM_EnableCompiler not supported");

   572 JVM_END

   573 

   574 

   575 JVM_LEAF(void, JVM_DisableCompiler(JNIEnv *env, jclass compCls))

   576   if (PrintJVMWarnings) warning("JVM_DisableCompiler not supported");

   577 JVM_END

   578 

   579 

   580 

   581 // Error message support //////////////////////////////////////////////////////

   582 

   583 JVM_LEAF(jint, JVM_GetLastErrorString(char *buf, int len))

   584   JVMWrapper("JVM_GetLastErrorString");

   585   return hpi::lasterror(buf, len);

   586 JVM_END

   587 

   588 

   589 // java.io.File ///////////////////////////////////////////////////////////////

   590 

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

   592   JVMWrapper2("JVM_NativePath (%s)", path);

   593   return hpi::native_path(path);

   594 JVM_END

   595 

   596 

   597 // Misc. class handling ///////////////////////////////////////////////////////////

   598 

   599 

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

   601   JVMWrapper("JVM_GetCallerClass");

   602   klassOop k = thread->security_get_caller_class(depth);

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

   604 JVM_END

   605 

   606 

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

   608   JVMWrapper("JVM_FindPrimitiveClass");

   609   oop mirror = NULL;

   610   BasicType t = name2type(utf);

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

   612     mirror = Universe::java_mirror(t);

   613   }

   614   if (mirror == NULL) {

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

   616   } else {

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

   618   }

   619 JVM_END

   620 

   621 

   622 JVM_ENTRY(void, JVM_ResolveClass(JNIEnv* env, jclass cls))

   623   JVMWrapper("JVM_ResolveClass");

   624   if (PrintJVMWarnings) warning("JVM_ResolveClass not implemented");

   625 JVM_END

   626 

   627 

   628 JVM_ENTRY(jclass, JVM_FindClassFromClassLoader(JNIEnv* env, const char* name,

   629                                                jboolean init, jobject loader,

   630                                                jboolean throwError))

   631   JVMWrapper3("JVM_FindClassFromClassLoader %s throw %s", name,

   632                throwError ? "error" : "exception");

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

   634   if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) {

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

   636     // into the constant pool.

   637     if (throwError) {

   638       THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

   639     } else {

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

   641     }

   642   }

   643   symbolHandle h_name = oopFactory::new_symbol_handle(name, CHECK_NULL);

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

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

   646                                                Handle(), throwError, thread);

   647 

   648   if (TraceClassResolution && result != NULL) {

   649     trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));

   650   }

   651 

   652   return result;

   653 JVM_END

   654 

   655 

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

   657                                          jboolean init, jclass from))

   658   JVMWrapper2("JVM_FindClassFromClass %s", name);

   659   if (name == NULL || (int)strlen(name) > symbolOopDesc::max_length()) {

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

   661     // into the constant pool.

   662     THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

   663   }

   664   symbolHandle h_name = oopFactory::new_symbol_handle(name, CHECK_NULL);

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

   666   klassOop from_class = (from_class_oop == NULL)

   667                            ? (klassOop)NULL

   668                            : java_lang_Class::as_klassOop(from_class_oop);

   669   oop class_loader = NULL;

   670   oop protection_domain = NULL;

   671   if (from_class != NULL) {

   672     class_loader = Klass::cast(from_class)->class_loader();

   673     protection_domain = Klass::cast(from_class)->protection_domain();

   674   }

   675   Handle h_loader(THREAD, class_loader);

   676   Handle h_prot  (THREAD, protection_domain);

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

   678                                                h_prot, true, thread);

   679 

   680   if (TraceClassResolution && result != NULL) {

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

   682     ResourceMark rm;

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

   684     klassOop from_class = java_lang_Class::as_klassOop(from_mirror);

   685     const char * from_name = Klass::cast(from_class)->external_name();

   686 

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

   688     klassOop to_class = java_lang_Class::as_klassOop(mirror);

   689     const char * to = Klass::cast(to_class)->external_name();

   690     tty->print("RESOLVE %s %s (verification)\n", from_name, to);

   691   }

   692 

   693   return result;

   694 JVM_END

   695 

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

   697   if (loader.is_null()) {

   698     return;

   699   }

   700 

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

   702   // If not, increment the corresponding counter

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

   704       ObjectSynchronizer::owner_self) {

   705     counter->inc();

   706   }

   707 }

   708 

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

   710 static jclass jvm_define_class_common(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source, TRAPS) {

   711 

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

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

   714   symbolHandle class_name;

   715   if (name != NULL) {

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

   717     if (str_len > symbolOopDesc::max_length()) {

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

   719       // into the constant pool.

   720       THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);

   721     }

   722     class_name = oopFactory::new_symbol_handle(name, str_len, CHECK_NULL);

   723   }

   724 

   725   ResourceMark rm(THREAD);

   726   ClassFileStream st((u1*) buf, len, (char *)source);

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

   728   if (UsePerfData) {

   729     is_lock_held_by_thread(class_loader,

   730                            ClassLoader::sync_JVMDefineClassLockFreeCounter(),

   731                            THREAD);

   732   }

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

   734   klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader,

   735                                                      protection_domain, &st,

   736                                                      CHECK_NULL);

   737 

   738   if (TraceClassResolution && k != NULL) {

   739     trace_class_resolution(k);

   740   }

   741 

   742   return (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());

   743 }

   744 

   745 

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

   747   JVMWrapper2("JVM_DefineClass %s", name);

   748 

   749   return jvm_define_class_common(env, name, loader, buf, len, pd, "__JVM_DefineClass__", THREAD);

   750 JVM_END

   751 

   752 

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

   754   JVMWrapper2("JVM_DefineClassWithSource %s", name);

   755 

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

   757 JVM_END

   758 

   759 

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

   761   JVMWrapper("JVM_FindLoadedClass");

   762   ResourceMark rm(THREAD);

   763 

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

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

   766 

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

   768   // Sanity check, don't expect null

   769   if (str == NULL) return NULL;

   770 

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

   772   if (str_len > symbolOopDesc::max_length()) {

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

   774     // into the constant pool.

   775     return NULL;

   776   }

   777   symbolHandle klass_name = oopFactory::new_symbol_handle(str, str_len,CHECK_NULL);

   778 

   779   // Security Note:

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

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

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

   783   if (UsePerfData) {

   784     is_lock_held_by_thread(h_loader,

   785                            ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(),

   786                            THREAD);

   787   }

   788 

   789   klassOop k = SystemDictionary::find_instance_or_array_klass(klass_name,

   790                                                               h_loader,

   791                                                               Handle(),

   792                                                               CHECK_NULL);

   793 

   794   return (k == NULL) ? NULL :

   795             (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());

   796 JVM_END

   797 

   798 

   799 // Reflection support //////////////////////////////////////////////////////////////////////////////

   800 

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

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

   803   JVMWrapper("JVM_GetClassName");

   804   JvmtiVMObjectAllocEventCollector oam;

   805   ResourceMark rm(THREAD);

   806   const char* name;

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

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

   809   } else {

   810     // Consider caching interned string in Klass

   811     klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));

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

   813     name = Klass::cast(k)->external_name();

   814   }

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

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

   817 JVM_END

   818 

   819 

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

   821   JVMWrapper("JVM_GetClassInterfaces");

   822   JvmtiVMObjectAllocEventCollector oam;

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

   824 

   825   // Special handling for primitive objects

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

   827     // Primitive objects does not have any interfaces

   828     objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL);

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

   830   }

   831 

   832   KlassHandle klass(thread, java_lang_Class::as_klassOop(mirror));

   833   // Figure size of result array

   834   int size;

   835   if (klass->oop_is_instance()) {

   836     size = instanceKlass::cast(klass())->local_interfaces()->length();

   837   } else {

   838     assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass");

   839     size = 2;

   840   }

   841 

   842   // Allocate result array

   843   objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), size, CHECK_NULL);

   844   objArrayHandle result (THREAD, r);

   845   // Fill in result

   846   if (klass->oop_is_instance()) {

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

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

   849       klassOop k = klassOop(instanceKlass::cast(klass())->local_interfaces()->obj_at(index));

   850       result->obj_at_put(index, Klass::cast(k)->java_mirror());

   851     }

   852   } else {

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

   854     result->obj_at_put(0, Klass::cast(SystemDictionary::cloneable_klass())->java_mirror());

   855     result->obj_at_put(1, Klass::cast(SystemDictionary::serializable_klass())->java_mirror());

   856   }

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

   858 JVM_END

   859 

   860 

   861 JVM_ENTRY(jobject, JVM_GetClassLoader(JNIEnv *env, jclass cls))

   862   JVMWrapper("JVM_GetClassLoader");

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

   864     return NULL;

   865   }

   866   klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));

   867   oop loader = Klass::cast(k)->class_loader();

   868   return JNIHandles::make_local(env, loader);

   869 JVM_END

   870 

   871 

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

   873   JVMWrapper("JVM_IsInterface");

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

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

   876     return JNI_FALSE;

   877   }

   878   klassOop k = java_lang_Class::as_klassOop(mirror);

   879   jboolean result = Klass::cast(k)->is_interface();

   880   assert(!result || Klass::cast(k)->oop_is_instance(),

   881          "all interfaces are instance types");

   882   // The compiler intrinsic for isInterface tests the

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

   884   return result;

   885 JVM_END

   886 

   887 

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

   889   JVMWrapper("JVM_GetClassSigners");

   890   JvmtiVMObjectAllocEventCollector oam;

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

   892     // There are no signers for primitive types

   893     return NULL;

   894   }

   895 

   896   klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));

   897   objArrayOop signers = NULL;

   898   if (Klass::cast(k)->oop_is_instance()) {

   899     signers = instanceKlass::cast(k)->signers();

   900   }

   901 

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

   903   // is an array, return NULL.

   904   if (signers == NULL) return NULL;

   905 

   906   // copy of the signers array

   907   klassOop element = objArrayKlass::cast(signers->klass())->element_klass();

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

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

   910     signers_copy->obj_at_put(index, signers->obj_at(index));

   911   }

   912 

   913   // return the copy

   914   return (jobjectArray) JNIHandles::make_local(env, signers_copy);

   915 JVM_END

   916 

   917 

   918 JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers))

   919   JVMWrapper("JVM_SetClassSigners");

   920   if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {

   921     // This call is ignored for primitive types and arrays.

   922     // Signers are only set once, ClassLoader.java, and thus shouldn't

   923     // be called with an array.  Only the bootstrap loader creates arrays.

   924     klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));

   925     if (Klass::cast(k)->oop_is_instance()) {

   926       instanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers)));

   927     }

   928   }

   929 JVM_END

   930 

   931 

   932 JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls))

   933   JVMWrapper("JVM_GetProtectionDomain");

   934   if (JNIHandles::resolve(cls) == NULL) {

   935     THROW_(vmSymbols::java_lang_NullPointerException(), NULL);

   936   }

   937 

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

   939     // Primitive types does not have a protection domain.

   940     return NULL;

   941   }

   942 

   943   klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));

   944   return (jobject) JNIHandles::make_local(env, Klass::cast(k)->protection_domain());

   945 JVM_END

   946 

   947 

   948 // Obsolete since 1.2 (Class.setProtectionDomain removed), although

   949 // still defined in core libraries as of 1.5.

   950 JVM_ENTRY(void, JVM_SetProtectionDomain(JNIEnv *env, jclass cls, jobject protection_domain))

   951   JVMWrapper("JVM_SetProtectionDomain");

   952   if (JNIHandles::resolve(cls) == NULL) {

   953     THROW(vmSymbols::java_lang_NullPointerException());

   954   }

   955   if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {

   956     // Call is ignored for primitive types

   957     klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));

   958 

   959     // cls won't be an array, as this called only from ClassLoader.defineClass

   960     if (Klass::cast(k)->oop_is_instance()) {

   961       oop pd = JNIHandles::resolve(protection_domain);

   962       assert(pd == NULL || pd->is_oop(), "just checking");

   963       instanceKlass::cast(k)->set_protection_domain(pd);

   964     }

   965   }

   966 JVM_END

   967 

   968 

   969 JVM_ENTRY(jobject, JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException))

   970   JVMWrapper("JVM_DoPrivileged");

   971 

   972   if (action == NULL) {

   973     THROW_MSG_0(vmSymbols::java_lang_NullPointerException(), "Null action");

   974   }

   975 

   976   // Stack allocated list of privileged stack elements

   977   PrivilegedElement pi;

   978 

   979   // Check that action object understands "Object run()"

   980   Handle object (THREAD, JNIHandles::resolve(action));

   981 

   982   // get run() method

   983   methodOop m_oop = Klass::cast(object->klass())->uncached_lookup_method(

   984                                            vmSymbols::run_method_name(),

   985                                            vmSymbols::void_object_signature());

   986   methodHandle m (THREAD, m_oop);

   987   if (m.is_null() || !m->is_method() || !methodOop(m())->is_public() || methodOop(m())->is_static()) {

   988     THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method");

   989   }

   990 

   991   // Compute the frame initiating the do privileged operation and setup the privileged stack

   992   vframeStream vfst(thread);

   993   vfst.security_get_caller_frame(1);

   994 

   995   if (!vfst.at_end()) {

   996     pi.initialize(&vfst, JNIHandles::resolve(context), thread->privileged_stack_top(), CHECK_NULL);

   997     thread->set_privileged_stack_top(&pi);

   998   }

   999 

  1000 

  1001   // invoke the Object run() in the action object. We cannot use call_interface here, since the static type

  1002   // is not really known - it is either java.security.PrivilegedAction or java.security.PrivilegedExceptionAction

  1003   Handle pending_exception;

  1004   JavaValue result(T_OBJECT);

  1005   JavaCallArguments args(object);

  1006   JavaCalls::call(&result, m, &args, THREAD);

  1007 

  1008   // done with action, remove ourselves from the list

  1009   if (!vfst.at_end()) {

  1010     assert(thread->privileged_stack_top() != NULL && thread->privileged_stack_top() == &pi, "wrong top element");

  1011     thread->set_privileged_stack_top(thread->privileged_stack_top()->next());

  1012   }

  1013 

  1014   if (HAS_PENDING_EXCEPTION) {

  1015     pending_exception = Handle(THREAD, PENDING_EXCEPTION);

  1016     CLEAR_PENDING_EXCEPTION;

  1017 

  1018     if ( pending_exception->is_a(SystemDictionary::exception_klass()) &&

  1019         !pending_exception->is_a(SystemDictionary::runtime_exception_klass())) {

  1020       // Throw a java.security.PrivilegedActionException(Exception e) exception

  1021       JavaCallArguments args(pending_exception);

  1022       THROW_ARG_0(vmSymbolHandles::java_security_PrivilegedActionException(),

  1023                   vmSymbolHandles::exception_void_signature(),

  1024                   &args);

  1025     }

  1026   }

  1027 

  1028   if (pending_exception.not_null()) THROW_OOP_0(pending_exception());

  1029   return JNIHandles::make_local(env, (oop) result.get_jobject());

  1030 JVM_END

  1031 

  1032 

  1033 // Returns the inherited_access_control_context field of the running thread.

  1034 JVM_ENTRY(jobject, JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls))

  1035   JVMWrapper("JVM_GetInheritedAccessControlContext");

  1036   oop result = java_lang_Thread::inherited_access_control_context(thread->threadObj());

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

  1038 JVM_END

  1039 

  1040 class RegisterArrayForGC {

  1041  private:

  1042   JavaThread *_thread;

  1043  public:

  1044   RegisterArrayForGC(JavaThread *thread, GrowableArray<oop>* array)  {

  1045     _thread = thread;

  1046     _thread->register_array_for_gc(array);

  1047   }

  1048 

  1049   ~RegisterArrayForGC() {

  1050     _thread->register_array_for_gc(NULL);

  1051   }

  1052 };

  1053 

  1054 

  1055 JVM_ENTRY(jobject, JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls))

  1056   JVMWrapper("JVM_GetStackAccessControlContext");

  1057   if (!UsePrivilegedStack) return NULL;

  1058 

  1059   ResourceMark rm(THREAD);

  1060   GrowableArray<oop>* local_array = new GrowableArray<oop>(12);

  1061   JvmtiVMObjectAllocEventCollector oam;

  1062 

  1063   // count the protection domains on the execution stack. We collapse

  1064   // duplicate consecutive protection domains into a single one, as

  1065   // well as stopping when we hit a privileged frame.

  1066 

  1067   // Use vframeStream to iterate through Java frames

  1068   vframeStream vfst(thread);

  1069 

  1070   oop previous_protection_domain = NULL;

  1071   Handle privileged_context(thread, NULL);

  1072   bool is_privileged = false;

  1073   oop protection_domain = NULL;

  1074 

  1075   for(; !vfst.at_end(); vfst.next()) {

  1076     // get method of frame

  1077     methodOop method = vfst.method();

  1078     intptr_t* frame_id   = vfst.frame_id();

  1079 

  1080     // check the privileged frames to see if we have a match

  1081     if (thread->privileged_stack_top() && thread->privileged_stack_top()->frame_id() == frame_id) {

  1082       // this frame is privileged

  1083       is_privileged = true;

  1084       privileged_context = Handle(thread, thread->privileged_stack_top()->privileged_context());

  1085       protection_domain  = thread->privileged_stack_top()->protection_domain();

  1086     } else {

  1087       protection_domain = instanceKlass::cast(method->method_holder())->protection_domain();

  1088     }

  1089 

  1090     if ((previous_protection_domain != protection_domain) && (protection_domain != NULL)) {

  1091       local_array->push(protection_domain);

  1092       previous_protection_domain = protection_domain;

  1093     }

  1094 

  1095     if (is_privileged) break;

  1096   }

  1097 

  1098 

  1099   // either all the domains on the stack were system domains, or

  1100   // we had a privileged system domain

  1101   if (local_array->is_empty()) {

  1102     if (is_privileged && privileged_context.is_null()) return NULL;

  1103 

  1104     oop result = java_security_AccessControlContext::create(objArrayHandle(), is_privileged, privileged_context, CHECK_NULL);

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

  1106   }

  1107 

  1108   // the resource area must be registered in case of a gc

  1109   RegisterArrayForGC ragc(thread, local_array);

  1110   objArrayOop context = oopFactory::new_objArray(SystemDictionary::protectionDomain_klass(),

  1111                                                  local_array->length(), CHECK_NULL);

  1112   objArrayHandle h_context(thread, context);

  1113   for (int index = 0; index < local_array->length(); index++) {

  1114     h_context->obj_at_put(index, local_array->at(index));

  1115   }

  1116 

  1117   oop result = java_security_AccessControlContext::create(h_context, is_privileged, privileged_context, CHECK_NULL);

  1118 

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

  1120 JVM_END

  1121 

  1122 

  1123 JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))

  1124   JVMWrapper("JVM_IsArrayClass");

  1125   klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));

  1126   return (k != NULL) && Klass::cast(k)->oop_is_javaArray() ? true : false;

  1127 JVM_END

  1128 

  1129 

  1130 JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))

  1131   JVMWrapper("JVM_IsPrimitiveClass");

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

  1133   return (jboolean) java_lang_Class::is_primitive(mirror);

  1134 JVM_END

  1135