1 /*
2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/classLoader.hpp"
27 #include "classfile/javaAssertions.hpp"
28 #include "classfile/javaClasses.hpp"
29 #include "classfile/stringTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/vmSymbols.hpp"
32 #include "gc_interface/collectedHeap.inline.hpp"
33 #include "interpreter/bytecode.hpp"
34 #include "memory/oopFactory.hpp"
35 #include "memory/universe.inline.hpp"
36 #include "oops/fieldStreams.hpp"
37 #include "oops/instanceKlass.hpp"
38 #include "oops/objArrayKlass.hpp"
39 #include "oops/method.hpp"
40 #include "prims/jvm.h"
41 #include "prims/jvm_misc.hpp"
42 #include "prims/jvmtiExport.hpp"
43 #include "prims/jvmtiThreadState.hpp"
44 #include "prims/nativeLookup.hpp"
45 #include "prims/privilegedStack.hpp"
46 #include "runtime/arguments.hpp"
47 #include "runtime/atomic.inline.hpp"
48 #include "runtime/handles.inline.hpp"
49 #include "runtime/init.hpp"
50 #include "runtime/interfaceSupport.hpp"
51 #include "runtime/java.hpp"
52 #include "runtime/javaCalls.hpp"
53 #include "runtime/jfieldIDWorkaround.hpp"
54 #include "runtime/orderAccess.inline.hpp"
55 #include "runtime/os.inline.hpp"
56 #include "runtime/perfData.hpp"
57 #include "runtime/reflection.hpp"
58 #include "runtime/thread.inline.hpp"
59 #include "runtime/vframe.hpp"
60 #include "runtime/vm_operations.hpp"
61 #include "runtime/vm_version.hpp"
62 #include "services/attachListener.hpp"
63 #include "services/management.hpp"
64 #include "services/threadService.hpp"
65 #include "trace/tracing.hpp"
66 #include "utilities/copy.hpp"
67 #include "utilities/defaultStream.hpp"
68 #include "utilities/dtrace.hpp"
69 #include "utilities/events.hpp"
70 #include "utilities/histogram.hpp"
71 #include "utilities/macros.hpp"
72 #include "utilities/top.hpp"
73 #include "utilities/utf8.hpp"
74 #if INCLUDE_CDS
75 #include "classfile/sharedClassUtil.hpp"
76 #include "classfile/systemDictionaryShared.hpp"
77 #endif
78 #ifdef TARGET_OS_FAMILY_linux
79 # include "jvm_linux.h"
80 #endif
81 #ifdef TARGET_OS_FAMILY_solaris
82 # include "jvm_solaris.h"
83 #endif
84 #ifdef TARGET_OS_FAMILY_windows
85 # include "jvm_windows.h"
86 #endif
87 #ifdef TARGET_OS_FAMILY_aix
88 # include "jvm_aix.h"
89 #endif
90 #ifdef TARGET_OS_FAMILY_bsd
91 # include "jvm_bsd.h"
92 #endif
93
94 #include <errno.h>
95
96 /*
97 NOTE about use of any ctor or function call that can trigger a safepoint/GC:
98 such ctors and calls MUST NOT come between an oop declaration/init and its
99 usage because if objects are move this may cause various memory stomps, bus
100 errors and segfaults. Here is a cookbook for causing so called "naked oop
101 failures":
102
103 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> {
104 JVMWrapper("JVM_GetClassDeclaredFields");
105
106 // Object address to be held directly in mirror & not visible to GC
107 oop mirror = JNIHandles::resolve_non_null(ofClass);
108
109 // If this ctor can hit a safepoint, moving objects around, then
110 ComplexConstructor foo;
111
112 // Boom! mirror may point to JUNK instead of the intended object
113 (some dereference of mirror)
114
115 // Here's another call that may block for GC, making mirror stale
116 MutexLocker ml(some_lock);
117
118 // And here's an initializer that can result in a stale oop
119 // all in one step.
120 oop o = call_that_can_throw_exception(TRAPS);
121
122
123 The solution is to keep the oop declaration BELOW the ctor or function
124 call that might cause a GC, do another resolve to reassign the oop, or
125 consider use of a Handle instead of an oop so there is immunity from object
126 motion. But note that the "QUICK" entries below do not have a handlemark
127 and thus can only support use of handles passed in.
128 */
129
130 static void trace_class_resolution_impl(Klass* to_class, TRAPS) {
131 ResourceMark rm;
132 int line_number = -1;
133 const char * source_file = NULL;
134 const char * trace = "explicit";
135 InstanceKlass* caller = NULL;
136 JavaThread* jthread = JavaThread::current();
137 if (jthread->has_last_Java_frame()) {
138 vframeStream vfst(jthread);
139
140 // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames
141 TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK);
142 Klass* access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);
143 TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK);
144 Klass* privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);
145
146 Method* last_caller = NULL;
147
148 while (!vfst.at_end()) {
149 Method* m = vfst.method();
150 if (!vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&
151 !vfst.method()->method_holder()->is_subclass_of(access_controller_klass) &&
152 !vfst.method()->method_holder()->is_subclass_of(privileged_action_klass)) {
153 break;
154 }
155 last_caller = m;
156 vfst.next();
157 }
158 // if this is called from Class.forName0 and that is called from Class.forName,
159 // then print the caller of Class.forName. If this is Class.loadClass, then print
160 // that caller, otherwise keep quiet since this should be picked up elsewhere.
161 bool found_it = false;
162 if (!vfst.at_end() &&
163 vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&
164 vfst.method()->name() == vmSymbols::forName0_name()) {
165 vfst.next();
166 if (!vfst.at_end() &&
167 vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&
168 vfst.method()->name() == vmSymbols::forName_name()) {
169 vfst.next();
170 found_it = true;
171 }
172 } else if (last_caller != NULL &&
173 last_caller->method_holder()->name() ==
174 vmSymbols::java_lang_ClassLoader() &&
175 (last_caller->name() == vmSymbols::loadClassInternal_name() ||
176 last_caller->name() == vmSymbols::loadClass_name())) {
177 found_it = true;
178 } else if (!vfst.at_end()) {
179 if (vfst.method()->is_native()) {
180 // JNI call
181 found_it = true;
182 }
183 }
184 if (found_it && !vfst.at_end()) {
185 // found the caller
186 caller = vfst.method()->method_holder();
187 line_number = vfst.method()->line_number_from_bci(vfst.bci());
188 if (line_number == -1) {
189 // show method name if it's a native method
190 trace = vfst.method()->name_and_sig_as_C_string();
191 }
192 Symbol* s = caller->source_file_name();
193 if (s != NULL) {
194 source_file = s->as_C_string();
195 }
196 }
197 }
198 if (caller != NULL) {
199 if (to_class != caller) {
200 const char * from = caller->external_name();
201 const char * to = to_class->external_name();
202 // print in a single call to reduce interleaving between threads
203 if (source_file != NULL) {
204 tty->print("RESOLVE %s %s %s:%d (%s)\n", from, to, source_file, line_number, trace);
205 } else {
206 tty->print("RESOLVE %s %s (%s)\n", from, to, trace);
207 }
208 }
209 }
210 }
211
212 void trace_class_resolution(Klass* to_class) {
213 EXCEPTION_MARK;
214 trace_class_resolution_impl(to_class, THREAD);
215 if (HAS_PENDING_EXCEPTION) {
216 CLEAR_PENDING_EXCEPTION;
217 }
218 }
219
220 // Wrapper to trace JVM functions
221
222 #ifdef ASSERT
223 class JVMTraceWrapper : public StackObj {
224 public:
225 JVMTraceWrapper(const char* format, ...) ATTRIBUTE_PRINTF(2, 3) {
226 if (TraceJVMCalls) {
227 va_list ap;
228 va_start(ap, format);
229 tty->print("JVM ");
230 tty->vprint_cr(format, ap);
231 va_end(ap);
232 }
233 }
234 };
235
236 Histogram* JVMHistogram;
237 volatile jint JVMHistogram_lock = 0;
238
239 class JVMHistogramElement : public HistogramElement {
240 public:
241 JVMHistogramElement(const char* name);
242 };
243
244 JVMHistogramElement::JVMHistogramElement(const char* elementName) {
245 _name = elementName;
246 uintx count = 0;
247
248 while (Atomic::cmpxchg(1, &JVMHistogram_lock, 0) != 0) {
249 while (OrderAccess::load_acquire(&JVMHistogram_lock) != 0) {
250 count +=1;
251 if ( (WarnOnStalledSpinLock > 0)
252 && (count % WarnOnStalledSpinLock == 0)) {
253 warning("JVMHistogram_lock seems to be stalled");
254 }
255 }
256 }
257
258 if(JVMHistogram == NULL)
259 JVMHistogram = new Histogram("JVM Call Counts",100);
260
261 JVMHistogram->add_element(this);
262 Atomic::dec(&JVMHistogram_lock);
263 }
264
265 #define JVMCountWrapper(arg) \
266 static JVMHistogramElement* e = new JVMHistogramElement(arg); \
267 if (e != NULL) e->increment_count(); // Due to bug in VC++, we need a NULL check here eventhough it should never happen!
268
269 #define JVMWrapper(arg1) JVMCountWrapper(arg1); JVMTraceWrapper(arg1)
270 #define JVMWrapper2(arg1, arg2) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2)
271 #define JVMWrapper3(arg1, arg2, arg3) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3)
272 #define JVMWrapper4(arg1, arg2, arg3, arg4) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3, arg4)
273 #else
274 #define JVMWrapper(arg1)
275 #define JVMWrapper2(arg1, arg2)
276 #define JVMWrapper3(arg1, arg2, arg3)
277 #define JVMWrapper4(arg1, arg2, arg3, arg4)
278 #endif
279
280
281 // Interface version /////////////////////////////////////////////////////////////////////
282
283
284 JVM_LEAF(jint, JVM_GetInterfaceVersion())
285 return JVM_INTERFACE_VERSION;
286 JVM_END
287
288
289 // java.lang.System //////////////////////////////////////////////////////////////////////
290
291
292 JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored))
293 JVMWrapper("JVM_CurrentTimeMillis");
294 return os::javaTimeMillis();
295 JVM_END
296
297 JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored))
298 JVMWrapper("JVM_NanoTime");
299 return os::javaTimeNanos();
300 JVM_END
301
302 // The function below is actually exposed by sun.misc.VM and not
303 // java.lang.System, but we choose to keep it here so that it stays next
304 // to JVM_CurrentTimeMillis and JVM_NanoTime
305
306 const jlong MAX_DIFF_SECS = 0x0100000000LL; // 2^32
307 const jlong MIN_DIFF_SECS = -MAX_DIFF_SECS; // -2^32
308
309 JVM_LEAF(jlong, JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs))
310 JVMWrapper("JVM_GetNanoTimeAdjustment");
311 jlong seconds;
312 jlong nanos;
313
314 os::javaTimeSystemUTC(seconds, nanos);
315
316 // We're going to verify that the result can fit in a long.
317 // For that we need the difference in seconds between 'seconds'
318 // and 'offset_secs' to be such that:
319 // |seconds - offset_secs| < (2^63/10^9)
320 // We're going to approximate 10^9 ~< 2^30 (1000^3 ~< 1024^3)
321 // which makes |seconds - offset_secs| < 2^33
322 // and we will prefer +/- 2^32 as the maximum acceptable diff
323 // as 2^32 has a more natural feel than 2^33...
324 //
325 // So if |seconds - offset_secs| >= 2^32 - we return a special
326 // sentinel value (-1) which the caller should take as an
327 // exception value indicating that the offset given to us is
328 // too far from range of the current time - leading to too big
329 // a nano adjustment. The caller is expected to recover by
330 // computing a more accurate offset and calling this method
331 // again. (For the record 2^32 secs is ~136 years, so that
332 // should rarely happen)
333 //
334 jlong diff = seconds - offset_secs;
335 if (diff >= MAX_DIFF_SECS || diff <= MIN_DIFF_SECS) {
336 return -1; // sentinel value: the offset is too far off the target
337 }
338
339 // return the adjustment. If you compute a time by adding
340 // this number of nanoseconds along with the number of seconds
341 // in the offset you should get the current UTC time.
342 return (diff * (jlong)1000000000) + nanos;
343 JVM_END
344
345 JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,
346 jobject dst, jint dst_pos, jint length))
347 JVMWrapper("JVM_ArrayCopy");
348 // Check if we have null pointers
349 if (src == NULL || dst == NULL) {
350 THROW(vmSymbols::java_lang_NullPointerException());
351 }
352 arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));
353 arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));
354 assert(s->is_oop(), "JVM_ArrayCopy: src not an oop");
355 assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop");
356 // Do copy
357 s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread);
358 JVM_END
359
360
361 static void set_property(Handle props, const char* key, const char* value, TRAPS) {
362 JavaValue r(T_OBJECT);
363 // public synchronized Object put(Object key, Object value);
364 HandleMark hm(THREAD);
365 Handle key_str = java_lang_String::create_from_platform_dependent_str(key, CHECK);
366 Handle value_str = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);
367 JavaCalls::call_virtual(&r,
368 props,
369 KlassHandle(THREAD, SystemDictionary::Properties_klass()),
370 vmSymbols::put_name(),
371 vmSymbols::object_object_object_signature(),
372 key_str,
373 value_str,
374 THREAD);
375 }
376
377
378 #define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties));
379
380
381 JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties))
382 JVMWrapper("JVM_InitProperties");
383 ResourceMark rm;
384
385 Handle props(THREAD, JNIHandles::resolve_non_null(properties));
386
387 // System property list includes both user set via -D option and
388 // jvm system specific properties.
389 for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) {
390 PUTPROP(props, p->key(), p->value());
391 }
392
393 // Convert the -XX:MaxDirectMemorySize= command line flag
394 // to the sun.nio.MaxDirectMemorySize property.
395 // Do this after setting user properties to prevent people
396 // from setting the value with a -D option, as requested.
397 {
398 if (FLAG_IS_DEFAULT(MaxDirectMemorySize)) {
399 PUTPROP(props, "sun.nio.MaxDirectMemorySize", "-1");
400 } else {
401 char as_chars[256];
402 jio_snprintf(as_chars, sizeof(as_chars), UINTX_FORMAT, MaxDirectMemorySize);
403 PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars);
404 }
405 }
406
407 // JVM monitoring and management support
408 // Add the sun.management.compiler property for the compiler's name
409 {
410 #undef CSIZE
411 #if defined(_LP64) || defined(_WIN64)
412 #define CSIZE "64-Bit "
413 #else
414 #define CSIZE
415 #endif // 64bit
416
417 #ifdef TIERED
418 const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers";
419 #else
420 #if defined(COMPILER1)
421 const char* compiler_name = "HotSpot " CSIZE "Client Compiler";
422 #elif defined(COMPILER2)
423 const char* compiler_name = "HotSpot " CSIZE "Server Compiler";
424 #else
425 const char* compiler_name = "";
426 #endif // compilers
427 #endif // TIERED
428
429 if (*compiler_name != '\0' &&
430 (Arguments::mode() != Arguments::_int)) {
431 PUTPROP(props, "sun.management.compiler", compiler_name);
432 }
433 }
434
435 return properties;
436 JVM_END
437
438
439 /*
440 * Return the temporary directory that the VM uses for the attach
441 * and perf data files.
442 *
443 * It is important that this directory is well-known and the
444 * same for all VM instances. It cannot be affected by configuration
445 * variables such as java.io.tmpdir.
446 */
447 JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))
448 JVMWrapper("JVM_GetTemporaryDirectory");
449 HandleMark hm(THREAD);
450 const char* temp_dir = os::get_temp_directory();
451 Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);
452 return (jstring) JNIHandles::make_local(env, h());
453 JVM_END
454
455
456 // java.lang.Runtime /////////////////////////////////////////////////////////////////////////
457
458 extern volatile jint vm_created;
459
460 JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))
461 before_exit(thread);
462 vm_exit(code);
463 JVM_END
464
465
466 JVM_ENTRY_NO_ENV(void, JVM_GC(void))
467 JVMWrapper("JVM_GC");
468 if (!DisableExplicitGC) {
469 Universe::heap()->collect(GCCause::_java_lang_system_gc);
470 }
471 JVM_END
472
473
474 JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))
475 JVMWrapper("JVM_MaxObjectInspectionAge");
476 return Universe::heap()->millis_since_last_gc();
477 JVM_END
478
479
480 static inline jlong convert_size_t_to_jlong(size_t val) {
481 // In the 64-bit vm, a size_t can overflow a jlong (which is signed).
482 NOT_LP64 (return (jlong)val;)
483 LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)
484 }
485
486 JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))
487 JVMWrapper("JVM_TotalMemory");
488 size_t n = Universe::heap()->capacity();
489 return convert_size_t_to_jlong(n);
490 JVM_END
491
492
493 JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))
494 JVMWrapper("JVM_FreeMemory");
495 CollectedHeap* ch = Universe::heap();
496 size_t n;
497 {
498 MutexLocker x(Heap_lock);
499 n = ch->capacity() - ch->used();
500 }
501 return convert_size_t_to_jlong(n);
502 JVM_END
503
504
505 JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))
506 JVMWrapper("JVM_MaxMemory");
507 size_t n = Universe::heap()->max_capacity();
508 return convert_size_t_to_jlong(n);
509 JVM_END
510
511
512 JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))
513 JVMWrapper("JVM_ActiveProcessorCount");
514 return os::active_processor_count();
515 JVM_END
516
517
518
519 // java.lang.Throwable //////////////////////////////////////////////////////
520
521
522 JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver))
523 JVMWrapper("JVM_FillInStackTrace");
524 Handle exception(thread, JNIHandles::resolve_non_null(receiver));
525 java_lang_Throwable::fill_in_stack_trace(exception);
526 JVM_END
527
528
529 JVM_ENTRY(jint, JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable))
530 JVMWrapper("JVM_GetStackTraceDepth");
531 oop exception = JNIHandles::resolve(throwable);
532 return java_lang_Throwable::get_stack_trace_depth(exception, THREAD);
533 JVM_END
534
535
536 JVM_ENTRY(jobject, JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index))
537 JVMWrapper("JVM_GetStackTraceElement");
538 JvmtiVMObjectAllocEventCollector oam; // This ctor (throughout this module) may trigger a safepoint/GC
539 oop exception = JNIHandles::resolve(throwable);
540 oop element = java_lang_Throwable::get_stack_trace_element(exception, index, CHECK_NULL);
541 return JNIHandles::make_local(env, element);
542 JVM_END
543
544
545 // java.lang.Object ///////////////////////////////////////////////
546
547
548 JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))
549 JVMWrapper("JVM_IHashCode");
550 // as implemented in the classic virtual machine; return 0 if object is NULL
551 return handle == NULL ? 0 : ObjectSynchronizer::FastHashCode (THREAD, JNIHandles::resolve_non_null(handle)) ;
552 JVM_END
553
554
555 JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
556 JVMWrapper("JVM_MonitorWait");
557 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
558 JavaThreadInObjectWaitState jtiows(thread, ms != 0);
559 if (JvmtiExport::should_post_monitor_wait()) {
560 JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);
561
562 // The current thread already owns the monitor and it has not yet
563 // been added to the wait queue so the current thread cannot be
564 // made the successor. This means that the JVMTI_EVENT_MONITOR_WAIT
565 // event handler cannot accidentally consume an unpark() meant for
566 // the ParkEvent associated with this ObjectMonitor.
567 }
568 ObjectSynchronizer::wait(obj, ms, CHECK);
569 JVM_END
570
571
572 JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
573 JVMWrapper("JVM_MonitorNotify");
574 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
575 ObjectSynchronizer::notify(obj, CHECK);
576 JVM_END
577
578
579 JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
580 JVMWrapper("JVM_MonitorNotifyAll");
581 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
582 ObjectSynchronizer::notifyall(obj, CHECK);
583 JVM_END
584
585
586 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
587 JVMWrapper("JVM_Clone");
588 Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
589 const KlassHandle klass (THREAD, obj->klass());
590 JvmtiVMObjectAllocEventCollector oam;
591
592 #ifdef ASSERT
593 // Just checking that the cloneable flag is set correct
594 if (obj->is_array()) {
595 guarantee(klass->is_cloneable(), "all arrays are cloneable");
596 } else {
597 guarantee(obj->is_instance(), "should be instanceOop");
598 bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
599 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
600 }
601 #endif
602
603 // Check if class of obj supports the Cloneable interface.
604 // All arrays are considered to be cloneable (See JLS 20.1.5)
605 if (!klass->is_cloneable()) {
606 ResourceMark rm(THREAD);
607 THROW_MSG_0(vmSymbols::java_lang_CloneNotSupportedException(), klass->external_name());
608 }
609
610 // Make shallow object copy
611 const int size = obj->size();
612 oop new_obj_oop = NULL;
613 if (obj->is_array()) {
614 const int length = ((arrayOop)obj())->length();
615 new_obj_oop = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);
616 } else {
617 new_obj_oop = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);
618 }
619
620 // 4839641 (4840070): We must do an oop-atomic copy, because if another thread
621 // is modifying a reference field in the clonee, a non-oop-atomic copy might
622 // be suspended in the middle of copying the pointer and end up with parts
623 // of two different pointers in the field. Subsequent dereferences will crash.
624 // 4846409: an oop-copy of objects with long or double fields or arrays of same
625 // won't copy the longs/doubles atomically in 32-bit vm's, so we copy jlongs instead
626 // of oops. We know objects are aligned on a minimum of an jlong boundary.
627 // The same is true of StubRoutines::object_copy and the various oop_copy
628 // variants, and of the code generated by the inline_native_clone intrinsic.
629 assert(MinObjAlignmentInBytes >= BytesPerLong, "objects misaligned");
630 Copy::conjoint_jlongs_atomic((jlong*)obj(), (jlong*)new_obj_oop,
631 (size_t)align_object_size(size) / HeapWordsPerLong);
632 // Clear the header
633 new_obj_oop->init_mark();
634
635 // Store check (mark entire object and let gc sort it out)
636 BarrierSet* bs = Universe::heap()->barrier_set();
637 assert(bs->has_write_region_opt(), "Barrier set does not have write_region");
638 bs->write_region(MemRegion((HeapWord*)new_obj_oop, size));
639
640 Handle new_obj(THREAD, new_obj_oop);
641 // Special handling for MemberNames. Since they contain Method* metadata, they
642 // must be registered so that RedefineClasses can fix metadata contained in them.
643 if (java_lang_invoke_MemberName::is_instance(new_obj()) &&
644 java_lang_invoke_MemberName::is_method(new_obj())) {
645 Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(new_obj());
646 // MemberName may be unresolved, so doesn't need registration until resolved.
647 if (method != NULL) {
648 methodHandle m(THREAD, method);
649 // This can safepoint and redefine method, so need both new_obj and method
650 // in a handle, for two different reasons. new_obj can move, method can be
651 // deleted if nothing is using it on the stack.
652 m->method_holder()->add_member_name(new_obj());
653 }
654 }
655
656 // Caution: this involves a java upcall, so the clone should be
657 // "gc-robust" by this stage.
658 if (klass->has_finalizer()) {
659 assert(obj->is_instance(), "should be instanceOop");
660 new_obj_oop = InstanceKlass::register_finalizer(instanceOop(new_obj()), CHECK_NULL);
661 new_obj = Handle(THREAD, new_obj_oop);
662 }
663
664 return JNIHandles::make_local(env, new_obj());
665 JVM_END
666
667 // java.io.File ///////////////////////////////////////////////////////////////
668
669 JVM_LEAF(char*, JVM_NativePath(char* path))
670 JVMWrapper2("JVM_NativePath (%s)", path);
671 return os::native_path(path);
672 JVM_END
673
674
675 // Misc. class handling ///////////////////////////////////////////////////////////
676
677
678 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))
679 JVMWrapper("JVM_GetCallerClass");
680
681 // Pre-JDK 8 and early builds of JDK 8 don't have a CallerSensitive annotation; or
682 // sun.reflect.Reflection.getCallerClass with a depth parameter is provided
683 // temporarily for existing code to use until a replacement API is defined.
684 if (SystemDictionary::reflect_CallerSensitive_klass() == NULL || depth != JVM_CALLER_DEPTH) {
685 Klass* k = thread->security_get_caller_class(depth);
686 return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror());
687 }
688
689 // Getting the class of the caller frame.
690 //
691 // The call stack at this point looks something like this:
692 //
693 // [0] [ @CallerSensitive public sun.reflect.Reflection.getCallerClass ]
694 // [1] [ @CallerSensitive API.method ]
695 // [.] [ (skipped intermediate frames) ]
696 // [n] [ caller ]
697 vframeStream vfst(thread);
698 // Cf. LibraryCallKit::inline_native_Reflection_getCallerClass
699 for (int n = 0; !vfst.at_end(); vfst.security_next(), n++) {
700 Method* m = vfst.method();
701 assert(m != NULL, "sanity");
702 switch (n) {
703 case 0:
704 // This must only be called from Reflection.getCallerClass
705 if (m->intrinsic_id() != vmIntrinsics::_getCallerClass) {
706 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetCallerClass must only be called from Reflection.getCallerClass");
707 }
708 // fall-through
709 case 1:
710 // Frame 0 and 1 must be caller sensitive.
711 if (!m->caller_sensitive()) {
712 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), err_msg("CallerSensitive annotation expected at frame %d", n));
713 }
714 break;
715 default:
716 if (!m->is_ignored_by_security_stack_walk()) {
717 // We have reached the desired frame; return the holder class.
718 return (jclass) JNIHandles::make_local(env, m->method_holder()->java_mirror());
719 }
720 break;
721 }
722 }
723 return NULL;
724 JVM_END
725
726
727 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
728 JVMWrapper("JVM_FindPrimitiveClass");
729 oop mirror = NULL;
730 BasicType t = name2type(utf);
731 if (t != T_ILLEGAL && t != T_OBJECT && t != T_ARRAY) {
732 mirror = Universe::java_mirror(t);
733 }
734 if (mirror == NULL) {
735 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), (char*) utf);
736 } else {
737 return (jclass) JNIHandles::make_local(env, mirror);
738 }
739 JVM_END
740
741
742 // Returns a class loaded by the bootstrap class loader; or null
743 // if not found. ClassNotFoundException is not thrown.
744 // FindClassFromBootLoader is exported to the launcher for windows.
745 JVM_ENTRY(jclass, JVM_FindClassFromBootLoader(JNIEnv* env,
746 const char* name))
747 JVMWrapper2("JVM_FindClassFromBootLoader %s", name);
748
749 // Java libraries should ensure that name is never null...
750 if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
751 // It's impossible to create this class; the name cannot fit
752 // into the constant pool.
753 return NULL;
754 }
755
756 TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
757 Klass* k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);
758 if (k == NULL) {
759 return NULL;
760 }
761
762 if (TraceClassResolution) {
763 trace_class_resolution(k);
764 }
765 return (jclass) JNIHandles::make_local(env, k->java_mirror());
766 JVM_END
767
768 // Find a class with this name in this loader, using the caller's protection domain.
769 JVM_ENTRY(jclass, JVM_FindClassFromCaller(JNIEnv* env, const char* name,
770 jboolean init, jobject loader,
771 jclass caller))
772 JVMWrapper2("JVM_FindClassFromCaller %s throws ClassNotFoundException", name);
773 // Java libraries should ensure that name is never null...
774 if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
775 // It's impossible to create this class; the name cannot fit
776 // into the constant pool.
777 THROW_MSG_0(vmSymbols::java_lang_ClassNotFoundException(), name);
778 }
779
780 TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
781
782 oop loader_oop = JNIHandles::resolve(loader);
783 oop from_class = JNIHandles::resolve(caller);
784 oop protection_domain = NULL;
785 // If loader is null, shouldn't call ClassLoader.checkPackageAccess; otherwise get
786 // NPE. Put it in another way, the bootstrap class loader has all permission and
787 // thus no checkPackageAccess equivalence in the VM class loader.
788 // The caller is also passed as NULL by the java code if there is no security
789 // manager to avoid the performance cost of getting the calling class.
790 if (from_class != NULL && loader_oop != NULL) {
791 protection_domain = java_lang_Class::as_Klass(from_class)->protection_domain();
792 }
793
794 Handle h_loader(THREAD, loader_oop);
795 Handle h_prot(THREAD, protection_domain);
796 jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
797 h_prot, false, THREAD);
798
799 if (TraceClassResolution && result != NULL) {
800 trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
801 }
802 return result;
803 JVM_END
804
805 JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name,
806 jboolean init, jclass from))
807 JVMWrapper2("JVM_FindClassFromClass %s", name);
808 if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
809 // It's impossible to create this class; the name cannot fit
810 // into the constant pool.
811 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
812 }
813 TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
814 oop from_class_oop = JNIHandles::resolve(from);
815 Klass* from_class = (from_class_oop == NULL)
816 ? (Klass*)NULL
817 : java_lang_Class::as_Klass(from_class_oop);
818 oop class_loader = NULL;
819 oop protection_domain = NULL;
820 if (from_class != NULL) {
821 class_loader = from_class->class_loader();
822 protection_domain = from_class->protection_domain();
823 }
824 Handle h_loader(THREAD, class_loader);
825 Handle h_prot (THREAD, protection_domain);
826 jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
827 h_prot, true, thread);
828
829 if (TraceClassResolution && result != NULL) {
830 // this function is generally only used for class loading during verification.
831 ResourceMark rm;
832 oop from_mirror = JNIHandles::resolve_non_null(from);
833 Klass* from_class = java_lang_Class::as_Klass(from_mirror);
834 const char * from_name = from_class->external_name();
835
836 oop mirror = JNIHandles::resolve_non_null(result);
837 Klass* to_class = java_lang_Class::as_Klass(mirror);
838 const char * to = to_class->external_name();
839 tty->print("RESOLVE %s %s (verification)\n", from_name, to);
840 }
841
842 return result;
843 JVM_END
844
845 static void is_lock_held_by_thread(Handle loader, PerfCounter* counter, TRAPS) {
846 if (loader.is_null()) {
847 return;
848 }
849
850 // check whether the current caller thread holds the lock or not.
851 // If not, increment the corresponding counter
852 if (ObjectSynchronizer::query_lock_ownership((JavaThread*)THREAD, loader) !=
853 ObjectSynchronizer::owner_self) {
854 counter->inc();
855 }
856 }
857
858 // common code for JVM_DefineClass() and JVM_DefineClassWithSource()
859 // and JVM_DefineClassWithSourceCond()
860 static jclass jvm_define_class_common(JNIEnv *env, const char *name,
861 jobject loader, const jbyte *buf,
862 jsize len, jobject pd, const char *source,
863 jboolean verify, TRAPS) {
864 if (source == NULL) source = "__JVM_DefineClass__";
865
866 assert(THREAD->is_Java_thread(), "must be a JavaThread");
867 JavaThread* jt = (JavaThread*) THREAD;
868
869 PerfClassTraceTime vmtimer(ClassLoader::perf_define_appclass_time(),
870 ClassLoader::perf_define_appclass_selftime(),
871 ClassLoader::perf_define_appclasses(),
872 jt->get_thread_stat()->perf_recursion_counts_addr(),
873 jt->get_thread_stat()->perf_timers_addr(),
874 PerfClassTraceTime::DEFINE_CLASS);
875
876 if (UsePerfData) {
877 ClassLoader::perf_app_classfile_bytes_read()->inc(len);
878 }
879
880 // Since exceptions can be thrown, class initialization can take place
881 // if name is NULL no check for class name in .class stream has to be made.
882 TempNewSymbol class_name = NULL;
883 if (name != NULL) {
884 const int str_len = (int)strlen(name);
885 if (str_len > Symbol::max_length()) {
886 // It's impossible to create this class; the name cannot fit
887 // into the constant pool.
888 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
889 }
890 class_name = SymbolTable::new_symbol(name, str_len, CHECK_NULL);
891 }
892
893 ResourceMark rm(THREAD);
894 ClassFileStream st((u1*) buf, len, (char *)source);
895 Handle class_loader (THREAD, JNIHandles::resolve(loader));
896 if (UsePerfData) {
897 is_lock_held_by_thread(class_loader,
898 ClassLoader::sync_JVMDefineClassLockFreeCounter(),
899 THREAD);
900 }
901 Handle protection_domain (THREAD, JNIHandles::resolve(pd));
902 Klass* k = SystemDictionary::resolve_from_stream(class_name, class_loader,
903 protection_domain, &st,
904 verify != 0,
905 CHECK_NULL);
906
907 if (TraceClassResolution && k != NULL) {
908 trace_class_resolution(k);
909 }
910
911 return (jclass) JNIHandles::make_local(env, k->java_mirror());
912 }
913
914
915 JVM_ENTRY(jclass, JVM_DefineClass(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd))
916 JVMWrapper2("JVM_DefineClass %s", name);
917
918 return jvm_define_class_common(env, name, loader, buf, len, pd, NULL, true, THREAD);
919 JVM_END
920
921
922 JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
923 JVMWrapper2("JVM_DefineClassWithSource %s", name);
924
925 return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD);
926 JVM_END
927
928 JVM_ENTRY(jclass, JVM_DefineClassWithSourceCond(JNIEnv *env, const char *name,
929 jobject loader, const jbyte *buf,
930 jsize len, jobject pd,
931 const char *source, jboolean verify))
932 JVMWrapper2("JVM_DefineClassWithSourceCond %s", name);
933
934 return jvm_define_class_common(env, name, loader, buf, len, pd, source, verify, THREAD);
935 JVM_END
936
937 JVM_ENTRY(jclass, JVM_FindLoadedClass(JNIEnv *env, jobject loader, jstring name))
938 JVMWrapper("JVM_FindLoadedClass");
939 ResourceMark rm(THREAD);
940
941 Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
942 Handle string = java_lang_String::internalize_classname(h_name, CHECK_NULL);
943
944 const char* str = java_lang_String::as_utf8_string(string());
945 // Sanity check, don't expect null
946 if (str == NULL) return NULL;
947
948 const int str_len = (int)strlen(str);
949 if (str_len > Symbol::max_length()) {
950 // It's impossible to create this class; the name cannot fit
951 // into the constant pool.
952 return NULL;
953 }
954 TempNewSymbol klass_name = SymbolTable::new_symbol(str, str_len, CHECK_NULL);
955
956 // Security Note:
957 // The Java level wrapper will perform the necessary security check allowing
958 // us to pass the NULL as the initiating class loader.
959 Handle h_loader(THREAD, JNIHandles::resolve(loader));
960 if (UsePerfData) {
961 is_lock_held_by_thread(h_loader,
962 ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(),
963 THREAD);
964 }
965
966 Klass* k = SystemDictionary::find_instance_or_array_klass(klass_name,
967 h_loader,
968 Handle(),
969 CHECK_NULL);
970 #if INCLUDE_CDS
971 if (k == NULL) {
972 // If the class is not already loaded, try to see if it's in the shared
973 // archive for the current classloader (h_loader).
974 instanceKlassHandle ik = SystemDictionaryShared::find_or_load_shared_class(
975 klass_name, h_loader, CHECK_NULL);
976 k = ik();
977 }
978 #endif
979 return (k == NULL) ? NULL :
980 (jclass) JNIHandles::make_local(env, k->java_mirror());
981 JVM_END
982
983
984 // Reflection support //////////////////////////////////////////////////////////////////////////////
985
986 JVM_ENTRY(jstring, JVM_GetClassName(JNIEnv *env, jclass cls))
987 assert (cls != NULL, "illegal class");
988 JVMWrapper("JVM_GetClassName");
989 JvmtiVMObjectAllocEventCollector oam;
990 ResourceMark rm(THREAD);
991 const char* name;
992 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
993 name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls)));
994 } else {
995 // Consider caching interned string in Klass
996 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
997 assert(k->is_klass(), "just checking");
998 name = k->external_name();
999 }
1000 oop result = StringTable::intern((char*) name, CHECK_NULL);
1001 return (jstring) JNIHandles::make_local(env, result);
1002 JVM_END
1003
1004
1005 JVM_ENTRY(jobjectArray, JVM_GetClassInterfaces(JNIEnv *env, jclass cls))
1006 JVMWrapper("JVM_GetClassInterfaces");
1007 JvmtiVMObjectAllocEventCollector oam;
1008 oop mirror = JNIHandles::resolve_non_null(cls);
1009
1010 // Special handling for primitive objects
1011 if (java_lang_Class::is_primitive(mirror)) {
1012 // Primitive objects does not have any interfaces
1013 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
1014 return (jobjectArray) JNIHandles::make_local(env, r);
1015 }
1016
1017 KlassHandle klass(thread, java_lang_Class::as_Klass(mirror));
1018 // Figure size of result array
1019 int size;
1020 if (klass->oop_is_instance()) {
1021 size = InstanceKlass::cast(klass())->local_interfaces()->length();
1022 } else {
1023 assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass");
1024 size = 2;
1025 }
1026
1027 // Allocate result array
1028 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), size, CHECK_NULL);
1029 objArrayHandle result (THREAD, r);
1030 // Fill in result
1031 if (klass->oop_is_instance()) {
1032 // Regular instance klass, fill in all local interfaces
1033 for (int index = 0; index < size; index++) {
1034 Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index);
1035 result->obj_at_put(index, k->java_mirror());
1036 }
1037 } else {
1038 // All arrays implement java.lang.Cloneable and java.io.Serializable
1039 result->obj_at_put(0, SystemDictionary::Cloneable_klass()->java_mirror());
1040 result->obj_at_put(1, SystemDictionary::Serializable_klass()->java_mirror());
1041 }
1042 return (jobjectArray) JNIHandles::make_local(env, result());
1043 JVM_END
1044
1045
1046 JVM_QUICK_ENTRY(jboolean, JVM_IsInterface(JNIEnv *env, jclass cls))
1047 JVMWrapper("JVM_IsInterface");
1048 oop mirror = JNIHandles::resolve_non_null(cls);
1049 if (java_lang_Class::is_primitive(mirror)) {
1050 return JNI_FALSE;
1051 }
1052 Klass* k = java_lang_Class::as_Klass(mirror);
1053 jboolean result = k->is_interface();
1054 assert(!result || k->oop_is_instance(),
1055 "all interfaces are instance types");
1056 // The compiler intrinsic for isInterface tests the
1057 // Klass::_access_flags bits in the same way.
1058 return result;
1059 JVM_END
1060
1061
1062 JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
1063 JVMWrapper("JVM_GetClassSigners");
1064 JvmtiVMObjectAllocEventCollector oam;
1065 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1066 // There are no signers for primitive types
1067 return NULL;
1068 }
1069
1070 objArrayOop signers = java_lang_Class::signers(JNIHandles::resolve_non_null(cls));
1071
1072 // If there are no signers set in the class, or if the class
1073 // is an array, return NULL.
1074 if (signers == NULL) return NULL;
1075
1076 // copy of the signers array
1077 Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
1078 objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
1079 for (int index = 0; index < signers->length(); index++) {
1080 signers_copy->obj_at_put(index, signers->obj_at(index));
1081 }
1082
1083 // return the copy
1084 return (jobjectArray) JNIHandles::make_local(env, signers_copy);
1085 JVM_END
1086
1087
1088 JVM_ENTRY(void, JVM_SetClassSigners(JNIEnv *env, jclass cls, jobjectArray signers))
1089 JVMWrapper("JVM_SetClassSigners");
1090 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1091 // This call is ignored for primitive types and arrays.
1092 // Signers are only set once, ClassLoader.java, and thus shouldn't
1093 // be called with an array. Only the bootstrap loader creates arrays.
1094 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1095 if (k->oop_is_instance()) {
1096 java_lang_Class::set_signers(k->java_mirror(), objArrayOop(JNIHandles::resolve(signers)));
1097 }
1098 }
1099 JVM_END
1100
1101
1102 JVM_ENTRY(jobject, JVM_GetProtectionDomain(JNIEnv *env, jclass cls))
1103 JVMWrapper("JVM_GetProtectionDomain");
1104 if (JNIHandles::resolve(cls) == NULL) {
1105 THROW_(vmSymbols::java_lang_NullPointerException(), NULL);
1106 }
1107
1108 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1109 // Primitive types does not have a protection domain.
1110 return NULL;
1111 }
1112
1113 oop pd = java_lang_Class::protection_domain(JNIHandles::resolve(cls));
1114 return (jobject) JNIHandles::make_local(env, pd);
1115 JVM_END
1116
1117
1118 static bool is_authorized(Handle context, instanceKlassHandle klass, TRAPS) {
1119 // If there is a security manager and protection domain, check the access
1120 // in the protection domain, otherwise it is authorized.
1121 if (java_lang_System::has_security_manager()) {
1122
1123 // For bootstrapping, if pd implies method isn't in the JDK, allow
1124 // this context to revert to older behavior.
1125 // In this case the isAuthorized field in AccessControlContext is also not
1126 // present.
1127 if (Universe::protection_domain_implies_method() == NULL) {
1128 return true;
1129 }
1130
1131 // Whitelist certain access control contexts
1132 if (java_security_AccessControlContext::is_authorized(context)) {
1133 return true;
1134 }
1135
1136 oop prot = klass->protection_domain();
1137 if (prot != NULL) {
1138 // Call pd.implies(new SecurityPermission("createAccessControlContext"))
1139 // in the new wrapper.
1140 methodHandle m(THREAD, Universe::protection_domain_implies_method());
1141 Handle h_prot(THREAD, prot);
1142 JavaValue result(T_BOOLEAN);
1143 JavaCallArguments args(h_prot);
1144 JavaCalls::call(&result, m, &args, CHECK_false);
1145 return (result.get_jboolean() != 0);
1146 }
1147 }
1148 return true;
1149 }
1150
1151 // Create an AccessControlContext with a protection domain with null codesource
1152 // and null permissions - which gives no permissions.
1153 oop create_dummy_access_control_context(TRAPS) {
1154 InstanceKlass* pd_klass = InstanceKlass::cast(SystemDictionary::ProtectionDomain_klass());
1155 Handle obj = pd_klass->allocate_instance_handle(CHECK_NULL);
1156 // Call constructor ProtectionDomain(null, null);
1157 JavaValue result(T_VOID);
1158 JavaCalls::call_special(&result, obj, KlassHandle(THREAD, pd_klass),
1159 vmSymbols::object_initializer_name(),
1160 vmSymbols::codesource_permissioncollection_signature(),
1161 Handle(), Handle(), CHECK_NULL);
1162
1163 // new ProtectionDomain[] {pd};
1164 objArrayOop context = oopFactory::new_objArray(pd_klass, 1, CHECK_NULL);
1165 context->obj_at_put(0, obj());
1166
1167 // new AccessControlContext(new ProtectionDomain[] {pd})
1168 objArrayHandle h_context(THREAD, context);
1169 oop acc = java_security_AccessControlContext::create(h_context, false, Handle(), CHECK_NULL);
1170 return acc;
1171 }
1172
1173 JVM_ENTRY(jobject, JVM_DoPrivileged(JNIEnv *env, jclass cls, jobject action, jobject context, jboolean wrapException))
1174 JVMWrapper("JVM_DoPrivileged");
1175
1176 if (action == NULL) {
1177 THROW_MSG_0(vmSymbols::java_lang_NullPointerException(), "Null action");
1178 }
1179
1180 // Compute the frame initiating the do privileged operation and setup the privileged stack
1181 vframeStream vfst(thread);
1182 vfst.security_get_caller_frame(1);
1183
1184 if (vfst.at_end()) {
1185 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "no caller?");
1186 }
1187
1188 Method* method = vfst.method();
1189 instanceKlassHandle klass (THREAD, method->method_holder());
1190
1191 // Check that action object understands "Object run()"
1192 Handle h_context;
1193 if (context != NULL) {
1194 h_context = Handle(THREAD, JNIHandles::resolve(context));
1195 bool authorized = is_authorized(h_context, klass, CHECK_NULL);
1196 if (!authorized) {
1197 // Create an unprivileged access control object and call it's run function
1198 // instead.
1199 oop noprivs = create_dummy_access_control_context(CHECK_NULL);
1200 h_context = Handle(THREAD, noprivs);
1201 }
1202 }
1203
1204 // Check that action object understands "Object run()"
1205 Handle object (THREAD, JNIHandles::resolve(action));
1206
1207 // get run() method
1208 Method* m_oop = object->klass()->uncached_lookup_method(
1209 vmSymbols::run_method_name(),
1210 vmSymbols::void_object_signature(),
1211 Klass::find_overpass);
1212 methodHandle m (THREAD, m_oop);
1213 if (m.is_null() || !m->is_method() || !m()->is_public() || m()->is_static()) {
1214 THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method");
1215 }
1216
1217 // Stack allocated list of privileged stack elements
1218 PrivilegedElement pi;
1219 if (!vfst.at_end()) {
1220 pi.initialize(&vfst, h_context(), thread->privileged_stack_top(), CHECK_NULL);
1221 thread->set_privileged_stack_top(&pi);
1222 }
1223
1224
1225 // invoke the Object run() in the action object. We cannot use call_interface here, since the static type
1226 // is not really known - it is either java.security.PrivilegedAction or java.security.PrivilegedExceptionAction
1227 Handle pending_exception;
1228 JavaValue result(T_OBJECT);
1229 JavaCallArguments args(object);
1230 JavaCalls::call(&result, m, &args, THREAD);
1231
1232 // done with action, remove ourselves from the list
1233 if (!vfst.at_end()) {
1234 assert(thread->privileged_stack_top() != NULL && thread->privileged_stack_top() == &pi, "wrong top element");
1235 thread->set_privileged_stack_top(thread->privileged_stack_top()->next());
1236 }
1237
1238 if (HAS_PENDING_EXCEPTION) {
1239 pending_exception = Handle(THREAD, PENDING_EXCEPTION);
1240 CLEAR_PENDING_EXCEPTION;
1241 // JVMTI has already reported the pending exception
1242 // JVMTI internal flag reset is needed in order to report PrivilegedActionException
1243 if (THREAD->is_Java_thread()) {
1244 JvmtiExport::clear_detected_exception((JavaThread*) THREAD);
1245 }
1246 if ( pending_exception->is_a(SystemDictionary::Exception_klass()) &&
1247 !pending_exception->is_a(SystemDictionary::RuntimeException_klass())) {
1248 // Throw a java.security.PrivilegedActionException(Exception e) exception
1249 JavaCallArguments args(pending_exception);
1250 THROW_ARG_0(vmSymbols::java_security_PrivilegedActionException(),
1251 vmSymbols::exception_void_signature(),
1252 &args);
1253 }
1254 }
1255
1256 if (pending_exception.not_null()) THROW_OOP_0(pending_exception());
1257 return JNIHandles::make_local(env, (oop) result.get_jobject());
1258 JVM_END
1259
1260
1261 // Returns the inherited_access_control_context field of the running thread.
1262 JVM_ENTRY(jobject, JVM_GetInheritedAccessControlContext(JNIEnv *env, jclass cls))
1263 JVMWrapper("JVM_GetInheritedAccessControlContext");
1264 oop result = java_lang_Thread::inherited_access_control_context(thread->threadObj());
1265 return JNIHandles::make_local(env, result);
1266 JVM_END
1267
1268 class RegisterArrayForGC {
1269 private:
1270 JavaThread *_thread;
1271 public:
1272 RegisterArrayForGC(JavaThread *thread, GrowableArray<oop>* array) {
1273 _thread = thread;
1274 _thread->register_array_for_gc(array);
1275 }
1276
1277 ~RegisterArrayForGC() {
1278 _thread->register_array_for_gc(NULL);
1279 }
1280 };
1281
1282
1283 JVM_ENTRY(jobject, JVM_GetStackAccessControlContext(JNIEnv *env, jclass cls))
1284 JVMWrapper("JVM_GetStackAccessControlContext");
1285 if (!UsePrivilegedStack) return NULL;
1286
1287 ResourceMark rm(THREAD);
1288 GrowableArray<oop>* local_array = new GrowableArray<oop>(12);
1289 JvmtiVMObjectAllocEventCollector oam;
1290
1291 // count the protection domains on the execution stack. We collapse
1292 // duplicate consecutive protection domains into a single one, as
1293 // well as stopping when we hit a privileged frame.
1294
1295 // Use vframeStream to iterate through Java frames
1296 vframeStream vfst(thread);
1297
1298 oop previous_protection_domain = NULL;
1299 Handle privileged_context(thread, NULL);
1300 bool is_privileged = false;
1301 oop protection_domain = NULL;
1302
1303 for(; !vfst.at_end(); vfst.next()) {
1304 // get method of frame
1305 Method* method = vfst.method();
1306 intptr_t* frame_id = vfst.frame_id();
1307
1308 // check the privileged frames to see if we have a match
1309 if (thread->privileged_stack_top() && thread->privileged_stack_top()->frame_id() == frame_id) {
1310 // this frame is privileged
1311 is_privileged = true;
1312 privileged_context = Handle(thread, thread->privileged_stack_top()->privileged_context());
1313 protection_domain = thread->privileged_stack_top()->protection_domain();
1314 } else {
1315 protection_domain = method->method_holder()->protection_domain();
1316 }
1317
1318 if ((previous_protection_domain != protection_domain) && (protection_domain != NULL)) {
1319 local_array->push(protection_domain);
1320 previous_protection_domain = protection_domain;
1321 }
1322
1323 if (is_privileged) break;
1324 }
1325
1326
1327 // either all the domains on the stack were system domains, or
1328 // we had a privileged system domain
1329 if (local_array->is_empty()) {
1330 if (is_privileged && privileged_context.is_null()) return NULL;
1331
1332 oop result = java_security_AccessControlContext::create(objArrayHandle(), is_privileged, privileged_context, CHECK_NULL);
1333 return JNIHandles::make_local(env, result);
1334 }
1335
1336 // the resource area must be registered in case of a gc
1337 RegisterArrayForGC ragc(thread, local_array);
1338 objArrayOop context = oopFactory::new_objArray(SystemDictionary::ProtectionDomain_klass(),
1339 local_array->length(), CHECK_NULL);
1340 objArrayHandle h_context(thread, context);
1341 for (int index = 0; index < local_array->length(); index++) {
1342 h_context->obj_at_put(index, local_array->at(index));
1343 }
1344
1345 oop result = java_security_AccessControlContext::create(h_context, is_privileged, privileged_context, CHECK_NULL);
1346
1347 return JNIHandles::make_local(env, result);
1348 JVM_END
1349
1350
1351 JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
1352 JVMWrapper("JVM_IsArrayClass");
1353 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1354 return (k != NULL) && k->oop_is_array() ? true : false;
1355 JVM_END
1356
1357
1358 JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))
1359 JVMWrapper("JVM_IsPrimitiveClass");
1360 oop mirror = JNIHandles::resolve_non_null(cls);
1361 return (jboolean) java_lang_Class::is_primitive(mirror);
1362 JVM_END
1363
1364
1365 JVM_ENTRY(jint, JVM_GetClassModifiers(JNIEnv *env, jclass cls))
1366 JVMWrapper("JVM_GetClassModifiers");
1367 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1368 // Primitive type
1369 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
1370 }
1371
1372 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1373 debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0));
1374 assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK");
1375 return k->modifier_flags();
1376 JVM_END
1377
1378
1379 // Inner class reflection ///////////////////////////////////////////////////////////////////////////////
1380
1381 JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
1382 JvmtiVMObjectAllocEventCollector oam;
1383 // ofClass is a reference to a java_lang_Class object. The mirror object
1384 // of an InstanceKlass
1385
1386 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1387 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_instance()) {
1388 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
1389 return (jobjectArray)JNIHandles::make_local(env, result);
1390 }
1391
1392 instanceKlassHandle k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
1393 InnerClassesIterator iter(k);
1394
1395 if (iter.length() == 0) {
1396 // Neither an inner nor outer class
1397 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
1398 return (jobjectArray)JNIHandles::make_local(env, result);
1399 }
1400
1401 // find inner class info
1402 constantPoolHandle cp(thread, k->constants());
1403 int length = iter.length();
1404
1405 // Allocate temp. result array
1406 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), length/4, CHECK_NULL);
1407 objArrayHandle result (THREAD, r);
1408 int members = 0;
1409
1410 for (; !iter.done(); iter.next()) {
1411 int ioff = iter.inner_class_info_index();
1412 int ooff = iter.outer_class_info_index();
1413
1414 if (ioff != 0 && ooff != 0) {
1415 // Check to see if the name matches the class we're looking for
1416 // before attempting to find the class.
1417 if (cp->klass_name_at_matches(k, ooff)) {
1418 Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL);
1419 if (outer_klass == k()) {
1420 Klass* ik = cp->klass_at(ioff, CHECK_NULL);
1421 instanceKlassHandle inner_klass (THREAD, ik);
1422
1423 // Throws an exception if outer klass has not declared k as
1424 // an inner klass
1425 Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL);
1426
1427 result->obj_at_put(members, inner_klass->java_mirror());
1428 members++;
1429 }
1430 }
1431 }
1432 }
1433
1434 if (members != length) {
1435 // Return array of right length
1436 objArrayOop res = oopFactory::new_objArray(SystemDictionary::Class_klass(), members, CHECK_NULL);
1437 for(int i = 0; i < members; i++) {
1438 res->obj_at_put(i, result->obj_at(i));
1439 }
1440 return (jobjectArray)JNIHandles::make_local(env, res);
1441 }
1442
1443 return (jobjectArray)JNIHandles::make_local(env, result());
1444 JVM_END
1445
1446
1447 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
1448 {
1449 // ofClass is a reference to a java_lang_Class object.
1450 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1451 ! java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_instance()) {
1452 return NULL;
1453 }
1454
1455 bool inner_is_member = false;
1456 Klass* outer_klass
1457 = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))
1458 )->compute_enclosing_class(&inner_is_member, CHECK_NULL);
1459 if (outer_klass == NULL) return NULL; // already a top-level class
1460 if (!inner_is_member) return NULL; // an anonymous class (inside a method)
1461 return (jclass) JNIHandles::make_local(env, outer_klass->java_mirror());
1462 }
1463 JVM_END
1464
1465 // should be in InstanceKlass.cpp, but is here for historical reasons
1466 Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k,
1467 bool* inner_is_member,
1468 TRAPS) {
1469 Thread* thread = THREAD;
1470 InnerClassesIterator iter(k);
1471 if (iter.length() == 0) {
1472 // No inner class info => no declaring class
1473 return NULL;
1474 }
1475
1476 constantPoolHandle i_cp(thread, k->constants());
1477
1478 bool found = false;
1479 Klass* ok;
1480 instanceKlassHandle outer_klass;
1481 *inner_is_member = false;
1482
1483 // Find inner_klass attribute
1484 for (; !iter.done() && !found; iter.next()) {
1485 int ioff = iter.inner_class_info_index();
1486 int ooff = iter.outer_class_info_index();
1487 int noff = iter.inner_name_index();
1488 if (ioff != 0) {
1489 // Check to see if the name matches the class we're looking for
1490 // before attempting to find the class.
1491 if (i_cp->klass_name_at_matches(k, ioff)) {
1492 Klass* inner_klass = i_cp->klass_at(ioff, CHECK_NULL);
1493 found = (k() == inner_klass);
1494 if (found && ooff != 0) {
1495 ok = i_cp->klass_at(ooff, CHECK_NULL);
1496 outer_klass = instanceKlassHandle(thread, ok);
1497 *inner_is_member = true;
1498 }
1499 }
1500 }
1501 }
1502
1503 if (found && outer_klass.is_null()) {
1504 // It may be anonymous; try for that.
1505 int encl_method_class_idx = k->enclosing_method_class_index();
1506 if (encl_method_class_idx != 0) {
1507 ok = i_cp->klass_at(encl_method_class_idx, CHECK_NULL);
1508 outer_klass = instanceKlassHandle(thread, ok);
1509 *inner_is_member = false;
1510 }
1511 }
1512
1513 // If no inner class attribute found for this class.
1514 if (outer_klass.is_null()) return NULL;
1515
1516 // Throws an exception if outer klass has not declared k as an inner klass
1517 // We need evidence that each klass knows about the other, or else
1518 // the system could allow a spoof of an inner class to gain access rights.
1519 Reflection::check_for_inner_class(outer_klass, k, *inner_is_member, CHECK_NULL);
1520 return outer_klass();
1521 }
1522
1523 JVM_ENTRY(jstring, JVM_GetClassSignature(JNIEnv *env, jclass cls))
1524 assert (cls != NULL, "illegal class");
1525 JVMWrapper("JVM_GetClassSignature");
1526 JvmtiVMObjectAllocEventCollector oam;
1527 ResourceMark rm(THREAD);
1528 // Return null for arrays and primatives
1529 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1530 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1531 if (k->oop_is_instance()) {
1532 Symbol* sym = InstanceKlass::cast(k)->generic_signature();
1533 if (sym == NULL) return NULL;
1534 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
1535 return (jstring) JNIHandles::make_local(env, str());
1536 }
1537 }
1538 return NULL;
1539 JVM_END
1540
1541
1542 JVM_ENTRY(jbyteArray, JVM_GetClassAnnotations(JNIEnv *env, jclass cls))
1543 assert (cls != NULL, "illegal class");
1544 JVMWrapper("JVM_GetClassAnnotations");
1545
1546 // Return null for arrays and primitives
1547 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1548 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1549 if (k->oop_is_instance()) {
1550 typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
1551 return (jbyteArray) JNIHandles::make_local(env, a);
1552 }
1553 }
1554 return NULL;
1555 JVM_END
1556
1557
1558 static bool jvm_get_field_common(jobject field, fieldDescriptor& fd, TRAPS) {
1559 // some of this code was adapted from from jni_FromReflectedField
1560
1561 oop reflected = JNIHandles::resolve_non_null(field);
1562 oop mirror = java_lang_reflect_Field::clazz(reflected);
1563 Klass* k = java_lang_Class::as_Klass(mirror);
1564 int slot = java_lang_reflect_Field::slot(reflected);
1565 int modifiers = java_lang_reflect_Field::modifiers(reflected);
1566
1567 KlassHandle kh(THREAD, k);
1568 intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot);
1569
1570 if (modifiers & JVM_ACC_STATIC) {
1571 // for static fields we only look in the current class
1572 if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) {
1573 assert(false, "cannot find static field");
1574 return false;
1575 }
1576 } else {
1577 // for instance fields we start with the current class and work
1578 // our way up through the superclass chain
1579 if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) {
1580 assert(false, "cannot find instance field");
1581 return false;
1582 }
1583 }
1584 return true;
1585 }
1586
1587 static Method* jvm_get_method_common(jobject method) {
1588 // some of this code was adapted from from jni_FromReflectedMethod
1589
1590 oop reflected = JNIHandles::resolve_non_null(method);
1591 oop mirror = NULL;
1592 int slot = 0;
1593
1594 if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
1595 mirror = java_lang_reflect_Constructor::clazz(reflected);
1596 slot = java_lang_reflect_Constructor::slot(reflected);
1597 } else {
1598 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(),
1599 "wrong type");
1600 mirror = java_lang_reflect_Method::clazz(reflected);
1601 slot = java_lang_reflect_Method::slot(reflected);
1602 }
1603 Klass* k = java_lang_Class::as_Klass(mirror);
1604
1605 Method* m = InstanceKlass::cast(k)->method_with_idnum(slot);
1606 assert(m != NULL, "cannot find method");
1607 return m; // caller has to deal with NULL in product mode
1608 }
1609
1610 /* Type use annotations support (JDK 1.8) */
1611
1612 JVM_ENTRY(jbyteArray, JVM_GetClassTypeAnnotations(JNIEnv *env, jclass cls))
1613 assert (cls != NULL, "illegal class");
1614 JVMWrapper("JVM_GetClassTypeAnnotations");
1615 ResourceMark rm(THREAD);
1616 // Return null for arrays and primitives
1617 if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
1618 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
1619 if (k->oop_is_instance()) {
1620 AnnotationArray* type_annotations = InstanceKlass::cast(k)->class_type_annotations();
1621 if (type_annotations != NULL) {
1622 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
1623 return (jbyteArray) JNIHandles::make_local(env, a);
1624 }
1625 }
1626 }
1627 return NULL;
1628 JVM_END
1629
1630 JVM_ENTRY(jbyteArray, JVM_GetMethodTypeAnnotations(JNIEnv *env, jobject method))
1631 assert (method != NULL, "illegal method");
1632 JVMWrapper("JVM_GetMethodTypeAnnotations");
1633
1634 // method is a handle to a java.lang.reflect.Method object
1635 Method* m = jvm_get_method_common(method);
1636 if (m == NULL) {
1637 return NULL;
1638 }
1639
1640 AnnotationArray* type_annotations = m->type_annotations();
1641 if (type_annotations != NULL) {
1642 typeArrayOop a = Annotations::make_java_array(type_annotations, CHECK_NULL);
1643 return (jbyteArray) JNIHandles::make_local(env, a);
1644 }
1645
1646 return NULL;
1647 JVM_END
1648
1649 JVM_ENTRY(jbyteArray, JVM_GetFieldTypeAnnotations(JNIEnv *env, jobject field))
1650 assert (field != NULL, "illegal field");
1651 JVMWrapper("JVM_GetFieldTypeAnnotations");
1652
1653 fieldDescriptor fd;
1654 bool gotFd = jvm_get_field_common(field, fd, CHECK_NULL);
1655 if (!gotFd) {
1656 return NULL;
1657 }
1658
1659 return (jbyteArray) JNIHandles::make_local(env, Annotations::make_java_array(fd.type_annotations(), THREAD));
1660 JVM_END
1661
1662 static void bounds_check(constantPoolHandle cp, jint index, TRAPS) {
1663 if (!cp->is_within_bounds(index)) {
1664 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds");
1665 }
1666 }
1667
1668 JVM_ENTRY(jobjectArray, JVM_GetMethodParameters(JNIEnv *env, jobject method))
1669 {
1670 JVMWrapper("JVM_GetMethodParameters");
1671 // method is a handle to a java.lang.reflect.Method object
1672 Method* method_ptr = jvm_get_method_common(method);
1673 methodHandle mh (THREAD, method_ptr);
1674 Handle reflected_method (THREAD, JNIHandles::resolve_non_null(method));
1675 const int num_params = mh->method_parameters_length();
1676
1677 if (num_params < 0) {
1678 // A -1 return value from method_parameters_length means there is no
1679 // parameter data. Return null to indicate this to the reflection
1680 // API.
1681 assert(num_params == -1, "num_params should be -1 if it is less than zero");
1682 return (jobjectArray)NULL;
1683 } else {
1684 // Otherwise, we return something up to reflection, even if it is
1685 // a zero-length array. Why? Because in some cases this can
1686 // trigger a MalformedParametersException.
1687
1688 // make sure all the symbols are properly formatted
1689 for (int i = 0; i < num_params; i++) {
1690 MethodParametersElement* params = mh->method_parameters_start();
1691 int index = params[i].name_cp_index;
1692 bounds_check(mh->constants(), index, CHECK_NULL);
1693
1694 if (0 != index && !mh->constants()->tag_at(index).is_utf8()) {
1695 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
1696 "Wrong type at constant pool index");
1697 }
1698
1699 }
1700
1701 objArrayOop result_oop = oopFactory::new_objArray(SystemDictionary::reflect_Parameter_klass(), num_params, CHECK_NULL);
1702 objArrayHandle result (THREAD, result_oop);
1703
1704 for (int i = 0; i < num_params; i++) {
1705 MethodParametersElement* params = mh->method_parameters_start();
1706 // For a 0 index, give a NULL symbol
1707 Symbol* sym = 0 != params[i].name_cp_index ?
1708 mh->constants()->symbol_at(params[i].name_cp_index) : NULL;
1709 int flags = params[i].flags;
1710 oop param = Reflection::new_parameter(reflected_method, i, sym,
1711 flags, CHECK_NULL);
1712 result->obj_at_put(i, param);
1713 }
1714 return (jobjectArray)JNIHandles::make_local(env, result());
1715 }
1716 }
1717 JVM_END
1718
1719 // New (JDK 1.4) reflection implementation /////////////////////////////////////
1720
1721 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1722 {
1723 JVMWrapper("JVM_GetClassDeclaredFields");
1724 JvmtiVMObjectAllocEventCollector oam;
1725
1726 // Exclude primitive types and array types
1727 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
1728 java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_array()) {
1729 // Return empty array
1730 oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL);
1731 return (jobjectArray) JNIHandles::make_local(env, res);
1732 }
1733
1734 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
1735 constantPoolHandle cp(THREAD, k->constants());
1736
1737 // Ensure class is linked
1738 k->link_class(CHECK_NULL);
1739
1740 // 4496456 We need to filter out java.lang.Throwable.backtrace
1741 bool skip_backtrace = false;
1742
1743 // Allocate result
1744 int num_fields;
1745
1746 if (publicOnly) {
1747 num_fields = 0;
1748 for (JavaFieldStream fs(k()); !fs.done(); fs.next()) {
1749 if (fs.access_flags().is_public()) ++num_fields;
1750 }
1751 } else {
1752 num_fields = k->java_fields_count();
1753
1754 if (k() == SystemDictionary::Throwable_klass()) {
1755 num_fields--;
1756 skip_backtrace = true;
1757 }
1758 }
1759
1760 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), num_fields, CHECK_NULL);
1761 objArrayHandle result (THREAD, r);
1762
1763 int out_idx = 0;
1764 fieldDescriptor fd;
1765 for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
1766 if (skip_backtrace) {
1767 // 4496456 skip java.lang.Throwable.backtrace
1768 int offset = fs.offset();
1769 if (offset == java_lang_Throwable::get_backtrace_offset()) continue;
1770 }
1771
1772 if (!publicOnly || fs.access_flags().is_public()) {
1773 fd.reinitialize(k(), fs.index());
1774 oop field = Reflection::new_field(&fd, CHECK_NULL);
1775 result->obj_at_put(out_idx, field);
1776 ++out_idx;
1777 }
1778 }
1779 assert(out_idx == num_fields, "just checking");
1780 return (jobjectArray) JNIHandles::make_local(env, result());
1781 }
1782 JVM_END
1783
1784 static bool select_method(methodHandle method, bool want_constructor) {
1785 if (want_constructor) {
1786 return (method->is_initializer() && !method->is_static());
1787 } else {
1788 return (!method->is_initializer() && !method->is_overpass());
1789 }
1790 }
1791
1792 static jobjectArray get_class_declared_methods_helper(
1793 JNIEnv *env,
1794 jclass ofClass, jboolean publicOnly,
1795 bool want_constructor,
1796 Klass* klass, TRAPS) {
1797
1798 JvmtiVMObjectAllocEventCollector oam;
1799
1800 // Exclude primitive types and array types
1801 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
1802 || java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))->oop_is_array()) {
1803 // Return empty array
1804 oop res = oopFactory::new_objArray(klass, 0, CHECK_NULL);
1805 return (jobjectArray) JNIHandles::make_local(env, res);
1806 }
1807
1808 instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
1809
1810 // Ensure class is linked
1811 k->link_class(CHECK_NULL);
1812
1813 Array<Method*>* methods = k->methods();
1814 int methods_length = methods->length();
1815
1816 // Save original method_idnum in case of redefinition, which can change
1817 // the idnum of obsolete methods. The new method will have the same idnum
1818 // but if we refresh the methods array, the counts will be wrong.
1819 ResourceMark rm(THREAD);
1820 GrowableArray<int>* idnums = new GrowableArray<int>(methods_length);
1821 int num_methods = 0;
1822
1823 for (int i = 0; i < methods_length; i++) {
1824 methodHandle method(THREAD, methods->at(i));
1825 if (select_method(method, want_constructor)) {
1826 if (!publicOnly || method->is_public()) {
1827 idnums->push(method->method_idnum());
1828 ++num_methods;
1829 }
1830 }
1831 }
1832
1833 // Allocate result
1834 objArrayOop r = oopFactory::new_objArray(klass, num_methods, CHECK_NULL);
1835 objArrayHandle result (THREAD, r);
1836
1837 // Now just put the methods that we selected above, but go by their idnum
1838 // in case of redefinition. The methods can be redefined at any safepoint,
1839 // so above when allocating the oop array and below when creating reflect
1840 // objects.
1841 for (int i = 0; i < num_methods; i++) {
1842 methodHandle method(THREAD, k->method_with_idnum(idnums->at(i)));
1843 if (method.is_null()) {
1844 // Method may have been deleted and seems this API can handle null
1845 // Otherwise should probably put a method that throws NSME
1846 result->obj_at_put(i, NULL);
1847 } else {
1848 oop m;
1849 if (want_constructor) {
1850 m = Reflection::new_constructor(method, CHECK_NULL);
1851 } else {
1852 m = Reflection::new_method(method, false, CHECK_NULL);
1853 }
1854 result->obj_at_put(i, m);
1855 }
1856 }
1857
1858 return (jobjectArray) JNIHandles::make_local(env, result());
1859 }
1860
1861 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1862 {
1863 JVMWrapper("JVM_GetClassDeclaredMethods");
1864 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1865 /*want_constructor*/ false,
1866 SystemDictionary::reflect_Method_klass(), THREAD);
1867 }
1868 JVM_END
1869
1870 JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass, jboolean publicOnly))
1871 {
1872 JVMWrapper("JVM_GetClassDeclaredConstructors");
1873 return get_class_declared_methods_helper(env, ofClass, publicOnly,
1874 /*want_constructor*/ true,
1875 SystemDictionary::reflect_Constructor_klass(), THREAD);
1876 }
1877 JVM_END
1878
1879 JVM_ENTRY(jint, JVM_GetClassAccessFlags(JNIEnv *env, jclass cls))
1880 {
1881 JVMWrapper("JVM_GetClassAccessFlags");
1882 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1883 // Primitive type
1884 return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
1885 }
1886
1887 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1888 return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS;
1889 }
1890 JVM_END
1891
1892
1893 // Constant pool access //////////////////////////////////////////////////////////
1894
1895 JVM_ENTRY(jobject, JVM_GetClassConstantPool(JNIEnv *env, jclass cls))
1896 {
1897 JVMWrapper("JVM_GetClassConstantPool");
1898 JvmtiVMObjectAllocEventCollector oam;
1899
1900 // Return null for primitives and arrays
1901 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
1902 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1903 if (k->oop_is_instance()) {
1904 instanceKlassHandle k_h(THREAD, k);
1905 Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL);
1906 sun_reflect_ConstantPool::set_cp(jcp(), k_h->constants());
1907 return JNIHandles::make_local(jcp());
1908 }
1909 }
1910 return NULL;
1911 }
1912 JVM_END
1913
1914
1915 JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused))
1916 {
1917 JVMWrapper("JVM_ConstantPoolGetSize");
1918 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
1919 return cp->length();
1920 }
1921 JVM_END
1922
1923
1924 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject obj, jobject unused, jint index))
1925 {
1926 JVMWrapper("JVM_ConstantPoolGetClassAt");
1927 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
1928 bounds_check(cp, index, CHECK_NULL);
1929 constantTag tag = cp->tag_at(index);
1930 if (!tag.is_klass() && !tag.is_unresolved_klass()) {
1931 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
1932 }
1933 Klass* k = cp->klass_at(index, CHECK_NULL);
1934 return (jclass) JNIHandles::make_local(k->java_mirror());
1935 }
1936 JVM_END
1937
1938 JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
1939 {
1940 JVMWrapper("JVM_ConstantPoolGetClassAtIfLoaded");
1941 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
1942 bounds_check(cp, index, CHECK_NULL);
1943 constantTag tag = cp->tag_at(index);
1944 if (!tag.is_klass() && !tag.is_unresolved_klass()) {
1945 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
1946 }
1947 Klass* k = ConstantPool::klass_at_if_loaded(cp, index);
1948 if (k == NULL) return NULL;
1949 return (jclass) JNIHandles::make_local(k->java_mirror());
1950 }
1951 JVM_END
1952
1953 static jobject get_method_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) {
1954 constantTag tag = cp->tag_at(index);
1955 if (!tag.is_method() && !tag.is_interface_method()) {
1956 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
1957 }
1958 int klass_ref = cp->uncached_klass_ref_index_at(index);
1959 Klass* k_o;
1960 if (force_resolution) {
1961 k_o = cp->klass_at(klass_ref, CHECK_NULL);
1962 } else {
1963 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
1964 if (k_o == NULL) return NULL;
1965 }
1966 instanceKlassHandle k(THREAD, k_o);
1967 Symbol* name = cp->uncached_name_ref_at(index);
1968 Symbol* sig = cp->uncached_signature_ref_at(index);
1969 methodHandle m (THREAD, k->find_method(name, sig));
1970 if (m.is_null()) {
1971 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up method in target class");
1972 }
1973 oop method;
1974 if (!m->is_initializer() || m->is_static()) {
1975 method = Reflection::new_method(m, true, CHECK_NULL);
1976 } else {
1977 method = Reflection::new_constructor(m, CHECK_NULL);
1978 }
1979 return JNIHandles::make_local(method);
1980 }
1981
1982 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
1983 {
1984 JVMWrapper("JVM_ConstantPoolGetMethodAt");
1985 JvmtiVMObjectAllocEventCollector oam;
1986 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
1987 bounds_check(cp, index, CHECK_NULL);
1988 jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
1989 return res;
1990 }
1991 JVM_END
1992
1993 JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
1994 {
1995 JVMWrapper("JVM_ConstantPoolGetMethodAtIfLoaded");
1996 JvmtiVMObjectAllocEventCollector oam;
1997 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
1998 bounds_check(cp, index, CHECK_NULL);
1999 jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);
2000 return res;
2001 }
2002 JVM_END
2003
2004 static jobject get_field_at_helper(constantPoolHandle cp, jint index, bool force_resolution, TRAPS) {
2005 constantTag tag = cp->tag_at(index);
2006 if (!tag.is_field()) {
2007 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2008 }
2009 int klass_ref = cp->uncached_klass_ref_index_at(index);
2010 Klass* k_o;
2011 if (force_resolution) {
2012 k_o = cp->klass_at(klass_ref, CHECK_NULL);
2013 } else {
2014 k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
2015 if (k_o == NULL) return NULL;
2016 }
2017 instanceKlassHandle k(THREAD, k_o);
2018 Symbol* name = cp->uncached_name_ref_at(index);
2019 Symbol* sig = cp->uncached_signature_ref_at(index);
2020 fieldDescriptor fd;
2021 Klass* target_klass = k->find_field(name, sig, &fd);
2022 if (target_klass == NULL) {
2023 THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");
2024 }
2025 oop field = Reflection::new_field(&fd, CHECK_NULL);
2026 return JNIHandles::make_local(field);
2027 }
2028
2029 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject obj, jobject unusedl, jint index))
2030 {
2031 JVMWrapper("JVM_ConstantPoolGetFieldAt");
2032 JvmtiVMObjectAllocEventCollector oam;
2033 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2034 bounds_check(cp, index, CHECK_NULL);
2035 jobject res = get_field_at_helper(cp, index, true, CHECK_NULL);
2036 return res;
2037 }
2038 JVM_END
2039
2040 JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
2041 {
2042 JVMWrapper("JVM_ConstantPoolGetFieldAtIfLoaded");
2043 JvmtiVMObjectAllocEventCollector oam;
2044 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2045 bounds_check(cp, index, CHECK_NULL);
2046 jobject res = get_field_at_helper(cp, index, false, CHECK_NULL);
2047 return res;
2048 }
2049 JVM_END
2050
2051 JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2052 {
2053 JVMWrapper("JVM_ConstantPoolGetMemberRefInfoAt");
2054 JvmtiVMObjectAllocEventCollector oam;
2055 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2056 bounds_check(cp, index, CHECK_NULL);
2057 constantTag tag = cp->tag_at(index);
2058 if (!tag.is_field_or_method()) {
2059 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2060 }
2061 int klass_ref = cp->uncached_klass_ref_index_at(index);
2062 Symbol* klass_name = cp->klass_name_at(klass_ref);
2063 Symbol* member_name = cp->uncached_name_ref_at(index);
2064 Symbol* member_sig = cp->uncached_signature_ref_at(index);
2065 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::String_klass(), 3, CHECK_NULL);
2066 objArrayHandle dest(THREAD, dest_o);
2067 Handle str = java_lang_String::create_from_symbol(klass_name, CHECK_NULL);
2068 dest->obj_at_put(0, str());
2069 str = java_lang_String::create_from_symbol(member_name, CHECK_NULL);
2070 dest->obj_at_put(1, str());
2071 str = java_lang_String::create_from_symbol(member_sig, CHECK_NULL);
2072 dest->obj_at_put(2, str());
2073 return (jobjectArray) JNIHandles::make_local(dest());
2074 }
2075 JVM_END
2076
2077 JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2078 {
2079 JVMWrapper("JVM_ConstantPoolGetIntAt");
2080 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2081 bounds_check(cp, index, CHECK_0);
2082 constantTag tag = cp->tag_at(index);
2083 if (!tag.is_int()) {
2084 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2085 }
2086 return cp->int_at(index);
2087 }
2088 JVM_END
2089
2090 JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2091 {
2092 JVMWrapper("JVM_ConstantPoolGetLongAt");
2093 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2094 bounds_check(cp, index, CHECK_(0L));
2095 constantTag tag = cp->tag_at(index);
2096 if (!tag.is_long()) {
2097 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2098 }
2099 return cp->long_at(index);
2100 }
2101 JVM_END
2102
2103 JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2104 {
2105 JVMWrapper("JVM_ConstantPoolGetFloatAt");
2106 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2107 bounds_check(cp, index, CHECK_(0.0f));
2108 constantTag tag = cp->tag_at(index);
2109 if (!tag.is_float()) {
2110 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2111 }
2112 return cp->float_at(index);
2113 }
2114 JVM_END
2115
2116 JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2117 {
2118 JVMWrapper("JVM_ConstantPoolGetDoubleAt");
2119 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2120 bounds_check(cp, index, CHECK_(0.0));
2121 constantTag tag = cp->tag_at(index);
2122 if (!tag.is_double()) {
2123 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2124 }
2125 return cp->double_at(index);
2126 }
2127 JVM_END
2128
2129 JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject obj, jobject unused, jint index))
2130 {
2131 JVMWrapper("JVM_ConstantPoolGetStringAt");
2132 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2133 bounds_check(cp, index, CHECK_NULL);
2134 constantTag tag = cp->tag_at(index);
2135 if (!tag.is_string()) {
2136 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2137 }
2138 oop str = cp->string_at(index, CHECK_NULL);
2139 return (jstring) JNIHandles::make_local(str);
2140 }
2141 JVM_END
2142
2143 JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject obj, jobject unused, jint index))
2144 {
2145 JVMWrapper("JVM_ConstantPoolGetUTF8At");
2146 JvmtiVMObjectAllocEventCollector oam;
2147 constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
2148 bounds_check(cp, index, CHECK_NULL);
2149 constantTag tag = cp->tag_at(index);
2150 if (!tag.is_symbol()) {
2151 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
2152 }
2153 Symbol* sym = cp->symbol_at(index);
2154 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
2155 return (jstring) JNIHandles::make_local(str());
2156 }
2157 JVM_END
2158
2159
2160 // Assertion support. //////////////////////////////////////////////////////////
2161
2162 JVM_ENTRY(jboolean, JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls))
2163 JVMWrapper("JVM_DesiredAssertionStatus");
2164 assert(cls != NULL, "bad class");
2165
2166 oop r = JNIHandles::resolve(cls);
2167 assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed");
2168 if (java_lang_Class::is_primitive(r)) return false;
2169
2170 Klass* k = java_lang_Class::as_Klass(r);
2171 assert(k->oop_is_instance(), "must be an instance klass");
2172 if (! k->oop_is_instance()) return false;
2173
2174 ResourceMark rm(THREAD);
2175 const char* name = k->name()->as_C_string();
2176 bool system_class = k->class_loader() == NULL;
2177 return JavaAssertions::enabled(name, system_class);
2178
2179 JVM_END
2180
2181
2182 // Return a new AssertionStatusDirectives object with the fields filled in with
2183 // command-line assertion arguments (i.e., -ea, -da).
2184 JVM_ENTRY(jobject, JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused))
2185 JVMWrapper("JVM_AssertionStatusDirectives");
2186 JvmtiVMObjectAllocEventCollector oam;
2187 oop asd = JavaAssertions::createAssertionStatusDirectives(CHECK_NULL);
2188 return JNIHandles::make_local(env, asd);
2189 JVM_END
2190
2191 // Verification ////////////////////////////////////////////////////////////////////////////////
2192
2193 // Reflection for the verifier /////////////////////////////////////////////////////////////////
2194
2195 // RedefineClasses support: bug 6214132 caused verification to fail.
2196 // All functions from this section should call the jvmtiThreadSate function:
2197 // Klass* class_to_verify_considering_redefinition(Klass* klass).
2198 // The function returns a Klass* of the _scratch_class if the verifier
2199 // was invoked in the middle of the class redefinition.
2200 // Otherwise it returns its argument value which is the _the_class Klass*.
2201 // Please, refer to the description in the jvmtiThreadSate.hpp.
2202
2203 JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
2204 JVMWrapper("JVM_GetClassNameUTF");
2205 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2206 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2207 return k->name()->as_utf8();
2208 JVM_END
2209
2210
2211 JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
2212 JVMWrapper("JVM_GetClassCPTypes");
2213 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2214 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2215 // types will have length zero if this is not an InstanceKlass
2216 // (length is determined by call to JVM_GetClassCPEntriesCount)
2217 if (k->oop_is_instance()) {
2218 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2219 for (int index = cp->length() - 1; index >= 0; index--) {
2220 constantTag tag = cp->tag_at(index);
2221 types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : tag.value();
2222 }
2223 }
2224 JVM_END
2225
2226
2227 JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))
2228 JVMWrapper("JVM_GetClassCPEntriesCount");
2229 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2230 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2231 if (!k->oop_is_instance())
2232 return 0;
2233 return InstanceKlass::cast(k)->constants()->length();
2234 JVM_END
2235
2236
2237 JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))
2238 JVMWrapper("JVM_GetClassFieldsCount");
2239 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2240 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2241 if (!k->oop_is_instance())
2242 return 0;
2243 return InstanceKlass::cast(k)->java_fields_count();
2244 JVM_END
2245
2246
2247 JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))
2248 JVMWrapper("JVM_GetClassMethodsCount");
2249 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2250 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2251 if (!k->oop_is_instance())
2252 return 0;
2253 return InstanceKlass::cast(k)->methods()->length();
2254 JVM_END
2255
2256
2257 // The following methods, used for the verifier, are never called with
2258 // array klasses, so a direct cast to InstanceKlass is safe.
2259 // Typically, these methods are called in a loop with bounds determined
2260 // by the results of JVM_GetClass{Fields,Methods}Count, which return
2261 // zero for arrays.
2262 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions))
2263 JVMWrapper("JVM_GetMethodIxExceptionIndexes");
2264 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2265 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2266 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2267 int length = method->checked_exceptions_length();
2268 if (length > 0) {
2269 CheckedExceptionElement* table= method->checked_exceptions_start();
2270 for (int i = 0; i < length; i++) {
2271 exceptions[i] = table[i].class_cp_index;
2272 }
2273 }
2274 JVM_END
2275
2276
2277 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index))
2278 JVMWrapper("JVM_GetMethodIxExceptionsCount");
2279 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2280 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2281 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2282 return method->checked_exceptions_length();
2283 JVM_END
2284
2285
2286 JVM_QUICK_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code))
2287 JVMWrapper("JVM_GetMethodIxByteCode");
2288 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2289 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2290 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2291 memcpy(code, method->code_base(), method->code_size());
2292 JVM_END
2293
2294
2295 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index))
2296 JVMWrapper("JVM_GetMethodIxByteCodeLength");
2297 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2298 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2299 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2300 return method->code_size();
2301 JVM_END
2302
2303
2304 JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry))
2305 JVMWrapper("JVM_GetMethodIxExceptionTableEntry");
2306 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2307 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2308 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2309 ExceptionTable extable(method);
2310 entry->start_pc = extable.start_pc(entry_index);
2311 entry->end_pc = extable.end_pc(entry_index);
2312 entry->handler_pc = extable.handler_pc(entry_index);
2313 entry->catchType = extable.catch_type_index(entry_index);
2314 JVM_END
2315
2316
2317 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index))
2318 JVMWrapper("JVM_GetMethodIxExceptionTableLength");
2319 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2320 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2321 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2322 return method->exception_table_length();
2323 JVM_END
2324
2325
2326 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index))
2327 JVMWrapper("JVM_GetMethodIxModifiers");
2328 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2329 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2330 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2331 return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
2332 JVM_END
2333
2334
2335 JVM_QUICK_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index))
2336 JVMWrapper("JVM_GetFieldIxModifiers");
2337 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2338 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2339 return InstanceKlass::cast(k)->field_access_flags(field_index) & JVM_RECOGNIZED_FIELD_MODIFIERS;
2340 JVM_END
2341
2342
2343 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index))
2344 JVMWrapper("JVM_GetMethodIxLocalsCount");
2345 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2346 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2347 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2348 return method->max_locals();
2349 JVM_END
2350
2351
2352 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
2353 JVMWrapper("JVM_GetMethodIxArgsSize");
2354 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2355 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2356 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2357 return method->size_of_parameters();
2358 JVM_END
2359
2360
2361 JVM_QUICK_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
2362 JVMWrapper("JVM_GetMethodIxMaxStack");
2363 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2364 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2365 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2366 return method->verifier_max_stack();
2367 JVM_END
2368
2369
2370 JVM_QUICK_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
2371 JVMWrapper("JVM_IsConstructorIx");
2372 ResourceMark rm(THREAD);
2373 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2374 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2375 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2376 return method->name() == vmSymbols::object_initializer_name();
2377 JVM_END
2378
2379
2380 JVM_QUICK_ENTRY(jboolean, JVM_IsVMGeneratedMethodIx(JNIEnv *env, jclass cls, int method_index))
2381 JVMWrapper("JVM_IsVMGeneratedMethodIx");
2382 ResourceMark rm(THREAD);
2383 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2384 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2385 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2386 return method->is_overpass();
2387 JVM_END
2388
2389 JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
2390 JVMWrapper("JVM_GetMethodIxIxUTF");
2391 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2392 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2393 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2394 return method->name()->as_utf8();
2395 JVM_END
2396
2397
2398 JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
2399 JVMWrapper("JVM_GetMethodIxSignatureUTF");
2400 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2401 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2402 Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
2403 return method->signature()->as_utf8();
2404 JVM_END
2405
2406 /**
2407 * All of these JVM_GetCP-xxx methods are used by the old verifier to
2408 * read entries in the constant pool. Since the old verifier always
2409 * works on a copy of the code, it will not see any rewriting that
2410 * may possibly occur in the middle of verification. So it is important
2411 * that nothing it calls tries to use the cpCache instead of the raw
2412 * constant pool, so we must use cp->uncached_x methods when appropriate.
2413 */
2414 JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2415 JVMWrapper("JVM_GetCPFieldNameUTF");
2416 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2417 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2418 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2419 switch (cp->tag_at(cp_index).value()) {
2420 case JVM_CONSTANT_Fieldref:
2421 return cp->uncached_name_ref_at(cp_index)->as_utf8();
2422 default:
2423 fatal("JVM_GetCPFieldNameUTF: illegal constant");
2424 }
2425 ShouldNotReachHere();
2426 return NULL;
2427 JVM_END
2428
2429
2430 JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2431 JVMWrapper("JVM_GetCPMethodNameUTF");
2432 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2433 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2434 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2435 switch (cp->tag_at(cp_index).value()) {
2436 case JVM_CONSTANT_InterfaceMethodref:
2437 case JVM_CONSTANT_Methodref:
2438 case JVM_CONSTANT_NameAndType: // for invokedynamic
2439 return cp->uncached_name_ref_at(cp_index)->as_utf8();
2440 default:
2441 fatal("JVM_GetCPMethodNameUTF: illegal constant");
2442 }
2443 ShouldNotReachHere();
2444 return NULL;
2445 JVM_END
2446
2447
2448 JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
2449 JVMWrapper("JVM_GetCPMethodSignatureUTF");
2450 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2451 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2452 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2453 switch (cp->tag_at(cp_index).value()) {
2454 case JVM_CONSTANT_InterfaceMethodref:
2455 case JVM_CONSTANT_Methodref:
2456 case JVM_CONSTANT_NameAndType: // for invokedynamic
2457 return cp->uncached_signature_ref_at(cp_index)->as_utf8();
2458 default:
2459 fatal("JVM_GetCPMethodSignatureUTF: illegal constant");
2460 }
2461 ShouldNotReachHere();
2462 return NULL;
2463 JVM_END
2464
2465
2466 JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
2467 JVMWrapper("JVM_GetCPFieldSignatureUTF");
2468 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2469 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2470 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2471 switch (cp->tag_at(cp_index).value()) {
2472 case JVM_CONSTANT_Fieldref:
2473 return cp->uncached_signature_ref_at(cp_index)->as_utf8();
2474 default:
2475 fatal("JVM_GetCPFieldSignatureUTF: illegal constant");
2476 }
2477 ShouldNotReachHere();
2478 return NULL;
2479 JVM_END
2480
2481
2482 JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2483 JVMWrapper("JVM_GetCPClassNameUTF");
2484 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2485 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2486 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2487 Symbol* classname = cp->klass_name_at(cp_index);
2488 return classname->as_utf8();
2489 JVM_END
2490
2491
2492 JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2493 JVMWrapper("JVM_GetCPFieldClassNameUTF");
2494 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2495 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2496 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2497 switch (cp->tag_at(cp_index).value()) {
2498 case JVM_CONSTANT_Fieldref: {
2499 int class_index = cp->uncached_klass_ref_index_at(cp_index);
2500 Symbol* classname = cp->klass_name_at(class_index);
2501 return classname->as_utf8();
2502 }
2503 default:
2504 fatal("JVM_GetCPFieldClassNameUTF: illegal constant");
2505 }
2506 ShouldNotReachHere();
2507 return NULL;
2508 JVM_END
2509
2510
2511 JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
2512 JVMWrapper("JVM_GetCPMethodClassNameUTF");
2513 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2514 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2515 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2516 switch (cp->tag_at(cp_index).value()) {
2517 case JVM_CONSTANT_Methodref:
2518 case JVM_CONSTANT_InterfaceMethodref: {
2519 int class_index = cp->uncached_klass_ref_index_at(cp_index);
2520 Symbol* classname = cp->klass_name_at(class_index);
2521 return classname->as_utf8();
2522 }
2523 default:
2524 fatal("JVM_GetCPMethodClassNameUTF: illegal constant");
2525 }
2526 ShouldNotReachHere();
2527 return NULL;
2528 JVM_END
2529
2530
2531 JVM_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
2532 JVMWrapper("JVM_GetCPFieldModifiers");
2533 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2534 Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls));
2535 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2536 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
2537 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2538 ConstantPool* cp_called = InstanceKlass::cast(k_called)->constants();
2539 switch (cp->tag_at(cp_index).value()) {
2540 case JVM_CONSTANT_Fieldref: {
2541 Symbol* name = cp->uncached_name_ref_at(cp_index);
2542 Symbol* signature = cp->uncached_signature_ref_at(cp_index);
2543 for (JavaFieldStream fs(k_called); !fs.done(); fs.next()) {
2544 if (fs.name() == name && fs.signature() == signature) {
2545 return fs.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS;
2546 }
2547 }
2548 return -1;
2549 }
2550 default:
2551 fatal("JVM_GetCPFieldModifiers: illegal constant");
2552 }
2553 ShouldNotReachHere();
2554 return 0;
2555 JVM_END
2556
2557
2558 JVM_QUICK_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
2559 JVMWrapper("JVM_GetCPMethodModifiers");
2560 Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
2561 Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls));
2562 k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
2563 k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
2564 ConstantPool* cp = InstanceKlass::cast(k)->constants();
2565 switch (cp->tag_at(cp_index).value()) {
2566 case JVM_CONSTANT_Methodref:
2567 case JVM_CONSTANT_InterfaceMethodref: {
2568 Symbol* name = cp->uncached_name_ref_at(cp_index);
2569 Symbol* signature = cp->uncached_signature_ref_at(cp_index);
2570 Array<Method*>* methods = InstanceKlass::cast(k_called)->methods();
2571 int methods_count = methods->length();
2572 for (int i = 0; i < methods_count; i++) {
2573 Method* method = methods->at(i);
2574 if (method->name() == name && method->signature() == signature) {
2575 return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
2576 }
2577 }
2578 return -1;
2579 }
2580 default:
2581 fatal("JVM_GetCPMethodModifiers: illegal constant");
2582 }
2583 ShouldNotReachHere();
2584 return 0;
2585 JVM_END
2586
2587
2588 // Misc //////////////////////////////////////////////////////////////////////////////////////////////
2589
2590 JVM_LEAF(void, JVM_ReleaseUTF(const char *utf))
2591 // So long as UTF8::convert_to_utf8 returns resource strings, we don't have to do anything
2592 JVM_END
2593
2594
2595 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2))
2596 JVMWrapper("JVM_IsSameClassPackage");
2597 oop class1_mirror = JNIHandles::resolve_non_null(class1);
2598 oop class2_mirror = JNIHandles::resolve_non_null(class2);
2599 Klass* klass1 = java_lang_Class::as_Klass(class1_mirror);
2600 Klass* klass2 = java_lang_Class::as_Klass(class2_mirror);
2601 return (jboolean) Reflection::is_same_class_package(klass1, klass2);
2602 JVM_END
2603
2604 // Printing support //////////////////////////////////////////////////
2605 extern "C" {
2606
2607 ATTRIBUTE_PRINTF(3, 0)
2608 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {
2609 // see bug 4399518, 4417214
2610 if ((intptr_t)count <= 0) return -1;
2611
2612 int result = vsnprintf(str, count, fmt, args);
2613 // Note: on truncation vsnprintf(3) on Unix returns numbers of
2614 // characters which would have been written had the buffer been large
2615 // enough; on Windows, it returns -1. We handle both cases here and
2616 // always return -1, and perform null termination.
2617 if ((result > 0 && (size_t)result >= count) || result == -1) {
2618 str[count - 1] = '\0';
2619 result = -1;
2620 }
2621
2622 return result;
2623 }
2624
2625 ATTRIBUTE_PRINTF(3, 0)
2626 int jio_snprintf(char *str, size_t count, const char *fmt, ...) {
2627 va_list args;
2628 int len;
2629 va_start(args, fmt);
2630 len = jio_vsnprintf(str, count, fmt, args);
2631 va_end(args);
2632 return len;
2633 }
2634
2635 ATTRIBUTE_PRINTF(2,3)
2636 int jio_fprintf(FILE* f, const char *fmt, ...) {
2637 int len;
2638 va_list args;
2639 va_start(args, fmt);
2640 len = jio_vfprintf(f, fmt, args);
2641 va_end(args);
2642 return len;
2643 }
2644
2645 ATTRIBUTE_PRINTF(2, 0)
2646 int jio_vfprintf(FILE* f, const char *fmt, va_list args) {
2647 if (Arguments::vfprintf_hook() != NULL) {
2648 return Arguments::vfprintf_hook()(f, fmt, args);
2649 } else {
2650 return vfprintf(f, fmt, args);
2651 }
2652 }
2653
2654 ATTRIBUTE_PRINTF(1, 2)
2655 JNIEXPORT int jio_printf(const char *fmt, ...) {
2656 int len;
2657 va_list args;
2658 va_start(args, fmt);
2659 len = jio_vfprintf(defaultStream::output_stream(), fmt, args);
2660 va_end(args);
2661 return len;
2662 }
2663
2664
2665 // HotSpot specific jio method
2666 void jio_print(const char* s) {
2667 // Try to make this function as atomic as possible.
2668 if (Arguments::vfprintf_hook() != NULL) {
2669 jio_fprintf(defaultStream::output_stream(), "%s", s);
2670 } else {
2671 // Make an unused local variable to avoid warning from gcc 4.x compiler.
2672 size_t count = ::write(defaultStream::output_fd(), s, (int)strlen(s));
2673 }
2674 }
2675
2676 } // Extern C
2677
2678 // java.lang.Thread //////////////////////////////////////////////////////////////////////////////
2679
2680 // In most of the JVM Thread support functions we need to be sure to lock the Threads_lock
2681 // to prevent the target thread from exiting after we have a pointer to the C++ Thread or
2682 // OSThread objects. The exception to this rule is when the target object is the thread
2683 // doing the operation, in which case we know that the thread won't exit until the
2684 // operation is done (all exits being voluntary). There are a few cases where it is
2685 // rather silly to do operations on yourself, like resuming yourself or asking whether
2686 // you are alive. While these can still happen, they are not subject to deadlocks if
2687 // the lock is held while the operation occurs (this is not the case for suspend, for
2688 // instance), and are very unlikely. Because IsAlive needs to be fast and its
2689 // implementation is local to this file, we always lock Threads_lock for that one.
2690
2691 static void thread_entry(JavaThread* thread, TRAPS) {
2692 HandleMark hm(THREAD);
2693 Handle obj(THREAD, thread->threadObj());
2694 JavaValue result(T_VOID);
2695 JavaCalls::call_virtual(&result,
2696 obj,
2697 KlassHandle(THREAD, SystemDictionary::Thread_klass()),
2698 vmSymbols::run_method_name(),
2699 vmSymbols::void_method_signature(),
2700 THREAD);
2701 }
2702
2703
2704 JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
2705 JVMWrapper("JVM_StartThread");
2706 JavaThread *native_thread = NULL;
2707
2708 // We cannot hold the Threads_lock when we throw an exception,
2709 // due to rank ordering issues. Example: we might need to grab the
2710 // Heap_lock while we construct the exception.
2711 bool throw_illegal_thread_state = false;
2712
2713 // We must release the Threads_lock before we can post a jvmti event
2714 // in Thread::start.
2715 {
2716 // Ensure that the C++ Thread and OSThread structures aren't freed before
2717 // we operate.
2718 MutexLocker mu(Threads_lock);
2719
2720 // Since JDK 5 the java.lang.Thread threadStatus is used to prevent
2721 // re-starting an already started thread, so we should usually find
2722 // that the JavaThread is null. However for a JNI attached thread
2723 // there is a small window between the Thread object being created
2724 // (with its JavaThread set) and the update to its threadStatus, so we
2725 // have to check for this
2726 if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {
2727 throw_illegal_thread_state = true;
2728 } else {
2729 // We could also check the stillborn flag to see if this thread was already stopped, but
2730 // for historical reasons we let the thread detect that itself when it starts running
2731
2732 jlong size =
2733 java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
2734 // Allocate the C++ Thread structure and create the native thread. The
2735 // stack size retrieved from java is signed, but the constructor takes
2736 // size_t (an unsigned type), so avoid passing negative values which would
2737 // result in really large stacks.
2738 size_t sz = size > 0 ? (size_t) size : 0;
2739 native_thread = new JavaThread(&thread_entry, sz);
2740
2741 // At this point it may be possible that no osthread was created for the
2742 // JavaThread due to lack of memory. Check for this situation and throw
2743 // an exception if necessary. Eventually we may want to change this so
2744 // that we only grab the lock if the thread was created successfully -
2745 // then we can also do this check and throw the exception in the
2746 // JavaThread constructor.
2747 if (native_thread->osthread() != NULL) {
2748 // Note: the current thread is not being used within "prepare".
2749 native_thread->prepare(jthread);
2750 }
2751 }
2752 }
2753
2754 if (throw_illegal_thread_state) {
2755 THROW(vmSymbols::java_lang_IllegalThreadStateException());
2756 }
2757
2758 assert(native_thread != NULL, "Starting null thread?");
2759
2760 if (native_thread->osthread() == NULL) {
2761 // No one should hold a reference to the 'native_thread'.
2762 delete native_thread;
2763 if (JvmtiExport::should_post_resource_exhausted()) {
2764 JvmtiExport::post_resource_exhausted(
2765 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,
2766 os::native_thread_creation_failed_msg());
2767 }
2768 THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
2769 os::native_thread_creation_failed_msg());
2770 }
2771
2772 Thread::start(native_thread);
2773
2774 JVM_END
2775
2776 // JVM_Stop is implemented using a VM_Operation, so threads are forced to safepoints
2777 // before the quasi-asynchronous exception is delivered. This is a little obtrusive,
2778 // but is thought to be reliable and simple. In the case, where the receiver is the
2779 // same thread as the sender, no safepoint is needed.
2780 JVM_ENTRY(void, JVM_StopThread(JNIEnv* env, jobject jthread, jobject throwable))
2781 JVMWrapper("JVM_StopThread");
2782
2783 oop java_throwable = JNIHandles::resolve(throwable);
2784 if (java_throwable == NULL) {
2785 THROW(vmSymbols::java_lang_NullPointerException());
2786 }
2787 oop java_thread = JNIHandles::resolve_non_null(jthread);
2788 JavaThread* receiver = java_lang_Thread::thread(java_thread);
2789 Events::log_exception(JavaThread::current(),
2790 "JVM_StopThread thread JavaThread " INTPTR_FORMAT " as oop " INTPTR_FORMAT " [exception " INTPTR_FORMAT "]",
2791 p2i(receiver), p2i((address)java_thread), p2i(throwable));
2792 // First check if thread is alive
2793 if (receiver != NULL) {
2794 // Check if exception is getting thrown at self (use oop equality, since the
2795 // target object might exit)
2796 if (java_thread == thread->threadObj()) {
2797 THROW_OOP(java_throwable);
2798 } else {
2799 // Enques a VM_Operation to stop all threads and then deliver the exception...
2800 Thread::send_async_exception(java_thread, JNIHandles::resolve(throwable));
2801 }
2802 }
2803 else {
2804 // Either:
2805 // - target thread has not been started before being stopped, or
2806 // - target thread already terminated
2807 // We could read the threadStatus to determine which case it is
2808 // but that is overkill as it doesn't matter. We must set the
2809 // stillborn flag for the first case, and if the thread has already
2810 // exited setting this flag has no affect
2811 java_lang_Thread::set_stillborn(java_thread);
2812 }
2813 JVM_END
2814
2815
2816 JVM_ENTRY(jboolean, JVM_IsThreadAlive(JNIEnv* env, jobject jthread))
2817 JVMWrapper("JVM_IsThreadAlive");
2818
2819 oop thread_oop = JNIHandles::resolve_non_null(jthread);
2820 return java_lang_Thread::is_alive(thread_oop);
2821 JVM_END
2822
2823
2824 JVM_ENTRY(void, JVM_SuspendThread(JNIEnv* env, jobject jthread))
2825 JVMWrapper("JVM_SuspendThread");
2826 oop java_thread = JNIHandles::resolve_non_null(jthread);
2827 JavaThread* receiver = java_lang_Thread::thread(java_thread);
2828
2829 if (receiver != NULL) {
2830 // thread has run and has not exited (still on threads list)
2831
2832 {
2833 MutexLockerEx ml(receiver->SR_lock(), Mutex::_no_safepoint_check_flag);
2834 if (receiver->is_external_suspend()) {
2835 // Don't allow nested external suspend requests. We can't return
2836 // an error from this interface so just ignore the problem.
2837 return;
2838 }
2839 if (receiver->is_exiting()) { // thread is in the process of exiting
2840 return;
2841 }
2842 receiver->set_external_suspend();
2843 }
2844
2845 // java_suspend() will catch threads in the process of exiting
2846 // and will ignore them.
2847 receiver->java_suspend();
2848
2849 // It would be nice to have the following assertion in all the
2850 // time, but it is possible for a racing resume request to have
2851 // resumed this thread right after we suspended it. Temporarily
2852 // enable this assertion if you are chasing a different kind of
2853 // bug.
2854 //
2855 // assert(java_lang_Thread::thread(receiver->threadObj()) == NULL ||
2856 // receiver->is_being_ext_suspended(), "thread is not suspended");
2857 }
2858 JVM_END
2859
2860
2861 JVM_ENTRY(void, JVM_ResumeThread(JNIEnv* env, jobject jthread))
2862 JVMWrapper("JVM_ResumeThread");
2863 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate.
2864 // We need to *always* get the threads lock here, since this operation cannot be allowed during
2865 // a safepoint. The safepoint code relies on suspending a thread to examine its state. If other
2866 // threads randomly resumes threads, then a thread might not be suspended when the safepoint code
2867 // looks at it.
2868 MutexLocker ml(Threads_lock);
2869 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
2870 if (thr != NULL) {
2871 // the thread has run and is not in the process of exiting
2872 thr->java_resume();
2873 }
2874 JVM_END
2875
2876
2877 JVM_ENTRY(void, JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio))
2878 JVMWrapper("JVM_SetThreadPriority");
2879 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
2880 MutexLocker ml(Threads_lock);
2881 oop java_thread = JNIHandles::resolve_non_null(jthread);
2882 java_lang_Thread::set_priority(java_thread, (ThreadPriority)prio);
2883 JavaThread* thr = java_lang_Thread::thread(java_thread);
2884 if (thr != NULL) { // Thread not yet started; priority pushed down when it is
2885 Thread::set_priority(thr, (ThreadPriority)prio);
2886 }
2887 JVM_END
2888
2889
2890 JVM_ENTRY(void, JVM_Yield(JNIEnv *env, jclass threadClass))
2891 JVMWrapper("JVM_Yield");
2892 if (os::dont_yield()) return;
2893 HOTSPOT_THREAD_YIELD();
2894
2895 // When ConvertYieldToSleep is off (default), this matches the classic VM use of yield.
2896 // Critical for similar threading behaviour
2897 if (ConvertYieldToSleep) {
2898 os::sleep(thread, MinSleepInterval, false);
2899 } else {
2900 os::naked_yield();
2901 }
2902 JVM_END
2903
2904
2905 JVM_ENTRY(void, JVM_Sleep(JNIEnv* env, jclass threadClass, jlong millis))
2906 JVMWrapper("JVM_Sleep");
2907
2908 if (millis < 0) {
2909 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "timeout value is negative");
2910 }
2911
2912 if (Thread::is_interrupted (THREAD, true) && !HAS_PENDING_EXCEPTION) {
2913 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
2914 }
2915
2916 // Save current thread state and restore it at the end of this block.
2917 // And set new thread state to SLEEPING.
2918 JavaThreadSleepState jtss(thread);
2919
2920 HOTSPOT_THREAD_SLEEP_BEGIN(millis);
2921
2922 EventThreadSleep event;
2923
2924 if (millis == 0) {
2925 // When ConvertSleepToYield is on, this matches the classic VM implementation of
2926 // JVM_Sleep. Critical for similar threading behaviour (Win32)
2927 // It appears that in certain GUI contexts, it may be beneficial to do a short sleep
2928 // for SOLARIS
2929 if (ConvertSleepToYield) {
2930 os::naked_yield();
2931 } else {
2932 ThreadState old_state = thread->osthread()->get_state();
2933 thread->osthread()->set_state(SLEEPING);
2934 os::sleep(thread, MinSleepInterval, false);
2935 thread->osthread()->set_state(old_state);
2936 }
2937 } else {
2938 ThreadState old_state = thread->osthread()->get_state();
2939 thread->osthread()->set_state(SLEEPING);
2940 if (os::sleep(thread, millis, true) == OS_INTRPT) {
2941 // An asynchronous exception (e.g., ThreadDeathException) could have been thrown on
2942 // us while we were sleeping. We do not overwrite those.
2943 if (!HAS_PENDING_EXCEPTION) {
2944 if (event.should_commit()) {
2945 event.set_time(millis);
2946 event.commit();
2947 }
2948 HOTSPOT_THREAD_SLEEP_END(1);
2949
2950 // TODO-FIXME: THROW_MSG returns which means we will not call set_state()
2951 // to properly restore the thread state. That's likely wrong.
2952 THROW_MSG(vmSymbols::java_lang_InterruptedException(), "sleep interrupted");
2953 }
2954 }
2955 thread->osthread()->set_state(old_state);
2956 }
2957 if (event.should_commit()) {
2958 event.set_time(millis);
2959 event.commit();
2960 }
2961 HOTSPOT_THREAD_SLEEP_END(0);
2962 JVM_END
2963
2964 JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass))
2965 JVMWrapper("JVM_CurrentThread");
2966 oop jthread = thread->threadObj();
2967 assert (thread != NULL, "no current thread!");
2968 return JNIHandles::make_local(env, jthread);
2969 JVM_END
2970
2971
2972 JVM_ENTRY(jint, JVM_CountStackFrames(JNIEnv* env, jobject jthread))
2973 JVMWrapper("JVM_CountStackFrames");
2974
2975 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
2976 oop java_thread = JNIHandles::resolve_non_null(jthread);
2977 bool throw_illegal_thread_state = false;
2978 int count = 0;
2979
2980 {
2981 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
2982 // We need to re-resolve the java_thread, since a GC might have happened during the
2983 // acquire of the lock
2984 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
2985
2986 if (thr == NULL) {
2987 // do nothing
2988 } else if(! thr->is_external_suspend() || ! thr->frame_anchor()->walkable()) {
2989 // Check whether this java thread has been suspended already. If not, throws
2990 // IllegalThreadStateException. We defer to throw that exception until
2991 // Threads_lock is released since loading exception class has to leave VM.
2992 // The correct way to test a thread is actually suspended is
2993 // wait_for_ext_suspend_completion(), but we can't call that while holding
2994 // the Threads_lock. The above tests are sufficient for our purposes
2995 // provided the walkability of the stack is stable - which it isn't
2996 // 100% but close enough for most practical purposes.
2997 throw_illegal_thread_state = true;
2998 } else {
2999 // Count all java activation, i.e., number of vframes
3000 for(vframeStream vfst(thr); !vfst.at_end(); vfst.next()) {
3001 // Native frames are not counted
3002 if (!vfst.method()->is_native()) count++;
3003 }
3004 }
3005 }
3006
3007 if (throw_illegal_thread_state) {
3008 THROW_MSG_0(vmSymbols::java_lang_IllegalThreadStateException(),
3009 "this thread is not suspended");
3010 }
3011 return count;
3012 JVM_END
3013
3014 // Consider: A better way to implement JVM_Interrupt() is to acquire
3015 // Threads_lock to resolve the jthread into a Thread pointer, fetch
3016 // Thread->platformevent, Thread->native_thr, Thread->parker, etc.,
3017 // drop Threads_lock, and the perform the unpark() and thr_kill() operations
3018 // outside the critical section. Threads_lock is hot so we want to minimize
3019 // the hold-time. A cleaner interface would be to decompose interrupt into
3020 // two steps. The 1st phase, performed under Threads_lock, would return
3021 // a closure that'd be invoked after Threads_lock was dropped.
3022 // This tactic is safe as PlatformEvent and Parkers are type-stable (TSM) and
3023 // admit spurious wakeups.
3024
3025 JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
3026 JVMWrapper("JVM_Interrupt");
3027
3028 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
3029 oop java_thread = JNIHandles::resolve_non_null(jthread);
3030 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
3031 // We need to re-resolve the java_thread, since a GC might have happened during the
3032 // acquire of the lock
3033 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
3034 if (thr != NULL) {
3035 Thread::interrupt(thr);
3036 }
3037 JVM_END
3038
3039
3040 JVM_QUICK_ENTRY(jboolean, JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clear_interrupted))
3041 JVMWrapper("JVM_IsInterrupted");
3042
3043 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate
3044 oop java_thread = JNIHandles::resolve_non_null(jthread);
3045 MutexLockerEx ml(thread->threadObj() == java_thread ? NULL : Threads_lock);
3046 // We need to re-resolve the java_thread, since a GC might have happened during the
3047 // acquire of the lock
3048 JavaThread* thr = java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread));
3049 if (thr == NULL) {
3050 return JNI_FALSE;
3051 } else {
3052 return (jboolean) Thread::is_interrupted(thr, clear_interrupted != 0);
3053 }
3054 JVM_END
3055
3056
3057 // Return true iff the current thread has locked the object passed in
3058
3059 JVM_ENTRY(jboolean, JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj))
3060 JVMWrapper("JVM_HoldsLock");
3061 assert(THREAD->is_Java_thread(), "sanity check");
3062 if (obj == NULL) {
3063 THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE);
3064 }
3065 Handle h_obj(THREAD, JNIHandles::resolve(obj));
3066 return ObjectSynchronizer::current_thread_holds_lock((JavaThread*)THREAD, h_obj);
3067 JVM_END
3068
3069
3070 JVM_ENTRY(void, JVM_DumpAllStacks(JNIEnv* env, jclass))
3071 JVMWrapper("JVM_DumpAllStacks");
3072 VM_PrintThreads op;
3073 VMThread::execute(&op);
3074 if (JvmtiExport::should_post_data_dump()) {
3075 JvmtiExport::post_data_dump();
3076 }
3077 JVM_END
3078
3079 JVM_ENTRY(void, JVM_SetNativeThreadName(JNIEnv* env, jobject jthread, jstring name))
3080 JVMWrapper("JVM_SetNativeThreadName");
3081 ResourceMark rm(THREAD);
3082 oop java_thread = JNIHandles::resolve_non_null(jthread);
3083 JavaThread* thr = java_lang_Thread::thread(java_thread);
3084 // Thread naming only supported for the current thread, doesn't work for
3085 // target threads.
3086 if (Thread::current() == thr && !thr->has_attached_via_jni()) {
3087 // we don't set the name of an attached thread to avoid stepping
3088 // on other programs
3089 const char *thread_name = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name));
3090 os::set_native_thread_name(thread_name);
3091 }
3092 JVM_END
3093
3094 // java.lang.SecurityManager ///////////////////////////////////////////////////////////////////////
3095
3096 static bool is_trusted_frame(JavaThread* jthread, vframeStream* vfst) {
3097 assert(jthread->is_Java_thread(), "must be a Java thread");
3098 if (jthread->privileged_stack_top() == NULL) return false;
3099 if (jthread->privileged_stack_top()->frame_id() == vfst->frame_id()) {
3100 oop loader = jthread->privileged_stack_top()->class_loader();
3101 if (loader == NULL) return true;
3102 bool trusted = java_lang_ClassLoader::is_trusted_loader(loader);
3103 if (trusted) return true;
3104 }
3105 return false;
3106 }
3107
3108 JVM_ENTRY(jclass, JVM_CurrentLoadedClass(JNIEnv *env))
3109 JVMWrapper("JVM_CurrentLoadedClass");
3110 ResourceMark rm(THREAD);
3111
3112 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3113 // if a method in a class in a trusted loader is in a doPrivileged, return NULL
3114 bool trusted = is_trusted_frame(thread, &vfst);
3115 if (trusted) return NULL;
3116
3117 Method* m = vfst.method();
3118 if (!m->is_native()) {
3119 InstanceKlass* holder = m->method_holder();
3120 oop loader = holder->class_loader();
3121 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {
3122 return (jclass) JNIHandles::make_local(env, holder->java_mirror());
3123 }
3124 }
3125 }
3126 return NULL;
3127 JVM_END
3128
3129
3130 JVM_ENTRY(jobject, JVM_CurrentClassLoader(JNIEnv *env))
3131 JVMWrapper("JVM_CurrentClassLoader");
3132 ResourceMark rm(THREAD);
3133
3134 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3135
3136 // if a method in a class in a trusted loader is in a doPrivileged, return NULL
3137 bool trusted = is_trusted_frame(thread, &vfst);
3138 if (trusted) return NULL;
3139
3140 Method* m = vfst.method();
3141 if (!m->is_native()) {
3142 InstanceKlass* holder = m->method_holder();
3143 assert(holder->is_klass(), "just checking");
3144 oop loader = holder->class_loader();
3145 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {
3146 return JNIHandles::make_local(env, loader);
3147 }
3148 }
3149 }
3150 return NULL;
3151 JVM_END
3152
3153
3154 JVM_ENTRY(jobjectArray, JVM_GetClassContext(JNIEnv *env))
3155 JVMWrapper("JVM_GetClassContext");
3156 ResourceMark rm(THREAD);
3157 JvmtiVMObjectAllocEventCollector oam;
3158 vframeStream vfst(thread);
3159
3160 if (SystemDictionary::reflect_CallerSensitive_klass() != NULL) {
3161 // This must only be called from SecurityManager.getClassContext
3162 Method* m = vfst.method();
3163 if (!(m->method_holder() == SystemDictionary::SecurityManager_klass() &&
3164 m->name() == vmSymbols::getClassContext_name() &&
3165 m->signature() == vmSymbols::void_class_array_signature())) {
3166 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetClassContext must only be called from SecurityManager.getClassContext");
3167 }
3168 }
3169
3170 // Collect method holders
3171 GrowableArray<KlassHandle>* klass_array = new GrowableArray<KlassHandle>();
3172 for (; !vfst.at_end(); vfst.security_next()) {
3173 Method* m = vfst.method();
3174 // Native frames are not returned
3175 if (!m->is_ignored_by_security_stack_walk() && !m->is_native()) {
3176 Klass* holder = m->method_holder();
3177 assert(holder->is_klass(), "just checking");
3178 klass_array->append(holder);
3179 }
3180 }
3181
3182 // Create result array of type [Ljava/lang/Class;
3183 objArrayOop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), klass_array->length(), CHECK_NULL);
3184 // Fill in mirrors corresponding to method holders
3185 for (int i = 0; i < klass_array->length(); i++) {
3186 result->obj_at_put(i, klass_array->at(i)->java_mirror());
3187 }
3188
3189 return (jobjectArray) JNIHandles::make_local(env, result);
3190 JVM_END
3191
3192
3193 JVM_ENTRY(jint, JVM_ClassDepth(JNIEnv *env, jstring name))
3194 JVMWrapper("JVM_ClassDepth");
3195 ResourceMark rm(THREAD);
3196 Handle h_name (THREAD, JNIHandles::resolve_non_null(name));
3197 Handle class_name_str = java_lang_String::internalize_classname(h_name, CHECK_0);
3198
3199 const char* str = java_lang_String::as_utf8_string(class_name_str());
3200 TempNewSymbol class_name_sym = SymbolTable::probe(str, (int)strlen(str));
3201 if (class_name_sym == NULL) {
3202 return -1;
3203 }
3204
3205 int depth = 0;
3206
3207 for(vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3208 if (!vfst.method()->is_native()) {
3209 InstanceKlass* holder = vfst.method()->method_holder();
3210 assert(holder->is_klass(), "just checking");
3211 if (holder->name() == class_name_sym) {
3212 return depth;
3213 }
3214 depth++;
3215 }
3216 }
3217 return -1;
3218 JVM_END
3219
3220
3221 JVM_ENTRY(jint, JVM_ClassLoaderDepth(JNIEnv *env))
3222 JVMWrapper("JVM_ClassLoaderDepth");
3223 ResourceMark rm(THREAD);
3224 int depth = 0;
3225 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3226 // if a method in a class in a trusted loader is in a doPrivileged, return -1
3227 bool trusted = is_trusted_frame(thread, &vfst);
3228 if (trusted) return -1;
3229
3230 Method* m = vfst.method();
3231 if (!m->is_native()) {
3232 InstanceKlass* holder = m->method_holder();
3233 assert(holder->is_klass(), "just checking");
3234 oop loader = holder->class_loader();
3235 if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {
3236 return depth;
3237 }
3238 depth++;
3239 }
3240 }
3241 return -1;
3242 JVM_END
3243
3244
3245 // java.lang.Package ////////////////////////////////////////////////////////////////
3246
3247
3248 JVM_ENTRY(jstring, JVM_GetSystemPackage(JNIEnv *env, jstring name))
3249 JVMWrapper("JVM_GetSystemPackage");
3250 ResourceMark rm(THREAD);
3251 JvmtiVMObjectAllocEventCollector oam;
3252 char* str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(name));
3253 oop result = ClassLoader::get_system_package(str, CHECK_NULL);
3254 return (jstring) JNIHandles::make_local(result);
3255 JVM_END
3256
3257
3258 JVM_ENTRY(jobjectArray, JVM_GetSystemPackages(JNIEnv *env))
3259 JVMWrapper("JVM_GetSystemPackages");
3260 JvmtiVMObjectAllocEventCollector oam;
3261 objArrayOop result = ClassLoader::get_system_packages(CHECK_NULL);
3262 return (jobjectArray) JNIHandles::make_local(result);
3263 JVM_END
3264
3265
3266 // ObjectInputStream ///////////////////////////////////////////////////////////////
3267
3268 bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessFlags access, bool classloader_only) {
3269 if (current_class == NULL) {
3270 return true;
3271 }
3272 if ((current_class == field_class) || access.is_public()) {
3273 return true;
3274 }
3275
3276 if (access.is_protected()) {
3277 // See if current_class is a subclass of field_class
3278 if (current_class->is_subclass_of(field_class)) {
3279 return true;
3280 }
3281 }
3282
3283 return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class));
3284 }
3285
3286 // Return the first non-null class loader up the execution stack, or null
3287 // if only code from the null class loader is on the stack.
3288
3289 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
3290 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
3291 vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
3292 oop loader = vfst.method()->method_holder()->class_loader();
3293 if (loader != NULL) {
3294 return JNIHandles::make_local(env, loader);
3295 }
3296 }
3297 return NULL;
3298 JVM_END
3299
3300
3301 // Array ///////////////////////////////////////////////////////////////////////////////////////////
3302
3303
3304 // resolve array handle and check arguments
3305 static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) {
3306 if (arr == NULL) {
3307 THROW_0(vmSymbols::java_lang_NullPointerException());
3308 }
3309 oop a = JNIHandles::resolve_non_null(arr);
3310 if (!a->is_array()) {
3311 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array");
3312 } else if (type_array_only && !a->is_typeArray()) {
3313 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array of primitive type");
3314 }
3315 return arrayOop(a);
3316 }
3317
3318
3319 JVM_ENTRY(jint, JVM_GetArrayLength(JNIEnv *env, jobject arr))
3320 JVMWrapper("JVM_GetArrayLength");
3321 arrayOop a = check_array(env, arr, false, CHECK_0);
3322 return a->length();
3323 JVM_END
3324
3325
3326 JVM_ENTRY(jobject, JVM_GetArrayElement(JNIEnv *env, jobject arr, jint index))
3327 JVMWrapper("JVM_Array_Get");
3328 JvmtiVMObjectAllocEventCollector oam;
3329 arrayOop a = check_array(env, arr, false, CHECK_NULL);
3330 jvalue value;
3331 BasicType type = Reflection::array_get(&value, a, index, CHECK_NULL);
3332 oop box = Reflection::box(&value, type, CHECK_NULL);
3333 return JNIHandles::make_local(env, box);
3334 JVM_END
3335
3336
3337 JVM_ENTRY(jvalue, JVM_GetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jint wCode))
3338 JVMWrapper("JVM_GetPrimitiveArrayElement");
3339 jvalue value;
3340 value.i = 0; // to initialize value before getting used in CHECK
3341 arrayOop a = check_array(env, arr, true, CHECK_(value));
3342 assert(a->is_typeArray(), "just checking");
3343 BasicType type = Reflection::array_get(&value, a, index, CHECK_(value));
3344 BasicType wide_type = (BasicType) wCode;
3345 if (type != wide_type) {
3346 Reflection::widen(&value, type, wide_type, CHECK_(value));
3347 }
3348 return value;
3349 JVM_END
3350
3351
3352 JVM_ENTRY(void, JVM_SetArrayElement(JNIEnv *env, jobject arr, jint index, jobject val))
3353 JVMWrapper("JVM_SetArrayElement");
3354 arrayOop a = check_array(env, arr, false, CHECK);
3355 oop box = JNIHandles::resolve(val);
3356 jvalue value;
3357 value.i = 0; // to initialize value before getting used in CHECK
3358 BasicType value_type;
3359 if (a->is_objArray()) {
3360 // Make sure we do no unbox e.g. java/lang/Integer instances when storing into an object array
3361 value_type = Reflection::unbox_for_regular_object(box, &value);
3362 } else {
3363 value_type = Reflection::unbox_for_primitive(box, &value, CHECK);
3364 }
3365 Reflection::array_set(&value, a, index, value_type, CHECK);
3366 JVM_END
3367
3368
3369 JVM_ENTRY(void, JVM_SetPrimitiveArrayElement(JNIEnv *env, jobject arr, jint index, jvalue v, unsigned char vCode))
3370 JVMWrapper("JVM_SetPrimitiveArrayElement");
3371 arrayOop a = check_array(env, arr, true, CHECK);
3372 assert(a->is_typeArray(), "just checking");
3373 BasicType value_type = (BasicType) vCode;
3374 Reflection::array_set(&v, a, index, value_type, CHECK);
3375 JVM_END
3376
3377
3378 JVM_ENTRY(jobject, JVM_NewArray(JNIEnv *env, jclass eltClass, jint length))
3379 JVMWrapper("JVM_NewArray");
3380 JvmtiVMObjectAllocEventCollector oam;
3381 oop element_mirror = JNIHandles::resolve(eltClass);
3382 oop result = Reflection::reflect_new_array(element_mirror, length, CHECK_NULL);
3383 return JNIHandles::make_local(env, result);
3384 JVM_END
3385
3386
3387 JVM_ENTRY(jobject, JVM_NewMultiArray(JNIEnv *env, jclass eltClass, jintArray dim))
3388 JVMWrapper("JVM_NewMultiArray");
3389 JvmtiVMObjectAllocEventCollector oam;
3390 arrayOop dim_array = check_array(env, dim, true, CHECK_NULL);
3391 oop element_mirror = JNIHandles::resolve(eltClass);
3392 assert(dim_array->is_typeArray(), "just checking");
3393 oop result = Reflection::reflect_new_multi_array(element_mirror, typeArrayOop(dim_array), CHECK_NULL);
3394 return JNIHandles::make_local(env, result);
3395 JVM_END
3396
3397
3398 // Library support ///////////////////////////////////////////////////////////////////////////
3399
3400 JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name))
3401 //%note jvm_ct
3402 JVMWrapper2("JVM_LoadLibrary (%s)", name);
3403 char ebuf[1024];
3404 void *load_result;
3405 {
3406 ThreadToNativeFromVM ttnfvm(thread);
3407 load_result = os::dll_load(name, ebuf, sizeof ebuf);
3408 }
3409 if (load_result == NULL) {
3410 char msg[1024];
3411 jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf);
3412 // Since 'ebuf' may contain a string encoded using
3413 // platform encoding scheme, we need to pass
3414 // Exceptions::unsafe_to_utf8 to the new_exception method
3415 // as the last argument. See bug 6367357.
3416 Handle h_exception =
3417 Exceptions::new_exception(thread,
3418 vmSymbols::java_lang_UnsatisfiedLinkError(),
3419 msg, Exceptions::unsafe_to_utf8);
3420
3421 THROW_HANDLE_0(h_exception);
3422 }
3423 return load_result;
3424 JVM_END
3425
3426
3427 JVM_LEAF(void, JVM_UnloadLibrary(void* handle))
3428 JVMWrapper("JVM_UnloadLibrary");
3429 os::dll_unload(handle);
3430 JVM_END
3431
3432
3433 JVM_LEAF(void*, JVM_FindLibraryEntry(void* handle, const char* name))
3434 JVMWrapper2("JVM_FindLibraryEntry (%s)", name);
3435 return os::dll_lookup(handle, name);
3436 JVM_END
3437
3438
3439 // JNI version ///////////////////////////////////////////////////////////////////////////////
3440
3441 JVM_LEAF(jboolean, JVM_IsSupportedJNIVersion(jint version))
3442 JVMWrapper2("JVM_IsSupportedJNIVersion (%d)", version);
3443 return Threads::is_supported_jni_version_including_1_1(version);
3444 JVM_END
3445
3446
3447 // String support ///////////////////////////////////////////////////////////////////////////
3448
3449 JVM_ENTRY(jstring, JVM_InternString(JNIEnv *env, jstring str))
3450 JVMWrapper("JVM_InternString");
3451 JvmtiVMObjectAllocEventCollector oam;
3452 if (str == NULL) return NULL;
3453 oop string = JNIHandles::resolve_non_null(str);
3454 oop result = StringTable::intern(string, CHECK_NULL);
3455 return (jstring) JNIHandles::make_local(env, result);
3456 JVM_END
3457
3458
3459 // Raw monitor support //////////////////////////////////////////////////////////////////////
3460
3461 // The lock routine below calls lock_without_safepoint_check in order to get a raw lock
3462 // without interfering with the safepoint mechanism. The routines are not JVM_LEAF because
3463 // they might be called by non-java threads. The JVM_LEAF installs a NoHandleMark check
3464 // that only works with java threads.
3465
3466
3467 JNIEXPORT void* JNICALL JVM_RawMonitorCreate(void) {
3468 VM_Exit::block_if_vm_exited();
3469 JVMWrapper("JVM_RawMonitorCreate");
3470 return new Mutex(Mutex::native, "JVM_RawMonitorCreate");
3471 }
3472
3473
3474 JNIEXPORT void JNICALL JVM_RawMonitorDestroy(void *mon) {
3475 VM_Exit::block_if_vm_exited();
3476 JVMWrapper("JVM_RawMonitorDestroy");
3477 delete ((Mutex*) mon);
3478 }
3479
3480
3481 JNIEXPORT jint JNICALL JVM_RawMonitorEnter(void *mon) {
3482 VM_Exit::block_if_vm_exited();
3483 JVMWrapper("JVM_RawMonitorEnter");
3484 ((Mutex*) mon)->jvm_raw_lock();
3485 return 0;
3486 }
3487
3488
3489 JNIEXPORT void JNICALL JVM_RawMonitorExit(void *mon) {
3490 VM_Exit::block_if_vm_exited();
3491 JVMWrapper("JVM_RawMonitorExit");
3492 ((Mutex*) mon)->jvm_raw_unlock();
3493 }
3494
3495
3496 // Shared JNI/JVM entry points //////////////////////////////////////////////////////////////
3497
3498 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init,
3499 Handle loader, Handle protection_domain,
3500 jboolean throwError, TRAPS) {
3501 // Security Note:
3502 // The Java level wrapper will perform the necessary security check allowing
3503 // us to pass the NULL as the initiating class loader. The VM is responsible for
3504 // the checkPackageAccess relative to the initiating class loader via the
3505 // protection_domain. The protection_domain is passed as NULL by the java code
3506 // if there is no security manager in 3-arg Class.forName().
3507 Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
3508
3509 KlassHandle klass_handle(THREAD, klass);
3510 // Check if we should initialize the class
3511 if (init && klass_handle->oop_is_instance()) {
3512 klass_handle->initialize(CHECK_NULL);
3513 }
3514 return (jclass) JNIHandles::make_local(env, klass_handle->java_mirror());
3515 }
3516
3517
3518 // Method ///////////////////////////////////////////////////////////////////////////////////////////
3519
3520 JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
3521 JVMWrapper("JVM_InvokeMethod");
3522 Handle method_handle;
3523 if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
3524 method_handle = Handle(THREAD, JNIHandles::resolve(method));
3525 Handle receiver(THREAD, JNIHandles::resolve(obj));
3526 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3527 oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
3528 jobject res = JNIHandles::make_local(env, result);
3529 if (JvmtiExport::should_post_vm_object_alloc()) {
3530 oop ret_type = java_lang_reflect_Method::return_type(method_handle());
3531 assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");
3532 if (java_lang_Class::is_primitive(ret_type)) {
3533 // Only for primitive type vm allocates memory for java object.
3534 // See box() method.
3535 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
3536 }
3537 }
3538 return res;
3539 } else {
3540 THROW_0(vmSymbols::java_lang_StackOverflowError());
3541 }
3542 JVM_END
3543
3544
3545 JVM_ENTRY(jobject, JVM_NewInstanceFromConstructor(JNIEnv *env, jobject c, jobjectArray args0))
3546 JVMWrapper("JVM_NewInstanceFromConstructor");
3547 oop constructor_mirror = JNIHandles::resolve(c);
3548 objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
3549 oop result = Reflection::invoke_constructor(constructor_mirror, args, CHECK_NULL);
3550 jobject res = JNIHandles::make_local(env, result);
3551 if (JvmtiExport::should_post_vm_object_alloc()) {
3552 JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
3553 }
3554 return res;
3555 JVM_END
3556
3557 // Atomic ///////////////////////////////////////////////////////////////////////////////////////////
3558
3559 JVM_LEAF(jboolean, JVM_SupportsCX8())
3560 JVMWrapper("JVM_SupportsCX8");
3561 return VM_Version::supports_cx8();
3562 JVM_END
3563
3564 // Returns an array of all live Thread objects (VM internal JavaThreads,
3565 // jvmti agent threads, and JNI attaching threads are skipped)
3566 // See CR 6404306 regarding JNI attaching threads
3567 JVM_ENTRY(jobjectArray, JVM_GetAllThreads(JNIEnv *env, jclass dummy))
3568 ResourceMark rm(THREAD);
3569 ThreadsListEnumerator tle(THREAD, false, false);
3570 JvmtiVMObjectAllocEventCollector oam;
3571
3572 int num_threads = tle.num_threads();
3573 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Thread_klass(), num_threads, CHECK_NULL);
3574 objArrayHandle threads_ah(THREAD, r);
3575
3576 for (int i = 0; i < num_threads; i++) {
3577 Handle h = tle.get_threadObj(i);
3578 threads_ah->obj_at_put(i, h());
3579 }
3580
3581 return (jobjectArray) JNIHandles::make_local(env, threads_ah());
3582 JVM_END
3583
3584
3585 // Support for java.lang.Thread.getStackTrace() and getAllStackTraces() methods
3586 // Return StackTraceElement[][], each element is the stack trace of a thread in
3587 // the corresponding entry in the given threads array
3588 JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobjectArray threads))
3589 JVMWrapper("JVM_DumpThreads");
3590 JvmtiVMObjectAllocEventCollector oam;
3591
3592 // Check if threads is null
3593 if (threads == NULL) {
3594 THROW_(vmSymbols::java_lang_NullPointerException(), 0);
3595 }
3596
3597 objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(threads));
3598 objArrayHandle ah(THREAD, a);
3599 int num_threads = ah->length();
3600 // check if threads is non-empty array
3601 if (num_threads == 0) {
3602 THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0);
3603 }
3604
3605 // check if threads is not an array of objects of Thread class
3606 Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass();
3607 if (k != SystemDictionary::Thread_klass()) {
3608 THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0);
3609 }
3610
3611 ResourceMark rm(THREAD);
3612
3613 GrowableArray<instanceHandle>* thread_handle_array = new GrowableArray<instanceHandle>(num_threads);
3614 for (int i = 0; i < num_threads; i++) {
3615 oop thread_obj = ah->obj_at(i);
3616 instanceHandle h(THREAD, (instanceOop) thread_obj);
3617 thread_handle_array->append(h);
3618 }
3619
3620 Handle stacktraces = ThreadService::dump_stack_traces(thread_handle_array, num_threads, CHECK_NULL);
3621 return (jobjectArray)JNIHandles::make_local(env, stacktraces());
3622
3623 JVM_END
3624
3625 // JVM monitoring and management support
3626 JVM_ENTRY_NO_ENV(void*, JVM_GetManagement(jint version))
3627 return Management::get_jmm_interface(version);
3628 JVM_END
3629
3630 // com.sun.tools.attach.VirtualMachine agent properties support
3631 //
3632 // Initialize the agent properties with the properties maintained in the VM
3633 JVM_ENTRY(jobject, JVM_InitAgentProperties(JNIEnv *env, jobject properties))
3634 JVMWrapper("JVM_InitAgentProperties");
3635 ResourceMark rm;
3636
3637 Handle props(THREAD, JNIHandles::resolve_non_null(properties));
3638
3639 PUTPROP(props, "sun.java.command", Arguments::java_command());
3640 PUTPROP(props, "sun.jvm.flags", Arguments::jvm_flags());
3641 PUTPROP(props, "sun.jvm.args", Arguments::jvm_args());
3642 return properties;
3643 JVM_END
3644
3645 JVM_ENTRY(jobjectArray, JVM_GetEnclosingMethodInfo(JNIEnv *env, jclass ofClass))
3646 {
3647 JVMWrapper("JVM_GetEnclosingMethodInfo");
3648 JvmtiVMObjectAllocEventCollector oam;
3649
3650 if (ofClass == NULL) {
3651 return NULL;
3652 }
3653 Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass));
3654 // Special handling for primitive objects
3655 if (java_lang_Class::is_primitive(mirror())) {
3656 return NULL;
3657 }
3658 Klass* k = java_lang_Class::as_Klass(mirror());
3659 if (!k->oop_is_instance()) {
3660 return NULL;
3661 }
3662 instanceKlassHandle ik_h(THREAD, k);
3663 int encl_method_class_idx = ik_h->enclosing_method_class_index();
3664 if (encl_method_class_idx == 0) {
3665 return NULL;
3666 }
3667 objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL);
3668 objArrayHandle dest(THREAD, dest_o);
3669 Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
3670 dest->obj_at_put(0, enc_k->java_mirror());
3671 int encl_method_method_idx = ik_h->enclosing_method_method_index();
3672 if (encl_method_method_idx != 0) {
3673 Symbol* sym = ik_h->constants()->symbol_at(
3674 extract_low_short_from_int(
3675 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
3676 Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
3677 dest->obj_at_put(1, str());
3678 sym = ik_h->constants()->symbol_at(
3679 extract_high_short_from_int(
3680 ik_h->constants()->name_and_type_at(encl_method_method_idx)));
3681 str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
3682 dest->obj_at_put(2, str());
3683 }
3684 return (jobjectArray) JNIHandles::make_local(dest());
3685 }
3686 JVM_END
3687
3688 JVM_ENTRY(void, JVM_GetVersionInfo(JNIEnv* env, jvm_version_info* info, size_t info_size))
3689 {
3690 memset(info, 0, info_size);
3691
3692 info->jvm_version = Abstract_VM_Version::jvm_version();
3693 info->update_version = 0; /* 0 in HotSpot Express VM */
3694 info->special_update_version = 0; /* 0 in HotSpot Express VM */
3695
3696 // when we add a new capability in the jvm_version_info struct, we should also
3697 // consider to expose this new capability in the sun.rt.jvmCapabilities jvmstat
3698 // counter defined in runtimeService.cpp.
3699 info->is_attachable = AttachListener::is_attach_supported();
3700 }
3701 JVM_END