1 /*

     2  * Copyright (c) 2016, 2017, 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 

    26 #include "aot/aotCodeHeap.hpp"

    27 #include "aot/aotLoader.hpp"

    28 #include "aot/compiledIC_aot.hpp"

    29 #include "code/codeCache.hpp"

    30 #include "code/compiledIC.hpp"

    31 #include "code/nativeInst.hpp"

    32 #include "compiler/compilerOracle.hpp"

    33 #include "gc/shared/cardTableModRefBS.hpp"

    34 #include "gc/shared/collectedHeap.hpp"

    35 #include "gc/shared/gcLocker.hpp"

    36 #include "jvmci/compilerRuntime.hpp"

    37 #include "jvmci/jvmciRuntime.hpp"

    38 #include "oops/method.hpp"

    39 #include "runtime/java.hpp"

    40 #include "runtime/os.hpp"

    41 #include "runtime/sharedRuntime.hpp"

    42 #include "utilities/xmlstream.hpp"

    43 

    44 #include <stdio.h>

    45 

    46 #if 0

    47 static void metadata_oops_do(Metadata** metadata_begin, Metadata **metadata_end, OopClosure* f) {

    48   // Visit the metadata/oops section

    49   for (Metadata** p = metadata_begin; p < metadata_end; p++) {

    50     Metadata* m = *p;

    51 

    52     intptr_t meta = (intptr_t)m;

    53     if ((meta & 1) == 1) {

    54       // already resolved

    55       m = (Metadata*)(meta & ~1);

    56     } else {

    57       continue;

    58     }

    59     assert(Metaspace::contains(m), "");

    60     if (m->is_method()) {

    61       m = ((Method*)m)->method_holder();

    62     }

    63     assert(m->is_klass(), "must be");

    64     oop o = ((Klass*)m)->klass_holder();

    65     if (o != NULL) {

    66       f->do_oop(&o);

    67     }

    68   }

    69 }

    70 #endif

    71 

    72 bool AOTCompiledMethod::do_unloading_oops(address low_boundary, BoolObjectClosure* is_alive, bool unloading_occurred) {

    73   return false;

    74 }

    75 

    76 oop AOTCompiledMethod::oop_at(int index) const {

    77   if (index == 0) { // 0 is reserved

    78     return NULL;

    79   }

    80   Metadata** entry = _metadata_got + (index - 1);

    81   intptr_t meta = (intptr_t)*entry;

    82   if ((meta & 1) == 1) {

    83     // already resolved

    84     Klass* k = (Klass*)(meta & ~1);

    85     return k->java_mirror();

    86   }

    87   // The entry is string which we need to resolve.

    88   const char* meta_name = _heap->get_name_at((int)meta);

    89   int klass_len = build_u2_from((address)meta_name);

    90   const char* klass_name = meta_name + 2;

    91   // Quick check the current method's holder.

    92   Klass* k = _method->method_holder();

    93 

    94   ResourceMark rm; // for signature_name()

    95   if (strncmp(k->signature_name(), klass_name, klass_len) != 0) { // Does not match?

    96     // Search klass in got cells in DSO which have this compiled method.

    97     k = _heap->get_klass_from_got(klass_name, klass_len, _method);

    98   }

    99   int method_name_len = build_u2_from((address)klass_name + klass_len);

   100   guarantee(method_name_len == 0, "only klass is expected here");

   101   meta = ((intptr_t)k) | 1;

   102   *entry = (Metadata*)meta; // Should be atomic on x64

   103   return k->java_mirror();

   104 }

   105 

   106 Metadata* AOTCompiledMethod::metadata_at(int index) const {

   107   if (index == 0) { // 0 is reserved

   108     return NULL;

   109   }

   110   assert(index - 1 < _metadata_size, "");

   111   {

   112     Metadata** entry = _metadata_got + (index - 1);

   113     intptr_t meta = (intptr_t)*entry;

   114     if ((meta & 1) == 1) {

   115       // already resolved

   116       Metadata *m = (Metadata*)(meta & ~1);

   117       return m;

   118     }

   119     // The entry is string which we need to resolve.

   120     const char* meta_name = _heap->get_name_at((int)meta);

   121     int klass_len = build_u2_from((address)meta_name);

   122     const char* klass_name = meta_name + 2;

   123     // Quick check the current method's holder.

   124     Klass* k = _method->method_holder();

   125     bool klass_matched = true;

   126 

   127     ResourceMark rm; // for signature_name() and find_method()

   128     if (strncmp(k->signature_name(), klass_name, klass_len) != 0) { // Does not match?

   129       // Search klass in got cells in DSO which have this compiled method.

   130       k = _heap->get_klass_from_got(klass_name, klass_len, _method);

   131       klass_matched = false;

   132     }

   133     int method_name_len = build_u2_from((address)klass_name + klass_len);

   134     if (method_name_len == 0) { // Array or Klass name only?

   135       meta = ((intptr_t)k) | 1;

   136       *entry = (Metadata*)meta; // Should be atomic on x64

   137       return (Metadata*)k;

   138     } else { // Method

   139       // Quick check the current method's name.

   140       Method* m = _method;

   141       int signature_len = build_u2_from((address)klass_name + klass_len + 2 + method_name_len);

   142       int full_len = 2 + klass_len + 2 + method_name_len + 2 + signature_len;

   143       if (!klass_matched || memcmp(_name, meta_name, full_len) != 0) { // Does not match?

   144         Thread* thread = Thread::current();

   145         const char* method_name = klass_name + klass_len;

   146         m = AOTCodeHeap::find_method(k, thread, method_name);

   147       }

   148       meta = ((intptr_t)m) | 1;

   149       *entry = (Metadata*)meta; // Should be atomic on x64

   150       return (Metadata*)m;

   151     }

   152   }

   153   ShouldNotReachHere(); return NULL;

   154 }

   155 

   156 bool AOTCompiledMethod::make_not_entrant_helper(int new_state) {

   157   // Make sure the method is not flushed in case of a safepoint in code below.

   158   methodHandle the_method(method());

   159   NoSafepointVerifier nsv;

   160 

   161   {

   162     // Enter critical section.  Does not block for safepoint.

   163     MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);

   164 

   165     if (*_state_adr == new_state) {

   166       // another thread already performed this transition so nothing

   167       // to do, but return false to indicate this.

   168       return false;

   169     }

   170 

   171     // Change state

   172     OrderAccess::storestore();

   173     *_state_adr = new_state;

   174 

   175     // Log the transition once

   176     log_state_change();

   177 

   178 #ifdef TIERED

   179     // Remain non-entrant forever

   180     if (new_state == not_entrant && method() != NULL) {

   181         method()->set_aot_code(NULL);

   182     }

   183 #endif

   184 

   185     // Remove AOTCompiledMethod from method.

   186     if (method() != NULL && (method()->code() == this ||

   187                              method()->from_compiled_entry() == verified_entry_point())) {

   188       HandleMark hm;

   189       method()->clear_code(false /* already owns Patching_lock */);

   190     }

   191   } // leave critical region under Patching_lock

   192 

   193 

   194   if (TraceCreateZombies) {

   195     ResourceMark m;

   196     const char *new_state_str = (new_state == not_entrant) ? "not entrant" : "not used";

   197     tty->print_cr("aot method <" INTPTR_FORMAT "> %s code made %s", p2i(this), this->method() ? this->method()->name_and_sig_as_C_string() : "null", new_state_str);

   198   }

   199 

   200   return true;

   201 }

   202 

   203 bool AOTCompiledMethod::make_entrant() {

   204   assert(!method()->is_old(), "reviving evolved method!");

   205   assert(*_state_adr != not_entrant, "%s", method()->has_aot_code() ? "has_aot_code() not cleared" : "caller didn't check has_aot_code()");

   206 

   207   // Make sure the method is not flushed in case of a safepoint in code below.

   208   methodHandle the_method(method());

   209   NoSafepointVerifier nsv;

   210 

   211   {

   212     // Enter critical section.  Does not block for safepoint.

   213     MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);

   214 

   215     if (*_state_adr == in_use) {

   216       // another thread already performed this transition so nothing

   217       // to do, but return false to indicate this.

   218       return false;

   219     }

   220 

   221     // Change state

   222     OrderAccess::storestore();

   223     *_state_adr = in_use;

   224 

   225     // Log the transition once

   226     log_state_change();

   227   } // leave critical region under Patching_lock

   228 

   229 

   230   if (TraceCreateZombies) {

   231     ResourceMark m;

   232     tty->print_cr("aot method <" INTPTR_FORMAT "> %s code made entrant", p2i(this), this->method() ? this->method()->name_and_sig_as_C_string() : "null");

   233   }

   234 

   235   return true;

   236 }

   237 

   238 // We don't have full dependencies for AOT methods, so flushing is

   239 // more conservative than for nmethods.

   240 void AOTCompiledMethod::flush_evol_dependents_on(InstanceKlass* dependee) {

   241   if (is_java_method()) {

   242     cleanup_inline_caches();

   243     mark_for_deoptimization();

   244     make_not_entrant();

   245   }

   246 }

   247 

   248 // Iterate over metadata calling this function.   Used by RedefineClasses

   249 // Copied from nmethod::metadata_do

   250 void AOTCompiledMethod::metadata_do(void f(Metadata*)) {

   251   address low_boundary = verified_entry_point();

   252   {

   253     // Visit all immediate references that are embedded in the instruction stream.

   254     RelocIterator iter(this, low_boundary);

   255     while (iter.next()) {

   256       if (iter.type() == relocInfo::metadata_type ) {

   257         metadata_Relocation* r = iter.metadata_reloc();

   258         // In this metadata, we must only follow those metadatas directly embedded in

   259         // the code.  Other metadatas (oop_index>0) are seen as part of

   260         // the metadata section below.

   261         assert(1 == (r->metadata_is_immediate()) +

   262                (r->metadata_addr() >= metadata_begin() && r->metadata_addr() < metadata_end()),

   263                "metadata must be found in exactly one place");

   264         if (r->metadata_is_immediate() && r->metadata_value() != NULL) {

   265           Metadata* md = r->metadata_value();

   266           if (md != _method) f(md);

   267         }

   268       } else if (iter.type() == relocInfo::virtual_call_type) {

   269         // Check compiledIC holders associated with this nmethod

   270         CompiledIC *ic = CompiledIC_at(&iter);

   271         if (ic->is_icholder_call()) {

   272           CompiledICHolder* cichk = ic->cached_icholder();

   273           f(cichk->holder_method());

   274           f(cichk->holder_klass());

   275         } else {

   276           // Get Klass* or NULL (if value is -1) from GOT cell of virtual call PLT stub.

   277           Metadata* ic_oop = ic->cached_metadata();

   278           if (ic_oop != NULL) {

   279             f(ic_oop);

   280           }

   281         }

   282       } else if (iter.type() == relocInfo::static_call_type ||

   283                  iter.type() == relocInfo::opt_virtual_call_type){

   284         // Check Method* in AOT c2i stub for other calls.

   285         Metadata* meta = (Metadata*)nativeLoadGot_at(nativePltCall_at(iter.addr())->plt_c2i_stub())->data();

   286         if (meta != NULL) {

   287           f(meta);

   288         }

   289       }

   290     }

   291   }

   292 

   293   // Visit the metadata section

   294   for (Metadata** p = metadata_begin(); p < metadata_end(); p++) {

   295     Metadata* m = *p;

   296 

   297     intptr_t meta = (intptr_t)m;

   298     if ((meta & 1) == 1) {

   299       // already resolved

   300       m = (Metadata*)(meta & ~1);

   301     } else {

   302       continue;

   303     }

   304     assert(Metaspace::contains(m), "");

   305     f(m);

   306   }

   307 

   308   // Visit metadata not embedded in the other places.

   309   if (_method != NULL) f(_method);

   310 }

   311 

   312 void AOTCompiledMethod::print() const {

   313   print_on(tty, "AOTCompiledMethod");

   314 }

   315 

   316 void AOTCompiledMethod::print_on(outputStream* st) const {

   317   print_on(st, "AOTCompiledMethod");

   318 }

   319 

   320 // Print out more verbose output usually for a newly created aot method.

   321 void AOTCompiledMethod::print_on(outputStream* st, const char* msg) const {

   322   if (st != NULL) {

   323     ttyLocker ttyl;

   324     st->print("%7d ", (int) st->time_stamp().milliseconds());

   325     st->print("%4d ", _aot_id);    // print compilation number

   326     st->print("    aot[%2d]", _heap->dso_id());

   327     // Stubs have _method == NULL

   328     if (_method == NULL) {

   329       st->print("   %s", _name);

   330     } else {

   331       ResourceMark m;

   332       st->print("   %s", _method->name_and_sig_as_C_string());

   333     }

   334     if (Verbose) {

   335       st->print(" entry at " INTPTR_FORMAT, p2i(_code));

   336     }

   337     if (msg != NULL) {

   338       st->print("   %s", msg);

   339     }

   340     st->cr();

   341   }

   342 }

   343 

   344 void AOTCompiledMethod::print_value_on(outputStream* st) const {

   345   st->print("AOTCompiledMethod ");

   346   print_on(st, NULL);

   347 }

   348 

   349 // Print a short set of xml attributes to identify this aot method.  The

   350 // output should be embedded in some other element.

   351 void AOTCompiledMethod::log_identity(xmlStream* log) const {

   352   log->print(" aot_id='%d'", _aot_id);

   353   log->print(" aot='%2d'", _heap->dso_id());

   354 }

   355 

   356 void AOTCompiledMethod::log_state_change() const {

   357   if (LogCompilation) {

   358     ResourceMark m;

   359     if (xtty != NULL) {

   360       ttyLocker ttyl;  // keep the following output all in one block

   361       if (*_state_adr == not_entrant) {

   362         xtty->begin_elem("make_not_entrant thread='" UINTX_FORMAT "'",

   363                          os::current_thread_id());

   364       } else if (*_state_adr == not_used) {

   365         xtty->begin_elem("make_not_used thread='" UINTX_FORMAT "'",

   366                          os::current_thread_id());

   367       } else if (*_state_adr == in_use) {

   368         xtty->begin_elem("make_entrant thread='" UINTX_FORMAT "'",

   369                          os::current_thread_id());

   370       }

   371       log_identity(xtty);

   372       xtty->stamp();

   373       xtty->end_elem();

   374     }

   375   }

   376   if (PrintCompilation) {

   377     ResourceMark m;

   378     if (*_state_adr == not_entrant) {

   379       print_on(tty, "made not entrant");

   380     } else if (*_state_adr == not_used) {

   381       print_on(tty, "made not used");

   382     } else if (*_state_adr == in_use) {

   383       print_on(tty, "made entrant");

   384     }

   385   }

   386 }

   387 

   388 

   389 NativeInstruction* PltNativeCallWrapper::get_load_instruction(virtual_call_Relocation* r) const {

   390   return nativeLoadGot_at(_call->plt_load_got());

   391 }

   392 

   393 void PltNativeCallWrapper::verify_resolve_call(address dest) const {

   394   CodeBlob* db = CodeCache::find_blob_unsafe(dest);

   395   if (db == NULL) {

   396     assert(dest == _call->plt_resolve_call(), "sanity");

   397   }

   398 }

   399 

   400 void PltNativeCallWrapper::set_to_interpreted(const methodHandle& method, CompiledICInfo& info) {

   401   assert(!info.to_aot(), "only for nmethod");

   402   CompiledPltStaticCall* csc = CompiledPltStaticCall::at(instruction_address());

   403   csc->set_to_interpreted(method, info.entry());

   404 }

   405 

   406 NativeCallWrapper* AOTCompiledMethod::call_wrapper_at(address call) const {

   407   return new PltNativeCallWrapper((NativePltCall*) call);

   408 }

   409 

   410 NativeCallWrapper* AOTCompiledMethod::call_wrapper_before(address return_pc) const {

   411   return new PltNativeCallWrapper(nativePltCall_before(return_pc));

   412 }

   413 

   414 CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_at(Relocation* call_site) const {

   415   return CompiledPltStaticCall::at(call_site);

   416 }

   417 

   418 CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_at(address call_site) const {

   419   return CompiledPltStaticCall::at(call_site);

   420 }

   421 

   422 CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_before(address return_addr) const {

   423   return CompiledPltStaticCall::before(return_addr);

   424 }

   425 

   426 address AOTCompiledMethod::call_instruction_address(address pc) const {

   427   NativePltCall* pltcall = nativePltCall_before(pc);

   428   return pltcall->instruction_address();

   429 }

   430 

   431 bool AOTCompiledMethod::is_evol_dependent_on(Klass* dependee) {

   432   return !is_aot_runtime_stub() && _heap->is_dependent_method(dependee, this);

   433 }

   434 

   435 void AOTCompiledMethod::clear_inline_caches() {

   436   assert(SafepointSynchronize::is_at_safepoint(), "cleaning of IC's only allowed at safepoint");

   437   if (is_zombie()) {

   438     return;

   439   }

   440 

   441   RelocIterator iter(this);

   442   while (iter.next()) {

   443     iter.reloc()->clear_inline_cache();

   444     if (iter.type() == relocInfo::opt_virtual_call_type) {

   445       CompiledIC* cic = CompiledIC_at(&iter);

   446       assert(cic->is_clean(), "!");

   447       nativePltCall_at(iter.addr())->set_stub_to_clean();

   448     }

   449   }

   450 }

   451