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