Mercurial > hg > graal-jvmci-8

comparison src/share/vm/jvmci/jvmciCompilerToVM.cpp @ 22454:76af33d4d504

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Make jvmci redefinition safe
author Tom Rodriguez <tom.rodriguez@oracle.com>
date Fri, 21 Aug 2015 11:57:29 -0700
parents e3d9e0f9b50c
children 7ad03bf3d4a9
comparison
equal deleted inserted replaced
22453:d6bbd5d8d81e 22454:76af33d4d504
51 TRACE_jvmci_3("CompilerToVM::" #name); \ 51 TRACE_jvmci_3("CompilerToVM::" #name); \
52 JVMCI_VM_ENTRY_MARK; \ 52 JVMCI_VM_ENTRY_MARK; \
53 53
54 #define C2V_END } 54 #define C2V_END }
55 55
56 extern "C" { 56 oop CompilerToVM::get_jvmci_method(methodHandle method, TRAPS) {
57 extern VMStructEntry* gHotSpotVMStructs; 57 if (method() != NULL) {
58 extern uint64_t gHotSpotVMStructEntryTypeNameOffset; 58 JavaValue result(T_OBJECT);
59 extern uint64_t gHotSpotVMStructEntryFieldNameOffset; 59 JavaCallArguments args;
60 extern uint64_t gHotSpotVMStructEntryTypeStringOffset; 60 args.push_long((jlong) (address) method());
61 extern uint64_t gHotSpotVMStructEntryIsStaticOffset; 61 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedJavaMethodImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::method_fromMetaspace_signature(), &args, CHECK_NULL);
62 extern uint64_t gHotSpotVMStructEntryOffsetOffset; 62
63 extern uint64_t gHotSpotVMStructEntryAddressOffset; 63 return (oop)result.get_jobject();
64 extern uint64_t gHotSpotVMStructEntryArrayStride; 64 }
65 65 return NULL;
66 extern VMTypeEntry* gHotSpotVMTypes; 66 }
67 extern uint64_t gHotSpotVMTypeEntryTypeNameOffset; 67
68 extern uint64_t gHotSpotVMTypeEntrySuperclassNameOffset; 68 oop CompilerToVM::get_jvmci_type(KlassHandle klass, TRAPS) {
69 extern uint64_t gHotSpotVMTypeEntryIsOopTypeOffset; 69 if (klass() != NULL) {
70 extern uint64_t gHotSpotVMTypeEntryIsIntegerTypeOffset; 70 JavaValue result(T_OBJECT);
71 extern uint64_t gHotSpotVMTypeEntryIsUnsignedOffset; 71 JavaCallArguments args;
72 extern uint64_t gHotSpotVMTypeEntrySizeOffset; 72 args.push_oop(klass->java_mirror());
73 extern uint64_t gHotSpotVMTypeEntryArrayStride; 73 JavaCalls::call_static(&result, SystemDictionary::HotSpotResolvedObjectTypeImpl_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::klass_fromMetaspace_signature(), &args, CHECK_NULL);
74 74
75 extern VMIntConstantEntry* gHotSpotVMIntConstants; 75 return (oop)result.get_jobject();
76 extern uint64_t gHotSpotVMIntConstantEntryNameOffset; 76 }
77 extern uint64_t gHotSpotVMIntConstantEntryValueOffset; 77 return NULL;
78 extern uint64_t gHotSpotVMIntConstantEntryArrayStride;
79
80 extern VMLongConstantEntry* gHotSpotVMLongConstants;
81 extern uint64_t gHotSpotVMLongConstantEntryNameOffset;
82 extern uint64_t gHotSpotVMLongConstantEntryValueOffset;
83 extern uint64_t gHotSpotVMLongConstantEntryArrayStride;
84 } 78 }
85 79
86 C2V_VMENTRY(void, initializeConfiguration, (JNIEnv *, jobject, jobject config)) 80 C2V_VMENTRY(void, initializeConfiguration, (JNIEnv *, jobject, jobject config))
87 VMStructs::initHotSpotVMConfig(JNIHandles::resolve(config)); 81 VMStructs::initHotSpotVMConfig(JNIHandles::resolve(config));
88 C2V_END 82 C2V_END
89 83
90 C2V_VMENTRY(jbyteArray, getBytecode, (JNIEnv *, jobject, jlong metaspace_method)) 84 C2V_VMENTRY(jbyteArray, getBytecode, (JNIEnv *, jobject, jobject jvmci_method))
91 methodHandle method = asMethod(metaspace_method); 85 methodHandle method = CompilerToVM::asMethod(jvmci_method);
92 ResourceMark rm; 86 ResourceMark rm;
93 87
94 int code_size = method->code_size(); 88 int code_size = method->code_size();
95 typeArrayOop reconstituted_code = oopFactory::new_byteArray(code_size, CHECK_NULL); 89 typeArrayOop reconstituted_code = oopFactory::new_byteArray(code_size, CHECK_NULL);
96 90
155 } 149 }
156 150
157 return (jbyteArray) JNIHandles::make_local(THREAD, reconstituted_code); 151 return (jbyteArray) JNIHandles::make_local(THREAD, reconstituted_code);
158 C2V_END 152 C2V_END
159 153
160 C2V_VMENTRY(jint, getExceptionTableLength, (JNIEnv *, jobject, jlong metaspace_method)) 154 C2V_VMENTRY(jint, getExceptionTableLength, (JNIEnv *, jobject, jobject jvmci_method))
161 ResourceMark rm; 155 ResourceMark rm;
162 methodHandle method = asMethod(metaspace_method); 156 methodHandle method = CompilerToVM::asMethod(jvmci_method);
163 return method->exception_table_length(); 157 return method->exception_table_length();
164 C2V_END 158 C2V_END
165 159
166 C2V_VMENTRY(jlong, getExceptionTableStart, (JNIEnv *, jobject, jlong metaspace_method)) 160 C2V_VMENTRY(jlong, getExceptionTableStart, (JNIEnv *, jobject, jobject jvmci_method))
167 ResourceMark rm; 161 ResourceMark rm;
168 methodHandle method = asMethod(metaspace_method); 162 methodHandle method = CompilerToVM::asMethod(jvmci_method);
169 if (method->exception_table_length() == 0) { 163 if (method->exception_table_length() == 0) {
170 return 0L; 164 return 0L;
171 } 165 }
172 return (jlong) (address) method->exception_table_start(); 166 return (jlong) (address) method->exception_table_start();
173 C2V_END 167 C2V_END
174 168
175 C2V_VMENTRY(jint, hasBalancedMonitors, (JNIEnv *, jobject, jlong metaspace_method)) 169 C2V_VMENTRY(jint, hasBalancedMonitors, (JNIEnv *, jobject, jobject jvmci_method))
176 // Analyze the method to see if monitors are used properly. 170 // Analyze the method to see if monitors are used properly.
177 methodHandle method(THREAD, asMethod(metaspace_method)); 171 methodHandle method(THREAD, CompilerToVM::asMethod(jvmci_method));
178 { 172 {
179 EXCEPTION_MARK; 173 EXCEPTION_MARK;
180 ResourceMark rm(THREAD); 174 ResourceMark rm(THREAD);
181 GeneratePairingInfo gpi(method); 175 GeneratePairingInfo gpi(method);
182 gpi.compute_map(CATCH); 176 gpi.compute_map(CATCH);
186 method->set_guaranteed_monitor_matching(); 180 method->set_guaranteed_monitor_matching();
187 } 181 }
188 return true; 182 return true;
189 C2V_END 183 C2V_END
190 184
191 C2V_VMENTRY(jlong, getMetaspaceMethod, (JNIEnv *, jobject, jclass holder_handle, jint slot)) 185 C2V_VMENTRY(jobject, getResolvedJavaMethodAtSlot, (JNIEnv *, jobject, jclass holder_handle, jint slot))
192 oop java_class = JNIHandles::resolve(holder_handle); 186 oop java_class = JNIHandles::resolve(holder_handle);
193 Klass* holder = java_lang_Class::as_Klass(java_class); 187 Klass* holder = java_lang_Class::as_Klass(java_class);
194 methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot); 188 methodHandle method = InstanceKlass::cast(holder)->method_with_idnum(slot);
195 return (jlong) (address) method(); 189 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL);
190 return JNIHandles::make_local(THREAD, result);
196 } 191 }
197 192
198 C2V_VMENTRY(jlong, findUniqueConcreteMethod, (JNIEnv *, jobject, jlong metaspace_klass, jlong metaspace_method)) 193 C2V_VMENTRY(jobject, getResolvedJavaMethod, (JNIEnv *, jobject, jobject base, jlong offset))
199 methodHandle method = asMethod(metaspace_method); 194 methodHandle method;
200 KlassHandle holder = asKlass(metaspace_klass); 195 oop base_object = JNIHandles::resolve(base);
196 if (base_object == NULL) {
197 method = *((Method**)(offset));
198 } else if (base_object->is_a(SystemDictionary::MemberName_klass())) {
199 method = (Method*) (intptr_t) base_object->long_field(offset);
200 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) {
201 method = *((Method**)(HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object) + offset));
202 } else {
203 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
204 err_msg("Unexpected type: %s", base_object->klass()->external_name()));
205 }
206 assert (method.is_null() || method->is_method(), "invalid read");
207 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL);
208 return JNIHandles::make_local(THREAD, result);
209 }
210
211 C2V_VMENTRY(jobject, getConstantPool, (JNIEnv *, jobject, jobject base, jlong offset))
212 constantPoolHandle cp;
213 oop base_object = JNIHandles::resolve(base);
214 jlong base_address = 0;
215 if (base_object != NULL) {
216 if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) {
217 base_address = HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object);
218 } else if (base_object->is_a(SystemDictionary::HotSpotConstantPool_klass())) {
219 base_address = HotSpotConstantPool::metaspaceConstantPool(base_object);
220 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) {
221 base_address = (jlong) CompilerToVM::asKlass(base_object);
222 } else {
223 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
224 err_msg("Unexpected type: %s", base_object->klass()->external_name()));
225 }
226 }
227 cp = *((ConstantPool**) (intptr_t) (base_address + offset));
228 if (!cp.is_null()) {
229 JavaValue method_result(T_OBJECT);
230 JavaCallArguments args;
231 args.push_long((jlong) (address) cp());
232 JavaCalls::call_static(&method_result, SystemDictionary::HotSpotConstantPool_klass(), vmSymbols::fromMetaspace_name(), vmSymbols::constantPool_fromMetaspace_signature(), &args, CHECK_NULL);
233 return JNIHandles::make_local(THREAD, (oop)method_result.get_jobject());
234 }
235 return NULL;
236 }
237
238 C2V_VMENTRY(jobject, getResolvedJavaType, (JNIEnv *, jobject, jobject base, jlong offset, jboolean compressed))
239 KlassHandle klass;
240 oop base_object = JNIHandles::resolve(base);
241 jlong base_address = 0;
242 if (base_object != NULL && offset == oopDesc::klass_offset_in_bytes()) {
243 klass = base_object->klass();
244 } else if (!compressed) {
245 if (base_object != NULL) {
246 if (base_object->is_a(SystemDictionary::HotSpotResolvedJavaMethodImpl_klass())) {
247 base_address = HotSpotResolvedJavaMethodImpl::metaspaceMethod(base_object);
248 } else if (base_object->is_a(SystemDictionary::HotSpotConstantPool_klass())) {
249 base_address = HotSpotConstantPool::metaspaceConstantPool(base_object);
250 } else if (base_object->is_a(SystemDictionary::HotSpotResolvedObjectTypeImpl_klass())) {
251 base_address = (jlong) CompilerToVM::asKlass(base_object);
252 } else if (base_object->is_a(SystemDictionary::Class_klass())) {
253 base_address = (jlong) (address) base_object;
254 } else {
255 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
256 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", base_object->klass()->external_name(), offset, compressed ? "true" : "false"));
257 }
258 }
259 klass = *((Klass**) (intptr_t) (base_address + offset));
260 } else {
261 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
262 err_msg("Unexpected arguments: %s " JLONG_FORMAT " %s", base_object->klass()->external_name(), offset, compressed ? "true" : "false"));
263 }
264 assert (klass.is_null() || klass->is_klass(), "invalid read");
265 oop result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);
266 return JNIHandles::make_local(THREAD, result);
267 }
268
269 C2V_VMENTRY(jobject, findUniqueConcreteMethod, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method))
270 methodHandle method = CompilerToVM::asMethod(jvmci_method);
271 KlassHandle holder = CompilerToVM::asKlass(jvmci_type);
201 assert(!holder->is_interface(), "should be handled in Java code"); 272 assert(!holder->is_interface(), "should be handled in Java code");
202 ResourceMark rm; 273 ResourceMark rm;
203 MutexLocker locker(Compile_lock); 274 methodHandle ucm;
204 Method* ucm = Dependencies::find_unique_concrete_method(holder(), method()); 275 {
205 return (jlong) (address) ucm; 276 MutexLocker locker(Compile_lock);
206 C2V_END 277 ucm = Dependencies::find_unique_concrete_method(holder(), method());
207 278 }
208 C2V_VMENTRY(jlong, getKlassImplementor, (JNIEnv *, jobject, jlong metaspace_klass)) 279 oop result = CompilerToVM::get_jvmci_method(ucm, CHECK_NULL);
209 InstanceKlass* klass = (InstanceKlass*) asKlass(metaspace_klass); 280 return JNIHandles::make_local(THREAD, result);
210 return (jlong) (address) klass->implementor(); 281 C2V_END
211 C2V_END 282
212 283 C2V_VMENTRY(jobject, getKlassImplementor, (JNIEnv *, jobject, jobject jvmci_type))
213 C2V_VMENTRY(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv *, jobject, jlong metaspace_method)) 284 InstanceKlass* klass = (InstanceKlass*) CompilerToVM::asKlass(jvmci_type);
214 methodHandle method = asMethod(metaspace_method); 285 oop implementor = CompilerToVM::get_jvmci_type(klass->implementor(), CHECK_NULL);
286 return JNIHandles::make_local(THREAD, implementor);
287 C2V_END
288
289 C2V_VMENTRY(jboolean, methodIsIgnoredBySecurityStackWalk,(JNIEnv *, jobject, jobject jvmci_method))
290 methodHandle method = CompilerToVM::asMethod(jvmci_method);
215 return method->is_ignored_by_security_stack_walk(); 291 return method->is_ignored_by_security_stack_walk();
216 C2V_END 292 C2V_END
217 293
218 C2V_VMENTRY(jboolean, canInlineMethod,(JNIEnv *, jobject, jlong metaspace_method)) 294 C2V_VMENTRY(jboolean, canInlineMethod,(JNIEnv *, jobject, jobject jvmci_method))
219 methodHandle method = asMethod(metaspace_method); 295 methodHandle method = CompilerToVM::asMethod(jvmci_method);
220 return !method->is_not_compilable() && !CompilerOracle::should_not_inline(method) && !method->dont_inline(); 296 return !method->is_not_compilable() && !CompilerOracle::should_not_inline(method) && !method->dont_inline();
221 C2V_END 297 C2V_END
222 298
223 C2V_VMENTRY(jboolean, shouldInlineMethod,(JNIEnv *, jobject, jlong metaspace_method)) 299 C2V_VMENTRY(jboolean, shouldInlineMethod,(JNIEnv *, jobject, jobject jvmci_method))
224 methodHandle method = asMethod(metaspace_method); 300 methodHandle method = CompilerToVM::asMethod(jvmci_method);
225 return CompilerOracle::should_inline(method) || method->force_inline(); 301 return CompilerOracle::should_inline(method) || method->force_inline();
226 C2V_END 302 C2V_END
227 303
228 C2V_VMENTRY(jlong, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve)) 304 C2V_VMENTRY(jobject, lookupType, (JNIEnv*, jobject, jstring jname, jclass accessing_class, jboolean resolve))
229 ResourceMark rm; 305 ResourceMark rm;
230 Handle name = JNIHandles::resolve(jname); 306 Handle name = JNIHandles::resolve(jname);
231 Symbol* class_name = java_lang_String::as_symbol(name, THREAD); 307 Symbol* class_name = java_lang_String::as_symbol(name, THREAD);
232 assert(class_name != NULL, "name to symbol creation failed"); 308 assert(class_name != NULL, "name to symbol creation failed");
233 assert(class_name->size() > 1, "primitive types should be handled in Java code"); 309 assert(class_name->size() > 1, "primitive types should be handled in Java code");
274 resolved_klass = Universe::typeArrayKlassObj(t); 350 resolved_klass = Universe::typeArrayKlassObj(t);
275 resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0); 351 resolved_klass = TypeArrayKlass::cast(resolved_klass)->array_klass(fd.dimension(), CHECK_0);
276 } 352 }
277 } 353 }
278 } 354 }
279 return (jlong) (address) resolved_klass; 355 Handle result = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
280 C2V_END 356 return JNIHandles::make_local(THREAD, result());
281 357 C2V_END
282 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 358
283 ConstantPool* cp = (ConstantPool*) metaspace_constant_pool; 359 C2V_VMENTRY(jobject, resolveConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
360 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
284 oop result = cp->resolve_constant_at(index, CHECK_NULL); 361 oop result = cp->resolve_constant_at(index, CHECK_NULL);
285 return JNIHandles::make_local(THREAD, result); 362 return JNIHandles::make_local(THREAD, result);
286 C2V_END 363 C2V_END
287 364
288 C2V_VMENTRY(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 365 C2V_VMENTRY(jobject, resolvePossiblyCachedConstantInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
289 ConstantPool* cp = (ConstantPool*) metaspace_constant_pool; 366 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
290 oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL); 367 oop result = cp->resolve_possibly_cached_constant_at(index, CHECK_NULL);
291 return JNIHandles::make_local(THREAD, result); 368 return JNIHandles::make_local(THREAD, result);
292 C2V_END 369 C2V_END
293 370
294 C2V_VMENTRY(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 371 C2V_VMENTRY(jint, lookupNameAndTypeRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
295 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 372 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
296 return cp->name_and_type_ref_index_at(index); 373 return cp->name_and_type_ref_index_at(index);
297 C2V_END 374 C2V_END
298 375
299 C2V_VMENTRY(jobject, lookupNameRefInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 376 C2V_VMENTRY(jobject, lookupNameRefInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
300 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 377 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
301 Handle sym = java_lang_String::create_from_symbol(cp->name_ref_at(index), CHECK_NULL); 378 Handle sym = java_lang_String::create_from_symbol(cp->name_ref_at(index), CHECK_NULL);
302 return JNIHandles::make_local(THREAD, sym()); 379 return JNIHandles::make_local(THREAD, sym());
303 C2V_END 380 C2V_END
304 381
305 C2V_VMENTRY(jobject, lookupSignatureRefInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 382 C2V_VMENTRY(jobject, lookupSignatureRefInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
306 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 383 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
307 Handle sym = java_lang_String::create_from_symbol(cp->signature_ref_at(index), CHECK_NULL); 384 Handle sym = java_lang_String::create_from_symbol(cp->signature_ref_at(index), CHECK_NULL);
308 return JNIHandles::make_local(THREAD, sym()); 385 return JNIHandles::make_local(THREAD, sym());
309 C2V_END 386 C2V_END
310 387
311 C2V_VMENTRY(jint, lookupKlassRefIndexInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 388 C2V_VMENTRY(jint, lookupKlassRefIndexInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
312 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 389 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
313 return cp->klass_ref_index_at(index); 390 return cp->klass_ref_index_at(index);
314 C2V_END 391 C2V_END
315 392
316 C2V_VMENTRY(jlong, resolveKlassInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 393 C2V_VMENTRY(jobject, resolveKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
317 ConstantPool* cp = (ConstantPool*) metaspace_constant_pool; 394 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
318 return (jlong) (address) cp->klass_at(index, THREAD); 395 Klass* resolved_klass = cp->klass_at(index, CHECK_NULL);
319 C2V_END 396 Handle klass = CompilerToVM::get_jvmci_type(resolved_klass, CHECK_NULL);
320 397 return JNIHandles::make_local(THREAD, klass());
321 C2V_VMENTRY(jlong, lookupKlassInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index, jbyte opcode)) 398 C2V_END
322 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 399
400 C2V_VMENTRY(jobject, lookupKlassInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
401 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
323 KlassHandle loading_klass(cp->pool_holder()); 402 KlassHandle loading_klass(cp->pool_holder());
324 bool is_accessible = false; 403 bool is_accessible = false;
325 KlassHandle klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass); 404 KlassHandle klass = JVMCIEnv::get_klass_by_index(cp, index, is_accessible, loading_klass);
405 Symbol* symbol = NULL;
326 if (klass.is_null()) { 406 if (klass.is_null()) {
327 // We have to lock the cpool to keep the oop from being resolved 407 // We have to lock the cpool to keep the oop from being resolved
328 // while we are accessing it. 408 // while we are accessing it.
329 MonitorLockerEx ml(cp->lock()); 409 MonitorLockerEx ml(cp->lock());
330 constantTag tag = cp->tag_at(index); 410 constantTag tag = cp->tag_at(index);
331 if (tag.is_klass()) { 411 if (tag.is_klass()) {
332 // The klass has been inserted into the constant pool 412 // The klass has been inserted into the constant pool
333 // very recently. 413 // very recently.
334 return (jlong) CompilerToVM::tag_pointer(cp->resolved_klass_at(index)); 414 klass = cp->resolved_klass_at(index);
335 } else if (tag.is_symbol()) { 415 } else if (tag.is_symbol()) {
336 return (jlong) CompilerToVM::tag_pointer(cp->symbol_at(index)); 416 symbol = cp->symbol_at(index);
337 } else { 417 } else {
338 assert(cp->tag_at(index).is_unresolved_klass(), "wrong tag"); 418 assert(cp->tag_at(index).is_unresolved_klass(), "wrong tag");
339 return (jlong) CompilerToVM::tag_pointer(cp->unresolved_klass_at(index)); 419 symbol = cp->unresolved_klass_at(index);
340 } 420 }
341 } 421 }
342 return (jlong) CompilerToVM::tag_pointer(klass()); 422 Handle result;
343 C2V_END 423 if (!klass.is_null()) {
344 424 result = CompilerToVM::get_jvmci_type(klass, CHECK_NULL);
345 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 425 } else {
346 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 426 result = java_lang_String::create_from_symbol(symbol, CHECK_NULL);
427 }
428 return JNIHandles::make_local(THREAD, result());
429 C2V_END
430
431 C2V_VMENTRY(jobject, lookupAppendixInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
432 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
347 oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index); 433 oop appendix_oop = ConstantPool::appendix_at_if_loaded(cp, index);
348 return JNIHandles::make_local(THREAD, appendix_oop); 434 return JNIHandles::make_local(THREAD, appendix_oop);
349 C2V_END 435 C2V_END
350 436
351 C2V_VMENTRY(jlong, lookupMethodInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index, jbyte opcode)) 437 C2V_VMENTRY(jobject, lookupMethodInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode))
352 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 438 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
353 instanceKlassHandle pool_holder(cp->pool_holder()); 439 instanceKlassHandle pool_holder(cp->pool_holder());
354 Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF); 440 Bytecodes::Code bc = (Bytecodes::Code) (((int) opcode) & 0xFF);
355 methodHandle method = JVMCIEnv::get_method_by_index(cp, index, bc, pool_holder); 441 methodHandle method = JVMCIEnv::get_method_by_index(cp, index, bc, pool_holder);
356 return (jlong) (address) method(); 442 oop result = CompilerToVM::get_jvmci_method(method, CHECK_NULL);
357 C2V_END 443 return JNIHandles::make_local(THREAD, result);
358 444 C2V_END
359 C2V_VMENTRY(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 445
360 ConstantPool* cp = (ConstantPool*) metaspace_constant_pool; 446 C2V_VMENTRY(jint, constantPoolRemapInstructionOperandFromCache, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
447 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
361 return cp->remap_instruction_operand_from_cache(index); 448 return cp->remap_instruction_operand_from_cache(index);
362 C2V_END 449 C2V_END
363 450
364 C2V_VMENTRY(jlong, resolveFieldInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index, jbyte opcode, jlongArray info_handle)) 451 C2V_VMENTRY(jobject, resolveFieldInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index, jbyte opcode, jlongArray info_handle))
365 ResourceMark rm; 452 ResourceMark rm;
366 constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool; 453 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
367 Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF); 454 Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF);
368 fieldDescriptor result; 455 fieldDescriptor result;
369 LinkResolver::resolve_field_access(result, cp, index, Bytecodes::java_code(code), true, false, CHECK_0); 456 LinkResolver::resolve_field_access(result, cp, index, Bytecodes::java_code(code), true, false, CHECK_0);
370 typeArrayOop info = (typeArrayOop) JNIHandles::resolve(info_handle); 457 typeArrayOop info = (typeArrayOop) JNIHandles::resolve(info_handle);
371 assert(info != NULL && info->length() == 2, "must be"); 458 assert(info != NULL && info->length() == 2, "must be");
372 info->long_at_put(0, (jlong) result.access_flags().as_int()); 459 info->long_at_put(0, (jlong) result.access_flags().as_int());
373 info->long_at_put(1, (jlong) result.offset()); 460 info->long_at_put(1, (jlong) result.offset());
374 return (jlong) (address) result.field_holder(); 461 oop field_holder = CompilerToVM::get_jvmci_type(result.field_holder(), CHECK_NULL);
375 C2V_END 462 return JNIHandles::make_local(THREAD, field_holder);
376 463 C2V_END
377 C2V_VMENTRY(jint, getVtableIndexForInterface, (JNIEnv *, jobject, jlong metaspace_klass, jlong metaspace_method)) 464
378 Klass* klass = (Klass*) metaspace_klass; 465 C2V_VMENTRY(jint, getVtableIndexForInterface, (JNIEnv *, jobject, jobject jvmci_type, jobject jvmci_method))
379 Method* method = (Method*) metaspace_method; 466 Klass* klass = CompilerToVM::asKlass(jvmci_type);
467 Method* method = CompilerToVM::asMethod(jvmci_method);
380 assert(!klass->is_interface(), ""); 468 assert(!klass->is_interface(), "");
381 return LinkResolver::vtable_index_of_interface_method(klass, method); 469 return LinkResolver::vtable_index_of_interface_method(klass, method);
382 C2V_END 470 C2V_END
383 471
384 C2V_VMENTRY(jlong, resolveMethod, (JNIEnv *, jobject, jlong metaspace_klass_receiver, jlong metaspace_method, jlong metaspace_klass_caller)) 472 C2V_VMENTRY(jobject, resolveMethod, (JNIEnv *, jobject, jobject receiver_jvmci_type, jobject jvmci_method, jobject caller_jvmci_type))
385 Klass* recv_klass = (Klass*) metaspace_klass_receiver; 473 Klass* recv_klass = CompilerToVM::asKlass(receiver_jvmci_type);
386 Klass* caller_klass = (Klass*) metaspace_klass_caller; 474 Klass* caller_klass = CompilerToVM::asKlass(caller_jvmci_type);
387 Method* method = (Method*) metaspace_method; 475 Method* method = CompilerToVM::asMethod(jvmci_method);
388 476
389 if (recv_klass->oop_is_array() || (InstanceKlass::cast(recv_klass)->is_linked())) { 477 if (recv_klass->oop_is_array() || (InstanceKlass::cast(recv_klass)->is_linked())) {
390 Klass* holder_klass = method->method_holder(); 478 Klass* holder_klass = method->method_holder();
391 Symbol* method_name = method->name(); 479 Symbol* method_name = method->name();
392 Symbol* method_signature = method->signature(); 480 Symbol* method_signature = method->signature();
395 if (holder_klass->is_interface()) { 483 if (holder_klass->is_interface()) {
396 // do link-time resolution to check all access rules. 484 // do link-time resolution to check all access rules.
397 methodHandle resolved_method; 485 methodHandle resolved_method;
398 LinkResolver::linktime_resolve_interface_method(resolved_method, holder_klass, method_name, method_signature, caller_klass, true, CHECK_AND_CLEAR_0); 486 LinkResolver::linktime_resolve_interface_method(resolved_method, holder_klass, method_name, method_signature, caller_klass, true, CHECK_AND_CLEAR_0);
399 if (resolved_method->is_private()) { 487 if (resolved_method->is_private()) {
400 return (jlong) (address) NULL; 488 return NULL;
401 } 489 }
402 assert(recv_klass->is_subtype_of(holder_klass), ""); 490 assert(recv_klass->is_subtype_of(holder_klass), "");
403 // do actual lookup 491 // do actual lookup
404 methodHandle sel_method; 492 methodHandle sel_method;
405 LinkResolver::lookup_instance_method_in_klasses(sel_method, recv_klass, 493 LinkResolver::lookup_instance_method_in_klasses(sel_method, recv_klass,
406 resolved_method->name(), 494 resolved_method->name(),
407 resolved_method->signature(), CHECK_AND_CLEAR_0); 495 resolved_method->signature(), CHECK_AND_CLEAR_0);
408 return (jlong) (address) sel_method(); 496 oop result = CompilerToVM::get_jvmci_method(sel_method, CHECK_NULL);
497 return JNIHandles::make_local(THREAD, result);
409 } else { 498 } else {
410 // do link-time resolution to check all access rules. 499 // do link-time resolution to check all access rules.
411 methodHandle resolved_method; 500 methodHandle resolved_method;
412 LinkResolver::linktime_resolve_virtual_method(resolved_method, holder_klass, method_name, method_signature, caller_klass, true, CHECK_AND_CLEAR_0); 501 LinkResolver::linktime_resolve_virtual_method(resolved_method, holder_klass, method_name, method_signature, caller_klass, true, CHECK_AND_CLEAR_0);
413 // do actual lookup (see LinkResolver::runtime_resolve_virtual_method) 502 // do actual lookup (see LinkResolver::runtime_resolve_virtual_method)
438 // the same place. The cast is to avoid virtual call and assertion. 527 // the same place. The cast is to avoid virtual call and assertion.
439 InstanceKlass* inst = (InstanceKlass*)recv_klass; 528 InstanceKlass* inst = (InstanceKlass*)recv_klass;
440 selected_method = inst->method_at_vtable(vtable_index); 529 selected_method = inst->method_at_vtable(vtable_index);
441 } 530 }
442 } 531 }
443 return (jlong) (address) selected_method; 532 oop result = CompilerToVM::get_jvmci_method(selected_method, CHECK_NULL);
444 } 533 return JNIHandles::make_local(THREAD, result);
445 } 534 }
446 return (jlong) (address) NULL; 535 }
447 C2V_END 536 return NULL;
448 537 C2V_END
449 C2V_VMENTRY(jboolean, hasFinalizableSubclass,(JNIEnv *, jobject, jlong metaspace_klass)) 538
450 Klass* klass = (Klass*) metaspace_klass; 539 C2V_VMENTRY(jboolean, hasFinalizableSubclass,(JNIEnv *, jobject, jobject jvmci_type))
540 Klass* klass = CompilerToVM::asKlass(jvmci_type);
451 assert(klass != NULL, "method must not be called for primitive types"); 541 assert(klass != NULL, "method must not be called for primitive types");
452 return Dependencies::find_finalizable_subclass(klass) != NULL; 542 return Dependencies::find_finalizable_subclass(klass) != NULL;
453 C2V_END 543 C2V_END
454 544
455 C2V_VMENTRY(jlong, getClassInitializer, (JNIEnv *, jobject, jlong metaspace_klass)) 545 C2V_VMENTRY(jobject, getClassInitializer, (JNIEnv *, jobject, jobject jvmci_type))
456 InstanceKlass* klass = (InstanceKlass*) metaspace_klass; 546 InstanceKlass* klass = (InstanceKlass*) CompilerToVM::asKlass(jvmci_type);
457 return (jlong) (address) klass->class_initializer(); 547 oop result = CompilerToVM::get_jvmci_method(klass->class_initializer(), CHECK_NULL);
548 return JNIHandles::make_local(THREAD, result);
458 C2V_END 549 C2V_END
459 550
460 C2V_VMENTRY(jlong, getMaxCallTargetOffset, (JNIEnv*, jobject, jlong addr)) 551 C2V_VMENTRY(jlong, getMaxCallTargetOffset, (JNIEnv*, jobject, jlong addr))
461 address target_addr = (address) addr; 552 address target_addr = (address) addr;
462 if (target_addr != 0x0) { 553 if (target_addr != 0x0) {
465 return MAX2(ABS(off_low), ABS(off_high)); 556 return MAX2(ABS(off_low), ABS(off_high));
466 } 557 }
467 return -1; 558 return -1;
468 C2V_END 559 C2V_END
469 560
470 C2V_VMENTRY(void, doNotInlineOrCompile,(JNIEnv *, jobject, jlong metaspace_method)) 561 C2V_VMENTRY(void, doNotInlineOrCompile,(JNIEnv *, jobject, jobject jvmci_method))
471 methodHandle method = asMethod(metaspace_method); 562 methodHandle method = CompilerToVM::asMethod(jvmci_method);
472 method->set_not_c1_compilable(); 563 method->set_not_c1_compilable();
473 method->set_not_c2_compilable(); 564 method->set_not_c2_compilable();
474 method->set_dont_inline(true); 565 method->set_dont_inline(true);
475 C2V_END 566 C2V_END
476 567
535 stats->_nmethods_size += HotSpotInstalledCode::size(installed_code_handle); 626 stats->_nmethods_size += HotSpotInstalledCode::size(installed_code_handle);
536 stats->_nmethods_code_size += HotSpotInstalledCode::codeSize(installed_code_handle); 627 stats->_nmethods_code_size += HotSpotInstalledCode::codeSize(installed_code_handle);
537 } 628 }
538 629
539 if (CITimeEach) { 630 if (CITimeEach) {
540 methodHandle method = asMethod(HotSpotResolvedJavaMethodImpl::metaspaceMethod(hotspot_method)); 631 methodHandle method = CompilerToVM::asMethod(hotspot_method);
541 float bytes_per_sec = 1.0 * processedBytecodes / timer.seconds(); 632 float bytes_per_sec = 1.0 * processedBytecodes / timer.seconds();
542 tty->print_cr("%3d seconds: %f bytes/sec: %f (bytes %d)", 633 tty->print_cr("%3d seconds: %f bytes/sec: %f (bytes %d)",
543 id, timer.seconds(), bytes_per_sec, processedBytecodes); 634 id, timer.seconds(), bytes_per_sec, processedBytecodes);
544 } 635 }
545 C2V_END 636 C2V_END
583 674
584 Handle result = java_lang_String::create_from_platform_dependent_str(st.as_string(), CHECK_NULL); 675 Handle result = java_lang_String::create_from_platform_dependent_str(st.as_string(), CHECK_NULL);
585 return JNIHandles::make_local(THREAD, result()); 676 return JNIHandles::make_local(THREAD, result());
586 C2V_END 677 C2V_END
587 678
588 C2V_VMENTRY(jobject, getStackTraceElement, (JNIEnv*, jobject, jlong metaspace_method, int bci)) 679 C2V_VMENTRY(jobject, getStackTraceElement, (JNIEnv*, jobject, jobject jvmci_method, int bci))
589 ResourceMark rm; 680 ResourceMark rm;
590 HandleMark hm; 681 HandleMark hm;
591 682
592 methodHandle method = asMethod(metaspace_method); 683 methodHandle method = CompilerToVM::asMethod(jvmci_method);
593 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_NULL); 684 oop element = java_lang_StackTraceElement::create(method, bci, CHECK_NULL);
594 return JNIHandles::make_local(THREAD, element); 685 return JNIHandles::make_local(THREAD, element);
595 C2V_END 686 C2V_END
596 687
597 C2V_VMENTRY(jobject, executeInstalledCode, (JNIEnv*, jobject, jobject args, jobject hotspotInstalledCode)) 688 C2V_VMENTRY(jobject, executeInstalledCode, (JNIEnv*, jobject, jobject args, jobject hotspotInstalledCode))
636 oop o = java_lang_boxing_object::create(jap.get_ret_type(), value, CHECK_NULL); 727 oop o = java_lang_boxing_object::create(jap.get_ret_type(), value, CHECK_NULL);
637 return JNIHandles::make_local(THREAD, o); 728 return JNIHandles::make_local(THREAD, o);
638 } 729 }
639 C2V_END 730 C2V_END
640 731
641 C2V_VMENTRY(jlongArray, getLineNumberTable, (JNIEnv *, jobject, jlong metaspace_method)) 732 C2V_VMENTRY(jlongArray, getLineNumberTable, (JNIEnv *, jobject, jobject jvmci_method))
642 Method* method = (Method*) metaspace_method; 733 Method* method = CompilerToVM::asMethod(jvmci_method);
643 if (!method->has_linenumber_table()) { 734 if (!method->has_linenumber_table()) {
644 return NULL; 735 return NULL;
645 } 736 }
646 u2 num_entries = 0; 737 u2 num_entries = 0;
647 CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table()); 738 CompressedLineNumberReadStream streamForSize(method->compressed_linenumber_table());
663 } 754 }
664 755
665 return (jlongArray) JNIHandles::make_local(THREAD, result); 756 return (jlongArray) JNIHandles::make_local(THREAD, result);
666 C2V_END 757 C2V_END
667 758
668 C2V_VMENTRY(jlong, getLocalVariableTableStart, (JNIEnv *, jobject, jlong metaspace_method)) 759 C2V_VMENTRY(jlong, getLocalVariableTableStart, (JNIEnv *, jobject, jobject jvmci_method))
669 ResourceMark rm; 760 ResourceMark rm;
670 Method* method = (Method*) metaspace_method; 761 Method* method = CompilerToVM::asMethod(jvmci_method);
671 if (!method->has_localvariable_table()) { 762 if (!method->has_localvariable_table()) {
672 return 0; 763 return 0;
673 } 764 }
674 return (jlong) (address) method->localvariable_table_start(); 765 return (jlong) (address) method->localvariable_table_start();
675 C2V_END 766 C2V_END
676 767
677 C2V_VMENTRY(jint, getLocalVariableTableLength, (JNIEnv *, jobject, jlong metaspace_method)) 768 C2V_VMENTRY(jint, getLocalVariableTableLength, (JNIEnv *, jobject, jobject jvmci_method))
678 ResourceMark rm; 769 ResourceMark rm;
679 Method* method = (Method*) metaspace_method; 770 Method* method = CompilerToVM::asMethod(jvmci_method);
680 return method->localvariable_table_length(); 771 return method->localvariable_table_length();
681 C2V_END 772 C2V_END
682 773
683 C2V_VMENTRY(void, reprofile, (JNIEnv*, jobject, jlong metaspace_method)) 774 C2V_VMENTRY(void, reprofile, (JNIEnv*, jobject, jobject jvmci_method))
684 Method* method = asMethod(metaspace_method); 775 Method* method = CompilerToVM::asMethod(jvmci_method);
685 MethodCounters* mcs = method->method_counters(); 776 MethodCounters* mcs = method->method_counters();
686 if (mcs != NULL) { 777 if (mcs != NULL) {
687 mcs->clear_counters(); 778 mcs->clear_counters();
688 } 779 }
689 NOT_PRODUCT(method->set_compiled_invocation_count(0)); 780 NOT_PRODUCT(method->set_compiled_invocation_count(0));
713 VMThread::execute(&op); 804 VMThread::execute(&op);
714 } 805 }
715 InstalledCode::set_address(hotspotInstalledCode, 0); 806 InstalledCode::set_address(hotspotInstalledCode, 0);
716 C2V_END 807 C2V_END
717 808
718 C2V_VMENTRY(jobject, getJavaMirror, (JNIEnv* env, jobject, jlong metaspace_klass)) 809 C2V_VMENTRY(jobject, getJavaMirror, (JNIEnv* env, jobject, jobject jvmci_type))
719 Klass* klass = asKlass(metaspace_klass); 810 Klass* klass = CompilerToVM::asKlass(jvmci_type);
720 return JNIHandles::make_local(THREAD, klass->java_mirror()); 811 return JNIHandles::make_local(THREAD, klass->java_mirror());
721 C2V_END 812 C2V_END
722 813
723 C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv*, jobject, jlong addr)) 814 C2V_VMENTRY(jobject, readUncompressedOop, (JNIEnv*, jobject, jlong addr))
724 oop ret = oopDesc::load_decode_heap_oop((oop*)(address)addr); 815 oop ret = oopDesc::load_decode_heap_oop((oop*)(address)addr);
729 typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL); 820 typeArrayOop arrayOop = oopFactory::new_longArray(JVMCICounterSize, CHECK_NULL);
730 JavaThread::collect_counters(arrayOop); 821 JavaThread::collect_counters(arrayOop);
731 return (jlongArray) JNIHandles::make_local(THREAD, arrayOop); 822 return (jlongArray) JNIHandles::make_local(THREAD, arrayOop);
732 C2V_END 823 C2V_END
733 824
734 C2V_VMENTRY(int, allocateCompileId, (JNIEnv*, jobject, jlong metaspace_method, int entry_bci)) 825 C2V_VMENTRY(int, allocateCompileId, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci))
735 HandleMark hm; 826 HandleMark hm;
736 ResourceMark rm; 827 ResourceMark rm;
737 Method* method = (Method*) metaspace_method; 828 Method* method = CompilerToVM::asMethod(jvmci_method);
738 return CompileBroker::assign_compile_id_unlocked(THREAD, method, entry_bci); 829 return CompileBroker::assign_compile_id_unlocked(THREAD, method, entry_bci);
739 C2V_END 830 C2V_END
740 831
741 832
742 C2V_VMENTRY(jboolean, isMature, (JNIEnv*, jobject, jlong metaspace_method_data)) 833 C2V_VMENTRY(jboolean, isMature, (JNIEnv*, jobject, jlong metaspace_method_data))
743 MethodData* mdo = asMethodData(metaspace_method_data); 834 MethodData* mdo = CompilerToVM::asMethodData(metaspace_method_data);
744 return mdo != NULL && mdo->is_mature(); 835 return mdo != NULL && mdo->is_mature();
745 C2V_END 836 C2V_END
746 837
747 C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv*, jobject, jlong metaspace_method, int entry_bci, int comp_level)) 838 C2V_VMENTRY(jboolean, hasCompiledCodeForOSR, (JNIEnv*, jobject, jobject jvmci_method, int entry_bci, int comp_level))
748 Method* method = asMethod(metaspace_method); 839 Method* method = CompilerToVM::asMethod(jvmci_method);
749 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL; 840 return method->lookup_osr_nmethod_for(entry_bci, comp_level, true) != NULL;
750 C2V_END 841 C2V_END
751 842
752 C2V_VMENTRY(jlong, getTimeStamp, (JNIEnv*, jobject)) 843 C2V_VMENTRY(jlong, getTimeStamp, (JNIEnv*, jobject))
753 // tty->time_stamp is the time since VM start which should be used 844 // tty->time_stamp is the time since VM start which should be used
758 C2V_VMENTRY(jobject, getSymbol, (JNIEnv*, jobject, jlong metaspaceSymbol)) 849 C2V_VMENTRY(jobject, getSymbol, (JNIEnv*, jobject, jlong metaspaceSymbol))
759 Handle sym = java_lang_String::create_from_symbol((Symbol*)(address)metaspaceSymbol, CHECK_NULL); 850 Handle sym = java_lang_String::create_from_symbol((Symbol*)(address)metaspaceSymbol, CHECK_NULL);
760 return JNIHandles::make_local(THREAD, sym()); 851 return JNIHandles::make_local(THREAD, sym());
761 C2V_END 852 C2V_END
762 853
763 bool matches(jlongArray methods, Method* method) { 854 bool matches(jobjectArray methods, Method* method) {
764 typeArrayOop methods_oop = (typeArrayOop) JNIHandles::resolve(methods); 855 objArrayOop methods_oop = (objArrayOop) JNIHandles::resolve(methods);
765 856
766 for (int i = 0; i < methods_oop->length(); i++) { 857 for (int i = 0; i < methods_oop->length(); i++) {
767 if (methods_oop->long_at(i) == (jlong) method) { 858 if (CompilerToVM::asMethod(methods_oop->obj_at(i)) == method) {
768 return true; 859 return true;
769 } 860 }
770 } 861 }
771 return false; 862 return false;
772 } 863 }
773 864
774 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jlongArray methods, jint initialSkip)) 865 C2V_VMENTRY(jobject, getNextStackFrame, (JNIEnv*, jobject compilerToVM, jobject hs_frame, jobjectArray methods, jint initialSkip))
775 ResourceMark rm; 866 ResourceMark rm;
776 867
777 if (!thread->has_last_Java_frame()) return NULL; 868 if (!thread->has_last_Java_frame()) return NULL;
778 Handle result = InstanceKlass::cast(HotSpotStackFrameReference::klass())->allocate_instance(thread); 869 Handle result = InstanceKlass::cast(HotSpotStackFrameReference::klass())->allocate_instance(thread);
779 HotSpotStackFrameReference::klass()->initialize(thread); 870 HotSpotStackFrameReference::klass()->initialize(thread);
846 HotSpotStackFrameReference::set_localIsVirtual(result, NULL); 937 HotSpotStackFrameReference::set_localIsVirtual(result, NULL);
847 } 938 }
848 939
849 locals = cvf->locals(); 940 locals = cvf->locals();
850 HotSpotStackFrameReference::set_bci(result, cvf->bci()); 941 HotSpotStackFrameReference::set_bci(result, cvf->bci());
851 HotSpotStackFrameReference::set_metaspaceMethod(result, (jlong) cvf->method()); 942 oop method = CompilerToVM::get_jvmci_method(cvf->method(), CHECK_NULL);
943 HotSpotStackFrameReference::set_method(result, method);
852 } 944 }
853 } 945 }
854 } else if (vf->is_interpreted_frame()) { 946 } else if (vf->is_interpreted_frame()) {
855 // interpreted method frame 947 // interpreted method frame
856 interpretedVFrame* ivf = interpretedVFrame::cast(vf); 948 interpretedVFrame* ivf = interpretedVFrame::cast(vf);
858 if (initialSkip > 0) { 950 if (initialSkip > 0) {
859 initialSkip --; 951 initialSkip --;
860 } else { 952 } else {
861 locals = ivf->locals(); 953 locals = ivf->locals();
862 HotSpotStackFrameReference::set_bci(result, ivf->bci()); 954 HotSpotStackFrameReference::set_bci(result, ivf->bci());
863 HotSpotStackFrameReference::set_metaspaceMethod(result, (jlong) ivf->method()); 955 oop method = CompilerToVM::get_jvmci_method(ivf->method(), CHECK_NULL);
956 HotSpotStackFrameReference::set_method(result, method);
864 HotSpotStackFrameReference::set_localIsVirtual(result, NULL); 957 HotSpotStackFrameReference::set_localIsVirtual(result, NULL);
865 } 958 }
866 } 959 }
867 } 960 }
868 961
902 995
903 // the end was reached without finding a matching method 996 // the end was reached without finding a matching method
904 return NULL; 997 return NULL;
905 C2V_END 998 C2V_END
906 999
907 C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 1000 C2V_VMENTRY(void, resolveInvokeDynamicInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
908 ConstantPool* cp = (ConstantPool*)metaspace_constant_pool; 1001 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
909 CallInfo callInfo; 1002 CallInfo callInfo;
910 LinkResolver::resolve_invokedynamic(callInfo, cp, index, CHECK); 1003 LinkResolver::resolve_invokedynamic(callInfo, cp, index, CHECK);
911 ConstantPoolCacheEntry* cp_cache_entry = cp->invokedynamic_cp_cache_entry_at(index); 1004 ConstantPoolCacheEntry* cp_cache_entry = cp->invokedynamic_cp_cache_entry_at(index);
912 cp_cache_entry->set_dynamic_call(cp, callInfo); 1005 cp_cache_entry->set_dynamic_call(cp, callInfo);
913 C2V_END 1006 C2V_END
914 1007
915 C2V_VMENTRY(void, resolveInvokeHandleInPool, (JNIEnv*, jobject, jlong metaspace_constant_pool, jint index)) 1008 C2V_VMENTRY(void, resolveInvokeHandleInPool, (JNIEnv*, jobject, jobject jvmci_constant_pool, jint index))
916 ConstantPool* cp = (ConstantPool*)metaspace_constant_pool; 1009 constantPoolHandle cp = CompilerToVM::asConstantPool(jvmci_constant_pool);
917 CallInfo callInfo; 1010 CallInfo callInfo;
918 LinkResolver::resolve_invokehandle(callInfo, cp, index, CHECK); 1011 LinkResolver::resolve_invokehandle(callInfo, cp, index, CHECK);
919 ConstantPoolCacheEntry* cp_cache_entry = cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index)); 1012 ConstantPoolCacheEntry* cp_cache_entry = cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index));
920 cp_cache_entry->set_method_handle(cp, callInfo); 1013 cp_cache_entry->set_method_handle(cp, callInfo);
921 C2V_END 1014 C2V_END
1040 #define OBJECT "Ljava/lang/Object;" 1133 #define OBJECT "Ljava/lang/Object;"
1041 #define CLASS "Ljava/lang/Class;" 1134 #define CLASS "Ljava/lang/Class;"
1042 #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;" 1135 #define STACK_TRACE_ELEMENT "Ljava/lang/StackTraceElement;"
1043 #define INSTALLED_CODE "Ljdk/internal/jvmci/code/InstalledCode;" 1136 #define INSTALLED_CODE "Ljdk/internal/jvmci/code/InstalledCode;"
1044 #define RESOLVED_METHOD "Ljdk/internal/jvmci/meta/ResolvedJavaMethod;" 1137 #define RESOLVED_METHOD "Ljdk/internal/jvmci/meta/ResolvedJavaMethod;"
1045 #define HS_RESOLVED_METHOD "Ljdk/internal/jvmci/hotspot/HotSpotResolvedJavaMethod;" 1138 #define HS_RESOLVED_METHOD "Ljdk/internal/jvmci/hotspot/HotSpotResolvedJavaMethodImpl;"
1139 #define HS_RESOLVED_KLASS "Ljdk/internal/jvmci/hotspot/HotSpotResolvedObjectTypeImpl;"
1140 #define HS_CONSTANT_POOL "Ljdk/internal/jvmci/hotspot/HotSpotConstantPool;"
1046 #define HS_COMPILED_CODE "Ljdk/internal/jvmci/hotspot/HotSpotCompiledCode;" 1141 #define HS_COMPILED_CODE "Ljdk/internal/jvmci/hotspot/HotSpotCompiledCode;"
1047 #define HS_CONFIG "Ljdk/internal/jvmci/hotspot/HotSpotVMConfig;" 1142 #define HS_CONFIG "Ljdk/internal/jvmci/hotspot/HotSpotVMConfig;"
1048 #define HS_STACK_FRAME_REF "Ljdk/internal/jvmci/hotspot/HotSpotStackFrameReference;" 1143 #define HS_STACK_FRAME_REF "Ljdk/internal/jvmci/hotspot/HotSpotStackFrameReference;"
1049 #define METASPACE_KLASS "J"
1050 #define METASPACE_METHOD "J"
1051 #define METASPACE_METHOD_DATA "J" 1144 #define METASPACE_METHOD_DATA "J"
1052 #define METASPACE_CONSTANT_POOL "J" 1145
1053 1146 JNINativeMethod CompilerToVM::methods[] = {
1054 JNINativeMethod CompilerToVM_methods[] = { 1147 {CC"getBytecode", CC"("HS_RESOLVED_METHOD")[B", FN_PTR(getBytecode)},
1055 {CC"getBytecode", CC"("METASPACE_METHOD")[B", FN_PTR(getBytecode)}, 1148 {CC"getExceptionTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getExceptionTableStart)},
1056 {CC"getExceptionTableStart", CC"("METASPACE_METHOD")J", FN_PTR(getExceptionTableStart)}, 1149 {CC"getExceptionTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getExceptionTableLength)},
1057 {CC"getExceptionTableLength", CC"("METASPACE_METHOD")I", FN_PTR(getExceptionTableLength)}, 1150 {CC"hasBalancedMonitors", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(hasBalancedMonitors)},
1058 {CC"hasBalancedMonitors", CC"("METASPACE_METHOD")Z", FN_PTR(hasBalancedMonitors)}, 1151 {CC"findUniqueConcreteMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")"HS_RESOLVED_METHOD, FN_PTR(findUniqueConcreteMethod)},
1059 {CC"findUniqueConcreteMethod", CC"("METASPACE_KLASS METASPACE_METHOD")"METASPACE_METHOD, FN_PTR(findUniqueConcreteMethod)}, 1152 {CC"getKlassImplementor", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_KLASS, FN_PTR(getKlassImplementor)},
1060 {CC"getKlassImplementor", CC"("METASPACE_KLASS")"METASPACE_KLASS, FN_PTR(getKlassImplementor)}, 1153 {CC"getStackTraceElement", CC"("HS_RESOLVED_METHOD"I)"STACK_TRACE_ELEMENT, FN_PTR(getStackTraceElement)},
1061 {CC"getStackTraceElement", CC"("METASPACE_METHOD"I)"STACK_TRACE_ELEMENT, FN_PTR(getStackTraceElement)}, 1154 {CC"methodIsIgnoredBySecurityStackWalk", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(methodIsIgnoredBySecurityStackWalk)},
1062 {CC"methodIsIgnoredBySecurityStackWalk", CC"("METASPACE_METHOD")Z", FN_PTR(methodIsIgnoredBySecurityStackWalk)}, 1155 {CC"doNotInlineOrCompile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(doNotInlineOrCompile)},
1063 {CC"doNotInlineOrCompile", CC"("METASPACE_METHOD")V", FN_PTR(doNotInlineOrCompile)}, 1156 {CC"canInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(canInlineMethod)},
1064 {CC"canInlineMethod", CC"("METASPACE_METHOD")Z", FN_PTR(canInlineMethod)}, 1157 {CC"shouldInlineMethod", CC"("HS_RESOLVED_METHOD")Z", FN_PTR(shouldInlineMethod)},
1065 {CC"shouldInlineMethod", CC"("METASPACE_METHOD")Z", FN_PTR(shouldInlineMethod)}, 1158 {CC"lookupType", CC"("STRING CLASS"Z)"HS_RESOLVED_KLASS, FN_PTR(lookupType)},
1066 {CC"lookupType", CC"("STRING CLASS"Z)"METASPACE_KLASS, FN_PTR(lookupType)}, 1159 {CC"lookupNameRefInPool0", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupNameRefInPool)},
1067 {CC"lookupNameRefInPool0", CC"("METASPACE_CONSTANT_POOL"I)"STRING, FN_PTR(lookupNameRefInPool)}, 1160 {CC"lookupNameAndTypeRefIndexInPool", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupNameAndTypeRefIndexInPool)},
1068 {CC"lookupNameAndTypeRefIndexInPool", CC"("METASPACE_CONSTANT_POOL"I)I", FN_PTR(lookupNameAndTypeRefIndexInPool)}, 1161 {CC"lookupSignatureRefInPool0", CC"("HS_CONSTANT_POOL"I)"STRING, FN_PTR(lookupSignatureRefInPool)},
1069 {CC"lookupSignatureRefInPool0", CC"("METASPACE_CONSTANT_POOL"I)"STRING, FN_PTR(lookupSignatureRefInPool)}, 1162 {CC"lookupKlassRefIndexInPool0", CC"("HS_CONSTANT_POOL"I)I", FN_PTR(lookupKlassRefIndexInPool)},
1070 {CC"lookupKlassRefIndexInPool0", CC"("METASPACE_CONSTANT_POOL"I)I", FN_PTR(lookupKlassRefIndexInPool)}, 1163 {CC"lookupKlassInPool", CC"("HS_CONSTANT_POOL"I)Ljava/lang/Object;", FN_PTR(lookupKlassInPool)},
1071 {CC"lookupKlassInPool", CC"("METASPACE_CONSTANT_POOL"I)"METASPACE_KLASS, FN_PTR(lookupKlassInPool)}, 1164 {CC"lookupAppendixInPool0", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(lookupAppendixInPool)},
1072 {CC"lookupAppendixInPool0", CC"("METASPACE_CONSTANT_POOL"I)"OBJECT, FN_PTR(lookupAppendixInPool)}, 1165 {CC"lookupMethodInPool", CC"("HS_CONSTANT_POOL"IB)"HS_RESOLVED_METHOD, FN_PTR(lookupMethodInPool)},
1073 {CC"lookupMethodInPool", CC"("METASPACE_CONSTANT_POOL"IB)"METASPACE_METHOD, FN_PTR(lookupMethodInPool)}, 1166 {CC"constantPoolRemapInstructionOperandFromCache0",CC"("HS_CONSTANT_POOL"I)I", FN_PTR(constantPoolRemapInstructionOperandFromCache)},
1074 {CC"constantPoolRemapInstructionOperandFromCache0",CC"("METASPACE_CONSTANT_POOL"I)I", FN_PTR(constantPoolRemapInstructionOperandFromCache)}, 1167 {CC"resolveConstantInPool", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolveConstantInPool)},
1075 {CC"resolveConstantInPool", CC"("METASPACE_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolveConstantInPool)}, 1168 {CC"resolvePossiblyCachedConstantInPool0", CC"("HS_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolvePossiblyCachedConstantInPool)},
1076 {CC"resolvePossiblyCachedConstantInPool0", CC"("METASPACE_CONSTANT_POOL"I)"OBJECT, FN_PTR(resolvePossiblyCachedConstantInPool)}, 1169 {CC"resolveKlassInPool", CC"("HS_CONSTANT_POOL"I)"HS_RESOLVED_KLASS, FN_PTR(resolveKlassInPool)},
1077 {CC"resolveKlassInPool", CC"("METASPACE_CONSTANT_POOL"I)"METASPACE_KLASS, FN_PTR(resolveKlassInPool)}, 1170 {CC"resolveFieldInPool", CC"("HS_CONSTANT_POOL"IB[J)"HS_RESOLVED_KLASS, FN_PTR(resolveFieldInPool)},
1078 {CC"resolveFieldInPool", CC"("METASPACE_CONSTANT_POOL"IB[J)"METASPACE_KLASS, FN_PTR(resolveFieldInPool)}, 1171 {CC"resolveInvokeDynamicInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeDynamicInPool)},
1079 {CC"resolveInvokeDynamicInPool", CC"("METASPACE_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeDynamicInPool)}, 1172 {CC"resolveInvokeHandleInPool", CC"("HS_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeHandleInPool)},
1080 {CC"resolveInvokeHandleInPool", CC"("METASPACE_CONSTANT_POOL"I)V", FN_PTR(resolveInvokeHandleInPool)}, 1173 {CC"resolveMethod", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(resolveMethod)},
1081 {CC"resolveMethod", CC"("METASPACE_KLASS METASPACE_METHOD METASPACE_KLASS")"METASPACE_METHOD, FN_PTR(resolveMethod)}, 1174 {CC"getVtableIndexForInterface", CC"("HS_RESOLVED_KLASS HS_RESOLVED_METHOD")I", FN_PTR(getVtableIndexForInterface)},
1082 {CC"getVtableIndexForInterface", CC"("METASPACE_KLASS METASPACE_METHOD")I", FN_PTR(getVtableIndexForInterface)}, 1175 {CC"getClassInitializer", CC"("HS_RESOLVED_KLASS")"HS_RESOLVED_METHOD, FN_PTR(getClassInitializer)},
1083 {CC"getClassInitializer", CC"("METASPACE_KLASS")"METASPACE_METHOD, FN_PTR(getClassInitializer)}, 1176 {CC"hasFinalizableSubclass", CC"("HS_RESOLVED_KLASS")Z", FN_PTR(hasFinalizableSubclass)},
1084 {CC"hasFinalizableSubclass", CC"("METASPACE_KLASS")Z", FN_PTR(hasFinalizableSubclass)}, 1177 {CC"getMaxCallTargetOffset", CC"(J)J", FN_PTR(getMaxCallTargetOffset)},
1085 {CC"getMaxCallTargetOffset", CC"(J)J", FN_PTR(getMaxCallTargetOffset)}, 1178 {CC"getResolvedJavaMethodAtSlot", CC"("CLASS"I)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethodAtSlot)},
1086 {CC"getMetaspaceMethod", CC"("CLASS"I)"METASPACE_METHOD, FN_PTR(getMetaspaceMethod)}, 1179 {CC"getResolvedJavaMethod", CC"(Ljava/lang/Object;J)"HS_RESOLVED_METHOD, FN_PTR(getResolvedJavaMethod)},
1087 {CC"initializeConfiguration", CC"("HS_CONFIG")V", FN_PTR(initializeConfiguration)}, 1180 {CC"getConstantPool", CC"(Ljava/lang/Object;J)"HS_CONSTANT_POOL, FN_PTR(getConstantPool)},
1088 {CC"installCode", CC"("HS_COMPILED_CODE INSTALLED_CODE SPECULATION_LOG")I", FN_PTR(installCode)}, 1181 {CC"getResolvedJavaType", CC"(Ljava/lang/Object;JZ)"HS_RESOLVED_KLASS, FN_PTR(getResolvedJavaType)},
1089 {CC"notifyCompilationStatistics", CC"(I"HS_RESOLVED_METHOD"ZIJJ"INSTALLED_CODE")V", FN_PTR(notifyCompilationStatistics)}, 1182 {CC"initializeConfiguration", CC"("HS_CONFIG")V", FN_PTR(initializeConfiguration)},
1090 {CC"resetCompilationStatistics", CC"()V", FN_PTR(resetCompilationStatistics)}, 1183 {CC"installCode", CC"("HS_COMPILED_CODE INSTALLED_CODE SPECULATION_LOG")I", FN_PTR(installCode)},
1091 {CC"disassembleCodeBlob", CC"(J)"STRING, FN_PTR(disassembleCodeBlob)}, 1184 {CC"notifyCompilationStatistics", CC"(I"HS_RESOLVED_METHOD"ZIJJ"INSTALLED_CODE")V", FN_PTR(notifyCompilationStatistics)},
1092 {CC"executeInstalledCode", CC"(["OBJECT INSTALLED_CODE")"OBJECT, FN_PTR(executeInstalledCode)}, 1185 {CC"resetCompilationStatistics", CC"()V", FN_PTR(resetCompilationStatistics)},
1093 {CC"getLineNumberTable", CC"("METASPACE_METHOD")[J", FN_PTR(getLineNumberTable)}, 1186 {CC"disassembleCodeBlob", CC"(J)"STRING, FN_PTR(disassembleCodeBlob)},
1094 {CC"getLocalVariableTableStart", CC"("METASPACE_METHOD")J", FN_PTR(getLocalVariableTableStart)}, 1187 {CC"executeInstalledCode", CC"(["OBJECT INSTALLED_CODE")"OBJECT, FN_PTR(executeInstalledCode)},
1095 {CC"getLocalVariableTableLength", CC"("METASPACE_METHOD")I", FN_PTR(getLocalVariableTableLength)}, 1188 {CC"getLineNumberTable", CC"("HS_RESOLVED_METHOD")[J", FN_PTR(getLineNumberTable)},
1096 {CC"reprofile", CC"("METASPACE_METHOD")V", FN_PTR(reprofile)}, 1189 {CC"getLocalVariableTableStart", CC"("HS_RESOLVED_METHOD")J", FN_PTR(getLocalVariableTableStart)},
1097 {CC"invalidateInstalledCode", CC"("INSTALLED_CODE")V", FN_PTR(invalidateInstalledCode)}, 1190 {CC"getLocalVariableTableLength", CC"("HS_RESOLVED_METHOD")I", FN_PTR(getLocalVariableTableLength)},
1098 {CC"getJavaMirror", CC"("METASPACE_KLASS")"CLASS, FN_PTR(getJavaMirror)}, 1191 {CC"reprofile", CC"("HS_RESOLVED_METHOD")V", FN_PTR(reprofile)},
1099 {CC"readUncompressedOop", CC"(J)"OBJECT, FN_PTR(readUncompressedOop)}, 1192 {CC"invalidateInstalledCode", CC"("INSTALLED_CODE")V", FN_PTR(invalidateInstalledCode)},
1100 {CC"collectCounters", CC"()[J", FN_PTR(collectCounters)}, 1193 {CC"getJavaMirror", CC"("HS_RESOLVED_KLASS")"CLASS, FN_PTR(getJavaMirror)},
1101 {CC"allocateCompileId", CC"("METASPACE_METHOD"I)I", FN_PTR(allocateCompileId)}, 1194 {CC"readUncompressedOop", CC"(J)"OBJECT, FN_PTR(readUncompressedOop)},
1102 {CC"isMature", CC"("METASPACE_METHOD_DATA")Z", FN_PTR(isMature)}, 1195 {CC"collectCounters", CC"()[J", FN_PTR(collectCounters)},
1103 {CC"hasCompiledCodeForOSR", CC"("METASPACE_METHOD"II)Z", FN_PTR(hasCompiledCodeForOSR)}, 1196 {CC"allocateCompileId", CC"("HS_RESOLVED_METHOD"I)I", FN_PTR(allocateCompileId)},
1104 {CC"getSymbol0", CC"(J)"STRING, FN_PTR(getSymbol)}, 1197 {CC"isMature", CC"("METASPACE_METHOD_DATA")Z", FN_PTR(isMature)},
1105 {CC"getTimeStamp", CC"()J", FN_PTR(getTimeStamp)}, 1198 {CC"hasCompiledCodeForOSR", CC"("HS_RESOLVED_METHOD"II)Z", FN_PTR(hasCompiledCodeForOSR)},
1106 {CC"getNextStackFrame", CC"("HS_STACK_FRAME_REF "[JI)"HS_STACK_FRAME_REF, FN_PTR(getNextStackFrame)}, 1199 {CC"getSymbol0", CC"(J)"STRING, FN_PTR(getSymbol)},
1107 {CC"materializeVirtualObjects", CC"("HS_STACK_FRAME_REF"Z)V", FN_PTR(materializeVirtualObjects)}, 1200 {CC"getTimeStamp", CC"()J", FN_PTR(getTimeStamp)},
1108 {CC"shouldDebugNonSafepoints", CC"()Z", FN_PTR(shouldDebugNonSafepoints)}, 1201 {CC"getNextStackFrame", CC"("HS_STACK_FRAME_REF "["HS_RESOLVED_METHOD"I)"HS_STACK_FRAME_REF, FN_PTR(getNextStackFrame)},
1109 {CC"writeDebugOutput", CC"([BII)V", FN_PTR(writeDebugOutput)}, 1202 {CC"materializeVirtualObjects", CC"("HS_STACK_FRAME_REF"Z)V", FN_PTR(materializeVirtualObjects)},
1110 {CC"flushDebugOutput", CC"()V", FN_PTR(flushDebugOutput)}, 1203 {CC"shouldDebugNonSafepoints", CC"()Z", FN_PTR(shouldDebugNonSafepoints)},
1204 {CC"writeDebugOutput", CC"([BII)V", FN_PTR(writeDebugOutput)},
1205 {CC"flushDebugOutput", CC"()V", FN_PTR(flushDebugOutput)},
1111 }; 1206 };
1112 1207
1113 int CompilerToVM_methods_count() { 1208 int CompilerToVM::methods_count() {
1114 return sizeof(CompilerToVM_methods) / sizeof(JNINativeMethod); 1209 return sizeof(methods) / sizeof(JNINativeMethod);
1115 } 1210 }
1116 1211