< prev index next >

src/hotspot/share/oops/klassVtable.cpp

Print this page

1212                    interf->class_in_module_of_loader(false, true),
1213                    method_holder->class_in_module_of_loader(false, true));
1214           THROW_MSG(vmSymbols::java_lang_LinkageError(), ss.as_string());
1215         }
1216       }
1217     }
1218     ime++;
1219   }
1220 }
1221 
1222 void klassItable::initialize_itable_and_check_constraints(TRAPS) {
1223   // Save a super interface from each itable entry to do constraint checking
1224   ResourceMark rm(THREAD);
1225   GrowableArray<Method*>* supers =
1226     new GrowableArray<Method*>(_size_method_table, _size_method_table, NULL);
1227   initialize_itable(supers);
1228   check_constraints(supers, CHECK);
1229 }
1230 
1231 inline bool interface_method_needs_itable_index(Method* m) {
1232   if (m->is_static())           return false;   // e.g., Stream.empty
1233   if (m->is_initializer())      return false;   // <init> or <clinit>
1234   if (m->is_private())          return false;   // uses direct call

1235   // If an interface redeclares a method from java.lang.Object,
1236   // it should already have a vtable index, don't touch it.
1237   // e.g., CharSequence.toString (from initialize_vtable)
1238   // if (m->has_vtable_index())  return false; // NO!
1239   return true;
1240 }
1241 
1242 int klassItable::assign_itable_indices_for_interface(InstanceKlass* klass) {
1243   // an interface does not have an itable, but its methods need to be numbered
1244   if (log_develop_is_enabled(Trace, itables)) {
1245     ResourceMark rm;
1246     log_develop_debug(itables)("%3d: Initializing itable indices for interface %s",
1247                                ++initialize_count, klass->name()->as_C_string());
1248   }
1249 
1250   Array<Method*>* methods = klass->methods();
1251   int nof_methods = methods->length();
1252   int ime_num = 0;
1253   for (int i = 0; i < nof_methods; i++) {
1254     Method* m = methods->at(i);

1423       tty->print("      (%5d)  ", i);
1424       m->access_flags().print_on(tty);
1425       if (m->is_default_method()) {
1426         tty->print("default ");
1427       }
1428       tty->print(" --  ");
1429       m->print_name(tty);
1430       tty->cr();
1431     }
1432     ime++;
1433   }
1434 }
1435 #endif // INCLUDE_JVMTI
1436 
1437 // Setup
1438 class InterfaceVisiterClosure : public StackObj {
1439  public:
1440   virtual void doit(InstanceKlass* intf, int method_count) = 0;
1441 };
1442 












