1 /*
2 * Copyright (c) 2001, 2019, 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_GC_SHARED_GENOOPCLOSURES_HPP
26 #define SHARE_GC_SHARED_GENOOPCLOSURES_HPP
27
28 #include "memory/iterator.hpp"
29 #include "oops/oop.hpp"
30
31 class Generation;
32 class CardTableRS;
33 class CardTableBarrierSet;
34 class DefNewGeneration;
35 class KlassRemSet;
36
37 // Closure for iterating roots from a particular generation
38 // Note: all classes deriving from this MUST call this do_barrier
39 // method at the end of their own do_oop method!
40 // Note: no do_oop defined, this is an abstract class.
41
42 class OopsInGenClosure : public OopIterateClosure {
43 private:
44 Generation* _orig_gen; // generation originally set in ctor
45 Generation* _gen; // generation being scanned
46
47 protected:
48 // Some subtypes need access.
49 HeapWord* _gen_boundary; // start of generation
50 CardTableRS* _rs; // remembered set
51
52 // For assertions
53 Generation* generation() { return _gen; }
54 CardTableRS* rs() { return _rs; }
55
56 // Derived classes that modify oops so that they might be old-to-young
57 // pointers must call the method below.
58 template <class T> void do_barrier(T* p);
59
60 public:
61 OopsInGenClosure() : OopIterateClosure(NULL),
62 _orig_gen(NULL), _gen(NULL), _gen_boundary(NULL), _rs(NULL) {};
63
64 OopsInGenClosure(Generation* gen);
65 void set_generation(Generation* gen);
66
67 void reset_generation() { _gen = _orig_gen; }
68
69 // Problem with static closures: must have _gen_boundary set at some point,
70 // but cannot do this until after the heap is initialized.
71 void set_orig_generation(Generation* gen) {
72 _orig_gen = gen;
73 set_generation(gen);
74 }
75
76 HeapWord* gen_boundary() { return _gen_boundary; }
77
78 };
79
80 class BasicOopsInGenClosure: public OopsInGenClosure {
81 public:
82 BasicOopsInGenClosure() : OopsInGenClosure() {}
83 BasicOopsInGenClosure(Generation* gen);
84
85 virtual bool do_metadata() { return false; }
86 virtual void do_klass(Klass* k) { ShouldNotReachHere(); }
87 virtual void do_cld(ClassLoaderData* cld) { ShouldNotReachHere(); }
88 };
89
90 // Super class for scan closures. It contains code to dirty scanned class loader data.
91 class OopsInClassLoaderDataOrGenClosure: public BasicOopsInGenClosure {
92 ClassLoaderData* _scanned_cld;
93 public:
94 OopsInClassLoaderDataOrGenClosure(Generation* g) : BasicOopsInGenClosure(g), _scanned_cld(NULL) {}
95 void set_scanned_cld(ClassLoaderData* cld) {
96 assert(cld == NULL || _scanned_cld == NULL, "Must be");
97 _scanned_cld = cld;
98 }
99 bool is_scanning_a_cld() { return _scanned_cld != NULL; }
100 void do_cld_barrier();
101 };
102
103 #if INCLUDE_SERIALGC
104
105 // Closure for scanning DefNewGeneration.
106 //
107 // This closure will perform barrier store calls for ALL
108 // pointers in scanned oops.
109 class ScanClosure: public OopsInClassLoaderDataOrGenClosure {
110 private:
111 DefNewGeneration* _g;
112 HeapWord* _boundary;
113 bool _gc_barrier;
114 template <class T> inline void do_oop_work(T* p);
115 public:
116 ScanClosure(DefNewGeneration* g, bool gc_barrier);
117 virtual void do_oop(oop* p);
118 virtual void do_oop(narrowOop* p);
119 };
120
121 // Closure for scanning DefNewGeneration.
122 //
123 // This closure only performs barrier store calls on
124 // pointers into the DefNewGeneration. This is less
125 // precise, but faster, than a ScanClosure
126 class FastScanClosure: public OopsInClassLoaderDataOrGenClosure {
127 protected:
128 DefNewGeneration* _g;
129 HeapWord* _boundary;
130 bool _gc_barrier;
131 template <class T> inline void do_oop_work(T* p);
132 public:
133 FastScanClosure(DefNewGeneration* g, bool gc_barrier);
134 virtual void do_oop(oop* p);
135 virtual void do_oop(narrowOop* p);
136 };
137
138 #endif // INCLUDE_SERIALGC
139
140 class CLDScanClosure: public CLDClosure {
141 OopsInClassLoaderDataOrGenClosure* _scavenge_closure;
142 // true if the the modified oops state should be saved.
143 bool _accumulate_modified_oops;
144 public:
145 CLDScanClosure(OopsInClassLoaderDataOrGenClosure* scavenge_closure,
146 bool accumulate_modified_oops) :
147 _scavenge_closure(scavenge_closure), _accumulate_modified_oops(accumulate_modified_oops) {}
148 void do_cld(ClassLoaderData* cld);
149 };
150
151 class FilteringClosure: public OopIterateClosure {
152 private:
153 HeapWord* _boundary;
154 OopIterateClosure* _cl;
155 protected:
156 template <class T> inline void do_oop_work(T* p);
157 public:
158 FilteringClosure(HeapWord* boundary, OopIterateClosure* cl) :
159 OopIterateClosure(cl->ref_discoverer()), _boundary(boundary),
160 _cl(cl) {}
161 virtual void do_oop(oop* p);
162 virtual void do_oop(narrowOop* p);
163 virtual bool do_metadata() { assert(!_cl->do_metadata(), "assumption broken, must change to 'return _cl->do_metadata()'"); return false; }
164 virtual void do_klass(Klass*) { ShouldNotReachHere(); }
165 virtual void do_cld(ClassLoaderData*) { ShouldNotReachHere(); }
166 };
167
168 #if INCLUDE_SERIALGC
169
170 // Closure for scanning DefNewGeneration's weak references.
171 // NOTE: very much like ScanClosure but not derived from
172 // OopsInGenClosure -- weak references are processed all
173 // at once, with no notion of which generation they were in.
174 class ScanWeakRefClosure: public OopClosure {
175 protected:
176 DefNewGeneration* _g;
177 HeapWord* _boundary;
178 template <class T> inline void do_oop_work(T* p);
179 public:
180 ScanWeakRefClosure(DefNewGeneration* g);
181 virtual void do_oop(oop* p);
182 virtual void do_oop(narrowOop* p);
183 };
184
185 #endif // INCLUDE_SERIALGC
186
187 #endif // SHARE_GC_SHARED_GENOOPCLOSURES_HPP