< prev index next >

src/hotspot/share/code/icBuffer.hpp


82   friend ICStub* ICStub_from_destination_address(address destination_address);                                                       
83 };                                                                                                                                   
84 
85 // ICStub Creation                                                                                                                   
86 inline ICStub* ICStub_from_destination_address(address destination_address) {                                                        
87   ICStub* stub = (ICStub*) (destination_address - align_up(sizeof(ICStub), CodeEntryAlignment));                                     
88   #ifdef ASSERT                                                                                                                      
89   stub->verify();                                                                                                                    
90   #endif                                                                                                                             
91   return stub;                                                                                                                       
92 }                                                                                                                                    
93 
94 class InlineCacheBuffer: public AllStatic {                                                                                          
95  private:                                                                                                                            
96   // friends                                                                                                                         
97   friend class ICStub;                                                                                                               
98 
99   static int ic_stub_code_size();                                                                                                    
100 
101   static StubQueue* _buffer;                                                                                                         
102   static ICStub*    _next_stub;                                                                                                      
103 
104   static CompiledICHolder* _pending_released;                                                                                        
105   static int _pending_count;                                                                                                         
106 
107   static StubQueue* buffer()                         { return _buffer;         }                                                     
108   static void       set_next_stub(ICStub* next_stub) { _next_stub = next_stub; }                                                     
109   static ICStub*    get_next_stub()                  { return _next_stub;      }                                                     
110                                                                                                                                      
111   static void       init_next_stub();                                                                                                
112                                                                                                                                      
113 
114   static ICStub* new_ic_stub();                                                                                                      
115 
116   // Machine-dependent implementation of ICBuffer                                                                                    
117   static void    assemble_ic_buffer_code(address code_begin, void* cached_value, address entry_point);                               
118   static address ic_buffer_entry_point  (address code_begin);                                                                        
119   static void*   ic_buffer_cached_value (address code_begin);                                                                        
120 
121  public:                                                                                                                             
122 
123     // Initialization; must be called before first usage                                                                             
124   static void initialize();                                                                                                          
125 
126   // Access                                                                                                                          
127   static bool contains(address instruction_address);                                                                                 
128 
129     // removes the ICStubs after backpatching                                                                                        
130   static void update_inline_caches();                                                                                                
131   static void refill_ic_stubs();                                                                                                     

82   friend ICStub* ICStub_from_destination_address(address destination_address);
83 };
84 
85 // ICStub Creation
86 inline ICStub* ICStub_from_destination_address(address destination_address) {
87   ICStub* stub = (ICStub*) (destination_address - align_up(sizeof(ICStub), CodeEntryAlignment));
88   #ifdef ASSERT
89   stub->verify();
90   #endif
91   return stub;
92 }
93 
94 class InlineCacheBuffer: public AllStatic {
95  private:
96   // friends
97   friend class ICStub;
98 
99   static int ic_stub_code_size();
100 
101   static StubQueue* _buffer;

102 
103   static CompiledICHolder* _pending_released;
104   static int _pending_count;
105 
106   static StubQueue* buffer()                         { return _buffer;         }





107 
108   static ICStub* new_ic_stub();
109 
110   // Machine-dependent implementation of ICBuffer
111   static void    assemble_ic_buffer_code(address code_begin, void* cached_value, address entry_point);
112   static address ic_buffer_entry_point  (address code_begin);
113   static void*   ic_buffer_cached_value (address code_begin);
114 
115  public:
116 
117     // Initialization; must be called before first usage
118   static void initialize();
119 
120   // Access
121   static bool contains(address instruction_address);
122 
123     // removes the ICStubs after backpatching
124   static void update_inline_caches();
125   static void refill_ic_stubs();
< prev index next >