jdk8-mips64-public/hotspot: src/share/vm/memory/universe.hpp@f95d63e2154a

6989984: Use standard include model for Hospot
Summary: Replaced MakeDeps and the includeDB files with more standardized solutions.
Reviewed-by: coleenp, kvn, kamg

     1 /*

     2  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    25 #ifndef SHARE_VM_MEMORY_UNIVERSE_HPP

    26 #define SHARE_VM_MEMORY_UNIVERSE_HPP

    28 #include "runtime/handles.hpp"

    29 #include "utilities/growableArray.hpp"

    31 // Universe is a name space holding known system classes and objects in the VM.

    32 //

    33 // Loaded classes are accessible through the SystemDictionary.

    34 //

    35 // The object heap is allocated and accessed through Universe, and various allocation

    36 // support is provided. Allocation by the interpreter and compiled code is done inline

    37 // and bails out to Scavenge::invoke_and_allocate.

    39 class CollectedHeap;

    40 class DeferredObjAllocEvent;

    43 // Common parts of a methodOop cache. This cache safely interacts with

    44 // the RedefineClasses API.

    45 //

    46 class CommonMethodOopCache : public CHeapObj {

    47   // We save the klassOop and the idnum of methodOop in order to get

    48   // the current cached methodOop.

    49  private:

    50   klassOop              _klass;

    51   int                   _method_idnum;

    53  public:

    54   CommonMethodOopCache()   { _klass = NULL; _method_idnum = -1; }

    55   ~CommonMethodOopCache()  { _klass = NULL; _method_idnum = -1; }

    57   void     init(klassOop k, methodOop m, TRAPS);

    58   klassOop klass() const         { return _klass; }

    59   int      method_idnum() const  { return _method_idnum; }

    61   // GC support

    62   void     oops_do(OopClosure* f)  { f->do_oop((oop*)&_klass); }

    63 };

    66 // A helper class for caching a methodOop when the user of the cache

    67 // cares about all versions of the methodOop.

    68 //

    69 class ActiveMethodOopsCache : public CommonMethodOopCache {

    70   // This subclass adds weak references to older versions of the

    71   // methodOop and a query method for a methodOop.

    73  private:

    74   // If the cached methodOop has not been redefined, then

    75   // _prev_methods will be NULL. If all of the previous

    76   // versions of the method have been collected, then

    77   // _prev_methods can have a length of zero.

    78   GrowableArray<jweak>* _prev_methods;

    80  public:

    81   ActiveMethodOopsCache()   { _prev_methods = NULL; }

    82   ~ActiveMethodOopsCache();

    84   void add_previous_version(const methodOop method);

    85   bool is_same_method(const methodOop method) const;

    86 };

    89 // A helper class for caching a methodOop when the user of the cache

    90 // only cares about the latest version of the methodOop.

    91 //

    92 class LatestMethodOopCache : public CommonMethodOopCache {

    93   // This subclass adds a getter method for the latest methodOop.

    95  public:

    96   methodOop get_methodOop();

    97 };

    99 // For UseCompressedOops.

   100 struct NarrowOopStruct {

   101   // Base address for oop-within-java-object materialization.

   102   // NULL if using wide oops or zero based narrow oops.

   103   address _base;

   104   // Number of shift bits for encoding/decoding narrow oops.

   105   // 0 if using wide oops or zero based unscaled narrow oops,

   106   // LogMinObjAlignmentInBytes otherwise.

   107   int     _shift;

   108   // Generate code with implicit null checks for narrow oops.

   109   bool    _use_implicit_null_checks;

   110 };

   113 class Universe: AllStatic {

   114   // Ugh.  Universe is much too friendly.

   115   friend class MarkSweep;

   116   friend class oopDesc;

   117   friend class ClassLoader;

   118   friend class Arguments;

   119   friend class SystemDictionary;

   120   friend class VMStructs;

   121   friend class CompactingPermGenGen;

   122   friend class VM_PopulateDumpSharedSpace;

   124   friend jint  universe_init();

   125   friend void  universe2_init();

   126   friend bool  universe_post_init();

   128  private:

   129   // Known classes in the VM

   130   static klassOop _boolArrayKlassObj;

   131   static klassOop _byteArrayKlassObj;

   132   static klassOop _charArrayKlassObj;

   133   static klassOop _intArrayKlassObj;

   134   static klassOop _shortArrayKlassObj;

   135   static klassOop _longArrayKlassObj;

   136   static klassOop _singleArrayKlassObj;

   137   static klassOop _doubleArrayKlassObj;

   138   static klassOop _typeArrayKlassObjs[T_VOID+1];

   140   static klassOop _objectArrayKlassObj;

   142   static klassOop _symbolKlassObj;

   143   static klassOop _methodKlassObj;

   144   static klassOop _constMethodKlassObj;

   145   static klassOop _methodDataKlassObj;

   146   static klassOop _klassKlassObj;

   147   static klassOop _arrayKlassKlassObj;

   148   static klassOop _objArrayKlassKlassObj;

   149   static klassOop _typeArrayKlassKlassObj;

   150   static klassOop _instanceKlassKlassObj;

   151   static klassOop _constantPoolKlassObj;

   152   static klassOop _constantPoolCacheKlassObj;

   153   static klassOop _compiledICHolderKlassObj;

   154   static klassOop _systemObjArrayKlassObj;

   156   // Known objects in the VM

   158   // Primitive objects

   159   static oop _int_mirror;

   160   static oop _float_mirror;

   161   static oop _double_mirror;

   162   static oop _byte_mirror;

   163   static oop _bool_mirror;

   164   static oop _char_mirror;

   165   static oop _long_mirror;

   166   static oop _short_mirror;

   167   static oop _void_mirror;

   169   static oop          _main_thread_group;             // Reference to the main thread group object

   170   static oop          _system_thread_group;           // Reference to the system thread group object

   172   static typeArrayOop _the_empty_byte_array;          // Canonicalized byte array

   173   static typeArrayOop _the_empty_short_array;         // Canonicalized short array

   174   static typeArrayOop _the_empty_int_array;           // Canonicalized int array

   175   static objArrayOop  _the_empty_system_obj_array;    // Canonicalized system obj array

   176   static objArrayOop  _the_empty_class_klass_array;   // Canonicalized obj array of type java.lang.Class

   177   static objArrayOop  _the_array_interfaces_array;    // Canonicalized 2-array of cloneable & serializable klasses

   178   static oop          _the_null_string;               // A cache of "null" as a Java string

   179   static oop          _the_min_jint_string;          // A cache of "-2147483648" as a Java string

   180   static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects

   181   static LatestMethodOopCache* _loader_addClass_cache;    // method for registering loaded classes in class loader vector

   182   static ActiveMethodOopsCache* _reflect_invoke_cache;    // method for security checks

   183   static oop          _out_of_memory_error_java_heap; // preallocated error object (no backtrace)

   184   static oop          _out_of_memory_error_perm_gen;  // preallocated error object (no backtrace)

   185   static oop          _out_of_memory_error_array_size;// preallocated error object (no backtrace)

   186   static oop          _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace)

   188   // array of preallocated error objects with backtrace

   189   static objArrayOop   _preallocated_out_of_memory_error_array;

   191   // number of preallocated error objects available for use

   192   static volatile jint _preallocated_out_of_memory_error_avail_count;

   194   static oop          _null_ptr_exception_instance;   // preallocated exception object

   195   static oop          _arithmetic_exception_instance; // preallocated exception object

   196   static oop          _virtual_machine_error_instance; // preallocated exception object

   197   // The object used as an exception dummy when exceptions are thrown for

   198   // the vm thread.

   199   static oop          _vm_exception;

   201   static oop          _emptySymbol;                   // Canonical empty string ("") symbol

   203   // The particular choice of collected heap.

   204   static CollectedHeap* _collectedHeap;

   206   // For UseCompressedOops.

   207   static struct NarrowOopStruct _narrow_oop;

   209   // array of dummy objects used with +FullGCAlot

   210   debug_only(static objArrayOop _fullgc_alot_dummy_array;)

   211   // index of next entry to clear

   212   debug_only(static int         _fullgc_alot_dummy_next;)

   214   // Compiler/dispatch support

   215   static int  _base_vtable_size;                      // Java vtbl size of klass Object (in words)

   217   // Initialization

   218   static bool _bootstrapping;                         // true during genesis

   219   static bool _fully_initialized;                     // true after universe_init and initialize_vtables called

   221   // the array of preallocated errors with backtraces

   222   static objArrayOop  preallocated_out_of_memory_errors()     { return _preallocated_out_of_memory_error_array; }

   224   // generate an out of memory error; if possible using an error with preallocated backtrace;

   225   // otherwise return the given default error.

   226   static oop        gen_out_of_memory_error(oop default_err);

   228   // Historic gc information

   229   static size_t _heap_capacity_at_last_gc;

   230   static size_t _heap_used_at_last_gc;

   232   static jint initialize_heap();

   233   static void initialize_basic_type_mirrors(TRAPS);

   234   static void fixup_mirrors(TRAPS);

   236   static void reinitialize_vtable_of(KlassHandle h_k, TRAPS);

   237   static void reinitialize_itables(TRAPS);

   238   static void compute_base_vtable_size();             // compute vtable size of class Object

   240   static void genesis(TRAPS);                         // Create the initial world

   242   // Mirrors for primitive classes (created eagerly)

   243   static oop check_mirror(oop m) {

   244     assert(m != NULL, "mirror not initialized");

   245     return m;

   246   }

   248   // Debugging

   249   static int _verify_count;                           // number of verifies done

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

   251   static bool _verify_in_progress;

   253   static void compute_verify_oop_data();

   255  public:

   256   // Known classes in the VM

   257   static klassOop boolArrayKlassObj()                 { return _boolArrayKlassObj;   }

   258   static klassOop byteArrayKlassObj()                 { return _byteArrayKlassObj;   }

   259   static klassOop charArrayKlassObj()                 { return _charArrayKlassObj;   }

   260   static klassOop intArrayKlassObj()                  { return _intArrayKlassObj;    }

   261   static klassOop shortArrayKlassObj()                { return _shortArrayKlassObj;  }

   262   static klassOop longArrayKlassObj()                 { return _longArrayKlassObj;   }

   263   static klassOop singleArrayKlassObj()               { return _singleArrayKlassObj; }

   264   static klassOop doubleArrayKlassObj()               { return _doubleArrayKlassObj; }

   266   static klassOop objectArrayKlassObj() {

   267     return _objectArrayKlassObj;

   268   }

   270   static klassOop typeArrayKlassObj(BasicType t) {

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

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

   273     return _typeArrayKlassObjs[t];

   274   }

   276   static klassOop symbolKlassObj()                    { return _symbolKlassObj;            }

   277   static klassOop methodKlassObj()                    { return _methodKlassObj;            }

   278   static klassOop constMethodKlassObj()               { return _constMethodKlassObj;         }

   279   static klassOop methodDataKlassObj()                { return _methodDataKlassObj;        }

   280   static klassOop klassKlassObj()                     { return _klassKlassObj;             }

   281   static klassOop arrayKlassKlassObj()                { return _arrayKlassKlassObj;        }

   282   static klassOop objArrayKlassKlassObj()             { return _objArrayKlassKlassObj;     }

   283   static klassOop typeArrayKlassKlassObj()            { return _typeArrayKlassKlassObj;    }

   284   static klassOop instanceKlassKlassObj()             { return _instanceKlassKlassObj;     }

   285   static klassOop constantPoolKlassObj()              { return _constantPoolKlassObj;      }

   286   static klassOop constantPoolCacheKlassObj()         { return _constantPoolCacheKlassObj; }

   287   static klassOop compiledICHolderKlassObj()          { return _compiledICHolderKlassObj;  }

   288   static klassOop systemObjArrayKlassObj()            { return _systemObjArrayKlassObj;    }

   290   // Known objects in tbe VM

   291   static oop int_mirror()                   { return check_mirror(_int_mirror);

   292 }

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

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

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

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

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

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

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

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

   302   // table of same

   303   static oop _mirrors[T_VOID+1];

   305   static oop java_mirror(BasicType t) {

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

   307     return check_mirror(_mirrors[t]);

   308   }

   309   static oop      main_thread_group()                 { return _main_thread_group; }

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

   312   static oop      system_thread_group()               { return _system_thread_group; }

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

   315   static typeArrayOop the_empty_byte_array()          { return _the_empty_byte_array;          }

   316   static typeArrayOop the_empty_short_array()         { return _the_empty_short_array;         }

   317   static typeArrayOop the_empty_int_array()           { return _the_empty_int_array;           }

   318   static objArrayOop  the_empty_system_obj_array ()   { return _the_empty_system_obj_array;    }

   319   static objArrayOop  the_empty_class_klass_array ()  { return _the_empty_class_klass_array;   }

   320   static objArrayOop  the_array_interfaces_array()    { return _the_array_interfaces_array;    }

   321   static oop          the_null_string()               { return _the_null_string;               }

   322   static oop          the_min_jint_string()          { return _the_min_jint_string;          }

   323   static methodOop    finalizer_register_method()     { return _finalizer_register_cache->get_methodOop(); }

   324   static methodOop    loader_addClass_method()        { return _loader_addClass_cache->get_methodOop(); }

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

   326   static oop          null_ptr_exception_instance()   { return _null_ptr_exception_instance;   }

   327   static oop          arithmetic_exception_instance() { return _arithmetic_exception_instance; }

   328   static oop          virtual_machine_error_instance() { return _virtual_machine_error_instance; }

   329   static oop          vm_exception()                  { return _vm_exception; }

   330   static oop          emptySymbol()                   { return _emptySymbol; }

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

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

   334   // filled in.

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

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

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

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

   340   // Accessors needed for fast allocation

   341   static klassOop* boolArrayKlassObj_addr()           { return &_boolArrayKlassObj;   }

   342   static klassOop* byteArrayKlassObj_addr()           { return &_byteArrayKlassObj;   }

   343   static klassOop* charArrayKlassObj_addr()           { return &_charArrayKlassObj;   }

   344   static klassOop* intArrayKlassObj_addr()            { return &_intArrayKlassObj;    }

   345   static klassOop* shortArrayKlassObj_addr()          { return &_shortArrayKlassObj;  }

   346   static klassOop* longArrayKlassObj_addr()           { return &_longArrayKlassObj;   }

   347   static klassOop* singleArrayKlassObj_addr()         { return &_singleArrayKlassObj; }

   348   static klassOop* doubleArrayKlassObj_addr()         { return &_doubleArrayKlassObj; }

   349   static klassOop* systemObjArrayKlassObj_addr()      { return &_systemObjArrayKlassObj; }

   351   // The particular choice of collected heap.

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

   354   // For UseCompressedOops

   355   static address* narrow_oop_base_addr()              { return &_narrow_oop._base; }

   356   static address  narrow_oop_base()                   { return  _narrow_oop._base; }

   357   static bool  is_narrow_oop_base(void* addr)         { return (narrow_oop_base() == (address)addr); }

   358   static int      narrow_oop_shift()                  { return  _narrow_oop._shift; }

   359   static void     set_narrow_oop_base(address base)   { _narrow_oop._base  = base; }

   360   static void     set_narrow_oop_shift(int shift)     { _narrow_oop._shift = shift; }

   361   static bool     narrow_oop_use_implicit_null_checks()             { return  _narrow_oop._use_implicit_null_checks; }

   362   static void     set_narrow_oop_use_implicit_null_checks(bool use) { _narrow_oop._use_implicit_null_checks = use; }

   363   // Narrow Oop encoding mode:

   364   // 0 - Use 32-bits oops without encoding when

   365   //     NarrowOopHeapBaseMin + heap_size < 4Gb

   366   // 1 - Use zero based compressed oops with encoding when

   367   //     NarrowOopHeapBaseMin + heap_size < 32Gb

   368   // 2 - Use compressed oops with heap base + encoding.

   369   enum NARROW_OOP_MODE {

   370     UnscaledNarrowOop  = 0,

   371     ZeroBasedNarrowOop = 1,

   372     HeapBasedNarrowOop = 2

   373   };

   374   static char* preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode);

   376   // Historic gc information

   377   static size_t get_heap_capacity_at_last_gc()         { return _heap_capacity_at_last_gc; }

   378   static size_t get_heap_free_at_last_gc()             { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; }

   379   static size_t get_heap_used_at_last_gc()             { return _heap_used_at_last_gc; }

   380   static void update_heap_info_at_gc();

   382   // Testers

   383   static bool is_bootstrapping()                      { return _bootstrapping; }

   384   static bool is_fully_initialized()                  { return _fully_initialized; }

   386   static inline bool element_type_should_be_aligned(BasicType type);

   387   static inline bool field_type_should_be_aligned(BasicType type);

   388   static bool        on_page_boundary(void* addr);

   389   static bool        should_fill_in_stack_trace(Handle throwable);

   390   static void check_alignment(uintx size, uintx alignment, const char* name);

   392   // Finalizer support.

   393   static void run_finalizers_on_exit();

   395   // Iteration

   397   // Apply "f" to the addresses of all the direct heap pointers maintained

   398   // as static fields of "Universe".

   399   static void oops_do(OopClosure* f, bool do_all = false);

   401   // Apply "f" to all klasses for basic types (classes not present in

   402   // SystemDictionary).

   403   static void basic_type_classes_do(void f(klassOop));

   405   // Apply "f" to all system klasses (classes not present in SystemDictionary).

   406   static void system_classes_do(void f(klassOop));

   408   // For sharing -- fill in a list of known vtable pointers.

   409   static void init_self_patching_vtbl_list(void** list, int count);

   411   // Debugging

   412   static bool verify_in_progress() { return _verify_in_progress; }

   413   static void verify(bool allow_dirty = true, bool silent = false, bool option = true);

   414   static int  verify_count()                  { return _verify_count; }

   415   static void print();

   416   static void print_on(outputStream* st);

   417   static void print_heap_at_SIGBREAK();

   418   static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); }

   419   static void print_heap_after_gc()  { print_heap_after_gc(gclog_or_tty); }

   420   static void print_heap_before_gc(outputStream* st);

   421   static void print_heap_after_gc(outputStream* st);

   423   // Change the number of dummy objects kept reachable by the full gc dummy

   424   // array; this should trigger relocation in a sliding compaction collector.

   425   debug_only(static bool release_fullgc_alot_dummy();)

   426   // The non-oop pattern (see compiledIC.hpp, etc)

   427   static void*   non_oop_word();

   429   // Oop verification (see MacroAssembler::verify_oop)

   430   static uintptr_t verify_oop_mask()          PRODUCT_RETURN0;

   431   static uintptr_t verify_oop_bits()          PRODUCT_RETURN0;

   432   static uintptr_t verify_mark_bits()         PRODUCT_RETURN0;

   433   static uintptr_t verify_mark_mask()         PRODUCT_RETURN0;

   434   static uintptr_t verify_klass_mask()        PRODUCT_RETURN0;

   435   static uintptr_t verify_klass_bits()        PRODUCT_RETURN0;

   437   // Flushing and deoptimization

   438   static void flush_dependents_on(instanceKlassHandle dependee);

   439 #ifdef HOTSWAP

   440   // Flushing and deoptimization in case of evolution

   441   static void flush_evol_dependents_on(instanceKlassHandle dependee);

   442 #endif // HOTSWAP

   443   // Support for fullspeed debugging

   444   static void flush_dependents_on_method(methodHandle dependee);

   446   // Compiler support

   447   static int base_vtable_size()               { return _base_vtable_size; }

   448 };

   450 class DeferredObjAllocEvent : public CHeapObj {

   451   private:

   452     oop    _oop;

   453     size_t _bytesize;

   454     jint   _arena_id;

   456   public:

   457     DeferredObjAllocEvent(const oop o, const size_t s, const jint id) {

   458       _oop      = o;

   459       _bytesize = s;

   460       _arena_id = id;

   461     }

   463     ~DeferredObjAllocEvent() {

   464     }

   466     jint   arena_id() { return _arena_id; }

   467     size_t bytesize() { return _bytesize; }

   468     oop    get_oop()  { return _oop; }

   469 };

   471 #endif // SHARE_VM_MEMORY_UNIVERSE_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/memory/universe.hpp@f95d63e2154a

src/share/vm/memory/universe.hpp