258 default: assert(false, "bad CallInfo"); return NULL;
259 }
260
261 // @CallerSensitive annotation detected
262 if (m->caller_sensitive()) {
263 flags |= CALLER_SENSITIVE;
264 }
265
266 oop mname_oop = mname();
267 java_lang_invoke_MemberName::set_flags( mname_oop, flags);
268 java_lang_invoke_MemberName::set_vmtarget(mname_oop, m());
269 java_lang_invoke_MemberName::set_vmindex( mname_oop, vmindex); // vtable/itable index
270 java_lang_invoke_MemberName::set_clazz( mname_oop, m_klass->java_mirror());
271 // Note: name and type can be lazily computed by resolve_MemberName,
272 // if Java code needs them as resolved String and MethodType objects.
273 // The clazz must be eagerly stored, because it provides a GC
274 // root to help keep alive the Method*.
275 // If relevant, the vtable or itable value is stored as vmindex.
276 // This is done eagerly, since it is readily available without
277 // constructing any new objects.
278 // TO DO: maybe intern mname_oop
279 m->method_holder()->add_member_name(m->method_idnum(), mname);
280
281 return mname();
282 }
283
284 oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
285 int flags = (jushort)( fd.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS );
286 flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
287 if (is_setter) flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
288 Metadata* vmtarget = fd.field_holder();
289 int vmindex = fd.offset(); // determines the field uniquely when combined with static bit
290 oop mname_oop = mname();
291 java_lang_invoke_MemberName::set_flags(mname_oop, flags);
292 java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);
293 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
294 java_lang_invoke_MemberName::set_clazz(mname_oop, fd.field_holder()->java_mirror());
295 oop type = field_signature_type_or_null(fd.signature());
296 oop name = field_name_or_null(fd.name());
297 if (name != NULL)
298 java_lang_invoke_MemberName::set_name(mname_oop, name);
299 if (type != NULL)
914 // passed the filters
915 if (rskip > 0) {
916 --rskip;
917 } else if (rfill < rlimit) {
918 Handle result(thread, results->obj_at(rfill++));
919 if (!java_lang_invoke_MemberName::is_instance(result()))
920 return -99; // caller bug!
921 CallInfo info(m);
922 oop saved = MethodHandles::init_method_MemberName(result, info);
923 if (saved != result())
924 results->obj_at_put(rfill-1, saved); // show saved instance to user
925 } else if (++overflow >= overflow_limit) {
926 match_flags = 0; break; // got tired of looking at overflow
927 }
928 }
929 }
930
931 // return number of elements we at leasted wanted to initialize
932 return rfill + overflow;
933 }
934
935 //------------------------------------------------------------------------------
936 // MemberNameTable
937 //
938
939 MemberNameTable::MemberNameTable(int methods_cnt)
940 : GrowableArray<jweak>(methods_cnt, true) {
941 assert_locked_or_safepoint(MemberNameTable_lock);
942 }
943
944 MemberNameTable::~MemberNameTable() {
945 assert_locked_or_safepoint(MemberNameTable_lock);
946 int len = this->length();
947
948 for (int idx = 0; idx < len; idx++) {
949 jweak ref = this->at(idx);
950 JNIHandles::destroy_weak_global(ref);
951 }
952 }
953
954 void MemberNameTable::add_member_name(int index, jweak mem_name_wref) {
955 assert_locked_or_safepoint(MemberNameTable_lock);
956 this->at_put_grow(index, mem_name_wref);
957 }
958
959 // Return a member name oop or NULL.
960 oop MemberNameTable::get_member_name(int index) {
961 assert_locked_or_safepoint(MemberNameTable_lock);
962
963 jweak ref = this->at(index);
964 oop mem_name = JNIHandles::resolve(ref);
965 return mem_name;
966 }
967
968 #if INCLUDE_JVMTI
969 oop MemberNameTable::find_member_name_by_method(Method* old_method) {
970 assert_locked_or_safepoint(MemberNameTable_lock);
971 oop found = NULL;
972 int len = this->length();
973
974 for (int idx = 0; idx < len; idx++) {
975 oop mem_name = JNIHandles::resolve(this->at(idx));
976 if (mem_name == NULL) {
977 continue;
978 }
979 Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mem_name);
980 if (method == old_method) {
981 found = mem_name;
982 break;
983 }
984 }
985 return found;
986 }
987
988 // It is called at safepoint only
989 void MemberNameTable::adjust_method_entries(Method** old_methods, Method** new_methods,
990 int methods_length, bool *trace_name_printed) {
991 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
992 // search the MemberNameTable for uses of either obsolete or EMCP methods
993 for (int j = 0; j < methods_length; j++) {
994 Method* old_method = old_methods[j];
995 Method* new_method = new_methods[j];
996 oop mem_name = find_member_name_by_method(old_method);
997 if (mem_name != NULL) {
998 java_lang_invoke_MemberName::adjust_vmtarget(mem_name, new_method);
999
1000 if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
1001 if (!(*trace_name_printed)) {
1002 // RC_TRACE_MESG macro has an embedded ResourceMark
1003 RC_TRACE_MESG(("adjust: name=%s",
1004 old_method->method_holder()->external_name()));
1005 *trace_name_printed = true;
1006 }
1007 // RC_TRACE macro has an embedded ResourceMark
1008 RC_TRACE(0x00400000, ("MemberName method update: %s(%s)",
1009 new_method->name()->as_C_string(),
1010 new_method->signature()->as_C_string()));
1011 }
1012 }
1013 }
1014 }
1015 #endif // INCLUDE_JVMTI
1016
1017 //
1018 // Here are the native methods in java.lang.invoke.MethodHandleNatives
1019 // They are the private interface between this JVM and the HotSpot-specific
1020 // Java code that implements JSR 292 method handles.
1021 //
1022 // Note: We use a JVM_ENTRY macro to define each of these, for this is the way
1023 // that intrinsic (non-JNI) native methods are defined in HotSpot.
1024 //
1025
1026 JVM_ENTRY(jint, MHN_getConstant(JNIEnv *env, jobject igcls, jint which)) {
1027 switch (which) {
1028 case MethodHandles::GC_COUNT_GWT:
1029 #ifdef COMPILER2
1030 return true;
1031 #else
1032 return false;
1033 #endif
1034 }
1035 return 0;
|
258 default: assert(false, "bad CallInfo"); return NULL;
259 }
260
261 // @CallerSensitive annotation detected
262 if (m->caller_sensitive()) {
263 flags |= CALLER_SENSITIVE;
264 }
265
266 oop mname_oop = mname();
267 java_lang_invoke_MemberName::set_flags( mname_oop, flags);
268 java_lang_invoke_MemberName::set_vmtarget(mname_oop, m());
269 java_lang_invoke_MemberName::set_vmindex( mname_oop, vmindex); // vtable/itable index
270 java_lang_invoke_MemberName::set_clazz( mname_oop, m_klass->java_mirror());
271 // Note: name and type can be lazily computed by resolve_MemberName,
272 // if Java code needs them as resolved String and MethodType objects.
273 // The clazz must be eagerly stored, because it provides a GC
274 // root to help keep alive the Method*.
275 // If relevant, the vtable or itable value is stored as vmindex.
276 // This is done eagerly, since it is readily available without
277 // constructing any new objects.
278
279 return mname();
280 }
281
282 oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
283 int flags = (jushort)( fd.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS );
284 flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
285 if (is_setter) flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
286 Metadata* vmtarget = fd.field_holder();
287 int vmindex = fd.offset(); // determines the field uniquely when combined with static bit
288 oop mname_oop = mname();
289 java_lang_invoke_MemberName::set_flags(mname_oop, flags);
290 java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);
291 java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
292 java_lang_invoke_MemberName::set_clazz(mname_oop, fd.field_holder()->java_mirror());
293 oop type = field_signature_type_or_null(fd.signature());
294 oop name = field_name_or_null(fd.name());
295 if (name != NULL)
296 java_lang_invoke_MemberName::set_name(mname_oop, name);
297 if (type != NULL)
912 // passed the filters
913 if (rskip > 0) {
914 --rskip;
915 } else if (rfill < rlimit) {
916 Handle result(thread, results->obj_at(rfill++));
917 if (!java_lang_invoke_MemberName::is_instance(result()))
918 return -99; // caller bug!
919 CallInfo info(m);
920 oop saved = MethodHandles::init_method_MemberName(result, info);
921 if (saved != result())
922 results->obj_at_put(rfill-1, saved); // show saved instance to user
923 } else if (++overflow >= overflow_limit) {
924 match_flags = 0; break; // got tired of looking at overflow
925 }
926 }
927 }
928
929 // return number of elements we at leasted wanted to initialize
930 return rfill + overflow;
931 }
932
933 //
934 // Here are the native methods in java.lang.invoke.MethodHandleNatives
935 // They are the private interface between this JVM and the HotSpot-specific
936 // Java code that implements JSR 292 method handles.
937 //
938 // Note: We use a JVM_ENTRY macro to define each of these, for this is the way
939 // that intrinsic (non-JNI) native methods are defined in HotSpot.
940 //
941
942 JVM_ENTRY(jint, MHN_getConstant(JNIEnv *env, jobject igcls, jint which)) {
943 switch (which) {
944 case MethodHandles::GC_COUNT_GWT:
945 #ifdef COMPILER2
946 return true;
947 #else
948 return false;
949 #endif
950 }
951 return 0;
|