257   static void     set_narrow_oop_base(address base) {

   258     assert(UseCompressedOops, "no compressed oops?");

   259     _narrow_oop._base    = base;

   260   }

   261   static void     set_narrow_klass_base(address base) {

   262     assert(UseCompressedKlassPointers, "no compressed klass ptrs?");

   263     _narrow_klass._base   = base;

   264   }

   265   static void     set_narrow_oop_use_implicit_null_checks(bool use) {

   266     assert(UseCompressedOops, "no compressed ptrs?");

   267     _narrow_oop._use_implicit_null_checks   = use;

   268   }

   269   static bool     reserve_metaspace_helper(bool with_base = false);

   270   static ReservedHeapSpace reserve_heap_metaspace(size_t heap_size, size_t alignment, bool& contiguous);

   271 

   272   static size_t  class_metaspace_size() {

   273     return _class_metaspace_size;

   274   }

   275   static void    set_class_metaspace_size(size_t metaspace_size) {

   276     _class_metaspace_size = metaspace_size;

   277   }

   278 

   279   // Debugging

   280   static int _verify_count;                           // number of verifies done

   281   // True during call to verify().  Should only be set/cleared in verify().

   282   static bool _verify_in_progress;

   283 

   284   static void compute_verify_oop_data();

   285 

   286  public:

   287   // Known classes in the VM

   288   static Klass* boolArrayKlassObj()                 { return _boolArrayKlassObj;   }

   289   static Klass* byteArrayKlassObj()                 { return _byteArrayKlassObj;   }

   290   static Klass* charArrayKlassObj()                 { return _charArrayKlassObj;   }

   291   static Klass* intArrayKlassObj()                  { return _intArrayKlassObj;    }

   292   static Klass* shortArrayKlassObj()                { return _shortArrayKlassObj;  }

   293   static Klass* longArrayKlassObj()                 { return _longArrayKlassObj;   }

   294   static Klass* singleArrayKlassObj()               { return _singleArrayKlassObj; }

   295   static Klass* doubleArrayKlassObj()               { return _doubleArrayKlassObj; }

   296 

   297   static Klass* objectArrayKlassObj() {

   298     return _objectArrayKlassObj;

   299   }

   300 

   301   static Klass* typeArrayKlassObj(BasicType t) {

   302     assert((uint)t < T_VOID+1, err_msg("range check for type: %s", type2name(t)));

   303     assert(_typeArrayKlassObjs[t] != NULL, "domain check");

   304     return _typeArrayKlassObjs[t];

   305   }

   306 

   307   // Known objects in the VM

   308   static oop int_mirror()                   { return check_mirror(_int_mirror); }

   309   static oop float_mirror()                 { return check_mirror(_float_mirror); }

   310   static oop double_mirror()                { return check_mirror(_double_mirror); }

   311   static oop byte_mirror()                  { return check_mirror(_byte_mirror); }

   312   static oop bool_mirror()                  { return check_mirror(_bool_mirror); }

   313   static oop char_mirror()                  { return check_mirror(_char_mirror); }

   314   static oop long_mirror()                  { return check_mirror(_long_mirror); }

   315   static oop short_mirror()                 { return check_mirror(_short_mirror); }

   316   static oop void_mirror()                  { return check_mirror(_void_mirror); }

   317 

   318   // table of same

   319   static oop _mirrors[T_VOID+1];

   320 

   321   static oop java_mirror(BasicType t) {

   322     assert((uint)t < T_VOID+1, "range check");

   323     return check_mirror(_mirrors[t]);

   324   }

   325   static oop      main_thread_group()                 { return _main_thread_group; }

   326   static void set_main_thread_group(oop group)        { _main_thread_group = group;}

   327 

   328   static oop      system_thread_group()               { return _system_thread_group; }

   329   static void set_system_thread_group(oop group)      { _system_thread_group = group;}

   330 

   331   static objArrayOop  the_empty_class_klass_array ()  { return _the_empty_class_klass_array;   }

   332   static Array<Klass*>* the_array_interfaces_array() { return _the_array_interfaces_array;   }

   333   static oop          the_null_string()               { return _the_null_string;               }

   334   static oop          the_min_jint_string()          { return _the_min_jint_string;          }

   335   static Method*      finalizer_register_method()     { return _finalizer_register_cache->get_Method(); }

   336   static Method*      loader_addClass_method()        { return _loader_addClass_cache->get_Method(); }

   337 

   338   static Method*      protection_domain_implies_method() { return _pd_implies_cache->get_Method(); }

   339   static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; }

   340 

   341   static oop          null_ptr_exception_instance()   { return _null_ptr_exception_instance;   }

   342   static oop          arithmetic_exception_instance() { return _arithmetic_exception_instance; }

   343   static oop          virtual_machine_error_instance() { return _virtual_machine_error_instance; }

   344   static oop          vm_exception()                  { return _vm_exception; }

   345 

   346   static Array<int>*       the_empty_int_array()    { return _the_empty_int_array; }

   347   static Array<u2>*        the_empty_short_array()  { return _the_empty_short_array; }

   348   static Array<Method*>* the_empty_method_array() { return _the_empty_method_array; }

   349   static Array<Klass*>*  the_empty_klass_array()  { return _the_empty_klass_array; }

   350 

   351   // OutOfMemoryError support. Returns an error with the required message. The returned error

   352   // may or may not have a backtrace. If error has a backtrace then the stack trace is already

   353   // filled in.

   354   static oop out_of_memory_error_java_heap()          { return gen_out_of_memory_error(_out_of_memory_error_java_heap);  }

   355   static oop out_of_memory_error_perm_gen()           { return gen_out_of_memory_error(_out_of_memory_error_perm_gen);   }

   356   static oop out_of_memory_error_array_size()         { return gen_out_of_memory_error(_out_of_memory_error_array_size); }

   357   static oop out_of_memory_error_gc_overhead_limit()  { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit);  }

   358 

   359   // Accessors needed for fast allocation

   360   static Klass** boolArrayKlassObj_addr()           { return &_boolArrayKlassObj;   }

   361   static Klass** byteArrayKlassObj_addr()           { return &_byteArrayKlassObj;   }

   362   static Klass** charArrayKlassObj_addr()           { return &_charArrayKlassObj;   }

   363   static Klass** intArrayKlassObj_addr()            { return &_intArrayKlassObj;    }

   364   static Klass** shortArrayKlassObj_addr()          { return &_shortArrayKlassObj;  }

   365   static Klass** longArrayKlassObj_addr()           { return &_longArrayKlassObj;   }

   366   static Klass** singleArrayKlassObj_addr()         { return &_singleArrayKlassObj; }

   367   static Klass** doubleArrayKlassObj_addr()         { return &_doubleArrayKlassObj; }

   368   static Klass** objectArrayKlassObj_addr()         { return &_objectArrayKlassObj; }

   369 

   370   // The particular choice of collected heap.

   371   static CollectedHeap* heap() { return _collectedHeap; }

   372 

   373   // For UseCompressedOops

   385   static NARROW_OOP_MODE narrow_oop_mode();

   386   static const char* narrow_oop_mode_to_string(NARROW_OOP_MODE mode);