1 /*
2 * Copyright (c) 2011, 2019, 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 #include "precompiled.hpp"
25 #include "classfile/javaClasses.inline.hpp"
26 #include "classfile/stringTable.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "code/scopeDesc.hpp"
29 #include "compiler/compileBroker.hpp"
30 #include "compiler/disassembler.hpp"
31 #include "interpreter/linkResolver.hpp"
32 #include "interpreter/bytecodeStream.hpp"
33 #include "jvmci/jvmciCompilerToVM.hpp"
34 #include "jvmci/jvmciCodeInstaller.hpp"
35 #include "jvmci/jvmciRuntime.hpp"
36 #include "memory/oopFactory.hpp"
37 #include "oops/constantPool.inline.hpp"
38 #include "oops/method.inline.hpp"
39 #include "oops/typeArrayOop.inline.hpp"
40 #include "prims/nativeLookup.hpp"
41 #include "runtime/deoptimization.hpp"
42 #include "runtime/fieldDescriptor.inline.hpp"
43 #include "runtime/frame.inline.hpp"
44 #include "runtime/interfaceSupport.inline.hpp"
45 #include "runtime/jniHandles.inline.hpp"
46 #include "runtime/timerTrace.hpp"
47 #include "runtime/vframe_hp.hpp"
48
49 JVMCIKlassHandle::JVMCIKlassHandle(Thread* thread, Klass* klass) {
50 _thread = thread;
51 _klass = klass;
52 if (klass != NULL) {
53 _holder = Handle(_thread, klass->klass_holder());
54 }
55 }
56
57 JVMCIKlassHandle& JVMCIKlassHandle::operator=(Klass* klass) {
58 _klass = klass;
59 if (klass != NULL) {
60 _holder = Handle(_thread, klass->klass_holder());
61 }
62 return *this;
63 }
64
65 void JNIHandleMark::push_jni_handle_block() {
66 JavaThread* thread = JavaThread::current();
67 if (thread != NULL) {
68 // Allocate a new block for JNI handles.
69 // Inlined code from jni_PushLocalFrame()
70 JNIHandleBlock* java_handles = ((JavaThread*)thread)->active_handles();
71 JNIHandleBlock* compile_handles = JNIHandleBlock::allocate_block(thread);
72 assert(compile_handles != NULL && java_handles != NULL, "should not be NULL");
73 compile_handles->set_pop_frame_link(java_handles);
74 thread->set_active_handles(compile_handles);
75 }
76 }
77
78 void JNIHandleMark::pop_jni_handle_block() {
79 JavaThread* thread = JavaThread::current();
80 if (thread != NULL) {
81 // Release our JNI handle block
82 JNIHandleBlock* compile_handles = thread->active_handles();
83 JNIHandleBlock* java_handles = compile_handles->pop_frame_link();
84 thread->set_active_handles(java_handles);
85 compile_handles->set_pop_frame_link(NULL);
86 JNIHandleBlock::release_block(compile_handles, thread); // may block
87 }
88 }
89
90 class JVMCITraceMark : public StackObj {
91 const char* _msg;
92 public:
93 JVMCITraceMark(const char* msg) {
94 _msg = msg;
95 if (JVMCITraceLevel >= 1) {
96 tty->print_cr(PTR_FORMAT " JVMCITrace-1: Enter %s", p2i(JavaThread::current()), _msg);
97 }
98 }
99 ~JVMCITraceMark() {
100 if (JVMCITraceLevel >= 1) {
101 tty->print_cr(PTR_FORMAT " JVMCITrace-1: Exit %s", p2i(JavaThread::current()), _msg);
102 }
103 }
104 };
105
106
107 Handle JavaArgumentUnboxer::next_arg(BasicType expectedType) {
108 assert(_index < _args->length(), "out of bounds");
109 oop arg=((objArrayOop) (_args))->obj_at(_index++);
110 assert(expectedType == T_OBJECT || java_lang_boxing_object::is_instance(arg, expectedType), "arg type mismatch");
111 return Handle(Thread::current(), arg);
112 }
113
114 // Entry to native method implementation that transitions current thread to '_thread_in_vm'.
115 #define C2V_VMENTRY(result_type, name, signature) \
116 JNIEXPORT result_type JNICALL c2v_ ## name signature { \
117 JVMCITraceMark jtm("CompilerToVM::" #name); \
118 TRACE_CALL(result_type, jvmci_ ## name signature) \
119 JVMCI_VM_ENTRY_MARK; \
120 ResourceMark rm; \
121 JNI_JVMCIENV(env);
122
123 #define C2V_END }
124
125 jobjectArray readConfiguration0(JNIEnv *env, JVMCI_TRAPS);
126
127 C2V_VMENTRY(jobjectArray, readConfiguration, (JNIEnv* env))
128 jobjectArray config = readConfiguration0(env, JVMCI_CHECK_NULL);
129 return config;
130 }
131
132 C2V_VMENTRY(jobject, getFlagValue, (JNIEnv* env, jobject c2vm, jobject name_handle))
133 #define RETURN_BOXED_LONG(value) jvalue p; p.j = (jlong) (value); JVMCIObject box = JVMCIENV->create_box(T_LONG, &p, JVMCI_CHECK_NULL); return box.as_jobject();
134 #define RETURN_BOXED_DOUBLE(value) jvalue p; p.d = (jdouble) (value); JVMCIObject box = JVMCIENV->create_box(T_DOUBLE, &p, JVMCI_CHECK_NULL); return box.as_jobject();
135 JVMCIObject name = JVMCIENV->wrap(name_handle);
136 if (name.is_null()) {
137 JVMCI_THROW_NULL(NullPointerException);
138 }
139 const char* cstring = JVMCIENV->as_utf8_string(name);
140 JVMFlag* flag = JVMFlag::find_flag(cstring, strlen(cstring), /* allow_locked */ true, /* return_flag */ true);
141 if (flag == NULL) {
142 return c2vm;
143 }
144 if (flag->is_bool()) {
145 jvalue prim;
146 prim.z = flag->get_bool();
147 JVMCIObject box = JVMCIENV->create_box(T_BOOLEAN, &prim, JVMCI_CHECK_NULL);
148 return JVMCIENV->get_jobject(box);
149 } else if (flag->is_ccstr()) {
150 JVMCIObject value = JVMCIENV->create_string(flag->get_ccstr(), JVMCI_CHECK_NULL);
151 return JVMCIENV->get_jobject(value);
152 } else if (flag->is_intx()) {
153 RETURN_BOXED_LONG(flag->get_intx());
154 } else if (flag->is_int()) {
155 RETURN_BOXED_LONG(flag->get_int());
156 } else if (flag->is_uint()) {
157 RETURN_BOXED_LONG(flag->get_uint());
158 } else if (flag->is_uint64_t()) {
159 RETURN_BOXED_LONG(flag->get_uint64_t());
160 } else if (flag->is_size_t()) {
161 RETURN_BOXED_LONG(flag->get_size_t());
162 } else if (flag->is_uintx()) {
163 RETURN_BOXED_LONG(flag->get_uintx());
164 } else if (flag->is_double()) {
165 RETURN_BOXED_DOUBLE(flag->get_double());
166 } else {
167 JVMCI_ERROR_NULL("VM flag %s has unsupported type %s", flag->_name, flag->_type);
168 }
169 #undef RETURN_BOXED_LONG
170 #undef RETURN_BOXED_DOUBLE
171 C2V_END
172
173 C2V_VMENTRY(jobject, getObjectAtAddress, (JNIEnv* env, jobject c2vm, jlong oop_address))
174 if (env != JavaThread::current()->jni_environment()) {
175 JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
176 }
177 if (oop_address == 0) {
178 JVMCI_THROW_MSG_NULL(InternalError, "Handle must be non-zero");
179 }
180 oop obj = *((oopDesc**) oop_address);
181 if (obj != NULL) {
182 oopDesc::verify(obj);
183 }
184 return JNIHandles::make_local(obj);
185 C2V_END
186
187 C2V_VMENTRY(jbyteArray, getBytecode, (JNIEnv* env, jobject, jobject jvmci_method))
188 methodHandle method = JVMCIENV->asMethod(jvmci_method);
189
190 int code_size = method->code_size();
191 jbyte* reconstituted_code = NEW_RESOURCE_ARRAY(jbyte, code_size);
192
193 guarantee(method->method_holder()->is_rewritten(), "Method's holder should be rewritten");
194 // iterate over all bytecodes and replace non-Java bytecodes
195
196 for (BytecodeStream s(method); s.next() != Bytecodes::_illegal; ) {
197 Bytecodes::Code code = s.code();
198 Bytecodes::Code raw_code = s.raw_code();
199 int bci = s.bci();
200 int len = s.instruction_size();
201
202 // Restore original byte code.
203 reconstituted_code[bci] = (jbyte) (s.is_wide()? Bytecodes::_wide : code);
204 if (len > 1) {
205 memcpy(reconstituted_code + (bci + 1), s.bcp()+1, len-1);
206 }
207
208 if (len > 1) {
209 // Restore the big-endian constant pool indexes.
210 // Cf. Rewriter::scan_method
211 switch (code) {
212 case Bytecodes::_getstatic:
213 case Bytecodes::_putstatic:
214 case Bytecodes::_getfield:
215 case Bytecodes::_putfield:
216 case Bytecodes::_invokevirtual:
217 case Bytecodes::_invokespecial:
218 case Bytecodes::_invokestatic:
219 case Bytecodes::_invokeinterface:
220 case Bytecodes::_invokehandle: {
221 int cp_index = Bytes::get_native_u2((address) reconstituted_code + (bci + 1));
222 Bytes::put_Java_u2((address) reconstituted_code + (bci + 1), (u2) cp_index);
223 break;
224 }
225
226 case Bytecodes::_invokedynamic: {
227 int cp_index = Bytes::get_native_u4((address) reconstituted_code + (bci + 1));
228 Bytes::put_Java_u4((address) reconstituted_code + (bci + 1), (u4) cp_index);
229 break;
230 }
231
232 default:
233 break;
234 }
235
236 // Not all ldc byte code are rewritten.
237 switch (raw_code) {
238 case Bytecodes::_fast_aldc: {
239 int cpc_index = reconstituted_code[bci + 1] & 0xff;
240 int cp_index = method->constants()->object_to_cp_index(cpc_index);
241 assert(cp_index < method->constants()->length(), "sanity check");
242 reconstituted_code[bci + 1] = (jbyte) cp_index;
243 break;
244 }
245
246 case Bytecodes::_fast_aldc_w: {
247 int cpc_index = Bytes::get_native_u2((address) reconstituted_code + (bci + 1));
248 int cp_index = method->constants()->object_to_cp_index(cpc_index);
249 assert(cp_index < method->constants()->length(), "sanity check");
250 Bytes::put_Java_u2((address) reconstituted_code + (bci + 1), (u2) cp_index);
251 break;
252 }
253
254 default:
255 break;
256 }
257 }
258 }
259
260 JVMCIPrimitiveArray result = JVMCIENV->new_byteArray(code_size, JVMCI_CHECK_NULL);
261 JVMCIENV->copy_bytes_from(reconstituted_code, result, 0, code_size);
262 return JVMCIENV->get_jbyteArray(result);
263 C2V_END
264
265 C2V_VMENTRY(jint, getExceptionTableLength, (JNIEnv* env, jobject, jobject jvmci_method))
266 methodHandle method = JVMCIENV->asMethod(jvmci_method);
267 return method->exception_table_length();
268 C2V_END
269
270 C2V_VMENTRY(jlong, getExceptionTableStart, (JNIEnv* env, jobject, jobject jvmci_method))
271 methodHandle method = JVMCIENV->asMethod(jvmci_method);
272 if (method->exception_table_length() == 0) {
273 return 0L;
274 }
275 return (jlong) (address) method->exception_table_start();
276 C2V_END
277
278 C2V_VMENTRY(jobject, asResolvedJavaMethod, (JNIEnv* env, jobject, jobject executable_handle))
279 if (env != JavaThread::current()->jni_environment()) {
280 JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
281 }
282
283 oop executable = JNIHandles::resolve(executable_handle);
284 oop mirror = NULL;
285 int slot = 0;
286
287 if (executable->klass() == SystemDictionary::reflect_Constructor_klass()) {
288 mirror = java_lang_reflect_Constructor::clazz(executable);
289 slot = java_lang_reflect_Constructor::slot(executable);
290 } else {
291 assert(executable->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
292 mirror = java_lang_reflect_Method::clazz(executable);
293 slot = java_lang_reflect_Method::slot(executable);
294 }
295 Klass* holder = java_lang_Class::as_Klass(mirror);
296 methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot);
297 JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
298 return JVMCIENV->get_jobject(result);
299 }
300
301 C2V_VMENTRY(jobject, getResolvedJavaMethod, (JNIEnv* env, jobject, jobject base, jlong offset))
302 methodHandle method;
303 JVMCIObject base_object = JVMCIENV->wrap(base);
304 if (base_object.is_null()) {
305 method = *((Method**)(offset));
306 } else if (JVMCIENV->isa_HotSpotObjectConstantImpl(base_object)) {
307 Handle obj = JVMCIENV->asConstant(base_object, JVMCI_CHECK_NULL);
308 if (obj->is_a(SystemDictionary::ResolvedMethodName_klass())) {
309 method = (Method*) (intptr_t) obj->long_field(offset);
310 } else {
311 JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", obj->klass()->external_name()));
312 }
313 } else if (JVMCIENV->isa_HotSpotResolvedJavaMethodImpl(base_object)) {
314 method = JVMCIENV->asMethod(base_object);
315 }
316 if (method.is_null()) {
317 JVMCI_THROW_MSG_NULL(IllegalArgumentException, err_msg("Unexpected type: %s", JVMCIENV->klass_name(base_object)));
318 }
319 assert (method.is_null() || method->is_method(), "invalid read");
320 JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
321 return JVMCIENV->get_jobject(result);
322 }
323
324 C2V_VMENTRY(jobject, getConstantPool, (JNIEnv* env, jobject, jobject object_handle))
325 constantPoolHandle cp;
326 JVMCIObject object = JVMCIENV->wrap(object_handle);
327 if (object.is_null()) {
328 JVMCI_THROW_NULL(NullPointerException);
329 }
330 if (JVMCIENV->isa_HotSpotResolvedJavaMethodImpl(object)) {
331 cp = JVMCIENV->asMethod(object)->constMethod()->constants();
332 } else if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(object)) {
333 cp = InstanceKlass::cast(JVMCIENV->asKlass(object))->constants();
334 } else {
335 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
336 err_msg("Unexpected type: %s", JVMCIENV->klass_name(object)));
337 }
338 assert(!cp.is_null(), "npe");
339
340 JVMCIObject result = JVMCIENV->get_jvmci_constant_pool(cp, JVMCI_CHECK_NULL);
341 return JVMCIENV->get_jobject(result);
342 }
343
344 C2V_VMENTRY(jobject, getResolvedJavaType0, (JNIEnv* env, jobject, jobject base, jlong offset, jboolean compressed))
345 JVMCIKlassHandle klass(THREAD);
346 JVMCIObject base_object = JVMCIENV->wrap(base);
347 jlong base_address = 0;
348 if (base_object.is_non_null() && offset == oopDesc::klass_offset_in_bytes()) {
349 // klass = JVMCIENV->unhandle(base_object)->klass();
350 if (JVMCIENV->isa_HotSpotObjectConstantImpl(base_object)) {
351 Handle base_oop = JVMCIENV->asConstant(base_object, JVMCI_CHECK_NULL);
352 klass = base_oop->klass();
353 } else {
354 assert(false, "What types are we actually expecting here?");
355 }
356 } else if (!compressed) {
357 if (base_object.is_non_null()) {
358 if (JVMCIENV->isa_HotSpotResolvedJavaMethodImpl(base_object)) {
359 base_address = (intptr_t) JVMCIENV->asMethod(base_object);
360 } else if (JVMCIENV->isa_HotSpotConstantPool(base_object)) {
361 base_address = (intptr_t) JVMCIENV->asConstantPool(base_object);
362 } else if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(base_object)) {
363 base_address = (intptr_t) JVMCIENV->asKlass(base_object);
364 } else if (JVMCIENV->isa_HotSpotObjectConstantImpl(base_object)) {
365 Handle base_oop = JVMCIENV->asConstant(base_object, JVMCI_CHECK_NULL);
366 if (base_oop->is_a(SystemDictionary::Class_klass())) {
367 base_address = (jlong) (address) base_oop();
368 }
369 }
370 if (base_address == 0) {
371 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
372 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", JVMCIENV->klass_name(base_object), offset, compressed ? "true" : "false"));
373 }
374 }
375 klass = *((Klass**) (intptr_t) (base_address + offset));
376 } else {
377 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
378 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s",
379 base_object.is_non_null() ? JVMCIENV->klass_name(base_object) : "null",
380 offset, compressed ? "true" : "false"));
381 }
382 assert (klass == NULL || klass->is_klass(), "invalid read");
383 JVMCIObject result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);
384 return JVMCIENV->get_jobject(result);
385 }
386
387 C2V_VMENTRY(jobject, findUniqueConcreteMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
388 methodHandle method = JVMCIENV->asMethod(jvmci_method);
389 Klass* holder = JVMCIENV->asKlass(jvmci_type);
390 if (holder->is_interface()) {
391 JVMCI_THROW_MSG_NULL(InternalError, err_msg("Interface %s should be handled in Java code", holder->external_name()));
392 }
393
394 methodHandle ucm;
395 {
396 MutexLocker locker(Compile_lock);
397 ucm = Dependencies::find_unique_concrete_method(holder, method());
398 }
399 JVMCIObject result = JVMCIENV->get_jvmci_method(ucm, JVMCI_CHECK_NULL);
400 return JVMCIENV->get_jobject(result);
401 C2V_END
402
403 C2V_VMENTRY(jobject, getImplementor, (JNIEnv* env, jobject, jobject jvmci_type))
404 Klass* klass = JVMCIENV->asKlass(jvmci_type);
405 if (!klass->is_interface()) {
406 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
407 err_msg("Expected interface type, got %s", klass->external_name()));
408 }
409 InstanceKlass* iklass = InstanceKlass::cast(klass);
410 JVMCIKlassHandle handle(THREAD);
411 {
412 // Need Compile_lock around implementor()
413 MutexLocker locker(Compile_lock);
414 handle = iklass->implementor();
415 }
416 JVMCIObject implementor = JVMCIENV->get_jvmci_type(handle, JVMCI_CHECK_NULL);
417 return JVMCIENV->get_jobject(implementor);
418 C2V_END
419
420 C2V_VMENTRY(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv* env, jobject, jobject jvmci_method))
421 methodHandle method = JVMCIENV->asMethod(jvmci_method);
422 return method->is_ignored_by_security_stack_walk();
423 C2V_END
424
425 C2V_VMENTRY(jboolean, isCompilable,(JNIEnv* env, jobject, jobject jvmci_method))
426 methodHandle method = JVMCIENV->asMethod(jvmci_method);
427 constantPoolHandle cp = method->constMethod()->constants();
428 assert(!cp.is_null(), "npe");
429 // don't inline method when constant pool contains a CONSTANT_Dynamic
430 return !method->is_not_compilable(CompLevel_full_optimization) && !cp->has_dynamic_constant();
431 C2V_END
432
433 C2V_VMENTRY(jboolean, hasNeverInlineDirective,(JNIEnv* env, jobject, jobject jvmci_method))
434 methodHandle method = JVMCIENV->asMethod(jvmci_method);
435 return !Inline || CompilerOracle::should_not_inline(method) || method->dont_inline();
436 C2V_END
437
438 C2V_VMENTRY(jboolean, shouldInlineMethod,(JNIEnv* env, jobject, jobject jvmci_method))
439 methodHandle method = JVMCIENV->asMethod(jvmci_method);
440 return CompilerOracle::should_inline(method) || method->force_inline();
441 C2V_END
442
443 C2V_VMENTRY(jobject, lookupType, (JNIEnv* env, jobject, jstring jname, jclass accessing_class, jboolean resolve))
444 JVMCIObject name = JVMCIENV->wrap(jname);
445 const char* str = JVMCIENV->as_utf8_string(name);
446 TempNewSymbol class_name = SymbolTable::new_symbol(str, CHECK_NULL);
447
448 if (class_name->utf8_length() <= 1) {
449 JVMCI_THROW_MSG_0(InternalError, err_msg("Primitive type %s should be handled in Java code", class_name->as_C_string()));
450 }
451
452 JVMCIKlassHandle resolved_klass(THREAD);
453 Klass* accessing_klass = NULL;
454 Handle class_loader;
455 Handle protection_domain;
456 if (accessing_class != NULL) {
457 accessing_klass = JVMCIENV->asKlass(accessing_class);
458 class_loader = Handle(THREAD, accessing_klass->class_loader());
459 protection_domain = Handle(THREAD, accessing_klass->protection_domain());
460 } else {
461 // Use the System class loader
462 class_loader = Handle(THREAD, SystemDictionary::java_system_loader());
463 JVMCIENV->runtime()->initialize(JVMCIENV);
464 }
465
466 if (resolve) {
467 resolved_klass = SystemDictionary::resolve_or_null(class_name, class_loader, protection_domain, CHECK_0);
468 } else {
469 if (class_name->char_at(0) == 'L' &&
470 class_name->char_at(class_name->utf8_length()-1) == ';') {
471 // This is a name from a signature. Strip off the trimmings.
472 // Call recursive to keep scope of strippedsym.
473 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1,
474 class_name->utf8_length()-2,
475 CHECK_0);
476 resolved_klass = SystemDictionary::find(strippedsym, class_loader, protection_domain, CHECK_0);
477 } else if (FieldType::is_array(class_name)) {
478 FieldArrayInfo fd;
479 // dimension and object_key in FieldArrayInfo are assigned as a side-effect
480 // of this call
481 BasicType t = FieldType::get_array_info(class_name, fd, CHECK_0);
482 if (t == T_OBJECT) {
483 TempNewSymbol strippedsym = SymbolTable::new_symbol(class_name->as_utf8()+1+fd.dimension(),
484 class_name->utf8_length()-2-fd.dimension(),
485 CHECK_0);
486 // naked oop "k" is OK here -- we assign back into it
487 resolved_klass = SystemDictionary::find(strippedsym,
488 class_loader,
489 protection_domain,
490 CHECK_0);
491 if (!resolved_klass.is_null()) {
492 resolved_klass = resolved_klass->array_klass(fd.dimension(), CHECK_0);
493 }
494 } else {
495 resolved_klass = TypeArrayKlass::cast(Universe::typeArrayKlassObj(t))->array_klass(fd.dimension(), CHECK_0);
496 }
497 } else {
498 resolved_klass = SystemDictionary::find(class_name, class_loader, protection_domain, CHECK_0);
499 }
500 }
501 JVMCIObject result = JVMCIENV->get_jvmci_type(resolved_klass, JVMCI_CHECK_NULL);
502 return JVMCIENV->get_jobject(result);
503 C2V_END
504
505 C2V_VMENTRY(jobject, lookupClass, (JNIEnv* env, jobject, jclass mirror))
506 if (env != JavaThread::current()->jni_environment()) {
507 JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
508 }
509 if (mirror == NULL) {
510 return NULL;
511 }
512 JVMCIKlassHandle klass(THREAD);
513 klass = java_lang_Class::as_Klass(JNIHandles::resolve(mirror));
514 if (klass == NULL) {
515 JVMCI_THROW_MSG_NULL(IllegalArgumentException, "Primitive classes are unsupported");
516 }
517 JVMCIObject result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);
518 return JVMCIENV->get_jobject(result);
519 }
520
521 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
522 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
523 oop result = cp->resolve_constant_at(index, CHECK_NULL);
524 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(result));
525 C2V_END
526
527 C2V_VMENTRY(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
528 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
529 oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL);
530 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(result));
531 C2V_END
532
533 C2V_VMENTRY(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
534 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
535 return cp->name_and_type_ref_index_at(index);
536 C2V_END
537
538 C2V_VMENTRY(jobject, lookupNameInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
539 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
540 JVMCIObject sym = JVMCIENV->create_string(cp->name_ref_at(which), JVMCI_CHECK_NULL);
541 return JVMCIENV->get_jobject(sym);
542 C2V_END
543
544 C2V_VMENTRY(jobject, lookupSignatureInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint which))
545 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
546 JVMCIObject sym = JVMCIENV->create_string(cp->signature_ref_at(which), JVMCI_CHECK_NULL);
547 return JVMCIENV->get_jobject(sym);
548 C2V_END
549
550 C2V_VMENTRY(jint, lookupKlassRefIndexInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
551 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
552 return cp->klass_ref_index_at(index);
553 C2V_END
554
555 C2V_VMENTRY(jobject, resolveTypeInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
556 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
557 Klass* klass = cp->klass_at(index, CHECK_NULL);
558 JVMCIKlassHandle resolved_klass(THREAD, klass);
559 if (resolved_klass->is_instance_klass()) {
560 bool linked = InstanceKlass::cast(resolved_klass())->link_class_or_fail(CHECK_NULL);
561 if (!linked) {
562 return NULL;
563 }
564 }
565 JVMCIObject klassObject = JVMCIENV->get_jvmci_type(resolved_klass, JVMCI_CHECK_NULL);
566 return JVMCIENV->get_jobject(klassObject);
567 C2V_END
568
569 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
570 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
571 Klass* loading_klass = cp->pool_holder();
572 bool is_accessible = false;
573 JVMCIKlassHandle klass(THREAD, JVMCIRuntime::get_klass_by_index(cp, index, is_accessible, loading_klass));
574 Symbol* symbol = NULL;
575 if (klass.is_null()) {
576 constantTag tag = cp->tag_at(index);
577 if (tag.is_klass()) {
578 // The klass has been inserted into the constant pool
579 // very recently.
580 klass = cp->resolved_klass_at(index);
581 } else if (tag.is_symbol()) {
582 symbol = cp->symbol_at(index);
583 } else {
584 assert(cp->tag_at(index).is_unresolved_klass(), "wrong tag");
585 symbol = cp->klass_name_at(index);
586 }
587 }
588 JVMCIObject result;
589 if (!klass.is_null()) {
590 result = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);
591 } else {
592 result = JVMCIENV->create_string(symbol, JVMCI_CHECK_NULL);
593 }
594 return JVMCIENV->get_jobject(result);
595 C2V_END
596
597 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
598 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
599 oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
600 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(appendix_oop));
601 C2V_END
602
603 C2V_VMENTRY(jobject, lookupMethodInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
604 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
605 InstanceKlass* pool_holder = cp->pool_holder();
606 Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF);
607 methodHandle method = JVMCIRuntime::get_method_by_index(cp, index, bc, pool_holder);
608 JVMCIObject result = JVMCIENV->get_jvmci_method(method, JVMCI_CHECK_NULL);
609 return JVMCIENV->get_jobject(result);
610 C2V_END
611
612 C2V_VMENTRY(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
613 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
614 return cp->remap_instruction_operand_from_cache(index);
615 C2V_END
616
617 C2V_VMENTRY(jobject, resolveFieldInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index, jobject jvmci_method, jbyte opcode, jintArray info_handle))
618 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
619 Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF);
620 fieldDescriptor fd;
621 LinkInfo link_info(cp, index, (jvmci_method != NULL) ? JVMCIENV->asMethod(jvmci_method) : NULL, CHECK_0);
622 LinkResolver::resolve_field(fd, link_info, Bytecodes::java_code(code), false, CHECK_0);
623 JVMCIPrimitiveArray info = JVMCIENV->wrap(info_handle);
624 if (info.is_null() || JVMCIENV->get_length(info) != 3) {
625 JVMCI_ERROR_NULL("info must not be null and have a length of 3");
626 }
627 JVMCIENV->put_int_at(info, 0, fd.access_flags().as_int());
628 JVMCIENV->put_int_at(info, 1, fd.offset());
629 JVMCIENV->put_int_at(info, 2, fd.index());
630 JVMCIKlassHandle handle(THREAD, fd.field_holder());
631 JVMCIObject field_holder = JVMCIENV->get_jvmci_type(handle, JVMCI_CHECK_NULL);
632 return JVMCIENV->get_jobject(field_holder);
633 C2V_END
634
635 C2V_VMENTRY(jint, getVtableIndexForInterfaceMethod, (JNIEnv* env, jobject, jobject jvmci_type, jobject jvmci_method))
636 Klass* klass = JVMCIENV->asKlass(jvmci_type);
637 Method* method = JVMCIENV->asMethod(jvmci_method);
638 if (klass->is_interface()) {
639 JVMCI_THROW_MSG_0(InternalError, err_msg("Interface %s should be handled in Java code", klass->external_name()));
640 }
641 if (!method->method_holder()->is_interface()) {
642 JVMCI_THROW_MSG_0(InternalError, err_msg("Method %s is not held by an interface, this case should be handled in Java code", method->name_and_sig_as_C_string()));
643 }
644 if (!klass->is_instance_klass()) {
645 JVMCI_THROW_MSG_0(InternalError, err_msg("Class %s must be instance klass", klass->external_name()));
646 }
647 if (!InstanceKlass::cast(klass)->is_linked()) {
648 JVMCI_THROW_MSG_0(InternalError, err_msg("Class %s must be linked", klass->external_name()));
649 }
650 return LinkResolver::vtable_index_of_interface_method(klass, method);
651 C2V_END
652
653 C2V_VMENTRY(jobject, resolveMethod, (JNIEnv* env, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type))
654 Klass* recv_klass = JVMCIENV->asKlass(receiver_jvmci_type);
655 Klass* caller_klass = JVMCIENV->asKlass(caller_jvmci_type);
656 methodHandle method = JVMCIENV->asMethod(jvmci_method);
657
658 Klass* resolved = method->method_holder();
659 Symbol* h_name = method->name();
660 Symbol* h_signature = method->signature();
661
662 if (MethodHandles::is_signature_polymorphic_method(method())) {
663 // Signature polymorphic methods are already resolved, JVMCI just returns NULL in this case.
664 return NULL;
665 }
666
667 if (method->name() == vmSymbols::clone_name() &&
668 resolved == SystemDictionary::Object_klass() &&
669 recv_klass->is_array_klass()) {
670 // Resolution of the clone method on arrays always returns Object.clone even though that method
671 // has protected access. There's some trickery in the access checking to make this all work out
672 // so it's necessary to pass in the array class as the resolved class to properly trigger this.
673 // Otherwise it's impossible to resolve the array clone methods through JVMCI. See
674 // LinkResolver::check_method_accessability for the matching logic.
675 resolved = recv_klass;
676 }
677
678 LinkInfo link_info(resolved, h_name, h_signature, caller_klass);
679 methodHandle m;
680 // Only do exact lookup if receiver klass has been linked. Otherwise,
681 // the vtable has not been setup, and the LinkResolver will fail.
682 if (recv_klass->is_array_klass() ||
683 (InstanceKlass::cast(recv_klass)->is_linked() && !recv_klass->is_interface())) {
684 if (resolved->is_interface()) {
685 m = LinkResolver::resolve_interface_call_or_null(recv_klass, link_info);
686 } else {
687 m = LinkResolver::resolve_virtual_call_or_null(recv_klass, link_info);
688 }
689 }
690
691 if (m.is_null()) {
692 // Return NULL if there was a problem with lookup (uninitialized class, etc.)
693 return NULL;
694 }
695
696 JVMCIObject result = JVMCIENV->get_jvmci_method(m, JVMCI_CHECK_NULL);
697 return JVMCIENV->get_jobject(result);
698 C2V_END
699
700 C2V_VMENTRY(jboolean, hasFinalizableSubclass,(JNIEnv* env, jobject, jobject jvmci_type))
701 Klass* klass = JVMCIENV->asKlass(jvmci_type);
702 assert(klass != NULL, "method must not be called for primitive types");
703 return Dependencies::find_finalizable_subclass(klass) != NULL;
704 C2V_END
705
706 C2V_VMENTRY(jobject, getClassInitializer, (JNIEnv* env, jobject, jobject jvmci_type))
707 Klass* klass = JVMCIENV->asKlass(jvmci_type);
708 if (!klass->is_instance_klass()) {
709 return NULL;
710 }
711 InstanceKlass* iklass = InstanceKlass::cast(klass);
712 JVMCIObject result = JVMCIENV->get_jvmci_method(iklass->class_initializer(), JVMCI_CHECK_NULL);
713 return JVMCIENV->get_jobject(result);
714 C2V_END
715
716 C2V_VMENTRY(jlong, getMaxCallTargetOffset, (JNIEnv* env, jobject, jlong addr))
717 address target_addr = (address) addr;
718 if (target_addr != 0x0) {
719 int64_t off_low = (int64_t)target_addr - ((int64_t)CodeCache::low_bound() + sizeof(int));
720 int64_t off_high = (int64_t)target_addr - ((int64_t)CodeCache::high_bound() + sizeof(int));
721 return MAX2(ABS(off_low), ABS(off_high));
722 }
723 return -1;
724 C2V_END
725
726 C2V_VMENTRY(void, setNotInlinableOrCompilable,(JNIEnv* env, jobject, jobject jvmci_method))
727 methodHandle method = JVMCIENV->asMethod(jvmci_method);
728 method->set_not_c1_compilable();
729 method->set_not_c2_compilable();
730 method->set_dont_inline(true);
731 C2V_END
732
733 C2V_VMENTRY(jint, installCode, (JNIEnv *env, jobject, jobject target, jobject compiled_code,
734 jobject installed_code, jlong failed_speculations_address, jbyteArray speculations_obj))
735 HandleMark hm;
736 JNIHandleMark jni_hm;
737
738 JVMCIObject target_handle = JVMCIENV->wrap(target);
739 JVMCIObject compiled_code_handle = JVMCIENV->wrap(compiled_code);
740 CodeBlob* cb = NULL;
741 JVMCIObject installed_code_handle = JVMCIENV->wrap(installed_code);
742 JVMCIPrimitiveArray speculations_handle = JVMCIENV->wrap(speculations_obj);
743
744 int speculations_len = JVMCIENV->get_length(speculations_handle);
745 char* speculations = NEW_RESOURCE_ARRAY(char, speculations_len);
746 JVMCIENV->copy_bytes_to(speculations_handle, (jbyte*) speculations, 0, speculations_len);
747
748 JVMCICompiler* compiler = JVMCICompiler::instance(true, CHECK_JNI_ERR);
749
750 TraceTime install_time("installCode", JVMCICompiler::codeInstallTimer());
751 bool is_immutable_PIC = JVMCIENV->get_HotSpotCompiledCode_isImmutablePIC(compiled_code_handle) > 0;
752
753 CodeInstaller installer(JVMCIENV, is_immutable_PIC);
754 JVMCI::CodeInstallResult result = installer.install(compiler,
755 target_handle,
756 compiled_code_handle,
757 cb,
758 installed_code_handle,
759 (FailedSpeculation**)(address) failed_speculations_address,
760 speculations,
761 speculations_len,
762 JVMCI_CHECK_0);
763
764 if (PrintCodeCacheOnCompilation) {
765 stringStream s;
766 // Dump code cache into a buffer before locking the tty,
767 {
768 MutexLocker mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
769 CodeCache::print_summary(&s, false);
770 }
771 ttyLocker ttyl;
772 tty->print_raw_cr(s.as_string());
773 }
774
775 if (result != JVMCI::ok) {
776 assert(cb == NULL, "should be");
777 } else {
778 if (installed_code_handle.is_non_null()) {
779 if (cb->is_nmethod()) {
780 assert(JVMCIENV->isa_HotSpotNmethod(installed_code_handle), "wrong type");
781 // Clear the link to an old nmethod first
782 JVMCIObject nmethod_mirror = installed_code_handle;
783 JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, JVMCI_CHECK_0);
784 } else {
785 assert(JVMCIENV->isa_InstalledCode(installed_code_handle), "wrong type");
786 }
787 // Initialize the link to the new code blob
788 JVMCIENV->initialize_installed_code(installed_code_handle, cb, JVMCI_CHECK_0);
789 }
790 }
791 return result;
792 C2V_END
793
794 C2V_VMENTRY(jint, getMetadata, (JNIEnv *env, jobject, jobject target, jobject compiled_code, jobject metadata))
795 #if INCLUDE_AOT
796 HandleMark hm;
797 assert(JVMCIENV->is_hotspot(), "AOT code is executed only in HotSpot mode");
798
799 JVMCIObject target_handle = JVMCIENV->wrap(target);
800 JVMCIObject compiled_code_handle = JVMCIENV->wrap(compiled_code);
801 JVMCIObject metadata_handle = JVMCIENV->wrap(metadata);
802
803 CodeMetadata code_metadata;
804
805 CodeInstaller installer(JVMCIENV, true /* immutable PIC compilation */);
806 JVMCI::CodeInstallResult result = installer.gather_metadata(target_handle, compiled_code_handle, code_metadata, JVMCI_CHECK_0);
807 if (result != JVMCI::ok) {
808 return result;
809 }
810
811 if (code_metadata.get_nr_pc_desc() > 0) {
812 int size = sizeof(PcDesc) * code_metadata.get_nr_pc_desc();
813 JVMCIPrimitiveArray array = JVMCIENV->new_byteArray(size, JVMCI_CHECK_(JVMCI::cache_full));
814 JVMCIENV->copy_bytes_from((jbyte*) code_metadata.get_pc_desc(), array, 0, size);
815 HotSpotJVMCI::HotSpotMetaData::set_pcDescBytes(JVMCIENV, metadata_handle, array);
816 }
817
818 if (code_metadata.get_scopes_size() > 0) {
819 int size = code_metadata.get_scopes_size();
820 JVMCIPrimitiveArray array = JVMCIENV->new_byteArray(size, JVMCI_CHECK_(JVMCI::cache_full));
821 JVMCIENV->copy_bytes_from((jbyte*) code_metadata.get_scopes_desc(), array, 0, size);
822 HotSpotJVMCI::HotSpotMetaData::set_scopesDescBytes(JVMCIENV, metadata_handle, array);
823 }
824
825 RelocBuffer* reloc_buffer = code_metadata.get_reloc_buffer();
826 int size = (int) reloc_buffer->size();
827 JVMCIPrimitiveArray array = JVMCIENV->new_byteArray(size, JVMCI_CHECK_(JVMCI::cache_full));
828 JVMCIENV->copy_bytes_from((jbyte*) reloc_buffer->begin(), array, 0, size);
829 HotSpotJVMCI::HotSpotMetaData::set_relocBytes(JVMCIENV, metadata_handle, array);
830
831 const OopMapSet* oopMapSet = installer.oopMapSet();
832 {
833 ResourceMark mark;
834 ImmutableOopMapBuilder builder(oopMapSet);
835 int size = builder.heap_size();
836 JVMCIPrimitiveArray array = JVMCIENV->new_byteArray(size, JVMCI_CHECK_(JVMCI::cache_full));
837 builder.generate_into((address) HotSpotJVMCI::resolve(array)->byte_at_addr(0));
838 HotSpotJVMCI::HotSpotMetaData::set_oopMaps(JVMCIENV, metadata_handle, array);
839 }
840
841 AOTOopRecorder* recorder = code_metadata.get_oop_recorder();
842
843 int nr_meta_refs = recorder->nr_meta_refs();
844 JVMCIObjectArray metadataArray = JVMCIENV->new_Object_array(nr_meta_refs, JVMCI_CHECK_(JVMCI::cache_full));
845 for (int i = 0; i < nr_meta_refs; ++i) {
846 jobject element = recorder->meta_element(i);
847 if (element == NULL) {
848 return JVMCI::cache_full;
849 }
850 JVMCIENV->put_object_at(metadataArray, i, JVMCIENV->wrap(element));
851 }
852 HotSpotJVMCI::HotSpotMetaData::set_metadata(JVMCIENV, metadata_handle, metadataArray);
853
854 ExceptionHandlerTable* handler = code_metadata.get_exception_table();
855 int table_size = handler->size_in_bytes();
856 JVMCIPrimitiveArray exceptionArray = JVMCIENV->new_byteArray(table_size, JVMCI_CHECK_(JVMCI::cache_full));
857 if (table_size > 0) {
858 handler->copy_bytes_to((address) HotSpotJVMCI::resolve(exceptionArray)->byte_at_addr(0));
859 }
860 HotSpotJVMCI::HotSpotMetaData::set_exceptionBytes(JVMCIENV, metadata_handle, exceptionArray);
861
862 return result;
863 #else
864 JVMCI_THROW_MSG_0(InternalError, "unimplemented");
865 #endif
866 C2V_END
867
868 C2V_VMENTRY(void, resetCompilationStatistics, (JNIEnv* env, jobject))
869 JVMCICompiler* compiler = JVMCICompiler::instance(true, CHECK);
870 CompilerStatistics* stats = compiler->stats();
871 stats->_standard.reset();
872 stats->_osr.reset();
873 C2V_END
874
875 C2V_VMENTRY(jobject, disassembleCodeBlob, (JNIEnv* env, jobject, jobject installedCode))
876 HandleMark hm;
877
878 if (installedCode == NULL) {
879 JVMCI_THROW_MSG_NULL(NullPointerException, "installedCode is null");
880 }
881
882 JVMCIObject installedCodeObject = JVMCIENV->wrap(installedCode);
883 CodeBlob* cb = JVMCIENV->asCodeBlob(installedCodeObject);
884 if (cb == NULL) {
885 return NULL;
886 }
887
888 // We don't want the stringStream buffer to resize during disassembly as it
889 // uses scoped resource memory. If a nested function called during disassembly uses
890 // a ResourceMark and the buffer expands within the scope of the mark,
891 // the buffer becomes garbage when that scope is exited. Experience shows that
892 // the disassembled code is typically about 10x the code size so a fixed buffer
893 // sized to 20x code size plus a fixed amount for header info should be sufficient.
894 int bufferSize = cb->code_size() * 20 + 1024;
895 char* buffer = NEW_RESOURCE_ARRAY(char, bufferSize);
896 stringStream st(buffer, bufferSize);
897 if (cb->is_nmethod()) {
898 nmethod* nm = (nmethod*) cb;
899 if (!nm->is_alive()) {
900 return NULL;
901 }
902 }
903 Disassembler::decode(cb, &st);
904 if (st.size() <= 0) {
905 return NULL;
906 }
907
908 JVMCIObject result = JVMCIENV->create_string(st.as_string(), JVMCI_CHECK_NULL);
909 return JVMCIENV->get_jobject(result);
910 C2V_END
911
912 C2V_VMENTRY(jobject, getStackTraceElement, (JNIEnv* env, jobject, jobject jvmci_method, int bci))
913 HandleMark hm;
914
915 methodHandle method = JVMCIENV->asMethod(jvmci_method);
916 JVMCIObject element = JVMCIENV->new_StackTraceElement(method, bci, JVMCI_CHECK_NULL);
917 return JVMCIENV->get_jobject(element);
918 C2V_END
919
920 C2V_VMENTRY(jobject, executeHotSpotNmethod, (JNIEnv* env, jobject, jobject args, jobject hs_nmethod))
921 if (env != JavaThread::current()->jni_environment()) {
922 // The incoming arguments array would have to contain JavaConstants instead of regular objects
923 // and the return value would have to be wrapped as a JavaConstant.
924 JVMCI_THROW_MSG_NULL(InternalError, "Wrapping of arguments is currently unsupported");
925 }
926
927 HandleMark hm;
928
929 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
930 nmethod* nm = JVMCIENV->asNmethod(nmethod_mirror);
931 if (nm == NULL) {
932 JVMCI_THROW_NULL(InvalidInstalledCodeException);
933 }
934 methodHandle mh = nm->method();
935 Symbol* signature = mh->signature();
936 JavaCallArguments jca(mh->size_of_parameters());
937
938 JavaArgumentUnboxer jap(signature, &jca, (arrayOop) JNIHandles::resolve(args), mh->is_static());
939 JavaValue result(jap.get_ret_type());
940 jca.set_alternative_target(nm);
941 JavaCalls::call(&result, mh, &jca, CHECK_NULL);
942
943 if (jap.get_ret_type() == T_VOID) {
944 return NULL;
945 } else if (jap.get_ret_type() == T_OBJECT || jap.get_ret_type() == T_ARRAY) {
946 return JNIHandles::make_local((oop) result.get_jobject());
947 } else {
948 jvalue *value = (jvalue *) result.get_value_addr();
949 // Narrow the value down if required (Important on big endian machines)
950 switch (jap.get_ret_type()) {
951 case T_BOOLEAN:
952 value->z = (jboolean) value->i;
953 break;
954 case T_BYTE:
955 value->b = (jbyte) value->i;
956 break;
957 case T_CHAR:
958 value->c = (jchar) value->i;
959 break;
960 case T_SHORT:
961 value->s = (jshort) value->i;
962 break;
963 default:
964 break;
965 }
966 JVMCIObject o = JVMCIENV->create_box(jap.get_ret_type(), value, JVMCI_CHECK_NULL);
967 return JVMCIENV->get_jobject(o);
968 }
969 C2V_END
970
971 C2V_VMENTRY(jlongArray, getLineNumberTable, (JNIEnv* env, jobject, jobject jvmci_method))
972 Method* method = JVMCIENV->asMethod(jvmci_method);
973 if (!method->has_linenumber_table()) {
974 return NULL;
975 }
976 u2 num_entries = 0;
977 CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table());
978 while (streamForSize.read_pair()) {
979 num_entries++;
980 }
981
982 CompressedLineNumberReadStream stream(method->compressed_linenumber_table());
983 JVMCIPrimitiveArray result = JVMCIENV->new_longArray(2 * num_entries, JVMCI_CHECK_NULL);
984
985 int i = 0;
986 jlong value;
987 while (stream.read_pair()) {
988 value = ((long) stream.bci());
989 JVMCIENV->put_long_at(result, i, value);
990 value = ((long) stream.line());
991 JVMCIENV->put_long_at(result, i + 1, value);
992 i += 2;
993 }
994
995 return (jlongArray) JVMCIENV->get_jobject(result);
996 C2V_END
997
998 C2V_VMENTRY(jlong, getLocalVariableTableStart, (JNIEnv* env, jobject, jobject jvmci_method))
999 Method* method = JVMCIENV->asMethod(jvmci_method);
1000 if (!method->has_localvariable_table()) {
1001 return 0;
1002 }
1003 return (jlong) (address) method->localvariable_table_start();
1004 C2V_END
1005
1006 C2V_VMENTRY(jint, getLocalVariableTableLength, (JNIEnv* env, jobject, jobject jvmci_method))
1007 Method* method = JVMCIENV->asMethod(jvmci_method);
1008 return method->localvariable_table_length();
1009 C2V_END
1010
1011 C2V_VMENTRY(void, reprofile, (JNIEnv* env, jobject, jobject jvmci_method))
1012 Method* method = JVMCIENV->asMethod(jvmci_method);
1013 MethodCounters* mcs = method->method_counters();
1014 if (mcs != NULL) {
1015 mcs->clear_counters();
1016 }
1017 NOT_PRODUCT(method->set_compiled_invocation_count(0));
1018
1019 CompiledMethod* code = method->code();
1020 if (code != NULL) {
1021 code->make_not_entrant();
1022 }
1023
1024 MethodData* method_data = method->method_data();
1025 if (method_data == NULL) {
1026 ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
1027 method_data = MethodData::allocate(loader_data, method, CHECK);
1028 method->set_method_data(method_data);
1029 } else {
1030 method_data->initialize();
1031 }
1032 C2V_END
1033
1034
1035 C2V_VMENTRY(void, invalidateHotSpotNmethod, (JNIEnv* env, jobject, jobject hs_nmethod))
1036 JVMCIObject nmethod_mirror = JVMCIENV->wrap(hs_nmethod);
1037 JVMCIENV->invalidate_nmethod_mirror(nmethod_mirror, JVMCI_CHECK);
1038 C2V_END
1039
1040 C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv* env, jobject, jlong addr))
1041 oop ret = RawAccess<>::oop_load((oop*)(address)addr);
1042 return JVMCIENV->get_jobject(JVMCIENV->get_object_constant(ret));
1043 C2V_END
1044
1045 C2V_VMENTRY(jlongArray, collectCounters, (JNIEnv* env, jobject))
1046 JVMCIPrimitiveArray array = JVMCIENV->new_longArray(JVMCICounterSize, JVMCI_CHECK_NULL);
1047 JavaThread::collect_counters(JVMCIENV, array);
1048 return (jlongArray) JVMCIENV->get_jobject(array);
1049 C2V_END
1050
1051 C2V_VMENTRY(int, allocateCompileId, (JNIEnv* env, jobject, jobject jvmci_method, int entry_bci))
1052 HandleMark hm;
1053 if (jvmci_method == NULL) {
1054 JVMCI_THROW_0(NullPointerException);
1055 }
1056 Method* method = JVMCIENV->asMethod(jvmci_method);
1057 if (entry_bci >= method->code_size() || entry_bci < -1) {
1058 JVMCI_THROW_MSG_0(IllegalArgumentException, err_msg("Unexpected bci %d", entry_bci));
1059 }
1060 return CompileBroker::assign_compile_id_unlocked(THREAD, method, entry_bci);
1061 C2V_END
1062
1063
1064 C2V_VMENTRY(jboolean, isMature, (JNIEnv* env, jobject, jlong metaspace_method_data))
1065 MethodData* mdo = JVMCIENV->asMethodData(metaspace_method_data);
1066 return mdo != NULL && mdo->is_mature();
1067 C2V_END
1068
1069 C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv* env, jobject, jobject jvmci_method, int entry_bci, int comp_level))
1070 Method* method = JVMCIENV->asMethod(jvmci_method);
1071 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL;
1072 C2V_END
1073
1074 C2V_VMENTRY(jobject, getSymbol, (JNIEnv* env, jobject, jlong symbol))
1075 JVMCIObject sym = JVMCIENV->create_string((Symbol*)(address)symbol, JVMCI_CHECK_NULL);
1076 return JVMCIENV->get_jobject(sym);
1077 C2V_END
1078
1079 bool matches(jobjectArray methods, Method* method, JVMCIEnv* JVMCIENV) {
1080 objArrayOop methods_oop = (objArrayOop) JNIHandles::resolve(methods);
1081
1082 for (int i = 0; i < methods_oop->length(); i++) {
1083 oop resolved = methods_oop->obj_at(i);
1084 if ((resolved->klass() == HotSpotJVMCI::HotSpotResolvedJavaMethodImpl::klass()) && HotSpotJVMCI::asMethod(JVMCIENV, resolved) == method) {
1085 return true;
1086 }
1087 }
1088 return false;
1089 }
1090
1091 void call_interface(JavaValue* result, Klass* spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS) {
1092 CallInfo callinfo;
1093 Handle receiver = args->receiver();
1094 Klass* recvrKlass = receiver.is_null() ? (Klass*)NULL : receiver->klass();
1095 LinkInfo link_info(spec_klass, name, signature);
1096 LinkResolver::resolve_interface_call(
1097 callinfo, receiver, recvrKlass, link_info, true, CHECK);
1098 methodHandle method = callinfo.selected_method();
1099 assert(method.not_null(), "should have thrown exception");
1100
1101 // Invoke the method
1102 JavaCalls::call(result, method, args, CHECK);
1103 }
1104
1105 C2V_VMENTRY(jobject, iterateFrames, (JNIEnv* env, jobject compilerToVM, jobjectArray initial_methods, jobjectArray match_methods, jint initialSkip, jobject visitor_handle))
1106
1107 if (!thread->has_last_Java_frame()) {
1108 return NULL;
1109 }
1110 Handle visitor(THREAD, JNIHandles::resolve_non_null(visitor_handle));
1111
1112 if (env != JavaThread::current()->jni_environment()) {
1113 JVMCI_THROW_MSG_NULL(InternalError, "getNextStackFrame is only supported for HotSpot stack walking");
1114 }
1115
1116 HotSpotJVMCI::HotSpotStackFrameReference::klass()->initialize(CHECK_NULL);
1117 Handle frame_reference = HotSpotJVMCI::HotSpotStackFrameReference::klass()->allocate_instance_handle(CHECK_NULL);
1118
1119 StackFrameStream fst(thread);
1120 jobjectArray methods = initial_methods;
1121
1122 int frame_number = 0;
1123 vframe* vf = vframe::new_vframe(fst.current(), fst.register_map(), thread);
1124
1125 while (true) {
1126 // look for the given method
1127 bool realloc_called = false;
1128 while (true) {
1129 StackValueCollection* locals = NULL;
1130 if (vf->is_compiled_frame()) {
1131 // compiled method frame
1132 compiledVFrame* cvf = compiledVFrame::cast(vf);
1133 if (methods == NULL || matches(methods, cvf->method(), JVMCIENV)) {
1134 if (initialSkip > 0) {
1135 initialSkip--;
1136 } else {
1137 ScopeDesc* scope = cvf->scope();
1138 // native wrappers do not have a scope
1139 if (scope != NULL && scope->objects() != NULL) {
1140 GrowableArray<ScopeValue*>* objects;
1141 if (!realloc_called) {
1142 objects = scope->objects();
1143 } else {
1144 // some object might already have been re-allocated, only reallocate the non-allocated ones
1145 objects = new GrowableArray<ScopeValue*>(scope->objects()->length());
1146 for (int i = 0; i < scope->objects()->length(); i++) {
1147 ObjectValue* sv = (ObjectValue*) scope->objects()->at(i);
1148 if (sv->value().is_null()) {
1149 objects->append(sv);
1150 }
1151 }
1152 }
1153 bool realloc_failures = Deoptimization::realloc_objects(thread, fst.current(), objects, CHECK_NULL);
1154 Deoptimization::reassign_fields(fst.current(), fst.register_map(), objects, realloc_failures, false);
1155 realloc_called = true;
1156
1157 GrowableArray<ScopeValue*>* local_values = scope->locals();
1158 assert(local_values != NULL, "NULL locals");
1159 typeArrayOop array_oop = oopFactory::new_boolArray(local_values->length(), CHECK_NULL);
1160 typeArrayHandle array(THREAD, array_oop);
1161 for (int i = 0; i < local_values->length(); i++) {
1162 ScopeValue* value = local_values->at(i);
1163 if (value->is_object()) {
1164 array->bool_at_put(i, true);
1165 }
1166 }
1167 HotSpotJVMCI::HotSpotStackFrameReference::set_localIsVirtual(JVMCIENV, frame_reference(), array());
1168 } else {
1169 HotSpotJVMCI::HotSpotStackFrameReference::set_localIsVirtual(JVMCIENV, frame_reference(), NULL);
1170 }
1171
1172 locals = cvf->locals();
1173 HotSpotJVMCI::HotSpotStackFrameReference::set_bci(JVMCIENV, frame_reference(), cvf->bci());
1174 JVMCIObject method = JVMCIENV->get_jvmci_method(cvf->method(), JVMCI_CHECK_NULL);
1175 HotSpotJVMCI::HotSpotStackFrameReference::set_method(JVMCIENV, frame_reference(), JNIHandles::resolve(method.as_jobject()));
1176 }
1177 }
1178 } else if (vf->is_interpreted_frame()) {
1179 // interpreted method frame
1180 interpretedVFrame* ivf = interpretedVFrame::cast(vf);
1181 if (methods == NULL || matches(methods, ivf->method(), JVMCIENV)) {
1182 if (initialSkip > 0) {
1183 initialSkip--;
1184 } else {
1185 locals = ivf->locals();
1186 HotSpotJVMCI::HotSpotStackFrameReference::set_bci(JVMCIENV, frame_reference(), ivf->bci());
1187 JVMCIObject method = JVMCIENV->get_jvmci_method(ivf->method(), JVMCI_CHECK_NULL);
1188 HotSpotJVMCI::HotSpotStackFrameReference::set_method(JVMCIENV, frame_reference(), JNIHandles::resolve(method.as_jobject()));
1189 HotSpotJVMCI::HotSpotStackFrameReference::set_localIsVirtual(JVMCIENV, frame_reference(), NULL);
1190 }
1191 }
1192 }
1193
1194 // locals != NULL means that we found a matching frame and result is already partially initialized
1195 if (locals != NULL) {
1196 methods = match_methods;
1197 HotSpotJVMCI::HotSpotStackFrameReference::set_compilerToVM(JVMCIENV, frame_reference(), JNIHandles::resolve(compilerToVM));
1198 HotSpotJVMCI::HotSpotStackFrameReference::set_stackPointer(JVMCIENV, frame_reference(), (jlong) fst.current()->sp());
1199 HotSpotJVMCI::HotSpotStackFrameReference::set_frameNumber(JVMCIENV, frame_reference(), frame_number);
1200
1201 // initialize the locals array
1202 objArrayOop array_oop = oopFactory::new_objectArray(locals->size(), CHECK_NULL);
1203 objArrayHandle array(THREAD, array_oop);
1204 for (int i = 0; i < locals->size(); i++) {
1205 StackValue* var = locals->at(i);
1206 if (var->type() == T_OBJECT) {
1207 array->obj_at_put(i, locals->at(i)->get_obj()());
1208 }
1209 }
1210 HotSpotJVMCI::HotSpotStackFrameReference::set_locals(JVMCIENV, frame_reference(), array());
1211 HotSpotJVMCI::HotSpotStackFrameReference::set_objectsMaterialized(JVMCIENV, frame_reference(), JNI_FALSE);
1212
1213 JavaValue result(T_OBJECT);
1214 JavaCallArguments args(visitor);
1215 args.push_oop(frame_reference);
1216 call_interface(&result, HotSpotJVMCI::InspectedFrameVisitor::klass(), vmSymbols::visitFrame_name(), vmSymbols::visitFrame_signature(), &args, CHECK_NULL);
1217 if (result.get_jobject() != NULL) {
1218 return JNIHandles::make_local(thread, (oop) result.get_jobject());
1219 }
1220 assert(initialSkip == 0, "There should be no match before initialSkip == 0");
1221 if (HotSpotJVMCI::HotSpotStackFrameReference::objectsMaterialized(JVMCIENV, frame_reference()) == JNI_TRUE) {
1222 // the frame has been deoptimized, we need to re-synchronize the frame and vframe
1223 intptr_t* stack_pointer = (intptr_t*) HotSpotJVMCI::HotSpotStackFrameReference::stackPointer(JVMCIENV, frame_reference());
1224 fst = StackFrameStream(thread);
1225 while (fst.current()->sp() != stack_pointer && !fst.is_done()) {
1226 fst.next();
1227 }
1228 if (fst.current()->sp() != stack_pointer) {
1229 THROW_MSG_NULL(vmSymbols::java_lang_IllegalStateException(), "stack frame not found after deopt")
1230 }
1231 vf = vframe::new_vframe(fst.current(), fst.register_map(), thread);
1232 if (!vf->is_compiled_frame()) {
1233 THROW_MSG_NULL(vmSymbols::java_lang_IllegalStateException(), "compiled stack frame expected")
1234 }
1235 for (int i = 0; i < frame_number; i++) {
1236 if (vf->is_top()) {
1237 THROW_MSG_NULL(vmSymbols::java_lang_IllegalStateException(), "vframe not found after deopt")
1238 }
1239 vf = vf->sender();
1240 assert(vf->is_compiled_frame(), "Wrong frame type");
1241 }
1242 }
1243 frame_reference = HotSpotJVMCI::HotSpotStackFrameReference::klass()->allocate_instance_handle(CHECK_NULL);
1244 HotSpotJVMCI::HotSpotStackFrameReference::klass()->initialize(CHECK_NULL);
1245 }
1246
1247 if (vf->is_top()) {
1248 break;
1249 }
1250 frame_number++;
1251 vf = vf->sender();
1252 } // end of vframe loop
1253
1254 if (fst.is_done()) {
1255 break;
1256 }
1257 fst.next();
1258 vf = vframe::new_vframe(fst.current(), fst.register_map(), thread);
1259 frame_number = 0;
1260 } // end of frame loop
1261
1262 // the end was reached without finding a matching method
1263 return NULL;
1264 C2V_END
1265
1266 C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
1267 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
1268 CallInfo callInfo;
1269 LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, Bytecodes::_invokedynamic, CHECK);
1270 ConstantPoolCacheEntry* cp_cache_entry = cp->invokedynamic_cp_cache_entry_at(index);
1271 cp_cache_entry->set_dynamic_call(cp, callInfo);
1272 C2V_END
1273
1274 C2V_VMENTRY(void, resolveInvokeHandleInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
1275 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
1276 Klass* holder = cp->klass_ref_at(index, CHECK);
1277 Symbol* name = cp->name_ref_at(index);
1278 if (MethodHandles::is_signature_polymorphic_name(holder, name)) {
1279 CallInfo callInfo;
1280 LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, Bytecodes::_invokehandle, CHECK);
1281 ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index));
1282 cp_cache_entry->set_method_handle(cp, callInfo);
1283 }
1284 C2V_END
1285
1286 C2V_VMENTRY(jint, isResolvedInvokeHandleInPool, (JNIEnv* env, jobject, jobject jvmci_constant_pool, jint index))
1287 constantPoolHandle cp = JVMCIENV->asConstantPool(jvmci_constant_pool);
1288 ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index));
1289 if (cp_cache_entry->is_resolved(Bytecodes::_invokehandle)) {
1290 // MethodHandle.invoke* --> LambdaForm?
1291 ResourceMark rm;
1292
1293 LinkInfo link_info(cp, index, CATCH);
1294
1295 Klass* resolved_klass = link_info.resolved_klass();
1296
1297 Symbol* name_sym = cp->name_ref_at(index);
1298
1299 vmassert(MethodHandles::is_method_handle_invoke_name(resolved_klass, name_sym), "!");
1300 vmassert(MethodHandles::is_signature_polymorphic_name(resolved_klass, name_sym), "!");
1301
1302 methodHandle adapter_method(cp_cache_entry->f1_as_method());
1303
1304 methodHandle resolved_method(adapter_method);
1305
1306 // Can we treat it as a regular invokevirtual?
1307 if (resolved_method->method_holder() == resolved_klass && resolved_method->name() == name_sym) {
1308 vmassert(!resolved_method->is_static(),"!");
1309 vmassert(MethodHandles::is_signature_polymorphic_method(resolved_method()),"!");
1310 vmassert(!MethodHandles::is_signature_polymorphic_static(resolved_method->intrinsic_id()), "!");
1311 vmassert(cp_cache_entry->appendix_if_resolved(cp) == NULL, "!");
1312
1313 methodHandle m(LinkResolver::linktime_resolve_virtual_method_or_null(link_info));
1314 vmassert(m == resolved_method, "!!");
1315 return -1;
1316 }
1317
1318 return Bytecodes::_invokevirtual;
1319 }
1320 if (cp_cache_entry->is_resolved(Bytecodes::_invokedynamic)) {
1321 return Bytecodes::_invokedynamic;
1322 }
1323 return -1;
1324 C2V_END
1325
1326
1327 C2V_VMENTRY(jobject, getSignaturePolymorphicHolders, (JNIEnv* env, jobject))
1328 JVMCIObjectArray holders = JVMCIENV->new_String_array(2, JVMCI_CHECK_NULL);
1329 JVMCIObject mh = JVMCIENV->create_string("Ljava/lang/invoke/MethodHandle;", JVMCI_CHECK_NULL);
1330 JVMCIObject vh = JVMCIENV->create_string("Ljava/lang/invoke/VarHandle;", JVMCI_CHECK_NULL);
1331 JVMCIENV->put_object_at(holders, 0, mh);
1332 JVMCIENV->put_object_at(holders, 1, vh);
1333 return JVMCIENV->get_jobject(holders);
1334 C2V_END
1335
1336 C2V_VMENTRY(jboolean, shouldDebugNonSafepoints, (JNIEnv* env, jobject))
1337 //see compute_recording_non_safepoints in debugInfroRec.cpp
1338 if (JvmtiExport::should_post_compiled_method_load() && FLAG_IS_DEFAULT(DebugNonSafepoints)) {
1339 return true;
1340 }
1341 return DebugNonSafepoints;
1342 C2V_END
1343
1344 // public native void materializeVirtualObjects(HotSpotStackFrameReference stackFrame, boolean invalidate);
1345 C2V_VMENTRY(void, materializeVirtualObjects, (JNIEnv* env, jobject, jobject _hs_frame, bool invalidate))
1346 JVMCIObject hs_frame = JVMCIENV->wrap(_hs_frame);
1347 if (hs_frame.is_null()) {
1348 JVMCI_THROW_MSG(NullPointerException, "stack frame is null");
1349 }
1350
1351 if (env != JavaThread::current()->jni_environment()) {
1352 JVMCI_THROW_MSG(InternalError, "getNextStackFrame is only supported for HotSpot stack walking");
1353 }
1354
1355 JVMCIENV->HotSpotStackFrameReference_initialize(JVMCI_CHECK);
1356
1357 // look for the given stack frame
1358 StackFrameStream fst(thread);
1359 intptr_t* stack_pointer = (intptr_t*) JVMCIENV->get_HotSpotStackFrameReference_stackPointer(hs_frame);
1360 while (fst.current()->sp() != stack_pointer && !fst.is_done()) {
1361 fst.next();
1362 }
1363 if (fst.current()->sp() != stack_pointer) {
1364 JVMCI_THROW_MSG(IllegalStateException, "stack frame not found");
1365 }
1366
1367 if (invalidate) {
1368 if (!fst.current()->is_compiled_frame()) {
1369 JVMCI_THROW_MSG(IllegalStateException, "compiled stack frame expected");
1370 }
1371 assert(fst.current()->cb()->is_nmethod(), "nmethod expected");
1372 ((nmethod*) fst.current()->cb())->make_not_entrant();
1373 }
1374 Deoptimization::deoptimize(thread, *fst.current(), fst.register_map(), Deoptimization::Reason_none);
1375 // look for the frame again as it has been updated by deopt (pc, deopt state...)
1376 StackFrameStream fstAfterDeopt(thread);
1377 while (fstAfterDeopt.current()->sp() != stack_pointer && !fstAfterDeopt.is_done()) {
1378 fstAfterDeopt.next();
1379 }
1380 if (fstAfterDeopt.current()->sp() != stack_pointer) {
1381 JVMCI_THROW_MSG(IllegalStateException, "stack frame not found after deopt");
1382 }
1383
1384 vframe* vf = vframe::new_vframe(fstAfterDeopt.current(), fstAfterDeopt.register_map(), thread);
1385 if (!vf->is_compiled_frame()) {
1386 JVMCI_THROW_MSG(IllegalStateException, "compiled stack frame expected");
1387 }
1388
1389 GrowableArray<compiledVFrame*>* virtualFrames = new GrowableArray<compiledVFrame*>(10);
1390 while (true) {
1391 assert(vf->is_compiled_frame(), "Wrong frame type");
1392 virtualFrames->push(compiledVFrame::cast(vf));
1393 if (vf->is_top()) {
1394 break;
1395 }
1396 vf = vf->sender();
1397 }
1398
1399 int last_frame_number = JVMCIENV->get_HotSpotStackFrameReference_frameNumber(hs_frame);
1400 if (last_frame_number >= virtualFrames->length()) {
1401 JVMCI_THROW_MSG(IllegalStateException, "invalid frame number");
1402 }
1403
1404 // Reallocate the non-escaping objects and restore their fields.
1405 assert (virtualFrames->at(last_frame_number)->scope() != NULL,"invalid scope");
1406 GrowableArray<ScopeValue*>* objects = virtualFrames->at(last_frame_number)->scope()->objects();
1407
1408 if (objects == NULL) {
1409 // no objects to materialize
1410 return;
1411 }
1412
1413 bool realloc_failures = Deoptimization::realloc_objects(thread, fstAfterDeopt.current(), objects, CHECK);
1414 Deoptimization::reassign_fields(fstAfterDeopt.current(), fstAfterDeopt.register_map(), objects, realloc_failures, false);
1415
1416 for (int frame_index = 0; frame_index < virtualFrames->length(); frame_index++) {
1417 compiledVFrame* cvf = virtualFrames->at(frame_index);
1418
1419 GrowableArray<ScopeValue*>* scopeLocals = cvf->scope()->locals();
1420 StackValueCollection* locals = cvf->locals();
1421 if (locals != NULL) {
1422 for (int i2 = 0; i2 < locals->size(); i2++) {
1423 StackValue* var = locals->at(i2);
1424 if (var->type() == T_OBJECT && scopeLocals->at(i2)->is_object()) {
1425 jvalue val;
1426 val.l = (jobject) locals->at(i2)->get_obj()();
1427 cvf->update_local(T_OBJECT, i2, val);
1428 }
1429 }
1430 }
1431
1432 GrowableArray<ScopeValue*>* scopeExpressions = cvf->scope()->expressions();
1433 StackValueCollection* expressions = cvf->expressions();
1434 if (expressions != NULL) {
1435 for (int i2 = 0; i2 < expressions->size(); i2++) {
1436 StackValue* var = expressions->at(i2);
1437 if (var->type() == T_OBJECT && scopeExpressions->at(i2)->is_object()) {
1438 jvalue val;
1439 val.l = (jobject) expressions->at(i2)->get_obj()();
1440 cvf->update_stack(T_OBJECT, i2, val);
1441 }
1442 }
1443 }
1444
1445 GrowableArray<MonitorValue*>* scopeMonitors = cvf->scope()->monitors();
1446 GrowableArray<MonitorInfo*>* monitors = cvf->monitors();
1447 if (monitors != NULL) {
1448 for (int i2 = 0; i2 < monitors->length(); i2++) {
1449 cvf->update_monitor(i2, monitors->at(i2));
1450 }
1451 }
1452 }
1453
1454 // all locals are materialized by now
1455 JVMCIENV->set_HotSpotStackFrameReference_localIsVirtual(hs_frame, NULL);
1456 // update the locals array
1457 JVMCIObjectArray array = JVMCIENV->get_HotSpotStackFrameReference_locals(hs_frame);
1458 StackValueCollection* locals = virtualFrames->at(last_frame_number)->locals();
1459 for (int i = 0; i < locals->size(); i++) {
1460 StackValue* var = locals->at(i);
1461 if (var->type() == T_OBJECT) {
1462 JVMCIENV->put_object_at(array, i, HotSpotJVMCI::wrap(locals->at(i)->get_obj()()));
1463 }
1464 }
1465 HotSpotJVMCI::HotSpotStackFrameReference::set_objectsMaterialized(JVMCIENV, hs_frame, JNI_TRUE);
1466 C2V_END
1467
1468 C2V_VMENTRY(void, writeDebugOutput, (JNIEnv* env, jobject, jbyteArray bytes, jint offset, jint length))
1469 if (bytes == NULL) {
1470 JVMCI_THROW(NullPointerException);
1471 }
1472 JVMCIPrimitiveArray array = JVMCIENV->wrap(bytes);
1473
1474 // Check if offset and length are non negative.
1475 if (offset < 0 || length < 0) {
1476 JVMCI_THROW(ArrayIndexOutOfBoundsException);
1477 }
1478 // Check if the range is valid.
1479 int array_length = JVMCIENV->get_length(array);
1480 if ((((unsigned int) length + (unsigned int) offset) > (unsigned int) array_length)) {
1481 JVMCI_THROW(ArrayIndexOutOfBoundsException);
1482 }
1483 jbyte buffer[O_BUFLEN];
1484 while (length > 0) {
1485 int copy_len = MIN2(length, (jint)O_BUFLEN);
1486 JVMCIENV->copy_bytes_to(array, buffer, offset, copy_len);
1487 tty->write((char*) buffer, copy_len);
1488 length -= O_BUFLEN;
1489 offset += O_BUFLEN;
1490 }
1491 C2V_END
1492
1493 C2V_VMENTRY(void, flushDebugOutput, (JNIEnv* env, jobject))
1494 tty->flush();
1495 C2V_END
1496
1497 C2V_VMENTRY(int, methodDataProfileDataSize, (JNIEnv* env, jobject, jlong metaspace_method_data, jint position))
1498 MethodData* mdo = JVMCIENV->asMethodData(metaspace_method_data);
1499 ProfileData* profile_data = mdo->data_at(position);
1500 if (mdo->is_valid(profile_data)) {
1501 return profile_data->size_in_bytes();
1502 }
1503 DataLayout* data = mdo->extra_data_base();
1504 DataLayout* end = mdo->extra_data_limit();
1505 for (;; data = mdo->next_extra(data)) {
1506 assert(data < end, "moved past end of extra data");
1507 profile_data = data->data_in();
1508 if (mdo->dp_to_di(profile_data->dp()) == position) {
1509 return profile_data->size_in_bytes();
1510 }
1511 }
1512 JVMCI_THROW_MSG_0(IllegalArgumentException, err_msg("Invalid profile data position %d", position));
1513 C2V_END
1514
1515 C2V_VMENTRY(jlong, getFingerprint, (JNIEnv* env, jobject, jlong metaspace_klass))
1516 #if INCLUDE_AOT
1517 Klass *k = (Klass*) (address) metaspace_klass;
1518 if (k->is_instance_klass()) {
1519 return InstanceKlass::cast(k)->get_stored_fingerprint();
1520 } else {
1521 return 0;
1522 }
1523 #else
1524 JVMCI_THROW_MSG_0(InternalError, "unimplemented");
1525 #endif
1526 C2V_END
1527
1528 C2V_VMENTRY(jobject, getHostClass, (JNIEnv* env, jobject, jobject jvmci_type))
1529 InstanceKlass* k = InstanceKlass::cast(JVMCIENV->asKlass(jvmci_type));
1530 InstanceKlass* host = k->unsafe_anonymous_host();
1531 JVMCIKlassHandle handle(THREAD, host);
1532 JVMCIObject result = JVMCIENV->get_jvmci_type(handle, JVMCI_CHECK_NULL);
1533 return JVMCIENV->get_jobject(result);
1534 C2V_END
1535
1536 C2V_VMENTRY(jobject, getInterfaces, (JNIEnv* env, jobject, jobject jvmci_type))
1537 if (jvmci_type == NULL) {
1538 JVMCI_THROW_0(NullPointerException);
1539 }
1540
1541 Klass* klass = JVMCIENV->asKlass(jvmci_type);
1542 if (klass == NULL) {
1543 JVMCI_THROW_0(NullPointerException);
1544 }
1545 if (!klass->is_instance_klass()) {
1546 JVMCI_THROW_MSG_0(InternalError, err_msg("Class %s must be instance klass", klass->external_name()));
1547 }
1548 InstanceKlass* iklass = InstanceKlass::cast(klass);
1549
1550 // Regular instance klass, fill in all local interfaces
1551 int size = iklass->local_interfaces()->length();
1552 JVMCIObjectArray interfaces = JVMCIENV->new_HotSpotResolvedObjectTypeImpl_array(size, JVMCI_CHECK_NULL);
1553 for (int index = 0; index < size; index++) {
1554 JVMCIKlassHandle klass(THREAD);
1555 Klass* k = iklass->local_interfaces()->at(index);
1556 klass = k;
1557 JVMCIObject type = JVMCIENV->get_jvmci_type(klass, JVMCI_CHECK_NULL);
1558 JVMCIENV->put_object_at(interfaces, index, type);
1559 }
1560 return JVMCIENV->get_jobject(interfaces);
1561 C2V_END
1562
1563 C2V_VMENTRY(jobject, getComponentType, (JNIEnv* env, jobject, jobject jvmci_type))
1564 if (jvmci_type == NULL) {
1565 JVMCI_THROW_0(NullPointerException);
1566 }
1567
1568 Klass* klass = JVMCIENV->asKlass(jvmci_type);
1569 oop mirror = klass->java_mirror();
1570 if (java_lang_Class::is_primitive(mirror) ||
1571 !java_lang_Class::as_Klass(mirror)->is_array_klass()) {
1572 return NULL;
1573 }
1574
1575 oop component_mirror = java_lang_Class::component_mirror(mirror);
1576 if (component_mirror == NULL) {
1577 return NULL;
1578 }
1579 Klass* component_klass = java_lang_Class::as_Klass(component_mirror);
1580 if (component_klass != NULL) {
1581 JVMCIKlassHandle klass_handle(THREAD);
1582 klass_handle = component_klass;
1583 JVMCIObject result = JVMCIENV->get_jvmci_type(klass_handle, JVMCI_CHECK_NULL);
1584 return JVMCIENV->get_jobject(result);
1585 }
1586 BasicType type = java_lang_Class::primitive_type(component_mirror);
1587 JVMCIObject result = JVMCIENV->get_jvmci_primitive_type(type);
1588 return JVMCIENV->get_jobject(result);
1589 C2V_END
1590
1591 C2V_VMENTRY(void, ensureInitialized, (JNIEnv* env, jobject, jobject jvmci_type))
1592 if (jvmci_type == NULL) {
1593 JVMCI_THROW(NullPointerException);
1594 }
1595
1596 Klass* klass = JVMCIENV->asKlass(jvmci_type);
1597 if (klass != NULL && klass->should_be_initialized()) {
1598 InstanceKlass* k = InstanceKlass::cast(klass);
1599 k->initialize(CHECK);
1600 }
1601 C2V_END
1602
1603 C2V_VMENTRY(int, interpreterFrameSize, (JNIEnv* env, jobject, jobject bytecode_frame_handle))
1604 if (bytecode_frame_handle == NULL) {
1605 JVMCI_THROW_0(NullPointerException);
1606 }
1607
1608 JVMCIObject top_bytecode_frame = JVMCIENV->wrap(bytecode_frame_handle);
1609 JVMCIObject bytecode_frame = top_bytecode_frame;
1610 int size = 0;
1611 int callee_parameters = 0;
1612 int callee_locals = 0;
1613 Method* method = JVMCIENV->asMethod(JVMCIENV->get_BytecodePosition_method(bytecode_frame));
1614 int extra_args = method->max_stack() - JVMCIENV->get_BytecodeFrame_numStack(bytecode_frame);
1615
1616 while (bytecode_frame.is_non_null()) {
1617 int locks = JVMCIENV->get_BytecodeFrame_numLocks(bytecode_frame);
1618 int temps = JVMCIENV->get_BytecodeFrame_numStack(bytecode_frame);
1619 bool is_top_frame = (JVMCIENV->equals(bytecode_frame, top_bytecode_frame));
1620 Method* method = JVMCIENV->asMethod(JVMCIENV->get_BytecodePosition_method(bytecode_frame));
1621
1622 int frame_size = BytesPerWord * Interpreter::size_activation(method->max_stack(),
1623 temps + callee_parameters,
1624 extra_args,
1625 locks,
1626 callee_parameters,
1627 callee_locals,
1628 is_top_frame);
1629 size += frame_size;
1630
1631 callee_parameters = method->size_of_parameters();
1632 callee_locals = method->max_locals();
1633 extra_args = 0;
1634 bytecode_frame = JVMCIENV->get_BytecodePosition_caller(bytecode_frame);
1635 }
1636 return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord;
1637 C2V_END
1638
1639 C2V_VMENTRY(void, compileToBytecode, (JNIEnv* env, jobject, jobject lambda_form_handle))
1640 Handle lambda_form = JVMCIENV->asConstant(JVMCIENV->wrap(lambda_form_handle), JVMCI_CHECK);
1641 if (lambda_form->is_a(SystemDictionary::LambdaForm_klass())) {
1642 TempNewSymbol compileToBytecode = SymbolTable::new_symbol("compileToBytecode", CHECK);
1643 JavaValue result(T_VOID);
1644 JavaCalls::call_special(&result, lambda_form, SystemDictionary::LambdaForm_klass(), compileToBytecode, vmSymbols::void_method_signature(), CHECK);
1645 } else {
1646 JVMCI_THROW_MSG(IllegalArgumentException,
1647 err_msg("Unexpected type: %s", lambda_form->klass()->external_name()))
1648 }
1649 C2V_END
1650
1651 C2V_VMENTRY(int, getIdentityHashCode, (JNIEnv* env, jobject, jobject object))
1652 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0);
1653 return obj->identity_hash();
1654 C2V_END
1655
1656 C2V_VMENTRY(jboolean, isInternedString, (JNIEnv* env, jobject, jobject object))
1657 Handle str = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0);
1658 if (!java_lang_String::is_instance(str())) {
1659 return false;
1660 }
1661 int len;
1662 jchar* name = java_lang_String::as_unicode_string(str(), len, CHECK_0);
1663 return (StringTable::lookup(name, len) != NULL);
1664 C2V_END
1665
1666
1667 C2V_VMENTRY(jobject, unboxPrimitive, (JNIEnv* env, jobject, jobject object))
1668 if (object == NULL) {
1669 JVMCI_THROW_0(NullPointerException);
1670 }
1671 Handle box = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
1672 BasicType type = java_lang_boxing_object::basic_type(box());
1673 jvalue result;
1674 if (java_lang_boxing_object::get_value(box(), &result) == T_ILLEGAL) {
1675 return NULL;
1676 }
1677 JVMCIObject boxResult = JVMCIENV->create_box(type, &result, JVMCI_CHECK_NULL);
1678 return JVMCIENV->get_jobject(boxResult);
1679 C2V_END
1680
1681 C2V_VMENTRY(jobject, boxPrimitive, (JNIEnv* env, jobject, jobject object))
1682 if (object == NULL) {
1683 JVMCI_THROW_0(NullPointerException);
1684 }
1685 JVMCIObject box = JVMCIENV->wrap(object);
1686 BasicType type = JVMCIENV->get_box_type(box);
1687 if (type == T_ILLEGAL) {
1688 return NULL;
1689 }
1690 jvalue value = JVMCIENV->get_boxed_value(type, box);
1691 JavaValue box_result(T_OBJECT);
1692 JavaCallArguments jargs;
1693 Klass* box_klass = NULL;
1694 Symbol* box_signature = NULL;
1695 #define BOX_CASE(bt, v, argtype, name) \
1696 case bt: \
1697 jargs.push_##argtype(value.v); \
1698 box_klass = SystemDictionary::name##_klass(); \
1699 box_signature = vmSymbols::name##_valueOf_signature(); \
1700 break
1701
1702 switch (type) {
1703 BOX_CASE(T_BOOLEAN, z, int, Boolean);
1704 BOX_CASE(T_BYTE, b, int, Byte);
1705 BOX_CASE(T_CHAR, c, int, Character);
1706 BOX_CASE(T_SHORT, s, int, Short);
1707 BOX_CASE(T_INT, i, int, Integer);
1708 BOX_CASE(T_LONG, j, long, Long);
1709 BOX_CASE(T_FLOAT, f, float, Float);
1710 BOX_CASE(T_DOUBLE, d, double, Double);
1711 default:
1712 ShouldNotReachHere();
1713 }
1714 #undef BOX_CASE
1715
1716 JavaCalls::call_static(&box_result,
1717 box_klass,
1718 vmSymbols::valueOf_name(),
1719 box_signature, &jargs, CHECK_NULL);
1720 oop hotspot_box = (oop) box_result.get_jobject();
1721 JVMCIObject result = JVMCIENV->get_object_constant(hotspot_box, false);
1722 return JVMCIENV->get_jobject(result);
1723 C2V_END
1724
1725 C2V_VMENTRY(jobjectArray, getDeclaredConstructors, (JNIEnv* env, jobject, jobject holder))
1726 if (holder == NULL) {
1727 JVMCI_THROW_0(NullPointerException);
1728 }
1729 Klass* klass = JVMCIENV->asKlass(holder);
1730 if (!klass->is_instance_klass()) {
1731 JVMCIObjectArray methods = JVMCIENV->new_ResolvedJavaMethod_array(0, JVMCI_CHECK_NULL);
1732 return JVMCIENV->get_jobjectArray(methods);
1733 }
1734
1735 InstanceKlass* iklass = InstanceKlass::cast(klass);
1736 // Ensure class is linked
1737 iklass->link_class(CHECK_NULL);
1738
1739 GrowableArray<Method*> constructors_array;
1740 for (int i = 0; i < iklass->methods()->length(); i++) {
1741 Method* m = iklass->methods()->at(i);
1742 if (m->is_initializer() && !m->is_static()) {
1743 constructors_array.append(m);
1744 }
1745 }
1746 JVMCIObjectArray methods = JVMCIENV->new_ResolvedJavaMethod_array(constructors_array.length(), JVMCI_CHECK_NULL);
1747 for (int i = 0; i < constructors_array.length(); i++) {
1748 JVMCIObject method = JVMCIENV->get_jvmci_method(constructors_array.at(i), JVMCI_CHECK_NULL);
1749 JVMCIENV->put_object_at(methods, i, method);
1750 }
1751 return JVMCIENV->get_jobjectArray(methods);
1752 C2V_END
1753
1754 C2V_VMENTRY(jobjectArray, getDeclaredMethods, (JNIEnv* env, jobject, jobject holder))
1755 if (holder == NULL) {
1756 JVMCI_THROW_0(NullPointerException);
1757 }
1758 Klass* klass = JVMCIENV->asKlass(holder);
1759 if (!klass->is_instance_klass()) {
1760 JVMCIObjectArray methods = JVMCIENV->new_ResolvedJavaMethod_array(0, JVMCI_CHECK_NULL);
1761 return JVMCIENV->get_jobjectArray(methods);
1762 }
1763
1764 InstanceKlass* iklass = InstanceKlass::cast(klass);
1765 // Ensure class is linked
1766 iklass->link_class(CHECK_NULL);
1767
1768 GrowableArray<Method*> methods_array;
1769 for (int i = 0; i < iklass->methods()->length(); i++) {
1770 Method* m = iklass->methods()->at(i);
1771 if (!m->is_initializer() && !m->is_overpass()) {
1772 methods_array.append(m);
1773 }
1774 }
1775 JVMCIObjectArray methods = JVMCIENV->new_ResolvedJavaMethod_array(methods_array.length(), JVMCI_CHECK_NULL);
1776 for (int i = 0; i < methods_array.length(); i++) {
1777 JVMCIObject method = JVMCIENV->get_jvmci_method(methods_array.at(i), JVMCI_CHECK_NULL);
1778 JVMCIENV->put_object_at(methods, i, method);
1779 }
1780 return JVMCIENV->get_jobjectArray(methods);
1781 C2V_END
1782
1783 C2V_VMENTRY(jobject, readFieldValue, (JNIEnv* env, jobject, jobject object, jobject field, jboolean is_volatile))
1784 if (object == NULL || field == NULL) {
1785 JVMCI_THROW_0(NullPointerException);
1786 }
1787 JVMCIObject field_object = JVMCIENV->wrap(field);
1788 JVMCIObject java_type = JVMCIENV->get_HotSpotResolvedJavaFieldImpl_type(field_object);
1789 int modifiers = JVMCIENV->get_HotSpotResolvedJavaFieldImpl_modifiers(field_object);
1790 Klass* holder = JVMCIENV->asKlass(JVMCIENV->get_HotSpotResolvedJavaFieldImpl_holder(field_object));
1791 if (!holder->is_instance_klass()) {
1792 JVMCI_THROW_MSG_0(InternalError, err_msg("Holder %s must be instance klass", holder->external_name()));
1793 }
1794 InstanceKlass* ik = InstanceKlass::cast(holder);
1795 BasicType constant_type;
1796 if (JVMCIENV->isa_HotSpotResolvedPrimitiveType(java_type)) {
1797 constant_type = JVMCIENV->kindToBasicType(JVMCIENV->get_HotSpotResolvedPrimitiveType_kind(java_type), JVMCI_CHECK_NULL);
1798 } else {
1799 constant_type = T_OBJECT;
1800 }
1801 int displacement = JVMCIENV->get_HotSpotResolvedJavaFieldImpl_offset(field_object);
1802 fieldDescriptor fd;
1803 if (!ik->find_local_field_from_offset(displacement, (modifiers & JVM_ACC_STATIC) != 0, &fd)) {
1804 JVMCI_THROW_MSG_0(InternalError, err_msg("Can't find field with displacement %d", displacement));
1805 }
1806 JVMCIObject base = JVMCIENV->wrap(object);
1807 Handle obj;
1808 if (JVMCIENV->isa_HotSpotObjectConstantImpl(base)) {
1809 obj = JVMCIENV->asConstant(base, JVMCI_CHECK_NULL);
1810 } else if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(base)) {
1811 Klass* klass = JVMCIENV->asKlass(base);
1812 obj = Handle(THREAD, klass->java_mirror());
1813 } else {
1814 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
1815 err_msg("Unexpected type: %s", JVMCIENV->klass_name(base)));
1816 }
1817 jlong value = 0;
1818 JVMCIObject kind;
1819 switch (constant_type) {
1820 case T_OBJECT: {
1821 oop object = is_volatile ? obj->obj_field_acquire(displacement) : obj->obj_field(displacement);
1822 JVMCIObject result = JVMCIENV->get_object_constant(object);
1823 if (result.is_null()) {
1824 return JVMCIENV->get_jobject(JVMCIENV->get_JavaConstant_NULL_POINTER());
1825 }
1826 return JVMCIENV->get_jobject(result);
1827 }
1828 case T_FLOAT: {
1829 float f = is_volatile ? obj->float_field_acquire(displacement) : obj->float_field(displacement);
1830 JVMCIObject result = JVMCIENV->call_JavaConstant_forFloat(f, JVMCI_CHECK_NULL);
1831 return JVMCIENV->get_jobject(result);
1832 }
1833 case T_DOUBLE: {
1834 double f = is_volatile ? obj->double_field_acquire(displacement) : obj->double_field(displacement);
1835 JVMCIObject result = JVMCIENV->call_JavaConstant_forDouble(f, JVMCI_CHECK_NULL);
1836 return JVMCIENV->get_jobject(result);
1837 }
1838 case T_BOOLEAN: value = is_volatile ? obj->bool_field_acquire(displacement) : obj->bool_field(displacement); break;
1839 case T_BYTE: value = is_volatile ? obj->byte_field_acquire(displacement) : obj->byte_field(displacement); break;
1840 case T_SHORT: value = is_volatile ? obj->short_field_acquire(displacement) : obj->short_field(displacement); break;
1841 case T_CHAR: value = is_volatile ? obj->char_field_acquire(displacement) : obj->char_field(displacement); break;
1842 case T_INT: value = is_volatile ? obj->int_field_acquire(displacement) : obj->int_field(displacement); break;
1843 case T_LONG: value = is_volatile ? obj->long_field_acquire(displacement) : obj->long_field(displacement); break;
1844 default:
1845 ShouldNotReachHere();
1846 }
1847 JVMCIObject result = JVMCIENV->call_PrimitiveConstant_forTypeChar(type2char(constant_type), value, JVMCI_CHECK_NULL);
1848 return JVMCIENV->get_jobject(result);
1849 C2V_END
1850
1851 C2V_VMENTRY(jboolean, isInstance, (JNIEnv* env, jobject, jobject holder, jobject object))
1852 if (object == NULL || holder == NULL) {
1853 JVMCI_THROW_0(NullPointerException);
1854 }
1855 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_0);
1856 Klass* klass = JVMCIENV->asKlass(JVMCIENV->wrap(holder));
1857 return obj->is_a(klass);
1858 C2V_END
1859
1860 C2V_VMENTRY(jboolean, isAssignableFrom, (JNIEnv* env, jobject, jobject holder, jobject otherHolder))
1861 if (holder == NULL || otherHolder == NULL) {
1862 JVMCI_THROW_0(NullPointerException);
1863 }
1864 Klass* klass = JVMCIENV->asKlass(JVMCIENV->wrap(holder));
1865 Klass* otherKlass = JVMCIENV->asKlass(JVMCIENV->wrap(otherHolder));
1866 return otherKlass->is_subtype_of(klass);
1867 C2V_END
1868
1869 C2V_VMENTRY(jboolean, isTrustedForIntrinsics, (JNIEnv* env, jobject, jobject holder))
1870 if (holder == NULL) {
1871 JVMCI_THROW_0(NullPointerException);
1872 }
1873 InstanceKlass* ik = InstanceKlass::cast(JVMCIENV->asKlass(JVMCIENV->wrap(holder)));
1874 if (ik->class_loader_data()->is_builtin_class_loader_data()) {
1875 return true;
1876 }
1877 return false;
1878 C2V_END
1879
1880 C2V_VMENTRY(jobject, asJavaType, (JNIEnv* env, jobject, jobject object))
1881 if (object == NULL) {
1882 JVMCI_THROW_0(NullPointerException);
1883 }
1884 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
1885 if (java_lang_Class::is_instance(obj())) {
1886 if (java_lang_Class::is_primitive(obj())) {
1887 JVMCIObject type = JVMCIENV->get_jvmci_primitive_type(java_lang_Class::primitive_type(obj()));
1888 return JVMCIENV->get_jobject(type);
1889 }
1890 Klass* klass = java_lang_Class::as_Klass(obj());
1891 JVMCIKlassHandle klass_handle(THREAD);
1892 klass_handle = klass;
1893 JVMCIObject type = JVMCIENV->get_jvmci_type(klass_handle, JVMCI_CHECK_NULL);
1894 return JVMCIENV->get_jobject(type);
1895 }
1896 return NULL;
1897 C2V_END
1898
1899
1900 C2V_VMENTRY(jobject, asString, (JNIEnv* env, jobject, jobject object))
1901 if (object == NULL) {
1902 JVMCI_THROW_0(NullPointerException);
1903 }
1904 Handle obj = JVMCIENV->asConstant(JVMCIENV->wrap(object), JVMCI_CHECK_NULL);
1905 const char* str = java_lang_String::as_utf8_string(obj());
1906 JVMCIObject result = JVMCIENV->create_string(str, JVMCI_CHECK_NULL);
1907 return JVMCIENV->get_jobject(result);
1908 C2V_END
1909
1910
1911 C2V_VMENTRY(jboolean, equals, (JNIEnv* env, jobject, jobject x, jlong xHandle, jobject y, jlong yHandle))
1912 if (x == NULL || y == NULL) {
1913 JVMCI_THROW_0(NullPointerException);
1914 }
1915 return JVMCIENV->resolve_handle(xHandle) == JVMCIENV->resolve_handle(yHandle);
1916 C2V_END
1917
1918 C2V_VMENTRY(jobject, getJavaMirror, (JNIEnv* env, jobject, jobject object))
1919 if (object == NULL) {
1920 JVMCI_THROW_0(NullPointerException);
1921 }
1922 JVMCIObject base_object = JVMCIENV->wrap(object);
1923 Handle mirror;
1924 if (JVMCIENV->isa_HotSpotResolvedObjectTypeImpl(base_object)) {
1925 mirror = Handle(THREAD, JVMCIENV->asKlass(base_object)->java_mirror());
1926 } else if (JVMCIENV->isa_HotSpotResolvedPrimitiveType(base_object)) {
1927 mirror = JVMCIENV->asConstant(JVMCIENV->get_HotSpotResolvedPrimitiveType_mirror(base_object), JVMCI_CHECK_NULL);
1928 } else {
1929 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
1930 err_msg("Unexpected type: %s", JVMCIENV->klass_name(base_object)));
1931 }
1932 JVMCIObject result = JVMCIENV->get_object_constant(mirror());
1933 return JVMCIENV->get_jobject(result);
1934 C2V_END
1935
1936
1937 C2V_VMENTRY(jint, getArrayLength, (JNIEnv* env, jobject, jobject x))
1938 if (x == NULL) {
1939 JVMCI_THROW_0(NullPointerException);
1940 }
1941 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
1942 if (xobj->klass()->is_array_klass()) {
1943 return arrayOop(xobj())->length();
1944 }
1945 return -1;
1946 C2V_END
1947
1948
1949 C2V_VMENTRY(jobject, readArrayElement, (JNIEnv* env, jobject, jobject x, int index))
1950 if (x == NULL) {
1951 JVMCI_THROW_0(NullPointerException);
1952 }
1953 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_NULL);
1954 if (xobj->klass()->is_array_klass()) {
1955 arrayOop array = arrayOop(xobj());
1956 BasicType element_type = ArrayKlass::cast(array->klass())->element_type();
1957 if (index < 0 || index >= array->length()) {
1958 return NULL;
1959 }
1960 JVMCIObject result;
1961
1962 if (element_type == T_OBJECT) {
1963 result = JVMCIENV->get_object_constant(objArrayOop(xobj())->obj_at(index));
1964 if (result.is_null()) {
1965 result = JVMCIENV->get_JavaConstant_NULL_POINTER();
1966 }
1967 } else {
1968 jvalue value;
1969 switch (element_type) {
1970 case T_DOUBLE: value.d = typeArrayOop(xobj())->double_at(index); break;
1971 case T_FLOAT: value.f = typeArrayOop(xobj())->float_at(index); break;
1972 case T_LONG: value.j = typeArrayOop(xobj())->long_at(index); break;
1973 case T_INT: value.i = typeArrayOop(xobj())->int_at(index); break;
1974 case T_SHORT: value.s = typeArrayOop(xobj())->short_at(index); break;
1975 case T_CHAR: value.c = typeArrayOop(xobj())->char_at(index); break;
1976 case T_BYTE: value.b = typeArrayOop(xobj())->byte_at(index); break;
1977 case T_BOOLEAN: value.z = typeArrayOop(xobj())->byte_at(index) & 1; break;
1978 default: ShouldNotReachHere();
1979 }
1980 result = JVMCIENV->create_box(element_type, &value, JVMCI_CHECK_NULL);
1981 }
1982 assert(!result.is_null(), "must have a value");
1983 return JVMCIENV->get_jobject(result);
1984 }
1985 return NULL;;
1986 C2V_END
1987
1988
1989 C2V_VMENTRY(jint, arrayBaseOffset, (JNIEnv* env, jobject, jobject kind))
1990 if (kind == NULL) {
1991 JVMCI_THROW_0(NullPointerException);
1992 }
1993 BasicType type = JVMCIENV->kindToBasicType(JVMCIENV->wrap(kind), JVMCI_CHECK_0);
1994 return arrayOopDesc::header_size(type) * HeapWordSize;
1995 C2V_END
1996
1997 C2V_VMENTRY(jint, arrayIndexScale, (JNIEnv* env, jobject, jobject kind))
1998 if (kind == NULL) {
1999 JVMCI_THROW_0(NullPointerException);
2000 }
2001 BasicType type = JVMCIENV->kindToBasicType(JVMCIENV->wrap(kind), JVMCI_CHECK_0);
2002 return type2aelembytes(type);
2003 C2V_END
2004
2005 C2V_VMENTRY(jbyte, getByte, (JNIEnv* env, jobject, jobject x, long displacement))
2006 if (x == NULL) {
2007 JVMCI_THROW_0(NullPointerException);
2008 }
2009 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
2010 return xobj->byte_field(displacement);
2011 }
2012
2013 C2V_VMENTRY(jshort, getShort, (JNIEnv* env, jobject, jobject x, long displacement))
2014 if (x == NULL) {
2015 JVMCI_THROW_0(NullPointerException);
2016 }
2017 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
2018 return xobj->short_field(displacement);
2019 }
2020
2021 C2V_VMENTRY(jint, getInt, (JNIEnv* env, jobject, jobject x, long displacement))
2022 if (x == NULL) {
2023 JVMCI_THROW_0(NullPointerException);
2024 }
2025 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
2026 return xobj->int_field(displacement);
2027 }
2028
2029 C2V_VMENTRY(jlong, getLong, (JNIEnv* env, jobject, jobject x, long displacement))
2030 if (x == NULL) {
2031 JVMCI_THROW_0(NullPointerException);
2032 }
2033 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
2034 return xobj->long_field(displacement);
2035 }
2036
2037 C2V_VMENTRY(jobject, getObject, (JNIEnv* env, jobject, jobject x, long displacement))
2038 if (x == NULL) {
2039 JVMCI_THROW_0(NullPointerException);
2040 }
2041 Handle xobj = JVMCIENV->asConstant(JVMCIENV->wrap(x), JVMCI_CHECK_0);
2042 oop res = xobj->obj_field(displacement);
2043 JVMCIObject result = JVMCIENV->get_object_constant(res);
2044 return JVMCIENV->get_jobject(result);
2045 }
2046
2047 C2V_VMENTRY(void, deleteGlobalHandle, (JNIEnv* env, jobject, jlong h))
2048 jobject handle = (jobject)(address)h;
2049 if (handle != NULL) {
2050 assert(JVMCI::is_global_handle(handle), "Invalid delete of global JNI handle");
2051 *((oop*)handle) = NULL; // Mark the handle as deleted, allocate will reuse it
2052 }
2053 }
2054
2055 C2V_VMENTRY(jlongArray, registerNativeMethods, (JNIEnv* env, jobject, jclass mirror))
2056 if (!UseJVMCINativeLibrary) {
2057 JVMCI_THROW_MSG_0(UnsatisfiedLinkError, "JVMCI shared library is not enabled (requires -XX:+UseJVMCINativeLibrary)");
2058 }
2059 if (!JVMCIENV->is_hotspot()) {
2060 JVMCI_THROW_MSG_0(UnsatisfiedLinkError, "Cannot call registerNativeMethods from JVMCI shared library");
2061 }
2062 void* shared_library = JVMCIEnv::get_shared_library_handle();
2063 if (shared_library == NULL) {
2064 // Ensure the JVMCI shared library runtime is initialized.
2065 JVMCIEnv __peer_jvmci_env__(false, __FILE__, __LINE__);
2066 JVMCIEnv* peerEnv = &__peer_jvmci_env__;
2067 HandleMark hm;
2068 JVMCIRuntime* runtime = JVMCI::compiler_runtime();
2069 JVMCIObject receiver = runtime->get_HotSpotJVMCIRuntime(peerEnv);
2070 if (peerEnv->has_pending_exception()) {
2071 peerEnv->describe_pending_exception(true);
2072 JVMCI_THROW_MSG_0(InternalError, "Error initializing JVMCI runtime");
2073 }
2074 shared_library = JVMCIEnv::get_shared_library_handle();
2075 }
2076
2077 if (shared_library == NULL) {
2078 JVMCI_THROW_MSG_0(UnsatisfiedLinkError, "JVMCI shared library is unavailable");
2079 }
2080
2081 if (mirror == NULL) {
2082 JVMCI_THROW_0(NullPointerException);
2083 }
2084 Klass* klass = java_lang_Class::as_Klass(JNIHandles::resolve(mirror));
2085 if (klass == NULL || !klass->is_instance_klass()) {
2086 JVMCI_THROW_MSG_0(IllegalArgumentException, "clazz is for primitive type");
2087 }
2088
2089 InstanceKlass* iklass = InstanceKlass::cast(klass);
2090 for (int i = 0; i < iklass->methods()->length(); i++) {
2091 Method* method = iklass->methods()->at(i);
2092 if (method->is_native()) {
2093
2094 // Compute argument size
2095 int args_size = 1 // JNIEnv
2096 + (method->is_static() ? 1 : 0) // class for static methods
2097 + method->size_of_parameters(); // actual parameters
2098
2099 // 1) Try JNI short style
2100 stringStream st;
2101 char* pure_name = NativeLookup::pure_jni_name(method);
2102 os::print_jni_name_prefix_on(&st, args_size);
2103 st.print_raw(pure_name);
2104 os::print_jni_name_suffix_on(&st, args_size);
2105 char* jni_name = st.as_string();
2106
2107 address entry = (address) os::dll_lookup(shared_library, jni_name);
2108 if (entry == NULL) {
2109 // 2) Try JNI long style
2110 st.reset();
2111 char* long_name = NativeLookup::long_jni_name(method);
2112 os::print_jni_name_prefix_on(&st, args_size);
2113 st.print_raw(pure_name);
2114 st.print_raw(long_name);
2115 os::print_jni_name_suffix_on(&st, args_size);
2116 jni_name = st.as_string();
2117 entry = (address) os::dll_lookup(shared_library, jni_name);
2118 }
2119 if (entry == NULL) {
2120 JVMCI_THROW_MSG_0(UnsatisfiedLinkError, method->name_and_sig_as_C_string());
2121 }
2122 if (method->has_native_function() && entry != method->native_function()) {
2123 JVMCI_THROW_MSG_0(UnsatisfiedLinkError, err_msg("Cannot overwrite existing native implementation for %s",
2124 method->name_and_sig_as_C_string()));
2125 }
2126 method->set_native_function(entry, Method::native_bind_event_is_interesting);
2127 if (PrintJNIResolving) {
2128 tty->print_cr("[Dynamic-linking native method %s.%s ... JNI]",
2129 method->method_holder()->external_name(),
2130 method->name()->as_C_string());
2131 }
2132 }
2133 }
2134
2135 JavaVM* javaVM = JVMCIEnv::get_shared_library_javavm();
2136 JVMCIPrimitiveArray result = JVMCIENV->new_longArray(4, JVMCI_CHECK_NULL);
2137 JVMCIENV->put_long_at(result, 0, (jlong) (address) javaVM);
2138 JVMCIENV->put_long_at(result, 1, (jlong) (address) javaVM->functions->reserved0);
2139 JVMCIENV->put_long_at(result, 2, (jlong) (address) javaVM->functions->reserved1);
2140 JVMCIENV->put_long_at(result, 3, (jlong) (address) javaVM->functions->reserved2);
2141 return (jlongArray) JVMCIENV->get_jobject(result);
2142 }
2143
2144 C2V_VMENTRY(jlong, translate, (JNIEnv* env, jobject, jobject obj_handle))
2145 if (obj_handle == NULL) {
2146 return 0L;
2147 }
2148 JVMCIEnv __peer_jvmci_env__(!JVMCIENV->is_hotspot(), __FILE__, __LINE__);
2149 JVMCIEnv* peerEnv = &__peer_jvmci_env__;
2150 JVMCIEnv* thisEnv = JVMCIENV;
2151
2152 JVMCIObject obj = thisEnv->wrap(obj_handle);
2153 JVMCIObject result;
2154 if (thisEnv->isa_HotSpotResolvedJavaMethodImpl(obj)) {
2155 Method* method = thisEnv->asMethod(obj);
2156 result = peerEnv->get_jvmci_method(method, JVMCI_CHECK_0);
2157 } else if (thisEnv->isa_HotSpotResolvedObjectTypeImpl(obj)) {
2158 Klass* klass = thisEnv->asKlass(obj);
2159 JVMCIKlassHandle klass_handle(THREAD);
2160 klass_handle = klass;
2161 result = peerEnv->get_jvmci_type(klass_handle, JVMCI_CHECK_0);
2162 } else if (thisEnv->isa_HotSpotResolvedPrimitiveType(obj)) {
2163 BasicType type = JVMCIENV->kindToBasicType(JVMCIENV->get_HotSpotResolvedPrimitiveType_kind(obj), JVMCI_CHECK_0);
2164 result = peerEnv->get_jvmci_primitive_type(type);
2165 } else if (thisEnv->isa_IndirectHotSpotObjectConstantImpl(obj) ||
2166 thisEnv->isa_DirectHotSpotObjectConstantImpl(obj)) {
2167 Handle constant = thisEnv->asConstant(obj, JVMCI_CHECK_0);
2168 result = peerEnv->get_object_constant(constant());
2169 } else if (thisEnv->isa_HotSpotNmethod(obj)) {
2170 nmethod* nm = thisEnv->asNmethod(obj);
2171 if (nm != NULL) {
2172 JVMCINMethodData* data = nm->jvmci_nmethod_data();
2173 if (data != NULL) {
2174 if (peerEnv->is_hotspot()) {
2175 // Only the mirror in the HotSpot heap is accessible
2176 // through JVMCINMethodData
2177 oop nmethod_mirror = data->get_nmethod_mirror(nm);
2178 if (nmethod_mirror != NULL) {
2179 result = HotSpotJVMCI::wrap(nmethod_mirror);
2180 }
2181 }
2182 }
2183 }
2184 if (result.is_null()) {
2185 JVMCIObject methodObject = thisEnv->get_HotSpotNmethod_method(obj);
2186 methodHandle mh = thisEnv->asMethod(methodObject);
2187 jboolean isDefault = thisEnv->get_HotSpotNmethod_isDefault(obj);
2188 jlong compileIdSnapshot = thisEnv->get_HotSpotNmethod_compileIdSnapshot(obj);
2189 JVMCIObject name_string = thisEnv->get_InstalledCode_name(obj);
2190 const char* cstring = name_string.is_null() ? NULL : thisEnv->as_utf8_string(name_string);
2191 // Create a new HotSpotNmethod instance in the peer runtime
2192 result = peerEnv->new_HotSpotNmethod(mh(), cstring, isDefault, compileIdSnapshot, JVMCI_CHECK_0);
2193 if (nm == NULL) {
2194 // nmethod must have been unloaded
2195 } else {
2196 // Link the new HotSpotNmethod to the nmethod
2197 peerEnv->initialize_installed_code(result, nm, JVMCI_CHECK_0);
2198 // Only HotSpotNmethod instances in the HotSpot heap are tracked directly by the runtime.
2199 if (peerEnv->is_hotspot()) {
2200 JVMCINMethodData* data = nm->jvmci_nmethod_data();
2201 if (data == NULL) {
2202 JVMCI_THROW_MSG_0(IllegalArgumentException, "Cannot set HotSpotNmethod mirror for default nmethod");
2203 }
2204 if (data->get_nmethod_mirror(nm) != NULL) {
2205 JVMCI_THROW_MSG_0(IllegalArgumentException, "Cannot overwrite existing HotSpotNmethod mirror for nmethod");
2206 }
2207 oop nmethod_mirror = HotSpotJVMCI::resolve(result);
2208 data->set_nmethod_mirror(nm, nmethod_mirror);
2209 }
2210 }
2211 }
2212 } else {
2213 JVMCI_THROW_MSG_0(IllegalArgumentException,
2214 err_msg("Cannot translate object of type: %s", thisEnv->klass_name(obj)));
2215 }
2216 return (jlong) peerEnv->make_global(result).as_jobject();
2217 }
2218
2219 C2V_VMENTRY(jobject, unhand, (JNIEnv* env, jobject, jlong obj_handle))
2220 if (obj_handle == 0L) {
2221 return NULL;
2222 }
2223 jobject global_handle = (jobject) obj_handle;
2224 JVMCIObject global_handle_obj = JVMCIENV->wrap((jobject) obj_handle);
2225 jobject result = JVMCIENV->make_local(global_handle_obj).as_jobject();
2226
2227 JVMCIENV->destroy_global(global_handle_obj);
2228 return result;
2229 }
2230
2231 C2V_VMENTRY(void, updateHotSpotNmethod, (JNIEnv* env, jobject, jobject code_handle))
2232 JVMCIObject code = JVMCIENV->wrap(code_handle);
2233 // Execute this operation for the side effect of updating the InstalledCode state
2234 JVMCIENV->asNmethod(code);
2235 }
2236
2237 C2V_VMENTRY(jbyteArray, getCode, (JNIEnv* env, jobject, jobject code_handle))
2238 JVMCIObject code = JVMCIENV->wrap(code_handle);
2239 CodeBlob* cb = JVMCIENV->asCodeBlob(code);
2240 if (cb == NULL) {
2241 return NULL;
2242 }
2243 int code_size = cb->code_size();
2244 JVMCIPrimitiveArray result = JVMCIENV->new_byteArray(code_size, JVMCI_CHECK_NULL);
2245 JVMCIENV->copy_bytes_from((jbyte*) cb->code_begin(), result, 0, code_size);
2246 return JVMCIENV->get_jbyteArray(result);
2247 }
2248
2249 C2V_VMENTRY(jobject, asReflectionExecutable, (JNIEnv* env, jobject, jobject jvmci_method))
2250 if (env != JavaThread::current()->jni_environment()) {
2251 JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
2252 }
2253 methodHandle m = JVMCIENV->asMethod(jvmci_method);
2254 oop executable;
2255 if (m->is_initializer()) {
2256 if (m->is_static_initializer()) {
2257 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
2258 "Cannot create java.lang.reflect.Method for class initializer");
2259 }
2260 executable = Reflection::new_constructor(m, CHECK_NULL);
2261 } else {
2262 executable = Reflection::new_method(m, false, CHECK_NULL);
2263 }
2264 return JNIHandles::make_local(THREAD, executable);
2265 }
2266
2267 C2V_VMENTRY(jobject, asReflectionField, (JNIEnv* env, jobject, jobject jvmci_type, jint index))
2268 if (env != JavaThread::current()->jni_environment()) {
2269 JVMCI_THROW_MSG_NULL(InternalError, "Only supported when running in HotSpot");
2270 }
2271 Klass* klass = JVMCIENV->asKlass(jvmci_type);
2272 if (!klass->is_instance_klass()) {
2273 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
2274 err_msg("Expected non-primitive type, got %s", klass->external_name()));
2275 }
2276 InstanceKlass* iklass = InstanceKlass::cast(klass);
2277 Array<u2>* fields = iklass->fields();
2278 if (index < 0 ||index > fields->length()) {
2279 JVMCI_THROW_MSG_NULL(IllegalArgumentException,
2280 err_msg("Field index %d out of bounds for %s", index, klass->external_name()));
2281 }
2282 fieldDescriptor fd(iklass, index);
2283 oop reflected = Reflection::new_field(&fd, CHECK_NULL);
2284 return JNIHandles::make_local(env, reflected);
2285 }
2286
2287 C2V_VMENTRY(jobjectArray, getFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address, jobjectArray current))
2288 FailedSpeculation* head = *((FailedSpeculation**)(address) failed_speculations_address);
2289 int result_length = 0;
2290 for (FailedSpeculation* fs = head; fs != NULL; fs = fs->next()) {
2291 result_length++;
2292 }
2293 int current_length = 0;
2294 JVMCIObjectArray current_array = NULL;
2295 if (current != NULL) {
2296 current_array = JVMCIENV->wrap(current);
2297 current_length = JVMCIENV->get_length(current_array);
2298 if (current_length == result_length) {
2299 // No new failures
2300 return current;
2301 }
2302 }
2303 JVMCIObjectArray result = JVMCIENV->new_byte_array_array(result_length, JVMCI_CHECK_NULL);
2304 int result_index = 0;
2305 for (FailedSpeculation* fs = head; result_index < result_length; fs = fs->next()) {
2306 assert(fs != NULL, "npe");
2307 JVMCIPrimitiveArray entry;
2308 if (result_index < current_length) {
2309 entry = (JVMCIPrimitiveArray) JVMCIENV->get_object_at(current_array, result_index);
2310 } else {
2311 entry = JVMCIENV->new_byteArray(fs->data_len(), JVMCI_CHECK_NULL);
2312 JVMCIENV->copy_bytes_from((jbyte*) fs->data(), entry, 0, fs->data_len());
2313 }
2314 JVMCIENV->put_object_at(result, result_index++, entry);
2315 }
2316 return JVMCIENV->get_jobjectArray(result);
2317 }
2318
2319 C2V_VMENTRY(jlong, getFailedSpeculationsAddress, (JNIEnv* env, jobject, jobject jvmci_method))
2320 methodHandle method = JVMCIENV->asMethod(jvmci_method);
2321 MethodData* method_data = method->method_data();
2322 if (method_data == NULL) {
2323 ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
2324 method_data = MethodData::allocate(loader_data, method, CHECK_0);
2325 method->set_method_data(method_data);
2326 }
2327 return (jlong) method_data->get_failed_speculations_address();
2328 }
2329
2330 C2V_VMENTRY(void, releaseFailedSpeculations, (JNIEnv* env, jobject, jlong failed_speculations_address))
2331 FailedSpeculation::free_failed_speculations((FailedSpeculation**)(address) failed_speculations_address);
2332 }
2333
2334 C2V_VMENTRY(bool, addFailedSpeculation, (JNIEnv* env, jobject, jlong failed_speculations_address, jbyteArray speculation_obj))
2335 JVMCIPrimitiveArray speculation_handle = JVMCIENV->wrap(speculation_obj);
2336 int speculation_len = JVMCIENV->get_length(speculation_handle);
2337 char* speculation = NEW_RESOURCE_ARRAY(char, speculation_len);
2338 JVMCIENV->copy_bytes_to(speculation_handle, (jbyte*) speculation, 0, speculation_len);
2339 return FailedSpeculation::add_failed_speculation(NULL, (FailedSpeculation**)(address) failed_speculations_address, (address) speculation, speculation_len);
2340 }
2341
2342 #define CC (char*) /*cast a literal from (const char*)*/
2343 #define FN_PTR(f) CAST_FROM_FN_PTR(void*, &(c2v_ ## f))
2344
2345 #define STRING "Ljava/lang/String;"
2346 #define OBJECT "Ljava/lang/Object;"
2347 #define CLASS "Ljava/lang/Class;"
2348 #define OBJECTCONSTANT "Ljdk/vm/ci/hotspot/HotSpotObjectConstantImpl;"
2349 #define HANDLECONSTANT "Ljdk/vm/ci/hotspot/IndirectHotSpotObjectConstantImpl;"
2350 #define EXECUTABLE "Ljava/lang/reflect/Executable;"
2351 #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;"
2352 #define INSTALLED_CODE "Ljdk/vm/ci/code/InstalledCode;"
2353 #define TARGET_DESCRIPTION "Ljdk/vm/ci/code/TargetDescription;"
2354 #define BYTECODE_FRAME "Ljdk/vm/ci/code/BytecodeFrame;"
2355 #define JAVACONSTANT "Ljdk/vm/ci/meta/JavaConstant;"
2356 #define INSPECTED_FRAME_VISITOR "Ljdk/vm/ci/code/stack/InspectedFrameVisitor;"
2357 #define RESOLVED_METHOD "Ljdk/vm/ci/meta/ResolvedJavaMethod;"
2358 #define HS_RESOLVED_METHOD "Ljdk/vm/ci/hotspot/HotSpotResolvedJavaMethodImpl;"
2359 #define HS_RESOLVED_KLASS "Ljdk/vm/ci/hotspot/HotSpotResolvedObjectTypeImpl;"
2360 #define HS_RESOLVED_TYPE "Ljdk/vm/ci/hotspot/HotSpotResolvedJavaType;"
2361 #define HS_RESOLVED_FIELD "Ljdk/vm/ci/hotspot/HotSpotResolvedJavaField;"
2362 #define HS_INSTALLED_CODE "Ljdk/vm/ci/hotspot/HotSpotInstalledCode;"
2363 #define HS_NMETHOD "Ljdk/vm/ci/hotspot/HotSpotNmethod;"
2364 #define HS_CONSTANT_POOL "Ljdk/vm/ci/hotspot/HotSpotConstantPool;"
2365 #define HS_COMPILED_CODE "Ljdk/vm/ci/hotspot/HotSpotCompiledCode;"
2366 #define HS_CONFIG "Ljdk/vm/ci/hotspot/HotSpotVMConfig;"
2367 #define HS_METADATA "Ljdk/vm/ci/hotspot/HotSpotMetaData;"
2368 #define HS_STACK_FRAME_REF "Ljdk/vm/ci/hotspot/HotSpotStackFrameReference;"
2369 #define HS_SPECULATION_LOG "Ljdk/vm/ci/hotspot/HotSpotSpeculationLog;"
2370 #define METASPACE_OBJECT "Ljdk/vm/ci/hotspot/MetaspaceObject;"
2371 #define REFLECTION_EXECUTABLE "Ljava/lang/reflect/Executable;"
2372 #define REFLECTION_FIELD "Ljava/lang/reflect/Field;"
2373 #define METASPACE_METHOD_DATA "J"
2374
2375 JNINativeMethod CompilerToVM::methods[] = {
2376 {CC "getBytecode", CC "(" HS_RESOLVED_METHOD ")[B", FN_PTR(getBytecode)},
2377 {CC "getExceptionTableStart", CC "(" HS_RESOLVED_METHOD ")J", FN_PTR(getExceptionTableStart)},
2378 {CC "getExceptionTableLength", CC "(" HS_RESOLVED_METHOD ")I", FN_PTR(getExceptionTableLength)},
2379 {CC "findUniqueConcreteMethod", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_METHOD ")" HS_RESOLVED_METHOD, FN_PTR(findUniqueConcreteMethod)},
2380 {CC "getImplementor", CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_KLASS, FN_PTR(getImplementor)},
2381 {CC "getStackTraceElement", CC "(" HS_RESOLVED_METHOD "I)" STACK_TRACE_ELEMENT, FN_PTR(getStackTraceElement)},
2382 {CC "methodIsIgnoredBySecurityStackWalk", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(methodIsIgnoredBySecurityStackWalk)},
2383 {CC "setNotInlinableOrCompilable", CC "(" HS_RESOLVED_METHOD ")V", FN_PTR(setNotInlinableOrCompilable)},
2384 {CC "isCompilable", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(isCompilable)},
2385 {CC "hasNeverInlineDirective", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(hasNeverInlineDirective)},
2386 {CC "shouldInlineMethod", CC "(" HS_RESOLVED_METHOD ")Z", FN_PTR(shouldInlineMethod)},
2387 {CC "lookupType", CC "(" STRING HS_RESOLVED_KLASS "Z)" HS_RESOLVED_TYPE, FN_PTR(lookupType)},
2388 {CC "lookupClass", CC "(" CLASS ")" HS_RESOLVED_TYPE, FN_PTR(lookupClass)},
2389 {CC "lookupNameInPool", CC "(" HS_CONSTANT_POOL "I)" STRING, FN_PTR(lookupNameInPool)},
2390 {CC "lookupNameAndTypeRefIndexInPool", CC "(" HS_CONSTANT_POOL "I)I", FN_PTR(lookupNameAndTypeRefIndexInPool)},
2391 {CC "lookupSignatureInPool", CC "(" HS_CONSTANT_POOL "I)" STRING, FN_PTR(lookupSignatureInPool)},
2392 {CC "lookupKlassRefIndexInPool", CC "(" HS_CONSTANT_POOL "I)I", FN_PTR(lookupKlassRefIndexInPool)},
2393 {CC "lookupKlassInPool", CC "(" HS_CONSTANT_POOL "I)Ljava/lang/Object;", FN_PTR(lookupKlassInPool)},
2394 {CC "lookupAppendixInPool", CC "(" HS_CONSTANT_POOL "I)" OBJECTCONSTANT, FN_PTR(lookupAppendixInPool)},
2395 {CC "lookupMethodInPool", CC "(" HS_CONSTANT_POOL "IB)" HS_RESOLVED_METHOD, FN_PTR(lookupMethodInPool)},
2396 {CC "constantPoolRemapInstructionOperandFromCache", CC "(" HS_CONSTANT_POOL "I)I", FN_PTR(constantPoolRemapInstructionOperandFromCache)},
2397 {CC "resolveConstantInPool", CC "(" HS_CONSTANT_POOL "I)" OBJECTCONSTANT, FN_PTR(resolveConstantInPool)},
2398 {CC "resolvePossiblyCachedConstantInPool", CC "(" HS_CONSTANT_POOL "I)" OBJECTCONSTANT, FN_PTR(resolvePossiblyCachedConstantInPool)},
2399 {CC "resolveTypeInPool", CC "(" HS_CONSTANT_POOL "I)" HS_RESOLVED_KLASS, FN_PTR(resolveTypeInPool)},
2400 {CC "resolveFieldInPool", CC "(" HS_CONSTANT_POOL "I" HS_RESOLVED_METHOD "B[I)" HS_RESOLVED_KLASS, FN_PTR(resolveFieldInPool)},
2401 {CC "resolveInvokeDynamicInPool", CC "(" HS_CONSTANT_POOL "I)V", FN_PTR(resolveInvokeDynamicInPool)},
2402 {CC "resolveInvokeHandleInPool", CC "(" HS_CONSTANT_POOL "I)V", FN_PTR(resolveInvokeHandleInPool)},
2403 {CC "isResolvedInvokeHandleInPool", CC "(" HS_CONSTANT_POOL "I)I", FN_PTR(isResolvedInvokeHandleInPool)},
2404 {CC "resolveMethod", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_METHOD HS_RESOLVED_KLASS ")" HS_RESOLVED_METHOD, FN_PTR(resolveMethod)},
2405 {CC "getSignaturePolymorphicHolders", CC "()[" STRING, FN_PTR(getSignaturePolymorphicHolders)},
2406 {CC "getVtableIndexForInterfaceMethod", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_METHOD ")I", FN_PTR(getVtableIndexForInterfaceMethod)},
2407 {CC "getClassInitializer", CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_METHOD, FN_PTR(getClassInitializer)},
2408 {CC "hasFinalizableSubclass", CC "(" HS_RESOLVED_KLASS ")Z", FN_PTR(hasFinalizableSubclass)},
2409 {CC "getMaxCallTargetOffset", CC "(J)J", FN_PTR(getMaxCallTargetOffset)},
2410 {CC "asResolvedJavaMethod", CC "(" EXECUTABLE ")" HS_RESOLVED_METHOD, FN_PTR(asResolvedJavaMethod)},
2411 {CC "getResolvedJavaMethod", CC "(" OBJECTCONSTANT "J)" HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethod)},
2412 {CC "getConstantPool", CC "(" METASPACE_OBJECT ")" HS_CONSTANT_POOL, FN_PTR(getConstantPool)},
2413 {CC "getResolvedJavaType0", CC "(Ljava/lang/Object;JZ)" HS_RESOLVED_KLASS, FN_PTR(getResolvedJavaType0)},
2414 {CC "readConfiguration", CC "()[" OBJECT, FN_PTR(readConfiguration)},
2415 {CC "installCode", CC "(" TARGET_DESCRIPTION HS_COMPILED_CODE INSTALLED_CODE "J[B)I", FN_PTR(installCode)},
2416 {CC "getMetadata", CC "(" TARGET_DESCRIPTION HS_COMPILED_CODE HS_METADATA ")I", FN_PTR(getMetadata)},
2417 {CC "resetCompilationStatistics", CC "()V", FN_PTR(resetCompilationStatistics)},
2418 {CC "disassembleCodeBlob", CC "(" INSTALLED_CODE ")" STRING, FN_PTR(disassembleCodeBlob)},
2419 {CC "executeHotSpotNmethod", CC "([" OBJECT HS_NMETHOD ")" OBJECT, FN_PTR(executeHotSpotNmethod)},
2420 {CC "getLineNumberTable", CC "(" HS_RESOLVED_METHOD ")[J", FN_PTR(getLineNumberTable)},
2421 {CC "getLocalVariableTableStart", CC "(" HS_RESOLVED_METHOD ")J", FN_PTR(getLocalVariableTableStart)},
2422 {CC "getLocalVariableTableLength", CC "(" HS_RESOLVED_METHOD ")I", FN_PTR(getLocalVariableTableLength)},
2423 {CC "reprofile", CC "(" HS_RESOLVED_METHOD ")V", FN_PTR(reprofile)},
2424 {CC "invalidateHotSpotNmethod", CC "(" HS_NMETHOD ")V", FN_PTR(invalidateHotSpotNmethod)},
2425 {CC "readUncompressedOop", CC "(J)" OBJECTCONSTANT, FN_PTR(readUncompressedOop)},
2426 {CC "collectCounters", CC "()[J", FN_PTR(collectCounters)},
2427 {CC "allocateCompileId", CC "(" HS_RESOLVED_METHOD "I)I", FN_PTR(allocateCompileId)},
2428 {CC "isMature", CC "(" METASPACE_METHOD_DATA ")Z", FN_PTR(isMature)},
2429 {CC "hasCompiledCodeForOSR", CC "(" HS_RESOLVED_METHOD "II)Z", FN_PTR(hasCompiledCodeForOSR)},
2430 {CC "getSymbol", CC "(J)" STRING, FN_PTR(getSymbol)},
2431 {CC "iterateFrames", CC "([" RESOLVED_METHOD "[" RESOLVED_METHOD "I" INSPECTED_FRAME_VISITOR ")" OBJECT, FN_PTR(iterateFrames)},
2432 {CC "materializeVirtualObjects", CC "(" HS_STACK_FRAME_REF "Z)V", FN_PTR(materializeVirtualObjects)},
2433 {CC "shouldDebugNonSafepoints", CC "()Z", FN_PTR(shouldDebugNonSafepoints)},
2434 {CC "writeDebugOutput", CC "([BII)V", FN_PTR(writeDebugOutput)},
2435 {CC "flushDebugOutput", CC "()V", FN_PTR(flushDebugOutput)},
2436 {CC "methodDataProfileDataSize", CC "(JI)I", FN_PTR(methodDataProfileDataSize)},
2437 {CC "getFingerprint", CC "(J)J", FN_PTR(getFingerprint)},
2438 {CC "getHostClass", CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_KLASS, FN_PTR(getHostClass)},
2439 {CC "interpreterFrameSize", CC "(" BYTECODE_FRAME ")I", FN_PTR(interpreterFrameSize)},
2440 {CC "compileToBytecode", CC "(" OBJECTCONSTANT ")V", FN_PTR(compileToBytecode)},
2441 {CC "getFlagValue", CC "(" STRING ")" OBJECT, FN_PTR(getFlagValue)},
2442 {CC "getObjectAtAddress", CC "(J)" OBJECT, FN_PTR(getObjectAtAddress)},
2443 {CC "getInterfaces", CC "(" HS_RESOLVED_KLASS ")[" HS_RESOLVED_KLASS, FN_PTR(getInterfaces)},
2444 {CC "getComponentType", CC "(" HS_RESOLVED_KLASS ")" HS_RESOLVED_TYPE, FN_PTR(getComponentType)},
2445 {CC "ensureInitialized", CC "(" HS_RESOLVED_KLASS ")V", FN_PTR(ensureInitialized)},
2446 {CC "getIdentityHashCode", CC "(" OBJECTCONSTANT ")I", FN_PTR(getIdentityHashCode)},
2447 {CC "isInternedString", CC "(" OBJECTCONSTANT ")Z", FN_PTR(isInternedString)},
2448 {CC "unboxPrimitive", CC "(" OBJECTCONSTANT ")" OBJECT, FN_PTR(unboxPrimitive)},
2449 {CC "boxPrimitive", CC "(" OBJECT ")" OBJECTCONSTANT, FN_PTR(boxPrimitive)},
2450 {CC "getDeclaredConstructors", CC "(" HS_RESOLVED_KLASS ")[" RESOLVED_METHOD, FN_PTR(getDeclaredConstructors)},
2451 {CC "getDeclaredMethods", CC "(" HS_RESOLVED_KLASS ")[" RESOLVED_METHOD, FN_PTR(getDeclaredMethods)},
2452 {CC "readFieldValue", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_FIELD "Z)" JAVACONSTANT, FN_PTR(readFieldValue)},
2453 {CC "readFieldValue", CC "(" OBJECTCONSTANT HS_RESOLVED_FIELD "Z)" JAVACONSTANT, FN_PTR(readFieldValue)},
2454 {CC "isInstance", CC "(" HS_RESOLVED_KLASS OBJECTCONSTANT ")Z", FN_PTR(isInstance)},
2455 {CC "isAssignableFrom", CC "(" HS_RESOLVED_KLASS HS_RESOLVED_KLASS ")Z", FN_PTR(isAssignableFrom)},
2456 {CC "isTrustedForIntrinsics", CC "(" HS_RESOLVED_KLASS ")Z", FN_PTR(isTrustedForIntrinsics)},
2457 {CC "asJavaType", CC "(" OBJECTCONSTANT ")" HS_RESOLVED_TYPE, FN_PTR(asJavaType)},
2458 {CC "asString", CC "(" OBJECTCONSTANT ")" STRING, FN_PTR(asString)},
2459 {CC "equals", CC "(" OBJECTCONSTANT "J" OBJECTCONSTANT "J)Z", FN_PTR(equals)},
2460 {CC "getJavaMirror", CC "(" HS_RESOLVED_TYPE ")" OBJECTCONSTANT, FN_PTR(getJavaMirror)},
2461 {CC "getArrayLength", CC "(" OBJECTCONSTANT ")I", FN_PTR(getArrayLength)},
2462 {CC "readArrayElement", CC "(" OBJECTCONSTANT "I)Ljava/lang/Object;", FN_PTR(readArrayElement)},
2463 {CC "arrayBaseOffset", CC "(Ljdk/vm/ci/meta/JavaKind;)I", FN_PTR(arrayBaseOffset)},
2464 {CC "arrayIndexScale", CC "(Ljdk/vm/ci/meta/JavaKind;)I", FN_PTR(arrayIndexScale)},
2465 {CC "getByte", CC "(" OBJECTCONSTANT "J)B", FN_PTR(getByte)},
2466 {CC "getShort", CC "(" OBJECTCONSTANT "J)S", FN_PTR(getShort)},
2467 {CC "getInt", CC "(" OBJECTCONSTANT "J)I", FN_PTR(getInt)},
2468 {CC "getLong", CC "(" OBJECTCONSTANT "J)J", FN_PTR(getLong)},
2469 {CC "getObject", CC "(" OBJECTCONSTANT "J)" OBJECTCONSTANT, FN_PTR(getObject)},
2470 {CC "deleteGlobalHandle", CC "(J)V", FN_PTR(deleteGlobalHandle)},
2471 {CC "registerNativeMethods", CC "(" CLASS ")[J", FN_PTR(registerNativeMethods)},
2472 {CC "translate", CC "(" OBJECT ")J", FN_PTR(translate)},
2473 {CC "unhand", CC "(J)" OBJECT, FN_PTR(unhand)},
2474 {CC "updateHotSpotNmethod", CC "(" HS_NMETHOD ")V", FN_PTR(updateHotSpotNmethod)},
2475 {CC "getCode", CC "(" HS_INSTALLED_CODE ")[B", FN_PTR(getCode)},
2476 {CC "asReflectionExecutable", CC "(" HS_RESOLVED_METHOD ")" REFLECTION_EXECUTABLE, FN_PTR(asReflectionExecutable)},
2477 {CC "asReflectionField", CC "(" HS_RESOLVED_KLASS "I)" REFLECTION_FIELD, FN_PTR(asReflectionField)},
2478 {CC "getFailedSpeculations", CC "(J[[B)[[B", FN_PTR(getFailedSpeculations)},
2479 {CC "getFailedSpeculationsAddress", CC "(" HS_RESOLVED_METHOD ")J", FN_PTR(getFailedSpeculationsAddress)},
2480 {CC "releaseFailedSpeculations", CC "(J)V", FN_PTR(releaseFailedSpeculations)},
2481 {CC "addFailedSpeculation", CC "(J[B)Z", FN_PTR(addFailedSpeculation)},
2482 };
2483
2484 int CompilerToVM::methods_count() {
2485 return sizeof(methods) / sizeof(JNINativeMethod);
2486 }