< prev index next >

src/hotspot/share/oops/methodData.hpp

Concurrent class unloading

1115   }                                                                                                                                  
1116 
1117   virtual int cell_count() const {                                                                                                   
1118     return static_cell_count();                                                                                                      
1119   }                                                                                                                                  
1120 
1121   // Direct accessors                                                                                                                
1122   static uint row_limit() {                                                                                                          
1123     return TypeProfileWidth;                                                                                                         
1124   }                                                                                                                                  
1125   static int receiver_cell_index(uint row) {                                                                                         
1126     return receiver0_offset + row * receiver_type_row_cell_count;                                                                    
1127   }                                                                                                                                  
1128   static int receiver_count_cell_index(uint row) {                                                                                   
1129     return count0_offset + row * receiver_type_row_cell_count;                                                                       
1130   }                                                                                                                                  
1131 
1132   Klass* receiver(uint row) const {                                                                                                  
1133     assert(row < row_limit(), "oob");                                                                                                
1134 
1135     Klass* recv = (Klass*)intptr_at(receiver_cell_index(row));                                                                       
                                                                                                                                     
1136     assert(recv == NULL || recv->is_klass(), "wrong type");                                                                          
1137     return recv;                                                                                                                     
1138   }                                                                                                                                  
1139 
1140   void set_receiver(uint row, Klass* k) {                                                                                            
1141     assert((uint)row < row_limit(), "oob");                                                                                          
1142     set_intptr_at(receiver_cell_index(row), (uintptr_t)k);                                                                           
1143   }                                                                                                                                  
1144 
1145   uint receiver_count(uint row) const {                                                                                              
1146     assert(row < row_limit(), "oob");                                                                                                
1147     return uint_at(receiver_count_cell_index(row));                                                                                  
1148   }                                                                                                                                  
1149 
1150   void set_receiver_count(uint row, uint count) {                                                                                    
1151     assert(row < row_limit(), "oob");                                                                                                
1152     set_uint_at(receiver_count_cell_index(row), count);                                                                              
1153   }                                                                                                                                  
1154 

1115   }
1116 
1117   virtual int cell_count() const {
1118     return static_cell_count();
1119   }
1120 
1121   // Direct accessors
1122   static uint row_limit() {
1123     return TypeProfileWidth;
1124   }
1125   static int receiver_cell_index(uint row) {
1126     return receiver0_offset + row * receiver_type_row_cell_count;
1127   }
1128   static int receiver_count_cell_index(uint row) {
1129     return count0_offset + row * receiver_type_row_cell_count;
1130   }
1131 
1132   Klass* receiver(uint row) const {
1133     assert(row < row_limit(), "oob");
1134 
1135     int index = receiver_cell_index(row);
1136     Klass* recv = (Klass*)intptr_at(index);
1137     assert(recv == NULL || recv->is_klass(), "wrong type");
1138     return recv;
1139   }
1140 
1141   void set_receiver(uint row, Klass* k) {
1142     assert((uint)row < row_limit(), "oob");
1143     set_intptr_at(receiver_cell_index(row), (uintptr_t)k);
1144   }
1145 
1146   uint receiver_count(uint row) const {
1147     assert(row < row_limit(), "oob");
1148     return uint_at(receiver_count_cell_index(row));
1149   }
1150 
1151   void set_receiver_count(uint row, uint count) {
1152     assert(row < row_limit(), "oob");
1153     set_uint_at(receiver_count_cell_index(row), count);
1154   }
1155 
< prev index next >