1443 // Visit all interfaces with at least one itable method
1444 void visit_all_interfaces(Array<InstanceKlass*>* transitive_intf, InterfaceVisiterClosure *blk) {
1445   // Handle array argument
1446   for(int i = 0; i < transitive_intf->length(); i++) {
1447     InstanceKlass* intf = transitive_intf->at(i);
1448     assert(intf->is_interface(), "sanity check");
1449 
1450     // Find no. of itable methods
1451     int method_count = 0;
1452     // method_count = klassItable::method_count_for_interface(intf);
1453     Array<Method*>* methods = intf->methods();
1454     if (methods->length() > 0) {
1455       for (int i = methods->length(); --i >= 0; ) {
1456         if (interface_method_needs_itable_index(methods->at(i))) {
1457           method_count++;
1458         }
1459       }
1460     }
1461 
1462     // Visit all interfaces which either have any methods or can participate in receiver type check.

1491     _klass_begin  = klass_begin;
1492     _offset_entry = offset_entry;
1493     _method_entry = method_entry;
1494   }
1495 
1496   itableMethodEntry* method_entry() const { return _method_entry; }
1497 
1498   void doit(InstanceKlass* intf, int method_count) {
1499     int offset = ((address)_method_entry) - _klass_begin;
1500     _offset_entry->initialize(intf, offset);
1501     _offset_entry++;
1502     _method_entry += method_count;
1503   }
1504 };
1505 
1506 int klassItable::compute_itable_size(Array<InstanceKlass*>* transitive_interfaces) {
1507   // Count no of interfaces and total number of interface methods
1508   CountInterfacesClosure cic;
1509   visit_all_interfaces(transitive_interfaces, &cic);
1510 
1511   // There's alway an extra itable entry so we can null-terminate it.
1512   int itable_size = calc_itable_size(cic.nof_interfaces() + 1, cic.nof_methods());
1513 
1514   // Statistics
1515   update_stats(itable_size * wordSize);
1516 
1517   return itable_size;
1518 }
1519 
1520 
1521 // Fill out offset table and interface klasses into the itable space
1522 void klassItable::setup_itable_offset_table(InstanceKlass* klass) {
1523   if (klass->itable_length() == 0) return;
1524   assert(!klass->is_interface(), "Should have zero length itable");
1525 
1526   // Count no of interfaces and total number of interface methods
1527   CountInterfacesClosure cic;
1528   visit_all_interfaces(klass->transitive_interfaces(), &cic);
1529   int nof_methods    = cic.nof_methods();
1530   int nof_interfaces = cic.nof_interfaces();
1531 

1212                    interf->class_in_module_of_loader(false, true),
1213                    method_holder->class_in_module_of_loader(false, true));
1214           THROW_MSG(vmSymbols::java_lang_LinkageError(), ss.as_string());
1215         }
1216       }
1217     }
1218     ime++;
1219   }
1220 }
1221 
1222 void klassItable::initialize_itable_and_check_constraints(TRAPS) {
1223   // Save a super interface from each itable entry to do constraint checking
1224   ResourceMark rm(THREAD);
1225   GrowableArray<Method*>* supers =
1226     new GrowableArray<Method*>(_size_method_table, _size_method_table, NULL);
1227   initialize_itable(supers);
1228   check_constraints(supers, CHECK);
1229 }
1230 
1231 inline bool interface_method_needs_itable_index(Method* m) {
1232   if (m->is_static())             return false;   // e.g., Stream.empty
1233   if (m->is_private())            return false;   // uses direct call
1234   if (m->is_object_constructor()) return false;   // <init>(...)V
1235   if (m->is_class_initializer())  return false;   // <clinit>()V
1236   // If an interface redeclares a method from java.lang.Object,
1237   // it should already have a vtable index, don't touch it.
1238   // e.g., CharSequence.toString (from initialize_vtable)
1239   // if (m->has_vtable_index())  return false; // NO!
1240   return true;
1241 }
1242 
1243 int klassItable::assign_itable_indices_for_interface(InstanceKlass* klass) {
1244   // an interface does not have an itable, but its methods need to be numbered
1245   if (log_develop_is_enabled(Trace, itables)) {
1246     ResourceMark rm;
1247     log_develop_debug(itables)("%3d: Initializing itable indices for interface %s",
1248                                ++initialize_count, klass->name()->as_C_string());
1249   }
1250 
1251   Array<Method*>* methods = klass->methods();
1252   int nof_methods = methods->length();
1253   int ime_num = 0;
1254   for (int i = 0; i < nof_methods; i++) {
1255     Method* m = methods->at(i);

1424       tty->print("      (%5d)  ", i);
1425       m->access_flags().print_on(tty);
1426       if (m->is_default_method()) {
1427         tty->print("default ");
1428       }
1429       tty->print(" --  ");
1430       m->print_name(tty);
1431       tty->cr();
1432     }
1433     ime++;
1434   }
1435 }
1436 #endif // INCLUDE_JVMTI
1437 
1438 // Setup
1439 class InterfaceVisiterClosure : public StackObj {
1440  public:
1441   virtual void doit(InstanceKlass* intf, int method_count) = 0;
1442 };
1443 
1444 int count_interface_methods_needing_itable_index(Array<Method*>* methods) {
1445   int method_count = 0;
1446   if (methods->length() > 0) {
1447     for (int i = methods->length(); --i >= 0; ) {
1448       if (interface_method_needs_itable_index(methods->at(i))) {
1449         method_count++;
1450       }
1451     }
1452   }
1453   return method_count;
1454 }
1455 
1456 // Visit all interfaces with at least one itable method
1457 void visit_all_interfaces(Array<InstanceKlass*>* transitive_intf, InterfaceVisiterClosure *blk) {
1458   // Handle array argument
1459   for(int i = 0; i < transitive_intf->length(); i++) {
1460     InstanceKlass* intf = transitive_intf->at(i);
1461     assert(intf->is_interface(), "sanity check");
1462 
1463     // Find no. of itable methods
1464     int method_count = 0;
1465     // method_count = klassItable::method_count_for_interface(intf);
1466     Array<Method*>* methods = intf->methods();
1467     if (methods->length() > 0) {
1468       for (int i = methods->length(); --i >= 0; ) {
1469         if (interface_method_needs_itable_index(methods->at(i))) {
1470           method_count++;
1471         }
1472       }
1473     }
1474 
1475     // Visit all interfaces which either have any methods or can participate in receiver type check.

1504     _klass_begin  = klass_begin;
1505     _offset_entry = offset_entry;
1506     _method_entry = method_entry;
1507   }
1508 
1509   itableMethodEntry* method_entry() const { return _method_entry; }
1510 
1511   void doit(InstanceKlass* intf, int method_count) {
1512     int offset = ((address)_method_entry) - _klass_begin;
1513     _offset_entry->initialize(intf, offset);
1514     _offset_entry++;
1515     _method_entry += method_count;
1516   }
1517 };
1518 
1519 int klassItable::compute_itable_size(Array<InstanceKlass*>* transitive_interfaces) {
1520   // Count no of interfaces and total number of interface methods
1521   CountInterfacesClosure cic;
1522   visit_all_interfaces(transitive_interfaces, &cic);
1523 
1524   // There's always an extra itable entry so we can null-terminate it.
1525   int itable_size = calc_itable_size(cic.nof_interfaces() + 1, cic.nof_methods());
1526 
1527   // Statistics
1528   update_stats(itable_size * wordSize);
1529 
1530   return itable_size;
1531 }
1532 
1533 
1534 // Fill out offset table and interface klasses into the itable space
1535 void klassItable::setup_itable_offset_table(InstanceKlass* klass) {
1536   if (klass->itable_length() == 0) return;
1537   assert(!klass->is_interface(), "Should have zero length itable");
1538 
1539   // Count no of interfaces and total number of interface methods
1540   CountInterfacesClosure cic;
1541   visit_all_interfaces(klass->transitive_interfaces(), &cic);
1542   int nof_methods    = cic.nof_methods();
1543   int nof_interfaces = cic.nof_interfaces();
1544 
< prev index next >