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