1 /*

     2  * Copyright (c) 2001, 2016, 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  */

    24 

    25 #ifndef SHARE_VM_GC_SHARED_GENOOPCLOSURES_HPP

    26 #define SHARE_VM_GC_SHARED_GENOOPCLOSURES_HPP

    27 

    28 #include "memory/iterator.hpp"

    29 #include "oops/oop.hpp"

    30 

    31 class Generation;

    32 class HeapWord;

    33 class CardTableRS;

    34 class CardTableModRefBS;

    35 class DefNewGeneration;

    36 class KlassRemSet;

    37 

    38 // Closure for iterating roots from a particular generation

    39 // Note: all classes deriving from this MUST call this do_barrier

    40 // method at the end of their own do_oop method!

    41 // Note: no do_oop defined, this is an abstract class.

    42 

    43 class OopsInGenClosure : public ExtendedOopClosure {

    44  private:

    45   Generation*  _orig_gen;     // generation originally set in ctor

    46   Generation*  _gen;          // generation being scanned

    47 

    48  protected:

    49   // Some subtypes need access.

    50   HeapWord*    _gen_boundary; // start of generation

    51   CardTableRS* _rs;           // remembered set

    52 

    53   // For assertions

    54   Generation* generation() { return _gen; }

    55   CardTableRS* rs() { return _rs; }

    56 

    57   // Derived classes that modify oops so that they might be old-to-young

    58   // pointers must call the method below.

    59   template <class T> void do_barrier(T* p);

    60 

    61   // Version for use by closures that may be called in parallel code.

    62   template <class T> void par_do_barrier(T* p);

    63 

    64  public:

    65   OopsInGenClosure() : ExtendedOopClosure(NULL),

    66     _orig_gen(NULL), _gen(NULL), _gen_boundary(NULL), _rs(NULL) {};

    67 

    68   OopsInGenClosure(Generation* gen);

    69   void set_generation(Generation* gen);

    70 

    71   void reset_generation() { _gen = _orig_gen; }

    72 

    73   // Problem with static closures: must have _gen_boundary set at some point,

    74   // but cannot do this until after the heap is initialized.

    75   void set_orig_generation(Generation* gen) {

    76     _orig_gen = gen;

    77     set_generation(gen);

    78   }

    79 

    80   HeapWord* gen_boundary() { return _gen_boundary; }

    81 

    82 };

    83 

    84 // Super class for scan closures. It contains code to dirty scanned Klasses.

    85 class OopsInKlassOrGenClosure: public OopsInGenClosure {

    86   Klass* _scanned_klass;

    87  public:

    88   OopsInKlassOrGenClosure(Generation* g) : OopsInGenClosure(g), _scanned_klass(NULL) {}

    89   void set_scanned_klass(Klass* k) {

    90     assert(k == NULL || _scanned_klass == NULL, "Must be");

    91     _scanned_klass = k;

    92   }

    93   bool is_scanning_a_klass() { return _scanned_klass != NULL; }

    94   void do_klass_barrier();

    95 };

    96 

    97 // Closure for scanning DefNewGeneration.

    98 //

    99 // This closure will perform barrier store calls for ALL

   100 // pointers in scanned oops.

   101 class ScanClosure: public OopsInKlassOrGenClosure {

   102  protected:

   103   DefNewGeneration* _g;

   104   HeapWord*         _boundary;

   105   bool              _gc_barrier;

   106   template <class T> inline void do_oop_work(T* p);

   107  public:

   108   ScanClosure(DefNewGeneration* g, bool gc_barrier);

   109   virtual void do_oop(oop* p);

   110   virtual void do_oop(narrowOop* p);

   111   inline void do_oop_nv(oop* p);

   112   inline void do_oop_nv(narrowOop* p);

   113 };

   114 

   115 // Closure for scanning DefNewGeneration.

   116 //

   117 // This closure only performs barrier store calls on

   118 // pointers into the DefNewGeneration. This is less

   119 // precise, but faster, than a ScanClosure

   120 class FastScanClosure: public OopsInKlassOrGenClosure {

   121  protected:

   122   DefNewGeneration* _g;

   123   HeapWord*         _boundary;

   124   bool              _gc_barrier;

   125   template <class T> inline void do_oop_work(T* p);

   126  public:

   127   FastScanClosure(DefNewGeneration* g, bool gc_barrier);

   128   virtual void do_oop(oop* p);

   129   virtual void do_oop(narrowOop* p);

   130   inline void do_oop_nv(oop* p);

   131   inline void do_oop_nv(narrowOop* p);

   132 };

   133 

   134 class KlassScanClosure: public KlassClosure {

   135   OopsInKlassOrGenClosure* _scavenge_closure;

   136   // true if the the modified oops state should be saved.

   137   bool                     _accumulate_modified_oops;

   138  public:

   139   KlassScanClosure(OopsInKlassOrGenClosure* scavenge_closure,

   140                    KlassRemSet* klass_rem_set_policy);

   141   void do_klass(Klass* k);

   142 };

   143 

   144 class FilteringClosure: public ExtendedOopClosure {

   145  private:

   146   HeapWord*   _boundary;

   147   ExtendedOopClosure* _cl;

   148  protected:

   149   template <class T> inline void do_oop_work(T* p);

   150  public:

   151   FilteringClosure(HeapWord* boundary, ExtendedOopClosure* cl) :

   152     ExtendedOopClosure(cl->ref_processor()), _boundary(boundary),

   153     _cl(cl) {}

   154   virtual void do_oop(oop* p);

   155   virtual void do_oop(narrowOop* p);

   156   inline void do_oop_nv(oop* p);

   157   inline void do_oop_nv(narrowOop* p);

   158   virtual bool do_metadata()          { return do_metadata_nv(); }

   159   inline bool do_metadata_nv()        { assert(!_cl->do_metadata(), "assumption broken, must change to 'return _cl->do_metadata()'"); return false; }

   160 };

   161 

   162 // Closure for scanning DefNewGeneration's weak references.

   163 // NOTE: very much like ScanClosure but not derived from

   164 //  OopsInGenClosure -- weak references are processed all

   165 //  at once, with no notion of which generation they were in.

   166 class ScanWeakRefClosure: public OopClosure {

   167  protected:

   168   DefNewGeneration* _g;

   169   HeapWord*         _boundary;

   170   template <class T> inline void do_oop_work(T* p);

   171  public:

   172   ScanWeakRefClosure(DefNewGeneration* g);

   173   virtual void do_oop(oop* p);

   174   virtual void do_oop(narrowOop* p);

   175   inline void do_oop_nv(oop* p);

   176   inline void do_oop_nv(narrowOop* p);

   177 };

   178 

   179 #endif // SHARE_VM_GC_SHARED_GENOOPCLOSURES_HPP