1 /*

        2  * Copyright 1997-2009 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   const char * trace = "explicit";

       68   klassOop caller = NULL;

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

       70   if (jthread->has_last_Java_frame()) {

       71     vframeStream vfst(jthread);

       72 

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

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

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

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

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

       78 

       79     methodOop last_caller = NULL;

       80 

       81     while (!vfst.at_end()) {

       82       methodOop m = vfst.method();

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

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

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

       86         break;

       87       }

       88       last_caller = m;

       89       vfst.next();

       90     }

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

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

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

       94     bool found_it = false;

       95     if (!vfst.at_end() &&

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

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

       98       vfst.next();

       99       if (!vfst.at_end() &&

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

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

      102         vfst.next();

      103         found_it = true;

      104       }

      105     } else if (last_caller != NULL &&

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

      107                vmSymbols::java_lang_ClassLoader() &&

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

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

      110       found_it = true;

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

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

      113         // JNI call

      114         found_it = true;

      115       }

      116     }

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

      118       // found the caller

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

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

      121       if (line_number == -1) {

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

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

      124       }

      125       symbolOop s = instanceKlass::cast(caller)->source_file_name();

      126       if (s != NULL) {

      127         source_file = s->as_C_string();

      128       }

      129     }

      130   }

      131   if (caller != NULL) {

      132     if (to_class != caller) {

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

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

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

      136       if (source_file != NULL) {

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

      138       } else {

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

      140       }

      141     }

      142   }

      143 }

      144 

      145 void trace_class_resolution(klassOop to_class) {

      146   EXCEPTION_MARK;

      147   trace_class_resolution_impl(to_class, THREAD);

      148   if (HAS_PENDING_EXCEPTION) {

      149     CLEAR_PENDING_EXCEPTION;

      150   }

      151 }

      152 

      153 // Wrapper to trace JVM functions

      154 

      155 #ifdef ASSERT

      156   class JVMTraceWrapper : public StackObj {

      157    public:

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

      159       if (TraceJVMCalls) {

      160         va_list ap;

      161         va_start(ap, format);

      162         tty->print("JVM ");

      163         tty->vprint_cr(format, ap);

      164         va_end(ap);

      165       }

      166     }

      167   };

      168 

      169   Histogram* JVMHistogram;

      170   volatile jint JVMHistogram_lock = 0;

      171 

      172   class JVMHistogramElement : public HistogramElement {

      173     public:

      174      JVMHistogramElement(const char* name);

      175   };

      176 

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

      178     _name = elementName;

      179     uintx count = 0;

      180 

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

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

      183         count +=1;

      184         if ( (WarnOnStalledSpinLock > 0)

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

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

      187         }

      188       }

      189      }

      190 

      191     if(JVMHistogram == NULL)

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

      193 

      194     JVMHistogram->add_element(this);

      195     Atomic::dec(&JVMHistogram_lock);

      196   }

      197 

      198   #define JVMCountWrapper(arg) \

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

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

      201 

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

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

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

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

      206 #else

      207   #define JVMWrapper(arg1)

      208   #define JVMWrapper2(arg1, arg2)

      209   #define JVMWrapper3(arg1, arg2, arg3)

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

      211 #endif

      212 

      213 

      214 // Interface version /////////////////////////////////////////////////////////////////////

      215 

      216 

      217 JVM_LEAF(jint, JVM_GetInterfaceVersion())

      218   return JVM_INTERFACE_VERSION;

      219 JVM_END

      220 

      221 

      222 // java.lang.System //////////////////////////////////////////////////////////////////////

      223 

      224 

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

      226   JVMWrapper("JVM_CurrentTimeMillis");

      227   return os::javaTimeMillis();

      228 JVM_END

      229 

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

      231   JVMWrapper("JVM_NanoTime");

      232   return os::javaTimeNanos();

      233 JVM_END

      234 

      235 

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

      237                                jobject dst, jint dst_pos, jint length))

      238   JVMWrapper("JVM_ArrayCopy");

      239   // Check if we have null pointers

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

      241     THROW(vmSymbols::java_lang_NullPointerException());

      242   }

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

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

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

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

      247   // Do copy

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

      249 JVM_END

      250 

      251 

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

      253   JavaValue r(T_OBJECT);

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

      255   HandleMark hm(THREAD);

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

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

      258   JavaCalls::call_virtual(&r,

      259                           props,

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

      261                           vmSymbolHandles::put_name(),

      262                           vmSymbolHandles::object_object_object_signature(),

      263                           key_str,

      264                           value_str,

      265                           THREAD);

      266 }

      267 

      268 

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

      270 

      271 

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

      273   JVMWrapper("JVM_InitProperties");

      274   ResourceMark rm;

      275 

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

      277 

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

      279   // jvm system specific properties.

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

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

      282   }

      283 

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

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

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

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

      288   {

      289     char as_chars[256];

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

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

      292   }

      293 

      294   // JVM monitoring and management support

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

      296   {

      297 #undef CSIZE

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

      299   #define CSIZE "64-Bit "

      300 #else

      301   #define CSIZE

      302 #endif // 64bit

      303 

      304 #ifdef TIERED

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

      306 #else

      307 #if defined(COMPILER1)

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

      309 #elif defined(COMPILER2)

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

      311 #else

      312     const char* compiler_name = "";

      313 #endif // compilers

      314 #endif // TIERED

      315 

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

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

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

      319     }

      320   }

      321 

      322   return properties;

      323 JVM_END

      324 

      325 

      326 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////

      327 

      328 extern volatile jint vm_created;

      329 

      330 JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code))

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

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

      333     Universe::run_finalizers_on_exit();

      334   }

      335   before_exit(thread);

      336   vm_exit(code);

      337 JVM_END

      338 

      339 

      340 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))

      341   before_exit(thread);

      342   vm_exit(code);

      343 JVM_END

      344 

      345 

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

      347   register_on_exit_function(func);

      348 JVM_END

      349 

      350 

      351 JVM_ENTRY_NO_ENV(void, JVM_GC(void))

      352   JVMWrapper("JVM_GC");

      353   if (!DisableExplicitGC) {

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

      355   }

      356 JVM_END

      357 

      358 

      359 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))

      360   JVMWrapper("JVM_MaxObjectInspectionAge");

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

      362 JVM_END

      363 

      364 

      365 JVM_LEAF(void, JVM_TraceInstructions(jboolean on))

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

      367 JVM_END

      368 

      369 

      370 JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on))

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

      372 JVM_END

      373 

      374 static inline jlong convert_size_t_to_jlong(size_t val) {

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

      376   NOT_LP64 (return (jlong)val;)

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

      378 }

      379 

      380 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))

      381   JVMWrapper("JVM_TotalMemory");

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

      383   return convert_size_t_to_jlong(n);

      384 JVM_END

      385 

      386 

      387 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))

      388   JVMWrapper("JVM_FreeMemory");

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

      390   size_t n;

      391   {

      392      MutexLocker x(Heap_lock);

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

      394   }

      395   return convert_size_t_to_jlong(n);

      396 JVM_END

      397 

      398 

      399 JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))

      400   JVMWrapper("JVM_MaxMemory");

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

      402   return convert_size_t_to_jlong(n);

      403 JVM_END

      404 

      405 

      406 JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))

      407   JVMWrapper("JVM_ActiveProcessorCount");

      408   return os::active_processor_count();

      409 JVM_END

      410 

      411 

      412 

      413 // java.lang.Throwable //////////////////////////////////////////////////////

      414 

      415 

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

      417   JVMWrapper("JVM_FillInStackTrace");

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

      419   java_lang_Throwable::fill_in_stack_trace(exception);

      420 JVM_END

      421 

      422 

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

      424   JVMWrapper("JVM_PrintStackTrace");

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

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

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

      428   java_lang_Throwable::print_stack_trace(exception, stream);

      429 JVM_END

      430 

      431 

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

      433   JVMWrapper("JVM_GetStackTraceDepth");

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

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

      436 JVM_END

      437 

      438 

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

      440   JVMWrapper("JVM_GetStackTraceElement");

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

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

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

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

      445 JVM_END

      446 

      447 

      448 // java.lang.Object ///////////////////////////////////////////////

      449 

      450 

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

      452   JVMWrapper("JVM_IHashCode");

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

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

      455 JVM_END

      456 

      457 

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

      459   JVMWrapper("JVM_MonitorWait");

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

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

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

      463   if (JvmtiExport::should_post_monitor_wait()) {

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

      465   }

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

      467 JVM_END

      468 

      469 

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

      471   JVMWrapper("JVM_MonitorNotify");

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

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

      474   ObjectSynchronizer::notify(obj, CHECK);

      475 JVM_END

      476 

      477 

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

      479   JVMWrapper("JVM_MonitorNotifyAll");

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

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

      482   ObjectSynchronizer::notifyall(obj, CHECK);

      483 JVM_END

      484 

      485 

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

      487   JVMWrapper("JVM_Clone");

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

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

      490   JvmtiVMObjectAllocEventCollector oam;

      491 

      492 #ifdef ASSERT

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

      494   if (obj->is_javaArray()) {

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

      496   } else {

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

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

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

      500   }

      501 #endif

      502 

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

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

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

      506     ResourceMark rm(THREAD);

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

      508   }

      509 

      510   // Make shallow object copy

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

      512   oop new_obj = NULL;

      513   if (obj->is_javaArray()) {

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

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

      516   } else {

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

      518   }

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

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

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

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

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

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

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

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

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

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

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

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

      531   // Clear the header

      532   new_obj->init_mark();

      533 

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

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

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

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

      538 

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

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

      541   if (klass->has_finalizer()) {

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

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

      544   }

      545 

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

      547 JVM_END

      548 

      549 // java.lang.Compiler ////////////////////////////////////////////////////

      550 

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

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

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

      554 

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

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

      557 JVM_END

      558 

      559 

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

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

      562   return JNI_FALSE;

      563 JVM_END

      564 

      565 

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

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

      568   return JNI_FALSE;

      569 JVM_END

      570 

      571 

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

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

      574   return JNI_FALSE;

      575 JVM_END

      576 

      577 

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

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

      580   return NULL;

      581 JVM_END

      582 

      583 

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

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

      586 JVM_END

      587 

      588 

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

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

      591 JVM_END

      592 

      593 

      594 

      595 // Error message support //////////////////////////////////////////////////////

      596 

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

      598   JVMWrapper("JVM_GetLastErrorString");

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

      600 JVM_END

      601 

      602 

      603 // java.io.File ///////////////////////////////////////////////////////////////

      604 

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

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

      607   return hpi::native_path(path);

      608 JVM_END

      609 

      610 

      611 // Misc. class handling ///////////////////////////////////////////////////////////

      612 

      613 

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

      615   JVMWrapper("JVM_GetCallerClass");

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

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

      618 JVM_END

      619 

      620 

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

      622   JVMWrapper("JVM_FindPrimitiveClass");

      623   oop mirror = NULL;

      624   BasicType t = name2type(utf);

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

      626     mirror = Universe::java_mirror(t);

      627   }

      628   if (mirror == NULL) {

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

      630   } else {

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

      632   }

      633 JVM_END

      634 

      635 

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

      637   JVMWrapper("JVM_ResolveClass");

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

      639 JVM_END

      640 

      641 

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

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

      644 //

      645 // Rationale behind JVM_FindClassFromBootLoader

      646 // a> JVM_FindClassFromClassLoader was never exported in the export tables.

      647 // b> because of (a) java.dll has a direct dependecy on the  unexported

      648 //    private symbol "_JVM_FindClassFromClassLoader@20".

      649 // c> the launcher cannot use the private symbol as it dynamically opens

      650 //    the entry point, so if something changes, the launcher will fail

      651 //    unexpectedly at runtime, it is safest for the launcher to dlopen a

      652 //    stable exported interface.

      653 // d> re-exporting JVM_FindClassFromClassLoader as public, will cause its

      654 //    signature to change from _JVM_FindClassFromClassLoader@20 to

      655 //    JVM_FindClassFromClassLoader and will not be backward compatible

      656 //    with older JDKs.

      657 // Thus a public/stable exported entry point is the right solution,

      658 // public here means public in linker semantics, and is exported only

      659 // to the JDK, and is not intended to be a public API.

      660 

      661 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,

      662                                               const char* name))

      663   JVMWrapper2("JVM_FindClassFromBootLoader %s", name);

      664 

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

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

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

      668     // into the constant pool.

      669     return NULL;

      670   }

      671 

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

      673   klassOop k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);

      674   if (k == NULL) {

      675     return NULL;

      676   }

      677 

      678   if (TraceClassResolution) {

      679     trace_class_resolution(k);

      680   }

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

      682 JVM_END

      683 

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

      685                                                jboolean init, jobject loader,

      686                                                jboolean throwError))

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

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

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

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

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

      692     // into the constant pool.

      693     if (throwError) {

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

      695     } else {

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

      697     }

      698   }

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

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

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

      702                                                Handle(), throwError, THREAD);

      703 

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

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

      706   }

      707   return result;

      708 JVM_END

      709 

      710 

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

      712                                          jboolean init, jclass from))

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

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

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

      716     // into the constant pool.

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

      718   }

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

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

      721   klassOop from_class = (from_class_oop == NULL)

      722                            ? (klassOop)NULL

      723                            : java_lang_Class::as_klassOop(from_class_oop);

      724   oop class_loader = NULL;

      725   oop protection_domain = NULL;

      726   if (from_class != NULL) {

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

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

      729   }

      730   Handle h_loader(THREAD, class_loader);

      731   Handle h_prot  (THREAD, protection_domain);

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

      733                                                h_prot, true, thread);

      734 

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

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

      737     ResourceMark rm;

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

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

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

      741 

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

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

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

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

      746   }

      747 

      748   return result;

      749 JVM_END

      750 

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

      752   if (loader.is_null()) {

      753     return;

      754   }

      755 

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

      757   // If not, increment the corresponding counter

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

      759       ObjectSynchronizer::owner_self) {

      760     counter->inc();

      761   }

      762 }

      763 

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

      765 // and JVM_DefineClassWithSourceCond()

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

      767                                       jobject loader, const jbyte *buf,

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

      769                                       jboolean verify, TRAPS) {

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

      771 

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

      773   JavaThread* jt = (JavaThread*) THREAD;

      774 

      775   PerfClassTraceTime vmtimer(ClassLoader::perf_define_appclass_time(),

      776                              ClassLoader::perf_define_appclass_selftime(),

      777                              ClassLoader::perf_define_appclasses(),

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

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

      780                              PerfClassTraceTime::DEFINE_CLASS);

      781 

      782   if (UsePerfData) {

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

      784   }

      785 

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

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

      788   symbolHandle class_name;

      789   if (name != NULL) {

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

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

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

      793       // into the constant pool.

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

      795     }

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

      797   }

      798 

      799   ResourceMark rm(THREAD);

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

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

      802   if (UsePerfData) {

      803     is_lock_held_by_thread(class_loader,

      804                            ClassLoader::sync_JVMDefineClassLockFreeCounter(),

      805                            THREAD);

      806   }

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

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

      809                                                      protection_domain, &st,

      810                                                      verify != 0,

      811                                                      CHECK_NULL);

      812 

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

      814     trace_class_resolution(k);

      815   }

      816 

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

      818 }

      819 

      820 

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

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

      823 

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

      825 JVM_END

      826 

      827 

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

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

      830 

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

      832 JVM_END

      833 

      834 JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name,

      835                                                 jobject loader, const jbyte *buf,

      836                                                 jsize len, jobject pd,

      837                                                 const char *source, jboolean verify))

      838   JVMWrapper2("JVM_DefineClassWithSourceCond %s", name);

      839 

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

      841 JVM_END

      842 

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

      844   JVMWrapper("JVM_FindLoadedClass");

      845   ResourceMark rm(THREAD);

      846 

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

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

      849 

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

      851   // Sanity check, don't expect null

      852   if (str == NULL) return NULL;

      853 

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

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

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

      857     // into the constant pool.

      858     return NULL;

      859   }

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

      861 

      862   // Security Note:

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

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

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

      866   if (UsePerfData) {

      867     is_lock_held_by_thread(h_loader,

      868                            ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(),

      869                            THREAD);

      870   }

      871 

      872   klassOop k = SystemDictionary::find_instance_or_array_klass(klass_name,

      873                                                               h_loader,

      874                                                               Handle(),

      875                                                               CHECK_NULL);

      876 

      877   return (k == NULL) ? NULL :

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

      879 JVM_END

      880 

      881 

      882 // Reflection support //////////////////////////////////////////////////////////////////////////////

      883 

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

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

      886   JVMWrapper("JVM_GetClassName");

      887   JvmtiVMObjectAllocEventCollector oam;

      888   ResourceMark rm(THREAD);

      889   const char* name;

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

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

      892   } else {

      893     // Consider caching interned string in Klass

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

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

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

      897   }

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

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

      900 JVM_END

      901 

      902 

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

      904   JVMWrapper("JVM_GetClassInterfaces");

      905   JvmtiVMObjectAllocEventCollector oam;

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

      907 

      908   // Special handling for primitive objects

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

      910     // Primitive objects does not have any interfaces

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

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

      913   }

      914 

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

      916   // Figure size of result array

      917   int size;

      918   if (klass->oop_is_instance()) {

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

      920   } else {

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

      922     size = 2;

      923   }

      924 

      925   // Allocate result array

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

      927   objArrayHandle result (THREAD, r);

      928   // Fill in result

      929   if (klass->oop_is_instance()) {

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

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

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

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

      934     }

      935   } else {

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

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

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

      939   }

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

      941 JVM_END

      942 

      943 

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

      945   JVMWrapper("JVM_GetClassLoader");

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

      947     return NULL;

      948   }

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

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

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

      952 JVM_END

      953 

      954 

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

      956   JVMWrapper("JVM_IsInterface");

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

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

      959     return JNI_FALSE;

      960   }

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

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

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

      964          "all interfaces are instance types");

      965   // The compiler intrinsic for isInterface tests the

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

      967   return result;

      968 JVM_END

      969 

      970 

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

      972   JVMWrapper("JVM_GetClassSigners");

      973   JvmtiVMObjectAllocEventCollector oam;

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

      975     // There are no signers for primitive types

      976     return NULL;

      977   }

      978 

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

      980   objArrayOop signers = NULL;

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

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

      983   }

      984 

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

      986   // is an array, return NULL.

      987   if (signers == NULL) return NULL;

      988 

      989   // copy of the signers array

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

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

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

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

      994   }

      995 

      996   // return the copy

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

      998 JVM_END

      999 

     1000 

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

     1002   JVMWrapper("JVM_SetClassSigners");

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

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

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

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

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

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

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

     1010     }

     1011   }

     1012 JVM_END

     1013 

     1014 

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

     1016   JVMWrapper("JVM_GetProtectionDomain");

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

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

     1019   }

     1020 

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

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

     1023     return NULL;

     1024   }

     1025 

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

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

     1028 JVM_END

     1029 

     1030 

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

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

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

     1034   JVMWrapper("JVM_SetProtectionDomain");

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

     1036     THROW(vmSymbols::java_lang_NullPointerException());

     1037   }

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

     1039     // Call is ignored for primitive types

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

     1041 

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

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

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

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

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

     1047     }

     1048   }

     1049 JVM_END

     1050 

     1051 

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

     1053   JVMWrapper("JVM_DoPrivileged");

     1054 

     1055   if (action == NULL) {

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

     1057   }

     1058 

     1059   // Stack allocated list of privileged stack elements

     1060   PrivilegedElement pi;

     1061 

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

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

     1064 

     1065   // get run() method

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

     1067                                            vmSymbols::run_method_name(),

     1068                                            vmSymbols::void_object_signature());

     1069   methodHandle m (THREAD, m_oop);

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

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

     1072   }

     1073 

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

     1075   vframeStream vfst(thread);

     1076   vfst.security_get_caller_frame(1);

     1077 

     1078   if (!vfst.at_end()) {

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

     1080     thread->set_privileged_stack_top(&pi);

     1081   }

     1082 

     1083 

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

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

     1086   Handle pending_exception;

     1087   JavaValue result(T_OBJECT);

     1088   JavaCallArguments args(object);

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

     1090 

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

     1092   if (!vfst.at_end()) {

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

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

     1095   }

     1096 

     1097   if (HAS_PENDING_EXCEPTION) {

     1098     pending_exception = Handle(THREAD, PENDING_EXCEPTION);

     1099     CLEAR_PENDING_EXCEPTION;

     1100 

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

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

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

     1104       JavaCallArguments args(pending_exception);

     1105       THROW_ARG_0(vmSymbolHandles::java_security_PrivilegedActionException(),

     1106                   vmSymbolHandles::exception_void_signature(),

     1107                   &args);

     1108     }

     1109   }

     1110 

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

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

     1113 JVM_END

     1114 

     1115 

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

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

     1118   JVMWrapper("JVM_GetInheritedAccessControlContext");

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

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

     1121 JVM_END

     1122 

     1123 class RegisterArrayForGC {

     1124  private:

     1125   JavaThread *_thread;

     1126  public:

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

     1128     _thread = thread;

     1129     _thread->register_array_for_gc(array);

     1130   }

     1131 

     1132   ~RegisterArrayForGC() {

     1133     _thread->register_array_for_gc(NULL);

     1134   }

     1135 };

     1136 

     1137 

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

     1139   JVMWrapper("JVM_GetStackAccessControlContext");

     1140   if (!UsePrivilegedStack) return NULL;

     1141 

     1142   ResourceMark rm(THREAD);

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

     1144   JvmtiVMObjectAllocEventCollector oam;

     1145 

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

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

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

     1149 

     1150   // Use vframeStream to iterate through Java frames

     1151   vframeStream vfst(thread);

     1152 

     1153   oop previous_protection_domain = NULL;

     1154   Handle privileged_context(thread, NULL);

     1155   bool is_privileged = false;

     1156   oop protection_domain = NULL;

     1157 

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

     1159     // get method of frame

     1160     methodOop method = vfst.method();

     1161     intptr_t* frame_id   = vfst.frame_id();

     1162 

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

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

     1165       // this frame is privileged

     1166       is_privileged = true;

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

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

     1169     } else {

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

     1171     }

     1172 

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

     1174       local_array->push(protection_domain);

     1175       previous_protection_domain = protection_domain;

     1176     }

     1177 

     1178     if (is_privileged) break;

     1179   }

     1180 

     1181 

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

     1183   // we had a privileged system domain

     1184   if (local_array->is_empty()) {

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

     1186 

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

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

     1189   }

     1190 

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

     1192   RegisterArrayForGC ragc(thread, local_array);

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

     1194                                                  local_array->length(), CHECK_NULL);

     1195   objArrayHandle h_context(thread, context);

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

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

     1198   }

     1199 

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

     1201 

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

     1203 JVM_END

     1204 

     1205 

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

     1207   JVMWrapper("JVM_IsArrayClass");

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

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

     1210 JVM_END

     1211 

     1212 

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

     1214   JVMWrapper("JVM_IsPrimitiveClass");

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

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

     1217 JVM_END

     1218 

     1219 

     1220 JVM_ENTRY(jclass, JVM_GetComponentType(JNIEnv *env, jclass cls))

     1221   JVMWrapper("JVM_GetComponentType");

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

     1223   oop result = Reflection::array_component_type(mirror, CHECK_NULL);

     1224   return (jclass) JNIHandles::make_local(env, result);

     1225 JVM_END

     1226 

     1227 

     1228 JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv *env, jclass cls))

     1229   JVMWrapper("JVM_GetClassModifiers");

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

     1231     // Primitive type

     1232     return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;

     1233   }

     1234 

     1235   Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)));

     1236   debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0));

     1237   assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK");

     1238   return k->modifier_flags();

     1239 JVM_END

     1240 

     1241 

     1242 // Inner class reflection ///////////////////////////////////////////////////////////////////////////////

     1243 

     1244 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))

     1245   const int inner_class_info_index = 0;

     1246   const int outer_class_info_index = 1;

     1247 

     1248   JvmtiVMObjectAllocEventCollector oam;

     1249   // ofClass is a reference to a java_lang_Class object. The mirror object

     1250   // of an instanceKlass

     1251 

     1252   if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||

     1253       ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {

     1254     oop result = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL);

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

     1256   }

     1257 

     1258   instanceKlassHandle k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));

     1259 

     1260   if (k->inner_classes()->length() == 0) {

     1261     // Neither an inner nor outer class

     1262     oop result = oopFactory::new_objArray(SystemDictionary::class_klass(), 0, CHECK_NULL);

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

     1264   }

     1265 

     1266   // find inner class info

     1267   typeArrayHandle    icls(thread, k->inner_classes());

     1268   constantPoolHandle cp(thread, k->constants());

     1269   int length = icls->length();

     1270 

     1271   // Allocate temp. result array

     1272   objArrayOop r = oopFactory::new_objArray(SystemDictionary::class_klass(), length/4, CHECK_NULL);

     1273   objArrayHandle result (THREAD, r);

     1274   int members = 0;

     1275 

     1276   for(int i = 0; i < length; i += 4) {

     1277     int ioff = icls->ushort_at(i + inner_class_info_index);

     1278     int ooff = icls->ushort_at(i + outer_class_info_index);

     1279 

     1280     if (ioff != 0 && ooff != 0) {

     1281       // Check to see if the name matches the class we're looking for

     1282       // before attempting to find the class.

     1283       if (cp->klass_name_at_matches(k, ooff)) {

     1284         klassOop outer_klass = cp->klass_at(ooff, CHECK_NULL);

     1285         if (outer_klass == k()) {

     1286            klassOop ik = cp->klass_at(ioff, CHECK_NULL);

     1287            instanceKlassHandle inner_klass (THREAD, ik);

     1288 

     1289            // Throws an exception if outer klass has not declared k as

     1290            // an inner klass

     1291            Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL);

     1292 

     1293            result->obj_at_put(members, inner_klass->java_mirror());

     1294            members++;

     1295         }

     1296       }

     1297     }

     1298   }

     1299 

     1300   if (members != length) {

     1301     // Return array of right length

     1302     objArrayOop res = oopFactory::new_objArray(SystemDictionary::class_klass(), members, CHECK_NULL);

     1303     for(int i = 0; i < members; i++) {

     1304       res->obj_at_put(i, result->obj_at(i));

     1305     }

     1306     return (jobjectArray)JNIHandles::make_local(env, res);

     1307   }

     1308 

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

     1310 JVM_END

     1311 

     1312 

     1313 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))

     1314 {

     1315   // ofClass is a reference to a java_lang_Class object.

     1316   if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||

     1317       ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {

     1318     return NULL;

     1319   }

     1320 

     1321   symbolOop simple_name = NULL;

     1322   klassOop outer_klass

     1323     = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))

     1324                           )->compute_enclosing_class(simple_name, CHECK_NULL);

     1325   if (outer_klass == NULL)  return NULL;  // already a top-level class

     1326   if (simple_name == NULL)  return NULL;  // an anonymous class (inside a method)

     1327   return (jclass) JNIHandles::make_local(env, Klass::cast(outer_klass)->java_mirror());

     1328 }

     1329 JVM_END

     1330 

     1331 // should be in instanceKlass.cpp, but is here for historical reasons

     1332 klassOop instanceKlass::compute_enclosing_class_impl(instanceKlassHandle k,

     1333                                                      symbolOop& simple_name_result, TRAPS) {

     1334   Thread* thread = THREAD;

     1335   const int inner_class_info_index = inner_class_inner_class_info_offset;

     1336   const int outer_class_info_index = inner_class_outer_class_info_offset;

     1337 

     1338   if (k->inner_classes()->length() == 0) {

     1339     // No inner class info => no declaring class

     1340     return NULL;

     1341   }

     1342 

     1343   typeArrayHandle i_icls(thread, k->inner_classes());

     1344   constantPoolHandle i_cp(thread, k->constants());

     1345   int i_length = i_icls->length();

     1346 

     1347   bool found = false;

     1348   klassOop ok;

     1349   instanceKlassHandle outer_klass;

     1350   bool inner_is_member = false;

     1351   int simple_name_index = 0;

     1352 

     1353   // Find inner_klass attribute

     1354   for (int i = 0; i < i_length && !found; i += inner_class_next_offset) {

     1355     int ioff = i_icls->ushort_at(i + inner_class_info_index);

     1356     int ooff = i_icls->ushort_at(i + outer_class_info_index);

     1357     int noff = i_icls->ushort_at(i + inner_class_inner_name_offset);

     1358     if (ioff != 0) {

     1359       // Check to see if the name matches the class we're looking for

     1360       // before attempting to find the class.

     1361       if (i_cp->klass_name_at_matches(k, ioff)) {

     1362         klassOop inner_klass = i_cp->klass_at(ioff, CHECK_NULL);

     1363         found = (k() == inner_klass);

     1364         if (found && ooff != 0) {

     1365           ok = i_cp->klass_at(ooff, CHECK_NULL);

     1366           outer_klass = instanceKlassHandle(thread, ok);

     1367           simple_name_index = noff;

     1368           inner_is_member = true;

     1369         }

     1370       }

     1371     }

     1372   }

     1373 

     1374   if (found && outer_klass.is_null()) {

     1375     // It may be anonymous; try for that.

     1376     int encl_method_class_idx = k->enclosing_method_class_index();

     1377     if (encl_method_class_idx != 0) {

     1378       ok = i_cp->klass_at(encl_method_class_idx, CHECK_NULL);

     1379       outer_klass = instanceKlassHandle(thread, ok);

     1380       inner_is_member = false;

     1381     }

     1382   }

     1383 

     1384   // If no inner class attribute found for this class.

     1385   if (outer_klass.is_null())  return NULL;

     1386 

     1387   // Throws an exception if outer klass has not declared k as an inner klass

     1388   // We need evidence that each klass knows about the other, or else

     1389   // the system could allow a spoof of an inner class to gain access rights.

     1390   Reflection::check_for_inner_class(outer_klass, k, inner_is_member, CHECK_NULL);

     1391 

     1392   simple_name_result = (inner_is_member ? i_cp->symbol_at(simple_name_index) : symbolOop(NULL));

     1393   return outer_klass();

     1394 }

     1395 

     1396 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls))

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

     1398   JVMWrapper("JVM_GetClassSignature");

     1399   JvmtiVMObjectAllocEventCollector oam;

     1400   ResourceMark rm(THREAD);

     1401   // Return null for arrays and primatives

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

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

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

     1405       symbolHandle sym = symbolHandle(THREAD, instanceKlass::cast(k)->generic_signature());

     1406       if (sym.is_null()) return NULL;

     1407       Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);

     1408       return (jstring) JNIHandles::make_local(env, str());

     1409     }

     1410   }

     1411   return NULL;

     1412 JVM_END

     1413 

     1414 

     1415 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls))

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

     1417   JVMWrapper("JVM_GetClassAnnotations");

     1418   ResourceMark rm(THREAD);

     1419   // Return null for arrays and primitives

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

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

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

     1423       return (jbyteArray) JNIHandles::make_local(env,

     1424                                   instanceKlass::cast(k)->class_annotations());

     1425     }

     1426   }

     1427   return NULL;

     1428 JVM_END

     1429 

     1430 

     1431 JVM_ENTRY(jbyteArray, JVM_GetFieldAnnotations(JNIEnv *env, jobject field))

     1432   assert(field != NULL, "illegal field");

     1433   JVMWrapper("JVM_GetFieldAnnotations");

     1434 

     1435   // some of this code was adapted from from jni_FromReflectedField

     1436 

     1437   // field is a handle to a java.lang.reflect.Field object

     1438   oop reflected = JNIHandles::resolve_non_null(field);

     1439   oop mirror    = java_lang_reflect_Field::clazz(reflected);

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

     1441   int slot      = java_lang_reflect_Field::slot(reflected);

     1442   int modifiers = java_lang_reflect_Field::modifiers(reflected);

     1443 

     1444   fieldDescriptor fd;

     1445   KlassHandle kh(THREAD, k);

     1446   intptr_t offset = instanceKlass::cast(kh())->offset_from_fields(slot);

     1447 

     1448   if (modifiers & JVM_ACC_STATIC) {

     1449     // for static fields we only look in the current class

     1450     if (!instanceKlass::cast(kh())->find_local_field_from_offset(offset,

     1451                                                                  true, &fd)) {

     1452       assert(false, "cannot find static field");

     1453       return NULL;  // robustness

     1454     }

     1455   } else {

     1456     // for instance fields we start with the current class and work

     1457     // our way up through the superclass chain

     1458     if (!instanceKlass::cast(kh())->find_field_from_offset(offset, false,

     1459                                                            &fd)) {

     1460       assert(false, "cannot find instance field");

     1461       return NULL;  // robustness

     1462     }

     1463   }

     1464 

     1465   return (jbyteArray) JNIHandles::make_local(env, fd.annotations());

     1466 JVM_END

     1467 

     1468 

     1469 static methodOop jvm_get_method_common(jobject method, TRAPS) {

     1470   // some of this code was adapted from from jni_FromReflectedMethod

     1471 

     1472   oop reflected = JNIHandles::resolve_non_null(method);

     1473   oop mirror    = NULL;

     1474   int slot      = 0;

     1475 

     1476   if (reflected->klass() == SystemDictionary::reflect_constructor_klass()) {

     1477     mirror = java_lang_reflect_Constructor::clazz(reflected);

     1478     slot   = java_lang_reflect_Constructor::slot(reflected);

     1479   } else {

     1480     assert(reflected->klass() == SystemDictionary::reflect_method_klass(),

     1481            "wrong type");

     1482     mirror = java_lang_reflect_Method::clazz(reflected);

     1483     slot   = java_lang_reflect_Method::slot(reflected);

     1484   }

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

     1486 

     1487   KlassHandle kh(THREAD, k);

     1488   methodOop m = instanceKlass::cast(kh())->method_with_idnum(slot);

     1489   if (m == NULL) {

     1490     assert(false, "cannot find method");

     1491     return NULL;  // robustness

     1492   }

     1493 

     1494   return m;

     1495 }

     1496 

     1497 

     1498 JVM_ENTRY(jbyteArray, JVM_GetMethodAnnotations(JNIEnv *env, jobject method))

     1499   JVMWrapper("JVM_GetMethodAnnotations");

     1500 

     1501   // method is a handle to a java.lang.reflect.Method object

     1502   methodOop m = jvm_get_method_common(method, CHECK_NULL);

     1503   return (jbyteArray) JNIHandles::make_local(env, m->annotations());

     1504 JVM_END

     1505 

     1506 

     1507 JVM_ENTRY(jbyteArray, JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method))

     1508   JVMWrapper("JVM_GetMethodDefaultAnnotationValue");

     1509 

     1510   // method is a handle to a java.lang.reflect.Method object

     1511   methodOop m = jvm_get_method_common(method, CHECK_NULL);

     1512   return (jbyteArray) JNIHandles::make_local(env, m->annotation_default());

     1513 JVM_END

     1514 

     1515 

     1516 JVM_ENTRY(jbyteArray, JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method))

     1517   JVMWrapper("JVM_GetMethodParameterAnnotations");

     1518 

     1519   // method is a handle to a java.lang.reflect.Method object

     1520   methodOop m = jvm_get_method_common(method, CHECK_NULL);

     1521   return (jbyteArray) JNIHandles::make_local(env, m->parameter_annotations());

     1522 JVM_END

     1523 

     1524 

     1525 // New (JDK 1.4) reflection implementation /////////////////////////////////////

     1526 

     1527 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly))

     1528 {

     1529   JVMWrapper("JVM_GetClassDeclaredFields");

     1530   JvmtiVMObjectAllocEventCollector oam;

     1531 

     1532   // Exclude primitive types and array types

     1533   if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||

     1534       Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {

     1535     // Return empty array

     1536     oop res = oopFactory::new_objArray(SystemDictionary::reflect_field_klass(), 0, CHECK_NULL);

     1537     return (jobjectArray) JNIHandles::make_local(env, res);

     1538   }

     1539 

     1540   instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));

     1541   constantPoolHandle cp(THREAD, k->constants());

     1542 

     1543   // Ensure class is linked

     1544   k->link_class(CHECK_NULL);

     1545 

     1546   typeArrayHandle fields(THREAD, k->fields());

     1547   int fields_len = fields->length();

     1548 

     1549   // 4496456 We need to filter out java.lang.Throwable.backtrace

     1550   bool skip_backtrace = false;

     1551 

     1552   // Allocate result

     1553   int num_fields;

     1554 

     1555   if (publicOnly) {

     1556     num_fields = 0;

     1557     for (int i = 0, j = 0; i < fields_len; i += instanceKlass::next_offset, j++) {

     1558       int mods = fields->ushort_at(i + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS;

     1559       if (mods & JVM_ACC_PUBLIC) ++num_fields;

     1560     }

     1561   } else {

     1562     num_fields = fields_len / instanceKlass::next_offset;

     1563 

     1564     if (k() == SystemDictionary::throwable_klass()) {

     1565       num_fields--;

     1566       skip_backtrace = true;

     1567     }

     1568   }

     1569 

     1570   objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_field_klass(), num_fields, CHECK_NULL);

     1571   objArrayHandle result (THREAD, r);

     1572 

     1573   int out_idx = 0;

     1574   fieldDescriptor fd;

     1575   for (int i = 0; i < fields_len; i += instanceKlass::next_offset) {

     1576     if (skip_backtrace) {

     1577       // 4496456 skip java.lang.Throwable.backtrace

     1578       int offset = k->offset_from_fields(i);

     1579       if (offset == java_lang_Throwable::get_backtrace_offset()) continue;

     1580     }

     1581 

     1582     int mods = fields->ushort_at(i + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS;

     1583     if (!publicOnly || (mods & JVM_ACC_PUBLIC)) {

     1584       fd.initialize(k(), i);

     1585       oop field = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL);

     1586       result->obj_at_put(out_idx, field);

     1587       ++out_idx;

     1588     }

     1589   }

     1590   assert(out_idx == num_fields, "just checking");

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

     1592 }

     1593 JVM_END

     1594 

     1595 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))

     1596 {

     1597   JVMWrapper("JVM_GetClassDeclaredMethods");

     1598   JvmtiVMObjectAllocEventCollector oam;

     1599 

     1600   // Exclude primitive types and array types

     1601   if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))

     1602       || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {

     1603     // Return empty array

     1604     oop res = oopFactory::new_objArray(SystemDictionary::reflect_method_klass(), 0, CHECK_NULL);

     1605     return (jobjectArray) JNIHandles::make_local(env, res);

     1606   }

     1607 

     1608   instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));

     1609 

     1610   // Ensure class is linked

     1611   k->link_class(CHECK_NULL);

     1612 

     1613   objArrayHandle methods (THREAD, k->methods());

     1614   int methods_length = methods->length();

     1615   int num_methods = 0;

     1616 

     1617   int i;

     1618   for (i = 0; i < methods_length; i++) {

     1619     methodHandle method(THREAD, (methodOop) methods->obj_at(i));

     1620     if (!method->is_initializer()) {

     1621       if (!publicOnly || method->is_public()) {

     1622         ++num_methods;

     1623       }

     1624     }

     1625   }

     1626 

     1627   // Allocate result

     1628   objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_method_klass(), num_methods, CHECK_NULL);

     1629   objArrayHandle result (THREAD, r);

     1630 

     1631   int out_idx = 0;

     1632   for (i = 0; i < methods_length; i++) {

     1633     methodHandle method(THREAD, (methodOop) methods->obj_at(i));

     1634     if (!method->is_initializer()) {

     1635       if (!publicOnly || method->is_public()) {

     1636         oop m = Reflection::new_method(method, UseNewReflection, false, CHECK_NULL);

     1637         result->obj_at_put(out_idx, m);

     1638         ++out_idx;

     1639       }

     1640     }

     1641   }

     1642   assert(out_idx == num_methods, "just checking");

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

     1644 }

     1645 JVM_END

     1646 

     1647 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))

     1648 {

     1649   JVMWrapper("JVM_GetClassDeclaredConstructors");

     1650   JvmtiVMObjectAllocEventCollector oam;

     1651 

     1652   // Exclude primitive types and array types

     1653   if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))

     1654       || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {

     1655     // Return empty array

     1656     oop res = oopFactory::new_objArray(SystemDictionary::reflect_constructor_klass(), 0 , CHECK_NULL);

     1657     return (jobjectArray) JNIHandles::make_local(env, res);

     1658   }

     1659 

     1660   instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));

     1661 

     1662   // Ensure class is linked

     1663   k->link_class(CHECK_NULL);

     1664 

     1665   objArrayHandle methods (THREAD, k->methods());

     1666   int methods_length = methods->length();

     1667   int num_constructors = 0;

     1668 

     1669   int i;

     1670   for (i = 0; i < methods_length; i++) {

     1671     methodHandle method(THREAD, (methodOop) methods->obj_at(i));

     1672     if (method->is_initializer() && !method->is_static()) {

     1673       if (!publicOnly || method->is_public()) {

     1674         ++num_constructors;

     1675       }

     1676     }

     1677   }

     1678 

     1679   // Allocate result

     1680   objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_constructor_klass(), num_constructors, CHECK_NULL);

     1681   objArrayHandle result(THREAD, r);

     1682 

     1683   int out_idx = 0;

     1684   for (i = 0; i < methods_length; i++) {

     1685     methodHandle method(THREAD, (methodOop) methods->obj_at(i));

     1686     if (method->is_initializer() && !method->is_static()) {

     1687       if (!publicOnly || method->is_public()) {

     1688         oop m = Reflection::new_constructor(method, CHECK_NULL);

     1689         result->obj_at_put(out_idx, m);

     1690         ++out_idx;

     1691       }

     1692     }

     1693   }

     1694   assert(out_idx == num_constructors, "just checking");

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

     1696 }

     1697 JVM_END

     1698 

     1699 JVM_ENTRY(jint, JVM_GetClassAccessFlags(JNIEnv *env, jclass cls))

     1700 {

     1701   JVMWrapper("JVM_GetClassAccessFlags");

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

     1703     // Primitive type

     1704     return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;

     1705   }

     1706 

     1707   Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)));

     1708   return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS;

     1709 }

     1710 JVM_END

     1711 

     1712 

     1713 // Constant pool access //////////////////////////////////////////////////////////

     1714 

     1715 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls))

     1716 {

     1717   JVMWrapper("JVM_GetClassConstantPool");

     1718   JvmtiVMObjectAllocEventCollector oam;

     1719 

     1720   // Return null for primitives and arrays

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

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

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

     1724       instanceKlassHandle k_h(THREAD, k);

     1725       Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL);

     1726       sun_reflect_ConstantPool::set_cp_oop(jcp(), k_h->constants());

     1727       return JNIHandles::make_local(jcp());

     1728     }

     1729   }

     1730   return NULL;

     1731 }

     1732 JVM_END

     1733 

     1734 

     1735 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool))

     1736 {

     1737   JVMWrapper("JVM_ConstantPoolGetSize");

     1738   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1739   return cp->length();

     1740 }

     1741 JVM_END

     1742 

     1743 

     1744 static void bounds_check(constantPoolHandle cp, jint index, TRAPS) {

     1745   if (!cp->is_within_bounds(index)) {

     1746     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds");

     1747   }

     1748 }

     1749 

     1750 

     1751 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1752 {

     1753   JVMWrapper("JVM_ConstantPoolGetClassAt");

     1754   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1755   bounds_check(cp, index, CHECK_NULL);

     1756   constantTag tag = cp->tag_at(index);

     1757   if (!tag.is_klass() && !tag.is_unresolved_klass()) {

     1758     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1759   }

     1760   klassOop k = cp->klass_at(index, CHECK_NULL);

     1761   return (jclass) JNIHandles::make_local(k->klass_part()->java_mirror());

     1762 }

     1763 JVM_END

     1764 

     1765 

     1766 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1767 {

     1768   JVMWrapper("JVM_ConstantPoolGetClassAtIfLoaded");

     1769   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1770   bounds_check(cp, index, CHECK_NULL);

     1771   constantTag tag = cp->tag_at(index);

     1772   if (!tag.is_klass() && !tag.is_unresolved_klass()) {

     1773     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1774   }

     1775   klassOop k = constantPoolOopDesc::klass_at_if_loaded(cp, index);

     1776   if (k == NULL) return NULL;

     1777   return (jclass) JNIHandles::make_local(k->klass_part()->java_mirror());

     1778 }

     1779 JVM_END

     1780 

     1781 static jobject get_method_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) {

     1782   constantTag tag = cp->tag_at(index);

     1783   if (!tag.is_method() && !tag.is_interface_method()) {

     1784     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1785   }

     1786   int klass_ref  = cp->uncached_klass_ref_index_at(index);

     1787   klassOop k_o;

     1788   if (force_resolution) {

     1789     k_o = cp->klass_at(klass_ref, CHECK_NULL);

     1790   } else {

     1791     k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref);

     1792     if (k_o == NULL) return NULL;

     1793   }

     1794   instanceKlassHandle k(THREAD, k_o);

     1795   symbolOop name = cp->uncached_name_ref_at(index);

     1796   symbolOop sig  = cp->uncached_signature_ref_at(index);

     1797   methodHandle m (THREAD, k->find_method(name, sig));

     1798   if (m.is_null()) {

     1799     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");

     1800   }

     1801   oop method;

     1802   if (!m->is_initializer() || m->is_static()) {

     1803     method = Reflection::new_method(m, true, true, CHECK_NULL);

     1804   } else {

     1805     method = Reflection::new_constructor(m, CHECK_NULL);

     1806   }

     1807   return JNIHandles::make_local(method);

     1808 }

     1809 

     1810 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1811 {

     1812   JVMWrapper("JVM_ConstantPoolGetMethodAt");

     1813   JvmtiVMObjectAllocEventCollector oam;

     1814   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1815   bounds_check(cp, index, CHECK_NULL);

     1816   jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);

     1817   return res;

     1818 }

     1819 JVM_END

     1820 

     1821 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1822 {

     1823   JVMWrapper("JVM_ConstantPoolGetMethodAtIfLoaded");

     1824   JvmtiVMObjectAllocEventCollector oam;

     1825   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1826   bounds_check(cp, index, CHECK_NULL);

     1827   jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);

     1828   return res;

     1829 }

     1830 JVM_END

     1831 

     1832 static jobject get_field_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) {

     1833   constantTag tag = cp->tag_at(index);

     1834   if (!tag.is_field()) {

     1835     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1836   }

     1837   int klass_ref  = cp->uncached_klass_ref_index_at(index);

     1838   klassOop k_o;

     1839   if (force_resolution) {

     1840     k_o = cp->klass_at(klass_ref, CHECK_NULL);

     1841   } else {

     1842     k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref);

     1843     if (k_o == NULL) return NULL;

     1844   }

     1845   instanceKlassHandle k(THREAD, k_o);

     1846   symbolOop name = cp->uncached_name_ref_at(index);

     1847   symbolOop sig  = cp->uncached_signature_ref_at(index);

     1848   fieldDescriptor fd;

     1849   klassOop target_klass = k->find_field(name, sig, &fd);

     1850   if (target_klass == NULL) {

     1851     THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");

     1852   }

     1853   oop field = Reflection::new_field(&fd, true, CHECK_NULL);

     1854   return JNIHandles::make_local(field);

     1855 }

     1856 

     1857 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1858 {

     1859   JVMWrapper("JVM_ConstantPoolGetFieldAt");

     1860   JvmtiVMObjectAllocEventCollector oam;

     1861   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1862   bounds_check(cp, index, CHECK_NULL);

     1863   jobject res = get_field_at_helper(cp, index, true, CHECK_NULL);

     1864   return res;

     1865 }

     1866 JVM_END

     1867 

     1868 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1869 {

     1870   JVMWrapper("JVM_ConstantPoolGetFieldAtIfLoaded");

     1871   JvmtiVMObjectAllocEventCollector oam;

     1872   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1873   bounds_check(cp, index, CHECK_NULL);

     1874   jobject res = get_field_at_helper(cp, index, false, CHECK_NULL);

     1875   return res;

     1876 }

     1877 JVM_END

     1878 

     1879 JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1880 {

     1881   JVMWrapper("JVM_ConstantPoolGetMemberRefInfoAt");

     1882   JvmtiVMObjectAllocEventCollector oam;

     1883   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1884   bounds_check(cp, index, CHECK_NULL);

     1885   constantTag tag = cp->tag_at(index);

     1886   if (!tag.is_field_or_method()) {

     1887     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1888   }

     1889   int klass_ref = cp->uncached_klass_ref_index_at(index);

     1890   symbolHandle klass_name (THREAD, cp->klass_name_at(klass_ref));

     1891   symbolHandle member_name(THREAD, cp->uncached_name_ref_at(index));

     1892   symbolHandle member_sig (THREAD, cp->uncached_signature_ref_at(index));

     1893   objArrayOop  dest_o = oopFactory::new_objArray(SystemDictionary::string_klass(), 3, CHECK_NULL);

     1894   objArrayHandle dest(THREAD, dest_o);

     1895   Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL);

     1896   dest->obj_at_put(0, str());

     1897   str = java_lang_String::create_from_symbol(member_name, CHECK_NULL);

     1898   dest->obj_at_put(1, str());

     1899   str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL);

     1900   dest->obj_at_put(2, str());

     1901   return (jobjectArray) JNIHandles::make_local(dest());

     1902 }

     1903 JVM_END

     1904 

     1905 JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1906 {

     1907   JVMWrapper("JVM_ConstantPoolGetIntAt");

     1908   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1909   bounds_check(cp, index, CHECK_0);

     1910   constantTag tag = cp->tag_at(index);

     1911   if (!tag.is_int()) {

     1912     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1913   }

     1914   return cp->int_at(index);

     1915 }

     1916 JVM_END

     1917 

     1918 JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1919 {

     1920   JVMWrapper("JVM_ConstantPoolGetLongAt");

     1921   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1922   bounds_check(cp, index, CHECK_(0L));

     1923   constantTag tag = cp->tag_at(index);

     1924   if (!tag.is_long()) {

     1925     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1926   }

     1927   return cp->long_at(index);

     1928 }

     1929 JVM_END

     1930 

     1931 JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1932 {

     1933   JVMWrapper("JVM_ConstantPoolGetFloatAt");

     1934   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1935   bounds_check(cp, index, CHECK_(0.0f));

     1936   constantTag tag = cp->tag_at(index);

     1937   if (!tag.is_float()) {

     1938     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1939   }

     1940   return cp->float_at(index);

     1941 }

     1942 JVM_END

     1943 

     1944 JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1945 {

     1946   JVMWrapper("JVM_ConstantPoolGetDoubleAt");

     1947   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1948   bounds_check(cp, index, CHECK_(0.0));

     1949   constantTag tag = cp->tag_at(index);

     1950   if (!tag.is_double()) {

     1951     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1952   }

     1953   return cp->double_at(index);

     1954 }

     1955 JVM_END

     1956 

     1957 JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1958 {

     1959   JVMWrapper("JVM_ConstantPoolGetStringAt");

     1960   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1961   bounds_check(cp, index, CHECK_NULL);

     1962   constantTag tag = cp->tag_at(index);

     1963   if (!tag.is_string() && !tag.is_unresolved_string()) {

     1964     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1965   }

     1966   oop str = cp->string_at(index, CHECK_NULL);

     1967   return (jstring) JNIHandles::make_local(str);

     1968 }

     1969 JVM_END

     1970 

     1971 JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index))

     1972 {

     1973   JVMWrapper("JVM_ConstantPoolGetUTF8At");

     1974   JvmtiVMObjectAllocEventCollector oam;

     1975   constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));

     1976   bounds_check(cp, index, CHECK_NULL);

     1977   constantTag tag = cp->tag_at(index);

     1978   if (!tag.is_symbol()) {

     1979     THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");

     1980   }

     1981   symbolOop sym_o = cp->symbol_at(index);

     1982   symbolHandle sym(THREAD, sym_o);

     1983   Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);

     1984   return (jstring) JNIHandles::make_local(str());

     1985 }

     1986 JVM_END

     1987 

     1988 

     1989 // Assertion support. //////////////////////////////////////////////////////////

     1990 

     1991 JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls))

     1992   JVMWrapper("JVM_DesiredAssertionStatus");

     1993   assert(cls != NULL, "bad class");

     1994 

     1995   oop r = JNIHandles::resolve(cls);

     1996   assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed");

     1997   if (java_lang_Class::is_primitive(r)) return false;

     1998 

     1999   klassOop k = java_lang_Class::as_klassOop(r);

     2000   assert(Klass::cast(k)->oop_is_instance(), "must be an instance klass");

     2001   if (! Klass::cast(k)->oop_is_instance()) return false;

     2002 

     2003   ResourceMark rm(THREAD);

     2004   const char* name = Klass::cast(k)->name()->as_C_string();

     2005   bool system_class = Klass::cast(k)->class_loader() == NULL;

     2006   return JavaAssertions::enabled(name, system_class);

     2007 

     2008 JVM_END

     2009 

     2010 

     2011 // Return a new AssertionStatusDirectives object with the fields filled in with

     2012 // command-line assertion arguments (i.e., -ea, -da).

     2013 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))

     2014   JVMWrapper("JVM_AssertionStatusDirectives");

     2015   JvmtiVMObjectAllocEventCollector oam;

     2016   oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);

     2017   return JNIHandles::make_local(env, asd);

     2018 JVM_END

     2019 

     2020 // Verification ////////////////////////////////////////////////////////////////////////////////

     2021 

     2022 // Reflection for the verifier /////////////////////////////////////////////////////////////////

     2023 

     2024 // RedefineClasses support: bug 6214132 caused verification to fail.

     2025 // All functions from this section should call the jvmtiThreadSate function:

     2026 //   klassOop class_to_verify_considering_redefinition(klassOop klass).

     2027 // The function returns a klassOop of the _scratch_class if the verifier

     2028 // was invoked in the middle of the class redefinition.

     2029 // Otherwise it returns its argument value which is the _the_class klassOop.

     2030 // Please, refer to the description in the jvmtiThreadSate.hpp.

     2031 

     2032 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))

     2033   JVMWrapper("JVM_GetClassNameUTF");

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

     2035   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2036   return Klass::cast(k)->name()->as_utf8();

     2037 JVM_END

     2038 

     2039 

     2040 JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))

     2041   JVMWrapper("JVM_GetClassCPTypes");

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

     2043   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2044   // types will have length zero if this is not an instanceKlass

     2045   // (length is determined by call to JVM_GetClassCPEntriesCount)

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

     2047     constantPoolOop cp = instanceKlass::cast(k)->constants();

     2048     for (int index = cp->length() - 1; index >= 0; index--) {

     2049       constantTag tag = cp->tag_at(index);

     2050       types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class :

     2051                      (tag.is_unresolved_string()) ? JVM_CONSTANT_String : tag.value();

     2052   }

     2053   }

     2054 JVM_END

     2055 

     2056 

     2057 JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))

     2058   JVMWrapper("JVM_GetClassCPEntriesCount");

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

     2060   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2061   if (!Klass::cast(k)->oop_is_instance())

     2062     return 0;

     2063   return instanceKlass::cast(k)->constants()->length();

     2064 JVM_END

     2065 

     2066 

     2067 JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))

     2068   JVMWrapper("JVM_GetClassFieldsCount");

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

     2070   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2071   if (!Klass::cast(k)->oop_is_instance())

     2072     return 0;

     2073   return instanceKlass::cast(k)->fields()->length() / instanceKlass::next_offset;

     2074 JVM_END

     2075 

     2076 

     2077 JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))

     2078   JVMWrapper("JVM_GetClassMethodsCount");

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

     2080   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2081   if (!Klass::cast(k)->oop_is_instance())

     2082     return 0;

     2083   return instanceKlass::cast(k)->methods()->length();

     2084 JVM_END

     2085 

     2086 

     2087 // The following methods, used for the verifier, are never called with

     2088 // array klasses, so a direct cast to instanceKlass is safe.

     2089 // Typically, these methods are called in a loop with bounds determined

     2090 // by the results of JVM_GetClass{Fields,Methods}Count, which return

     2091 // zero for arrays.

     2092 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions))

     2093   JVMWrapper("JVM_GetMethodIxExceptionIndexes");

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

     2095   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2096   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2097   int length = methodOop(method)->checked_exceptions_length();

     2098   if (length > 0) {

     2099     CheckedExceptionElement* table= methodOop(method)->checked_exceptions_start();

     2100     for (int i = 0; i < length; i++) {

     2101       exceptions[i] = table[i].class_cp_index;

     2102     }

     2103   }

     2104 JVM_END

     2105 

     2106 

     2107 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index))

     2108   JVMWrapper("JVM_GetMethodIxExceptionsCount");

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

     2110   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2111   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2112   return methodOop(method)->checked_exceptions_length();

     2113 JVM_END

     2114 

     2115 

     2116 JVM_QUICK_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code))

     2117   JVMWrapper("JVM_GetMethodIxByteCode");

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

     2119   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2120   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2121   memcpy(code, methodOop(method)->code_base(), methodOop(method)->code_size());

     2122 JVM_END

     2123 

     2124 

     2125 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index))

     2126   JVMWrapper("JVM_GetMethodIxByteCodeLength");

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

     2128   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2129   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2130   return methodOop(method)->code_size();

     2131 JVM_END

     2132 

     2133 

     2134 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry))

     2135   JVMWrapper("JVM_GetMethodIxExceptionTableEntry");

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

     2137   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2138   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2139   typeArrayOop extable = methodOop(method)->exception_table();

     2140   entry->start_pc   = extable->int_at(entry_index * 4);

     2141   entry->end_pc     = extable->int_at(entry_index * 4 + 1);

     2142   entry->handler_pc = extable->int_at(entry_index * 4 + 2);

     2143   entry->catchType  = extable->int_at(entry_index * 4 + 3);

     2144 JVM_END

     2145 

     2146 

     2147 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index))

     2148   JVMWrapper("JVM_GetMethodIxExceptionTableLength");

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

     2150   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2151   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2152   return methodOop(method)->exception_table()->length() / 4;

     2153 JVM_END

     2154 

     2155 

     2156 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index))

     2157   JVMWrapper("JVM_GetMethodIxModifiers");

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

     2159   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2160   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2161   return methodOop(method)->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;

     2162 JVM_END

     2163 

     2164 

     2165 JVM_QUICK_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index))

     2166   JVMWrapper("JVM_GetFieldIxModifiers");

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

     2168   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2169   typeArrayOop fields = instanceKlass::cast(k)->fields();

     2170   return fields->ushort_at(field_index * instanceKlass::next_offset + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS;

     2171 JVM_END

     2172 

     2173 

     2174 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index))

     2175   JVMWrapper("JVM_GetMethodIxLocalsCount");

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

     2177   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2178   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2179   return methodOop(method)->max_locals();

     2180 JVM_END

     2181 

     2182 

     2183 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))

     2184   JVMWrapper("JVM_GetMethodIxArgsSize");

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

     2186   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2187   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2188   return methodOop(method)->size_of_parameters();

     2189 JVM_END

     2190 

     2191 

     2192 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))

     2193   JVMWrapper("JVM_GetMethodIxMaxStack");

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

     2195   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2196   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2197   return methodOop(method)->max_stack();

     2198 JVM_END

     2199 

     2200 

     2201 JVM_QUICK_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))

     2202   JVMWrapper("JVM_IsConstructorIx");

     2203   ResourceMark rm(THREAD);

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

     2205   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2206   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2207   return methodOop(method)->name() == vmSymbols::object_initializer_name();

     2208 JVM_END

     2209 

     2210 

     2211 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))

     2212   JVMWrapper("JVM_GetMethodIxIxUTF");

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

     2214   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2215   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2216   return methodOop(method)->name()->as_utf8();

     2217 JVM_END

     2218 

     2219 

     2220 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))

     2221   JVMWrapper("JVM_GetMethodIxSignatureUTF");

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

     2223   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2224   oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);

     2225   return methodOop(method)->signature()->as_utf8();

     2226 JVM_END

     2227 

     2228 /**

     2229  * All of these JVM_GetCP-xxx methods are used by the old verifier to

     2230  * read entries in the constant pool.  Since the old verifier always

     2231  * works on a copy of the code, it will not see any rewriting that

     2232  * may possibly occur in the middle of verification.  So it is important

     2233  * that nothing it calls tries to use the cpCache instead of the raw

     2234  * constant pool, so we must use cp->uncached_x methods when appropriate.

     2235  */

     2236 JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index))

     2237   JVMWrapper("JVM_GetCPFieldNameUTF");

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

     2239   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2240   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2241   switch (cp->tag_at(cp_index).value()) {

     2242     case JVM_CONSTANT_Fieldref:

     2243       return cp->uncached_name_ref_at(cp_index)->as_utf8();

     2244     default:

     2245       fatal("JVM_GetCPFieldNameUTF: illegal constant");

     2246   }

     2247   ShouldNotReachHere();

     2248   return NULL;

     2249 JVM_END

     2250 

     2251 

     2252 JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index))

     2253   JVMWrapper("JVM_GetCPMethodNameUTF");

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

     2255   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2256   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2257   switch (cp->tag_at(cp_index).value()) {

     2258     case JVM_CONSTANT_InterfaceMethodref:

     2259     case JVM_CONSTANT_Methodref:

     2260       return cp->uncached_name_ref_at(cp_index)->as_utf8();

     2261     case JVM_CONSTANT_NameAndType:

     2262       // for invokedynamic

     2263       return cp->nt_name_ref_at(cp_index)->as_utf8();

     2264     default:

     2265       fatal("JVM_GetCPMethodNameUTF: illegal constant");

     2266   }

     2267   ShouldNotReachHere();

     2268   return NULL;

     2269 JVM_END

     2270 

     2271 

     2272 JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))

     2273   JVMWrapper("JVM_GetCPMethodSignatureUTF");

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

     2275   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2276   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2277   switch (cp->tag_at(cp_index).value()) {

     2278     case JVM_CONSTANT_InterfaceMethodref:

     2279     case JVM_CONSTANT_Methodref:

     2280       return cp->uncached_signature_ref_at(cp_index)->as_utf8();

     2281     case JVM_CONSTANT_NameAndType:

     2282       // for invokedynamic

     2283       return cp->nt_signature_ref_at(cp_index)->as_utf8();

     2284     default:

     2285       fatal("JVM_GetCPMethodSignatureUTF: illegal constant");

     2286   }

     2287   ShouldNotReachHere();

     2288   return NULL;

     2289 JVM_END

     2290 

     2291 

     2292 JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))

     2293   JVMWrapper("JVM_GetCPFieldSignatureUTF");

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

     2295   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2296   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2297   switch (cp->tag_at(cp_index).value()) {

     2298     case JVM_CONSTANT_Fieldref:

     2299       return cp->uncached_signature_ref_at(cp_index)->as_utf8();

     2300     default:

     2301       fatal("JVM_GetCPFieldSignatureUTF: illegal constant");

     2302   }

     2303   ShouldNotReachHere();

     2304   return NULL;

     2305 JVM_END

     2306 

     2307 

     2308 JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))

     2309   JVMWrapper("JVM_GetCPClassNameUTF");

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

     2311   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2312   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2313   symbolOop classname = cp->klass_name_at(cp_index);

     2314   return classname->as_utf8();

     2315 JVM_END

     2316 

     2317 

     2318 JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))

     2319   JVMWrapper("JVM_GetCPFieldClassNameUTF");

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

     2321   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2322   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2323   switch (cp->tag_at(cp_index).value()) {

     2324     case JVM_CONSTANT_Fieldref: {

     2325       int class_index = cp->uncached_klass_ref_index_at(cp_index);

     2326       symbolOop classname = cp->klass_name_at(class_index);

     2327       return classname->as_utf8();

     2328     }

     2329     default:

     2330       fatal("JVM_GetCPFieldClassNameUTF: illegal constant");

     2331   }

     2332   ShouldNotReachHere();

     2333   return NULL;

     2334 JVM_END

     2335 

     2336 

     2337 JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))

     2338   JVMWrapper("JVM_GetCPMethodClassNameUTF");

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

     2340   k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2341   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2342   switch (cp->tag_at(cp_index).value()) {

     2343     case JVM_CONSTANT_Methodref:

     2344     case JVM_CONSTANT_InterfaceMethodref: {

     2345       int class_index = cp->uncached_klass_ref_index_at(cp_index);

     2346       symbolOop classname = cp->klass_name_at(class_index);

     2347       return classname->as_utf8();

     2348     }

     2349     default:

     2350       fatal("JVM_GetCPMethodClassNameUTF: illegal constant");

     2351   }

     2352   ShouldNotReachHere();

     2353   return NULL;

     2354 JVM_END

     2355 

     2356 

     2357 JVM_QUICK_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))

     2358   JVMWrapper("JVM_GetCPFieldModifiers");

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

     2360   klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls));

     2361   k        = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2362   k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);

     2363   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2364   constantPoolOop cp_called = instanceKlass::cast(k_called)->constants();

     2365   switch (cp->tag_at(cp_index).value()) {

     2366     case JVM_CONSTANT_Fieldref: {

     2367       symbolOop name      = cp->uncached_name_ref_at(cp_index);

     2368       symbolOop signature = cp->uncached_signature_ref_at(cp_index);

     2369       typeArrayOop fields = instanceKlass::cast(k_called)->fields();

     2370       int fields_count = fields->length();

     2371       for (int i = 0; i < fields_count; i += instanceKlass::next_offset) {

     2372         if (cp_called->symbol_at(fields->ushort_at(i + instanceKlass::name_index_offset)) == name &&

     2373             cp_called->symbol_at(fields->ushort_at(i + instanceKlass::signature_index_offset)) == signature) {

     2374           return fields->ushort_at(i + instanceKlass::access_flags_offset) & JVM_RECOGNIZED_FIELD_MODIFIERS;

     2375         }

     2376       }

     2377       return -1;

     2378     }

     2379     default:

     2380       fatal("JVM_GetCPFieldModifiers: illegal constant");

     2381   }

     2382   ShouldNotReachHere();

     2383   return 0;

     2384 JVM_END

     2385 

     2386 

     2387 JVM_QUICK_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))

     2388   JVMWrapper("JVM_GetCPMethodModifiers");

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

     2390   klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls));

     2391   k        = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);

     2392   k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);

     2393   constantPoolOop cp = instanceKlass::cast(k)->constants();

     2394   switch (cp->tag_at(cp_index).value()) {

     2395     case JVM_CONSTANT_Methodref:

     2396     case JVM_CONSTANT_InterfaceMethodref: {

     2397       symbolOop name      = cp->uncached_name_ref_at(cp_index);

     2398       symbolOop signature = cp->uncached_signature_ref_at(cp_index);

     2399       objArrayOop methods = instanceKlass::cast(k_called)->methods();

     2400       int methods_count = methods->length();

     2401       for (int i = 0; i < methods_count; i++) {

     2402         methodOop method = methodOop(methods->obj_at(i));

     2403         if (method->name() == name && method->signature() == signature) {

     2404             return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;

     2405         }

     2406       }

     2407       return -1;

     2408     }

     2409     default:

     2410       fatal("JVM_GetCPMethodModifiers: illegal constant");

     2411   }

     2412   ShouldNotReachHere();

     2413   return 0;

     2414 JVM_END

     2415 

     2416 

     2417 // Misc //////////////////////////////////////////////////////////////////////////////////////////////

     2418 

     2419 JVM_LEAF(void, JVM_ReleaseUTF(const char *utf))

     2420   // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything

     2421 JVM_END

     2422 

     2423 

     2424 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2))

     2425   JVMWrapper("JVM_IsSameClassPackage");

     2426   oop class1_mirror = JNIHandles::resolve_non_null(class1);

     2427   oop class2_mirror = JNIHandles::resolve_non_null(class2);

     2428   klassOop klass1 = java_lang_Class::as_klassOop(class1_mirror);

     2429   klassOop klass2 = java_lang_Class::as_klassOop(class2_mirror);

     2430   return (jboolean) Reflection::is_same_class_package(klass1, klass2);

     2431 JVM_END

     2432 

     2433 

     2434 // IO functions ////////////////////////////////////////////////////////////////////////////////////////

     2435 

     2436 JVM_LEAF(jint, JVM_Open(const char *fname, jint flags, jint mode))

     2437   JVMWrapper2("JVM_Open (%s)", fname);

     2438 

     2439   //%note jvm_r6

     2440   int result = hpi::open(fname, flags, mode);

     2441   if (result >= 0) {

     2442     return result;

     2443   } else {

     2444     switch(errno) {

     2445       case EEXIST:

     2446         return JVM_EEXIST;

     2447       default:

     2448         return -1;

     2449     }

     2450   }

     2451 JVM_END

     2452 

     2453 

     2454 JVM_LEAF(jint, JVM_Close(jint fd))

     2455   JVMWrapper2("JVM_Close (0x%x)", fd);

     2456   //%note jvm_r6

     2457   return hpi::close(fd);

     2458 JVM_END

     2459 

     2460 

     2461 JVM_LEAF(jint, JVM_Read(jint fd, char *buf, jint nbytes))

     2462   JVMWrapper2("JVM_Read (0x%x)", fd);

     2463 

     2464   //%note jvm_r6

     2465   return (jint)hpi::read(fd, buf, nbytes);

     2466 JVM_END

     2467 

     2468 

     2469 JVM_LEAF(jint, JVM_Write(jint fd, char *buf, jint nbytes))

     2470   JVMWrapper2("JVM_Write (0x%x)", fd);

     2471 

     2472   //%note jvm_r6

     2473   return (jint)hpi::write(fd, buf, nbytes);

     2474 JVM_END

     2475 

     2476 

     2477 JVM_LEAF(jint, JVM_Available(jint fd, jlong *pbytes))

     2478   JVMWrapper2("JVM_Available (0x%x)", fd);

     2479   //%note jvm_r6

     2480   return hpi::available(fd, pbytes);

     2481 JVM_END

     2482 

     2483 

     2484 JVM_LEAF(jlong, JVM_Lseek(jint fd, jlong offset, jint whence))

     2485   JVMWrapper4("JVM_Lseek (0x%x, %Ld, %d)", fd, offset, whence);

     2486   //%note jvm_r6

     2487   return hpi::lseek(fd, offset, whence);

     2488 JVM_END

     2489 

     2490 

     2491 JVM_LEAF(jint, JVM_SetLength(jint fd, jlong length))

     2492   JVMWrapper3("JVM_SetLength (0x%x, %Ld)", fd, length);

     2493   return hpi::ftruncate(fd, length);

     2494 JVM_END

     2495 

     2496 

     2497 JVM_LEAF(jint, JVM_Sync(jint fd))

     2498   JVMWrapper2("JVM_Sync (0x%x)", fd);

     2499   //%note jvm_r6

     2500   return hpi::fsync(fd);

     2501 JVM_END

     2502 

     2503 

     2504 // Printing support //////////////////////////////////////////////////

     2505 extern "C" {

     2506 

     2507 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {

     2508   // see bug 4399518, 4417214

     2509   if ((intptr_t)count <= 0) return -1;

     2510   return vsnprintf(str, count, fmt, args);

     2511 }

     2512 

     2513 

     2514 int jio_snprintf(char *str, size_t count, const char *fmt, ...) {

     2515   va_list args;

     2516   int len;

     2517   va_start(args, fmt);

     2518   len = jio_vsnprintf(str, count, fmt, args);

     2519   va_end(args);

     2520   return len;

     2521 }

     2522 

     2523 

     2524 int jio_fprintf(FILE* f, const char *fmt, ...) {

     2525   int len;

     2526   va_list args;

     2527   va_start(args, fmt);

     2528   len = jio_vfprintf(f, fmt, args);

     2529   va_end(args);

     2530   return len;

     2531 }

     2532 

     2533 

     2534 int jio_vfprintf(FILE* f, const char *fmt, va_list args) {

     2535   if (Arguments::vfprintf_hook() != NULL) {

     2536      return Arguments::vfprintf_hook()(f, fmt, args);

     2537   } else {

     2538     return vfprintf(f, fmt, args);

     2539   }

     2540 }

     2541 

     2542 

     2543 int jio_printf(const char *fmt, ...) {

     2544   int len;

     2545   va_list args;

     2546   va_start(args, fmt);

     2547   len = jio_vfprintf(defaultStream::output_stream(), fmt, args);

     2548   va_end(args);

     2549   return len;

     2550 }

     2551 

     2552 

     2553 // HotSpot specific jio method

     2554 void jio_print(const char* s) {

     2555   // Try to make this function as atomic as possible.

     2556   if (Arguments::vfprintf_hook() != NULL) {

     2557     jio_fprintf(defaultStream::output_stream(), "%s", s);

     2558   } else {

     2559     // Make an unused local variable to avoid warning from gcc 4.x compiler.

     2560     size_t count = ::write(defaultStream::output_fd(), s, (int)strlen(s));

     2561   }

     2562 }

     2563 

     2564 } // Extern C

     2565 

     2566 // java.lang.Thread //////////////////////////////////////////////////////////////////////////////

     2567 

     2568 // In most of the JVM Thread support functions we need to be sure to lock the Threads_lock

     2569 // to prevent the target thread from exiting after we have a pointer to the C++ Thread or

     2570 // OSThread objects.  The exception to this rule is when the target object is the thread

     2571 // doing the operation, in which case we know that the thread won't exit until the

     2572 // operation is done (all exits being voluntary).  There are a few cases where it is

     2573 // rather silly to do operations on yourself, like resuming yourself or asking whether

     2574 // you are alive.  While these can still happen, they are not subject to deadlocks if

     2575 // the lock is held while the operation occurs (this is not the case for suspend, for

     2576 // instance), and are very unlikely.  Because IsAlive needs to be fast and its

     2577 // implementation is local to this file, we always lock Threads_lock for that one.

     2578 

     2579 static void thread_entry(JavaThread* thread, TRAPS) {

     2580   HandleMark hm(THREAD);

     2581   Handle obj(THREAD, thread->threadObj());

     2582   JavaValue result(T_VOID);

     2583   JavaCalls::call_virtual(&result,

     2584                           obj,

     2585                           KlassHandle(THREAD, SystemDictionary::thread_klass()),

     2586                           vmSymbolHandles::run_method_name(),

     2587                           vmSymbolHandles::void_method_signature(),

     2588                           THREAD);

     2589 }

     2590 

     2591 

     2592 JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))

     2593   JVMWrapper("JVM_StartThread");

     2594   JavaThread *native_thread = NULL;

     2595 

     2596   // We cannot hold the Threads_lock when we throw an exception,

     2597   // due to rank ordering issues. Example:  we might need to grab the

     2598   // Heap_lock while we construct the exception.

     2599   bool throw_illegal_thread_state = false;

     2600 

     2601   // We must release the Threads_lock before we can post a jvmti event

     2602   // in Thread::start.

     2603   {

     2604     // Ensure that the C++ Thread and OSThread structures aren't freed before

     2605     // we operate.

     2606     MutexLocker mu(Threads_lock);

     2607 

     2608     // Check to see if we're running a thread that's already exited or was

     2609     // stopped (is_stillborn) or is still active (thread is not NULL).

     2610     if (java_lang_Thread::is_stillborn(JNIHandles::resolve_non_null(jthread)) ||

     2611         java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {

     2612         throw_illegal_thread_state = true;

     2613     } else {

     2614       jlong size =

     2615              java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));

     2616       // Allocate the C++ Thread structure and create the native thread.  The

     2617       // stack size retrieved from java is signed, but the constructor takes

     2618       // size_t (an unsigned type), so avoid passing negative values which would

     2619       // result in really large stacks.

     2620       size_t sz = size > 0 ? (size_t) size : 0;

     2621       native_thread = new JavaThread(&thread_entry, sz);

     2622 

     2623       // At this point it may be possible that no osthread was created for the

     2624       // JavaThread due to lack of memory. Check for this situation and throw

     2625       // an exception if necessary. Eventually we may want to change this so

     2626       // that we only grab the lock if the thread was created successfully -

     2627       // then we can also do this check and throw the exception in the

     2628       // JavaThread constructor.

     2629       if (native_thread->osthread() != NULL) {

     2630         // Note: the current thread is not being used within "prepare".

     2631         native_thread->prepare(jthread);

     2632       }

     2633     }

     2634   }

     2635 

     2636   if (throw_illegal_thread_state) {

     2637     THROW(vmSymbols::java_lang_IllegalThreadStateException());

     2638   }

     2639 

     2640   assert(native_thread != NULL, "Starting null thread?");

     2641 

     2642   if (native_thread->osthread() == NULL) {

     2643     // No one should hold a reference to the 'native_thread'.

     2644     delete native_thread;

     2645     if (JvmtiExport::should_post_resource_exhausted()) {

     2646       JvmtiExport::post_resource_exhausted(

     2647         JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,

     2648         "unable to create new native thread");

     2649     }

     2650     THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),

     2651               "unable to create new native thread");

     2652   }

     2653