< prev index next >

src/hotspot/share/ci/ciMethodData.hpp

Concurrent class unloading

177   }                                                                                                                                  
178 
179   ProfilePtrKind argument_ptr_kind(int i) const {                                                                                    
180     return args()->ptr_kind(i);                                                                                                      
181   }                                                                                                                                  
182 
183   ProfilePtrKind return_ptr_kind() const {                                                                                           
184     return ret()->ptr_kind();                                                                                                        
185   }                                                                                                                                  
186 
187 #ifndef PRODUCT                                                                                                                      
188   void print_data_on(outputStream* st, const char* extra = NULL) const;                                                              
189 #endif                                                                                                                               
190 };                                                                                                                                   
191 
192 class ciReceiverTypeData : public ReceiverTypeData {                                                                                 
193 public:                                                                                                                              
194   ciReceiverTypeData(DataLayout* layout) : ReceiverTypeData(layout) {};                                                              
195 
196   void set_receiver(uint row, ciKlass* recv) {                                                                                       
                                                                                                                                     
197     assert((uint)row < row_limit(), "oob");                                                                                          
198     set_intptr_at(receiver0_offset + row * receiver_type_row_cell_count,                                                             
199                   (intptr_t) recv);                                                                                                  
200   }                                                                                                                                  
201 
202   ciKlass* receiver(uint row) const {                                                                                                
203     assert((uint)row < row_limit(), "oob");                                                                                          
204     ciKlass* recv = (ciKlass*)intptr_at(receiver0_offset + row * receiver_type_row_cell_count);                                      
205     assert(recv == NULL || recv->is_klass(), "wrong type");                                                                          
206     return recv;                                                                                                                     
207   }                                                                                                                                  
208 
209   // Copy & translate from oop based ReceiverTypeData                                                                                
210   virtual void translate_from(const ProfileData* data) {                                                                             
211     translate_receiver_data_from(data);                                                                                              
212   }                                                                                                                                  
213   void translate_receiver_data_from(const ProfileData* data);                                                                        
214 #ifndef PRODUCT                                                                                                                      
215   void print_data_on(outputStream* st, const char* extra = NULL) const;                                                              

177   }
178 
179   ProfilePtrKind argument_ptr_kind(int i) const {
180     return args()->ptr_kind(i);
181   }
182 
183   ProfilePtrKind return_ptr_kind() const {
184     return ret()->ptr_kind();
185   }
186 
187 #ifndef PRODUCT
188   void print_data_on(outputStream* st, const char* extra = NULL) const;
189 #endif
190 };
191 
192 class ciReceiverTypeData : public ReceiverTypeData {
193 public:
194   ciReceiverTypeData(DataLayout* layout) : ReceiverTypeData(layout) {};
195 
196   void set_receiver(uint row, ciKlass* recv) {
197     assert(recv == NULL || recv->is_klass(), "wrong type");
198     assert((uint)row < row_limit(), "oob");
199     set_intptr_at(receiver0_offset + row * receiver_type_row_cell_count,
200                   (intptr_t) recv);
201   }
202 
203   ciKlass* receiver(uint row) const {
204     assert((uint)row < row_limit(), "oob");
205     ciKlass* recv = (ciKlass*)intptr_at(receiver0_offset + row * receiver_type_row_cell_count);
206     assert(recv == NULL || recv->is_klass(), "wrong type");
207     return recv;
208   }
209 
210   // Copy & translate from oop based ReceiverTypeData
211   virtual void translate_from(const ProfileData* data) {
212     translate_receiver_data_from(data);
213   }
214   void translate_receiver_data_from(const ProfileData* data);
215 #ifndef PRODUCT
216   void print_data_on(outputStream* st, const char* extra = NULL) const;
< prev index next >