1 /*
  2  * Copyright (c) 2017, 2018, 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 #include "precompiled.hpp"
 25 #include "code/relocInfo.hpp"
 26 #include "code/nmethod.hpp"
 27 #include "code/icBuffer.hpp"
 28 #include "gc/shared/barrierSet.hpp"
 29 #include "gc/shared/barrierSetNMethod.hpp"
 30 #include "gc/z/zGlobals.hpp"
 31 #include "gc/z/zLock.inline.hpp"
 32 #include "gc/z/zNMethod.hpp"
 33 #include "gc/z/zNMethodData.hpp"
 34 #include "gc/z/zNMethodTable.hpp"
 35 #include "gc/z/zOopClosures.inline.hpp"
 36 #include "gc/z/zTask.hpp"
 37 #include "gc/z/zWorkers.hpp"
 38 #include "logging/log.hpp"
 39 #include "memory/allocation.inline.hpp"
 40 #include "memory/iterator.hpp"
 41 #include "memory/resourceArea.hpp"
 42 #include "runtime/atomic.hpp"
 43 #include "runtime/orderAccess.hpp"
 44 #include "utilities/debug.hpp"
 45 
 46 static ZNMethodData* gc_data(const nmethod* nm) {
 47   return nm->gc_data<ZNMethodData>();
 48 }
 49 
 50 static void set_gc_data(nmethod* nm, ZNMethodData* data) {
 51   return nm->set_gc_data<ZNMethodData>(data);
 52 }
 53 
 54 void ZNMethod::attach_gc_data(nmethod* nm) {
 55   GrowableArray<oop*> immediate_oops;
 56   bool non_immediate_oops = false;
 57 
 58   // Find all oops relocations
 59   RelocIterator iter(nm);
 60   while (iter.next()) {
 61     if (iter.type() != relocInfo::oop_type) {
 62       // Not an oop
 63       continue;
 64     }
 65 
 66     oop_Relocation* r = iter.oop_reloc();
 67 
 68     if (!r->oop_is_immediate()) {
 69       // Non-immediate oop found
 70       non_immediate_oops = true;
 71       continue;
 72     }
 73 
 74     if (r->oop_value() != NULL) {
 75       // Non-NULL immediate oop found. NULL oops can safely be
 76       // ignored since the method will be re-registered if they
 77       // are later patched to be non-NULL.
 78       immediate_oops.push(r->oop_addr());
 79     }
 80   }
 81 
 82   // Attach GC data to nmethod
 83   ZNMethodData* data = gc_data(nm);
 84   if (data == NULL) {
 85     data = new ZNMethodData();
 86     set_gc_data(nm, data);
 87   }
 88 
 89   // Attach oops in GC data
 90   ZNMethodDataOops* const new_oops = ZNMethodDataOops::create(immediate_oops, non_immediate_oops);
 91   ZNMethodDataOops* const old_oops = data->swap_oops(new_oops);
 92   ZNMethodDataOops::destroy(old_oops);
 93 }
 94 
 95 ZReentrantLock* ZNMethod::lock_for_nmethod(nmethod* nm) {
 96   return gc_data(nm)->lock();
 97 }
 98 
 99 void ZNMethod::log_register(const nmethod* nm) {
100   LogTarget(Trace, gc, nmethod) log;
101   if (!log.is_enabled()) {
102     return;
103   }
104 
105   const ZNMethodDataOops* const oops = gc_data(nm)->oops();
106 
107   log.print("Register NMethod: %s.%s (" PTR_FORMAT "), "
108             "Compiler: %s, Oops: %d, ImmediateOops: " SIZE_FORMAT ", NonImmediateOops: %s",
109             nm->method()->method_holder()->external_name(),
110             nm->method()->name()->as_C_string(),
111             p2i(nm),
112             nm->compiler_name(),
113             nm->oops_count() - 1,
114             oops->immediates_count(),
115             oops->has_non_immediates() ? "Yes" : "No");
116 
117   LogTarget(Trace, gc, nmethod, oops) log_oops;
118   if (!log_oops.is_enabled()) {
119     return;
120   }
121 
122   // Print nmethod oops table
123   {
124     oop* const begin = nm->oops_begin();
125     oop* const end = nm->oops_end();
126     for (oop* p = begin; p < end; p++) {
127       log_oops.print("           Oop[" SIZE_FORMAT "] " PTR_FORMAT " (%s)",
128                      (p - begin), p2i(*p), (*p)->klass()->external_name());
129     }
130   }
131 
132   // Print nmethod immediate oops
133   {
134     oop** const begin = oops->immediates_begin();
135     oop** const end = oops->immediates_end();
136     for (oop** p = begin; p < end; p++) {
137       log_oops.print("  ImmediateOop[" SIZE_FORMAT "] " PTR_FORMAT " @ " PTR_FORMAT " (%s)",
138                      (p - begin), p2i(**p), p2i(*p), (**p)->klass()->external_name());
139     }
140   }
141 }
142 
143 void ZNMethod::log_unregister(const nmethod* nm) {
144   LogTarget(Debug, gc, nmethod) log;
145   if (!log.is_enabled()) {
146     return;
147   }
148 
149   log.print("Unregister NMethod: %s.%s (" PTR_FORMAT ")",
150             nm->method()->method_holder()->external_name(),
151             nm->method()->name()->as_C_string(),
152             p2i(nm));
153 }
154 
155 void ZNMethod::register_nmethod(nmethod* nm) {
156   ResourceMark rm;
157 
158   // Create and attach gc data
159   attach_gc_data(nm);
160 
161   log_register(nm);
162 
163   ZNMethodTable::register_nmethod(nm);
164 
165   // Disarm nmethod entry barrier
166   disarm_nmethod(nm);
167 }
168 
169 void ZNMethod::unregister_nmethod(nmethod* nm) {
170   assert(CodeCache_lock->owned_by_self(), "Lock must be held");
171 
172   if (Thread::current()->is_Code_cache_sweeper_thread()) {
173     // The sweeper must wait for any ongoing iteration to complete
174     // before it can unregister an nmethod.
175     ZNMethodTable::wait_until_iteration_done();
176   }
177 
178   ResourceMark rm;
179 
180   log_unregister(nm);
181 
182   ZNMethodTable::unregister_nmethod(nm);
183 }
184 
185 void ZNMethod::flush_nmethod(nmethod* nm) {
186   // Destroy GC data
187   delete gc_data(nm);
188 }
189 
190 void ZNMethod::disarm_nmethod(nmethod* nm) {
191   BarrierSetNMethod* const bs = BarrierSet::barrier_set()->barrier_set_nmethod();
192   if (bs != NULL) {
193     bs->disarm(nm);
194   }
195 }
196 
197 void ZNMethod::nmethod_oops_do(nmethod* nm, OopClosure* cl) {
198   // Process oops table
199   {
200     oop* const begin = nm->oops_begin();
201     oop* const end = nm->oops_end();
202     for (oop* p = begin; p < end; p++) {
203       if (*p != Universe::non_oop_word()) {
204         cl->do_oop(p);
205       }
206     }
207   }
208 
209   ZNMethodDataOops* const oops = gc_data(nm)->oops();
210 
211   // Process immediate oops
212   {
213     oop** const begin = oops->immediates_begin();
214     oop** const end = oops->immediates_end();
215     for (oop** p = begin; p < end; p++) {
216       if (**p != Universe::non_oop_word()) {
217         cl->do_oop(*p);
218       }
219     }
220   }
221 
222   // Process non-immediate oops
223   if (oops->has_non_immediates()) {
224     nm->fix_oop_relocations();
225   }
226 }
227 
228 class ZNMethodToOopsDoClosure : public NMethodClosure {
229 private:
230   OopClosure* _cl;
231 
232 public:
233   ZNMethodToOopsDoClosure(OopClosure* cl) :
234       _cl(cl) {}
235 
236   virtual void do_nmethod(nmethod* nm) {
237     ZNMethod::nmethod_oops_do(nm, _cl);
238   }
239 };
240 
241 void ZNMethod::oops_do_begin() {
242   ZNMethodTable::nmethods_do_begin();
243 }
244 
245 void ZNMethod::oops_do_end() {
246   ZNMethodTable::nmethods_do_end();
247 }
248 
249 void ZNMethod::oops_do(OopClosure* cl) {
250   ZNMethodToOopsDoClosure nmethod_cl(cl);
251   ZNMethodTable::nmethods_do(&nmethod_cl);
252 }
253 
254 class ZNMethodUnlinkClosure : public NMethodClosure {
255 private:
256   bool          _unloading_occurred;
257   volatile bool _failed;
258 
259   void set_failed() {
260     Atomic::store(true, &_failed);
261   }
262 
263 public:
264   ZNMethodUnlinkClosure(bool unloading_occurred) :
265       _unloading_occurred(unloading_occurred),
266       _failed(false) {}
267 
268   virtual void do_nmethod(nmethod* nm) {
269     if (failed()) {
270       return;
271     }
272 
273     if (!nm->is_alive()) {
274       return;
275     }
276 
277     ZLocker<ZReentrantLock> locker(ZNMethod::lock_for_nmethod(nm));
278 
279     if (nm->is_unloading()) {
280       // Unlinking of the dependencies must happen before the
281       // handshake separating unlink and purge.
282       nm->flush_dependencies(false /* delete_immediately */);
283 
284       // We don't need to take the lock when unlinking nmethods from
285       // the Method, because it is only concurrently unlinked by
286       // the entry barrier, which acquires the per nmethod lock.
287       nm->unlink_from_method(false /* acquire_lock */);
288       return;
289     }
290 
291     // Heal oops and disarm
292     ZNMethodOopClosure cl;
293     ZNMethod::nmethod_oops_do(nm, &cl);
294     ZNMethod::disarm_nmethod(nm);
295 
296     // Clear compiled ICs and exception caches
297     if (!nm->unload_nmethod_caches(_unloading_occurred)) {
298       set_failed();
299     }
300   }
301 
302   bool failed() const {
303     return Atomic::load(&_failed);
304   }
305 };
306 
307 class ZNMethodUnlinkTask : public ZTask {
308 private:
309   ZNMethodUnlinkClosure _cl;
310   ICRefillVerifier*     _verifier;
311 
312 public:
313   ZNMethodUnlinkTask(bool unloading_occurred, ICRefillVerifier* verifier) :
314       ZTask("ZNMethodUnlinkTask"),
315       _cl(unloading_occurred),
316       _verifier(verifier) {
317     ZNMethodTable::nmethods_do_begin();
318   }
319 
320   ~ZNMethodUnlinkTask() {
321     ZNMethodTable::nmethods_do_end();
322   }
323 
324   virtual void work() {
325     ICRefillVerifierMark mark(_verifier);
326     ZNMethodTable::nmethods_do(&_cl);
327   }
328 
329   bool success() const {
330     return !_cl.failed();
331   }
332 };
333 
334 void ZNMethod::unlink(ZWorkers* workers, bool unloading_occurred) {
335   for (;;) {
336     ICRefillVerifier verifier;
337 
338     {
339       ZNMethodUnlinkTask task(unloading_occurred, &verifier);
340       workers->run_concurrent(&task);
341       if (task.success()) {
342         return;
343       }
344     }
345 
346     // Cleaning failed because we ran out of transitional IC stubs,
347     // so we have to refill and try again. Refilling requires taking
348     // a safepoint, so we temporarily leave the suspendible thread set.
349     SuspendibleThreadSetLeaver sts;
350     InlineCacheBuffer::refill_ic_stubs();
351   }
352 }
353 
354 class ZNMethodPurgeClosure : public NMethodClosure {
355 public:
356   virtual void do_nmethod(nmethod* nm) {
357     if (nm->is_alive() && nm->is_unloading()) {
358       nm->make_unloaded();
359     }
360   }
361 };
362 
363 class ZNMethodPurgeTask : public ZTask {
364 private:
365   ZNMethodPurgeClosure _cl;
366 
367 public:
368   ZNMethodPurgeTask() :
369       ZTask("ZNMethodPurgeTask"),
370       _cl() {
371     ZNMethodTable::nmethods_do_begin();
372   }
373 
374   ~ZNMethodPurgeTask() {
375     ZNMethodTable::nmethods_do_end();
376   }
377 
378   virtual void work() {
379     ZNMethodTable::nmethods_do(&_cl);
380   }
381 };
382 
383 void ZNMethod::purge(ZWorkers* workers) {
384   ZNMethodPurgeTask task;
385   workers->run_concurrent(&task);
386 }