< prev index next >

src/hotspot/share/interpreter/linkResolver.cpp

Print this page

        

@@ -326,11 +326,11 @@
   Klass* klass = link_info.resolved_klass();
   Symbol* name = link_info.name();
   Symbol* signature = link_info.signature();
 
   // Ignore overpasses so statics can be found during resolution
-  Method* result = klass->uncached_lookup_method(name, signature, Klass::skip_overpass);
+  Method* result = klass->uncached_lookup_method(name, signature, Klass::OverpassLookupMode::skip_overpass);
 
   if (klass->is_array_klass()) {
     // Only consider klass and super klass for arrays
     return result;
   }

@@ -375,15 +375,15 @@
 // Looks up method in classes, then looks up local default methods
 Method* LinkResolver::lookup_instance_method_in_klasses(Klass* klass,
                                                         Symbol* name,
                                                         Symbol* signature,
                                                         Klass::PrivateLookupMode private_mode, TRAPS) {
-  Method* result = klass->uncached_lookup_method(name, signature, Klass::find_overpass, private_mode);
+  Method* result = klass->uncached_lookup_method(name, signature, Klass::OverpassLookupMode::find_overpass, private_mode);
 
   while (result != NULL && result->is_static() && result->method_holder()->super() != NULL) {
     Klass* super_klass = result->method_holder()->super();
-    result = super_klass->uncached_lookup_method(name, signature, Klass::find_overpass, private_mode);
+    result = super_klass->uncached_lookup_method(name, signature, Klass::OverpassLookupMode::find_overpass, private_mode);
   }
 
   if (klass->is_array_klass()) {
     // Only consider klass and super klass for arrays
     return result;

@@ -408,12 +408,14 @@
   InstanceKlass* ik = InstanceKlass::cast(klass);
 
   // First check in default method array
   if (!resolved_method->is_abstract() && ik->default_methods() != NULL) {
     int index = InstanceKlass::find_method_index(ik->default_methods(),
-                                                 name, signature, Klass::find_overpass,
-                                                 Klass::find_static, Klass::find_private);
+                                                 name, signature,
+                                                 Klass::OverpassLookupMode::find_overpass,
+                                                 Klass::StaticLookupMode::find_static,
+                                                 Klass::PrivateLookupMode::find_private);
     if (index >= 0 ) {
       vtable_index = ik->default_vtable_indices()->at(index);
     }
   }
   if (vtable_index == Method::invalid_vtable_index) {

@@ -428,11 +430,11 @@
   InstanceKlass *ik = InstanceKlass::cast(cp_info.resolved_klass());
 
   // Specify 'true' in order to skip default methods when searching the
   // interfaces.  Function lookup_method_in_klasses() already looked for
   // the method in the default methods table.
-  return ik->lookup_method_in_all_interfaces(cp_info.name(), cp_info.signature(), Klass::skip_defaults);
+  return ik->lookup_method_in_all_interfaces(cp_info.name(), cp_info.signature(), Klass::DefaultsLookupMode::skip_defaults);
 }
 
 Method* LinkResolver::lookup_polymorphic_method(const LinkInfo& link_info,
                                                 Handle *appendix_result_or_null,
                                                 TRAPS) {

@@ -1085,11 +1087,11 @@
   if (initialize_class && resolved_klass->should_be_initialized()) {
     resolved_klass->initialize(CHECK);
     // Use updated LinkInfo to reresolve with resolved method holder
     LinkInfo new_info(resolved_klass, link_info.name(), link_info.signature(),
                       link_info.current_klass(),
-                      link_info.check_access() ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
+                      link_info.check_access() ? LinkInfo::AccessCheck::needs_access_check : LinkInfo::AccessCheck::skip_access_check);
     resolved_method = linktime_resolve_static_method(new_info, CHECK);
   }
 
   // setup result
   result.set_static(resolved_klass, methodHandle(THREAD, resolved_method), CHECK);

@@ -1234,11 +1236,11 @@
       // Lookup super method
       Klass* super_klass = current_klass->super();
       Method* instance_method = lookup_instance_method_in_klasses(super_klass,
                                                      resolved_method->name(),
                                                      resolved_method->signature(),
-                                                     Klass::find_private, CHECK);
+                                                     Klass::PrivateLookupMode::find_private, CHECK);
       sel_method = methodHandle(THREAD, instance_method);
 
       // check if found
       if (sel_method.is_null()) {
         ResourceMark rm(THREAD);

@@ -1476,11 +1478,11 @@
     // to correctly enforce loader constraints for interface method inheritance.
     // Private methods are skipped as the resolved method was not private.
     Method* method = lookup_instance_method_in_klasses(recv_klass,
                                                        resolved_method->name(),
                                                        resolved_method->signature(),
-                                                       Klass::skip_private, CHECK);
+                                                       Klass::PrivateLookupMode::skip_private, CHECK);
     selected_method = methodHandle(THREAD, method);
 
     if (selected_method.is_null() && !check_null_and_abstract) {
       // In theory this is a harmless placeholder value, but
       // in practice leaving in null affects the nsk default method tests.
< prev index next >