< prev index next >

src/hotspot/share/memory/universe.hpp

Print this page

 99   static uintx _the_empty_klass_bitmap;
100 
101   // array of preallocated error objects with backtrace
102   static OopHandle     _preallocated_out_of_memory_error_array;
103 
104   // number of preallocated error objects available for use
105   static volatile jint _preallocated_out_of_memory_error_avail_count;
106 
107   // preallocated message detail strings for error objects
108   static OopHandle _msg_metaspace;
109   static OopHandle _msg_class_metaspace;
110 
111   // References waiting to be transferred to the ReferenceHandler
112   static OopHandle    _reference_pending_list;
113 
114   // The particular choice of collected heap.
115   static CollectedHeap* _collectedHeap;
116 
117   static intptr_t _non_oop_bits;
118 

119   // array of dummy objects used with +FullGCAlot
120   DEBUG_ONLY(static OopHandle   _fullgc_alot_dummy_array;)
121   DEBUG_ONLY(static int         _fullgc_alot_dummy_next;)
122 
123   // Compiler/dispatch support
124   static int  _base_vtable_size;                      // Java vtbl size of klass Object (in words)
125 
126   // Initialization
127   static bool _bootstrapping;                         // true during genesis
128   static bool _module_initialized;                    // true after call_initPhase2 called
129   static bool _fully_initialized;                     // true after universe_init and initialize_vtables called
130 
131   // the array of preallocated errors with backtraces
132   static objArrayOop  preallocated_out_of_memory_errors();
133 
134   static objArrayOop out_of_memory_errors();
135   // generate an out of memory error; if possible using an error with preallocated backtrace;
136   // otherwise return the given default error.
137   static oop        gen_out_of_memory_error(oop default_err);
138 

235   static oop          the_null_string();
236   static oop          the_min_jint_string();
237 
238   static oop          null_ptr_exception_instance();
239   static oop          arithmetic_exception_instance();
240   static oop          internal_error_instance();
241   static oop          array_index_out_of_bounds_exception_instance();
242   static oop          array_store_exception_instance();
243   static oop          class_cast_exception_instance();
244   static oop          vm_exception()                  { return internal_error_instance(); }
245 
246   static Array<Klass*>* the_array_interfaces_array()  { return _the_array_interfaces_array; }
247   static uintx        the_array_interfaces_bitmap()   { return _the_array_interfaces_bitmap; }
248 
249   static Method*      finalizer_register_method();
250   static Method*      loader_addClass_method();
251   static Method*      throw_illegal_access_error();
252   static Method*      throw_no_such_method_error();
253   static Method*      do_stack_walk_method();
254 



255   static oop          the_null_sentinel();
256   static address      the_null_sentinel_addr()        { return (address) &_the_null_sentinel;  }
257 
258   // Function to initialize these
259   static void initialize_known_methods(JavaThread* current);
260 
261   static void create_preallocated_out_of_memory_errors(TRAPS);
262 
263   // Reference pending list manipulation.  Access is protected by
264   // Heap_lock.  The getter, setter and predicate require the caller
265   // owns the lock.  Swap is used by parallel non-concurrent reference
266   // processing threads, where some higher level controller owns
267   // Heap_lock, so requires the lock is locked, but not necessarily by
268   // the current thread.
269   static oop          reference_pending_list();
270   static void         clear_reference_pending_list();
271   static bool         has_reference_pending_list();
272   static oop          swap_reference_pending_list(oop list);
273 
274   static Array<int>*             the_empty_int_array()    { return _the_empty_int_array; }

 99   static uintx _the_empty_klass_bitmap;
100 
101   // array of preallocated error objects with backtrace
102   static OopHandle     _preallocated_out_of_memory_error_array;
103 
104   // number of preallocated error objects available for use
105   static volatile jint _preallocated_out_of_memory_error_avail_count;
106 
107   // preallocated message detail strings for error objects
108   static OopHandle _msg_metaspace;
109   static OopHandle _msg_class_metaspace;
110 
111   // References waiting to be transferred to the ReferenceHandler
112   static OopHandle    _reference_pending_list;
113 
114   // The particular choice of collected heap.
115   static CollectedHeap* _collectedHeap;
116 
117   static intptr_t _non_oop_bits;
118 
119 
120   // array of dummy objects used with +FullGCAlot
121   DEBUG_ONLY(static OopHandle   _fullgc_alot_dummy_array;)
122   DEBUG_ONLY(static int         _fullgc_alot_dummy_next;)
123 
124   // Compiler/dispatch support
125   static int  _base_vtable_size;                      // Java vtbl size of klass Object (in words)
126 
127   // Initialization
128   static bool _bootstrapping;                         // true during genesis
129   static bool _module_initialized;                    // true after call_initPhase2 called
130   static bool _fully_initialized;                     // true after universe_init and initialize_vtables called
131 
132   // the array of preallocated errors with backtraces
133   static objArrayOop  preallocated_out_of_memory_errors();
134 
135   static objArrayOop out_of_memory_errors();
136   // generate an out of memory error; if possible using an error with preallocated backtrace;
137   // otherwise return the given default error.
138   static oop        gen_out_of_memory_error(oop default_err);
139 

236   static oop          the_null_string();
237   static oop          the_min_jint_string();
238 
239   static oop          null_ptr_exception_instance();
240   static oop          arithmetic_exception_instance();
241   static oop          internal_error_instance();
242   static oop          array_index_out_of_bounds_exception_instance();
243   static oop          array_store_exception_instance();
244   static oop          class_cast_exception_instance();
245   static oop          vm_exception()                  { return internal_error_instance(); }
246 
247   static Array<Klass*>* the_array_interfaces_array()  { return _the_array_interfaces_array; }
248   static uintx        the_array_interfaces_bitmap()   { return _the_array_interfaces_bitmap; }
249 
250   static Method*      finalizer_register_method();
251   static Method*      loader_addClass_method();
252   static Method*      throw_illegal_access_error();
253   static Method*      throw_no_such_method_error();
254   static Method*      do_stack_walk_method();
255 
256   static Method*      is_substitutable_method();
257   static Method*      value_object_hash_code_method();
258 
259   static oop          the_null_sentinel();
260   static address      the_null_sentinel_addr()        { return (address) &_the_null_sentinel;  }
261 
262   // Function to initialize these
263   static void initialize_known_methods(JavaThread* current);
264 
265   static void create_preallocated_out_of_memory_errors(TRAPS);
266 
267   // Reference pending list manipulation.  Access is protected by
268   // Heap_lock.  The getter, setter and predicate require the caller
269   // owns the lock.  Swap is used by parallel non-concurrent reference
270   // processing threads, where some higher level controller owns
271   // Heap_lock, so requires the lock is locked, but not necessarily by
272   // the current thread.
273   static oop          reference_pending_list();
274   static void         clear_reference_pending_list();
275   static bool         has_reference_pending_list();
276   static oop          swap_reference_pending_list(oop list);
277 
278   static Array<int>*             the_empty_int_array()    { return _the_empty_int_array; }
< prev index next >