Mercurial > hg > graal-compiler
annotate src/share/vm/gc_implementation/g1/g1OopClosures.hpp @ 17833:bfdf528be8e8
8038498: Fix includes and C inlining after 8035330
Summary: Change 8035330: Remove G1ParScanPartialArrayClosure and G1ParScanHeapEvacClosure broke the debug build on AIX. The method do_oop_partial_array() is added in a header, but requires the inline function par_write_ref() through several inlined calls. In some cpp files, like arguments.cpp, par_write_ref() is not defined as the corresponding inline header and is not included. The AIX debug VM does not start because of the missing symbol. This change solves this by cleaning up include dependencies.
Reviewed-by: tschatzl, stefank
author | tschatzl |
---|---|
date | Fri, 04 Apr 2014 10:43:56 +0200 |
parents | bc22cbb8b45a |
children | 8847586c9037 |
rev | line source |
---|---|
342 | 1 /* |
17650
5a9a209853bf
6991197: G1: specialize deal_with_reference() for narrowOop*
tschatzl
parents:
17636
diff
changeset
|
2 * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. |
342 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1261
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1261
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1261
diff
changeset
|
21 * questions. |
342 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP |
26 #define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP | |
27 | |
342 | 28 class HeapRegion; |
29 class G1CollectedHeap; | |
30 class G1RemSet; | |
31 class ConcurrentMark; | |
32 class DirtyCardToOopClosure; | |
33 class CMBitMap; | |
34 class CMMarkStack; | |
35 class G1ParScanThreadState; | |
3771 | 36 class CMTask; |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
37 class ReferenceProcessor; |
342 | 38 |
39 // A class that scans oops in a given heap region (much as OopsInGenClosure | |
40 // scans oops in a generation.) | |
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
12316
diff
changeset
|
41 class OopsInHeapRegionClosure: public ExtendedOopClosure { |
342 | 42 protected: |
43 HeapRegion* _from; | |
44 public: | |
3765
ae5b2f1dcf12
7045662: G1: OopsInHeapRegionClosure::set_region() should not be virtual
tonyp
parents:
1972
diff
changeset
|
45 void set_region(HeapRegion* from) { _from = from; } |
342 | 46 }; |
47 | |
48 class G1ParClosureSuper : public OopsInHeapRegionClosure { | |
49 protected: | |
50 G1CollectedHeap* _g1; | |
51 G1ParScanThreadState* _par_scan_state; | |
4836
d30fa85f9994
6484965: G1: piggy-back liveness accounting phase on marking
johnc
parents:
4787
diff
changeset
|
52 uint _worker_id; |
342 | 53 public: |
54 G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); | |
55 bool apply_to_weak_ref_discovered_field() { return true; } | |
56 }; | |
57 | |
1261 | 58 class G1ParPushHeapRSClosure : public G1ParClosureSuper { |
59 public: | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
60 G1ParPushHeapRSClosure(G1CollectedHeap* g1, |
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
61 G1ParScanThreadState* par_scan_state): |
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
62 G1ParClosureSuper(g1, par_scan_state) { } |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
63 |
1261 | 64 template <class T> void do_oop_nv(T* p); |
65 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
66 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
67 }; | |
68 | |
342 | 69 class G1ParScanClosure : public G1ParClosureSuper { |
70 public: | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
71 G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) : |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
72 G1ParClosureSuper(g1, par_scan_state) |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
73 { |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
74 assert(_ref_processor == NULL, "sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
75 _ref_processor = rp; |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
76 } |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
77 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
78 template <class T> void do_oop_nv(T* p); |
342 | 79 virtual void do_oop(oop* p) { do_oop_nv(p); } |
80 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
81 }; | |
82 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
83 // Add back base class for metadata |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
84 class G1ParCopyHelper : public G1ParClosureSuper { |
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
85 protected: |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
86 Klass* _scanned_klass; |
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
87 ConcurrentMark* _cm; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
88 |
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
89 // Mark the object if it's not already marked. This is used to mark |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
90 // objects pointed to by roots that are guaranteed not to move |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
91 // during the GC (i.e., non-CSet objects). It is MT-safe. |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
92 void mark_object(oop obj); |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
93 |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
94 // Mark the object if it's not already marked. This is used to mark |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
95 // objects pointed to by roots that have been forwarded during a |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
96 // GC. It is MT-safe. |
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
97 void mark_forwarded_object(oop from_obj, oop to_obj); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
98 public: |
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
99 G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
100 |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
101 void set_scanned_klass(Klass* k) { _scanned_klass = k; } |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
102 template <class T> void do_klass_barrier(T* p, oop new_obj); |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
103 }; |
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
104 |
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
12316
diff
changeset
|
105 template <G1Barrier barrier, bool do_mark_object> |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
106 class G1ParCopyClosure : public G1ParCopyHelper { |
17689
5d492d192cbf
8035329: Move G1ParCopyClosure::copy_to_survivor_space into G1ParScanThreadState
tschatzl
parents:
17687
diff
changeset
|
107 private: |
5987 | 108 template <class T> void do_oop_work(T* p); |
342 | 109 |
110 public: | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
111 G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
112 ReferenceProcessor* rp) : |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
113 G1ParCopyHelper(g1, par_scan_state) { |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
114 assert(_ref_processor == NULL, "sanity"); |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
115 } |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
116 |
17687
86b64209f715
8027559: Decrease code size and templatizing in G1ParCopyClosure::do_oop_work
tschatzl
parents:
17650
diff
changeset
|
117 template <class T> void do_oop_nv(T* p) { do_oop_work(p); } |
342 | 118 virtual void do_oop(oop* p) { do_oop_nv(p); } |
119 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
120 }; | |
121 | |
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
12316
diff
changeset
|
122 typedef G1ParCopyClosure<G1BarrierNone, false> G1ParScanExtRootClosure; |
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
12316
diff
changeset
|
123 typedef G1ParCopyClosure<G1BarrierKlass, false> G1ParScanMetadataClosure; |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
124 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
125 |
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
12316
diff
changeset
|
126 typedef G1ParCopyClosure<G1BarrierNone, true> G1ParScanAndMarkExtRootClosure; |
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
12316
diff
changeset
|
127 typedef G1ParCopyClosure<G1BarrierKlass, true> G1ParScanAndMarkMetadataClosure; |
1261 | 128 |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
129 // We use a separate closure to handle references during evacuation |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
130 // failure processing. |
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
131 |
17636
889068b9a088
8027746: Remove do_gen_barrier template parameter in G1ParCopyClosure
tschatzl
parents:
12316
diff
changeset
|
132 typedef G1ParCopyClosure<G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure; |
342 | 133 |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
134 class FilterIntoCSClosure: public ExtendedOopClosure { |
342 | 135 G1CollectedHeap* _g1; |
136 OopClosure* _oc; | |
137 DirtyCardToOopClosure* _dcto_cl; | |
138 public: | |
139 FilterIntoCSClosure( DirtyCardToOopClosure* dcto_cl, | |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
140 G1CollectedHeap* g1, |
3983
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
141 OopClosure* oc) : |
811ec3d0833b
7097053: G1: assert(da ? referent->is_oop() : referent->is_oop_or_null()) failed: referenceProcessor.cpp:1054
johnc
parents:
3979
diff
changeset
|
142 _dcto_cl(dcto_cl), _g1(g1), _oc(oc) { } |
3979
4dfb2df418f2
6484982: G1: process references during evacuation pauses
johnc
parents:
3973
diff
changeset
|
143 |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
144 template <class T> void do_oop_nv(T* p); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
145 virtual void do_oop(oop* p) { do_oop_nv(p); } |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
146 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
342 | 147 bool apply_to_weak_ref_discovered_field() { return true; } |
148 }; | |
149 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
150 class FilterOutOfRegionClosure: public ExtendedOopClosure { |
342 | 151 HeapWord* _r_bottom; |
152 HeapWord* _r_end; | |
153 OopClosure* _oc; | |
154 public: | |
155 FilterOutOfRegionClosure(HeapRegion* r, OopClosure* oc); | |
845
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
156 template <class T> void do_oop_nv(T* p); |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
157 virtual void do_oop(oop* p) { do_oop_nv(p); } |
df6caf649ff7
6700789: G1: Enable use of compressed oops with G1 heaps
ysr
parents:
579
diff
changeset
|
158 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
342 | 159 bool apply_to_weak_ref_discovered_field() { return true; } |
160 }; | |
1972 | 161 |
3771 | 162 // Closure for iterating over object fields during concurrent marking |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
163 class G1CMOopClosure : public ExtendedOopClosure { |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
164 private: |
3771 | 165 G1CollectedHeap* _g1h; |
166 ConcurrentMark* _cm; | |
167 CMTask* _task; | |
168 public: | |
169 G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task); | |
170 template <class T> void do_oop_nv(T* p); | |
171 virtual void do_oop( oop* p) { do_oop_nv(p); } | |
172 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
173 }; | |
174 | |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
175 // Closure to scan the root regions during concurrent marking |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
176 class G1RootRegionScanClosure : public ExtendedOopClosure { |
4837
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
177 private: |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
178 G1CollectedHeap* _g1h; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
179 ConcurrentMark* _cm; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
180 uint _worker_id; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
181 public: |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
182 G1RootRegionScanClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
183 uint worker_id) : |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
184 _g1h(g1h), _cm(cm), _worker_id(worker_id) { } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
185 template <class T> void do_oop_nv(T* p); |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
186 virtual void do_oop( oop* p) { do_oop_nv(p); } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
187 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
188 }; |
eff609af17d7
7127706: G1: re-enable survivors during the initial-mark pause
tonyp
parents:
4836
diff
changeset
|
189 |
4839 | 190 // Closure that applies the given two closures in sequence. |
191 // Used by the RSet refinement code (when updating RSets | |
192 // during an evacuation pause) to record cards containing | |
193 // pointers into the collection set. | |
194 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
195 class G1Mux2Closure : public ExtendedOopClosure { |
4839 | 196 OopClosure* _c1; |
197 OopClosure* _c2; | |
198 public: | |
199 G1Mux2Closure(OopClosure *c1, OopClosure *c2); | |
200 template <class T> void do_oop_nv(T* p); | |
201 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
202 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
203 }; | |
204 | |
205 // A closure that returns true if it is actually applied | |
206 // to a reference | |
207 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
208 class G1TriggerClosure : public ExtendedOopClosure { |
4839 | 209 bool _triggered; |
210 public: | |
211 G1TriggerClosure(); | |
212 bool triggered() const { return _triggered; } | |
213 template <class T> void do_oop_nv(T* p); | |
214 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
215 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
216 }; | |
217 | |
218 // A closure which uses a triggering closure to determine | |
219 // whether to apply an oop closure. | |
220 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
221 class G1InvokeIfNotTriggeredClosure: public ExtendedOopClosure { |
4839 | 222 G1TriggerClosure* _trigger_cl; |
223 OopClosure* _oop_cl; | |
224 public: | |
225 G1InvokeIfNotTriggeredClosure(G1TriggerClosure* t, OopClosure* oc); | |
226 template <class T> void do_oop_nv(T* p); | |
227 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
228 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
229 }; | |
230 | |
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6254
diff
changeset
|
231 class G1UpdateRSOrPushRefOopClosure: public ExtendedOopClosure { |
4839 | 232 G1CollectedHeap* _g1; |
233 G1RemSet* _g1_rem_set; | |
234 HeapRegion* _from; | |
235 OopsInHeapRegionClosure* _push_ref_cl; | |
236 bool _record_refs_into_cset; | |
237 int _worker_i; | |
238 | |
239 public: | |
240 G1UpdateRSOrPushRefOopClosure(G1CollectedHeap* g1h, | |
241 G1RemSet* rs, | |
242 OopsInHeapRegionClosure* push_ref_cl, | |
243 bool record_refs_into_cset, | |
244 int worker_i = 0); | |
245 | |
246 void set_from(HeapRegion* from) { | |
247 assert(from != NULL, "from region must be non-NULL"); | |
248 _from = from; | |
249 } | |
250 | |
251 bool self_forwarded(oop obj) { | |
252 bool result = (obj->is_forwarded() && (obj->forwardee()== obj)); | |
253 return result; | |
254 } | |
255 | |
256 bool apply_to_weak_ref_discovered_field() { return true; } | |
257 | |
258 template <class T> void do_oop_nv(T* p); | |
259 virtual void do_oop(narrowOop* p) { do_oop_nv(p); } | |
260 virtual void do_oop(oop* p) { do_oop_nv(p); } | |
261 }; | |
262 | |
1972 | 263 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP |