106 
107 template <class T>                                                                                                         
108 inline void PSParallelCompact::adjust_pointer(T* p, ParCompactionManager* cm) {                                            
109   T heap_oop = RawAccess<>::oop_load(p);                                                                                   
110   if (!CompressedOops::is_null(heap_oop)) {                                                                                
111     oop obj = CompressedOops::decode_not_null(heap_oop);                                                                   
112     assert(ParallelScavengeHeap::heap()->is_in(obj), "should be in heap");                                                 
113 
114     oop new_obj = (oop)summary_data().calc_new_pointer(obj, cm);                                                           
115     assert(new_obj != NULL,                    // is forwarding ptr?                                                       
116            "should be forwarded");                                                                                         
117     // Just always do the update unconditionally?                                                                          
118     if (new_obj != NULL) {                                                                                                 
119       assert(ParallelScavengeHeap::heap()->is_in_reserved(new_obj),                                                        
120              "should be in object space");                                                                                 
121       RawAccess<IS_NOT_NULL>::oop_store(p, new_obj);                                                                       
122     }                                                                                                                      
123   }                                                                                                                        
124 }                                                                                                                          
125 
126 template <typename T>                                                                                                      
127 void PSParallelCompact::AdjustPointerClosure::do_oop_work(T* p) {                                                          
128   adjust_pointer(p, _cm);                                                                                                  
129 }                                                                                                                          
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
130 
131 inline void PSParallelCompact::AdjustPointerClosure::do_oop(oop* p)       { do_oop_work(p); }                              
132 inline void PSParallelCompact::AdjustPointerClosure::do_oop(narrowOop* p) { do_oop_work(p); }                              
                                                                                                                           
                                                                                                                           
                                                                                                                           
                                                                                                                           
133 
134 #endif // SHARE_VM_GC_PARALLEL_PSPARALLELCOMPACT_INLINE_HPP                                                                

106 
107 template <class T>
108 inline void PSParallelCompact::adjust_pointer(T* p, ParCompactionManager* cm) {
109   T heap_oop = RawAccess<>::oop_load(p);
110   if (!CompressedOops::is_null(heap_oop)) {
111     oop obj = CompressedOops::decode_not_null(heap_oop);
112     assert(ParallelScavengeHeap::heap()->is_in(obj), "should be in heap");
113 
114     oop new_obj = (oop)summary_data().calc_new_pointer(obj, cm);
115     assert(new_obj != NULL,                    // is forwarding ptr?
116            "should be forwarded");
117     // Just always do the update unconditionally?
118     if (new_obj != NULL) {
119       assert(ParallelScavengeHeap::heap()->is_in_reserved(new_obj),
120              "should be in object space");
121       RawAccess<IS_NOT_NULL>::oop_store(p, new_obj);
122     }
123   }
124 }
125 
126 class PCAdjustPointerClosure: public BasicOopIterateClosure {
127 public:
128   PCAdjustPointerClosure(ParCompactionManager* cm) {
129     assert(cm != NULL, "associate ParCompactionManage should not be NULL");
130     _cm = cm;
131   }
132   template <typename T> void do_oop_nv(T* p) { PSParallelCompact::adjust_pointer(p, _cm); }
133   virtual void do_oop(oop* p)                { do_oop_nv(p); }
134   virtual void do_oop(narrowOop* p)          { do_oop_nv(p); }
135 
136   // This closure provides its own oop verification code.
137   debug_only(virtual bool should_verify_oops() { return false; })
138   virtual ReferenceIterationMode reference_iteration_mode() { return DO_FIELDS; }
139 private:
140   ParCompactionManager* _cm;
141 };
142 
143 #endif // SHARE_VM_GC_PARALLEL_PSPARALLELCOMPACT_INLINE_HPP