1 /*

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

    25 #include "precompiled.hpp"

    26 #include "classfile/metadataOnStackMark.hpp"

    27 #include "classfile/systemDictionary.hpp"

    28 #include "code/codeCache.hpp"

    29 #include "code/debugInfoRec.hpp"

    30 #include "gc/shared/collectedHeap.inline.hpp"

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

    32 #include "gc/shared/generation.hpp"

    33 #include "interpreter/bytecodeStream.hpp"

    34 #include "interpreter/bytecodeTracer.hpp"

    35 #include "interpreter/bytecodes.hpp"

    36 #include "interpreter/interpreter.hpp"

    37 #include "interpreter/oopMapCache.hpp"

    38 #include "memory/heapInspection.hpp"

    39 #include "memory/metadataFactory.hpp"

    40 #include "memory/metaspaceClosure.hpp"

    41 #include "memory/metaspaceShared.hpp"

    42 #include "memory/oopFactory.hpp"

    43 #include "memory/resourceArea.hpp"

    44 #include "oops/constMethod.hpp"

    45 #include "oops/method.hpp"

    46 #include "oops/methodData.hpp"

    47 #include "oops/objArrayOop.inline.hpp"

    48 #include "oops/oop.inline.hpp"

    49 #include "oops/symbol.hpp"

    50 #include "prims/jvmtiExport.hpp"

    51 #include "prims/methodHandles.hpp"

    52 #include "prims/nativeLookup.hpp"

    53 #include "runtime/arguments.hpp"

    54 #include "runtime/compilationPolicy.hpp"

    55 #include "runtime/frame.inline.hpp"

    56 #include "runtime/handles.inline.hpp"

    57 #include "runtime/init.hpp"

    58 #include "runtime/orderAccess.inline.hpp"

    59 #include "runtime/relocator.hpp"

    60 #include "runtime/sharedRuntime.hpp"

    61 #include "runtime/signature.hpp"

    62 #include "utilities/align.hpp"

    63 #include "utilities/quickSort.hpp"

    64 #include "utilities/vmError.hpp"

    65 #include "utilities/xmlstream.hpp"

    66 

    67 // Implementation of Method

    68 

    69 Method* Method::allocate(ClassLoaderData* loader_data,

    70                          int byte_code_size,

    71                          AccessFlags access_flags,

    72                          InlineTableSizes* sizes,

    73                          ConstMethod::MethodType method_type,

    74                          TRAPS) {

    75   assert(!access_flags.is_native() || byte_code_size == 0,

    76          "native methods should not contain byte codes");

    77   ConstMethod* cm = ConstMethod::allocate(loader_data,

    78                                           byte_code_size,

    79                                           sizes,

    80                                           method_type,

    81                                           CHECK_NULL);

    82   int size = Method::size(access_flags.is_native());

    83   return new (loader_data, size, MetaspaceObj::MethodType, THREAD) Method(cm, access_flags);

    84 }

    85 

    86 Method::Method(ConstMethod* xconst, AccessFlags access_flags) {

    87   NoSafepointVerifier no_safepoint;

    88   set_constMethod(xconst);

    89   set_access_flags(access_flags);

    90   set_intrinsic_id(vmIntrinsics::_none);

    91   set_force_inline(false);

    92   set_hidden(false);

    93   set_dont_inline(false);

    94   set_has_injected_profile(false);

    95   set_method_data(NULL);

    96   clear_method_counters();

    97   set_vtable_index(Method::garbage_vtable_index);

    98 

    99   // Fix and bury in Method*

   100   set_interpreter_entry(NULL); // sets i2i entry and from_int

   101   set_adapter_entry(NULL);

   102   clear_code(false /* don't need a lock */); // from_c/from_i get set to c2i/i2i

   103 

   104   if (access_flags.is_native()) {

   105     clear_native_function();

   106     set_signature_handler(NULL);

   107   }

   108 

   109   NOT_PRODUCT(set_compiled_invocation_count(0);)

   110 }

   111 

   112 // Release Method*.  The nmethod will be gone when we get here because

   113 // we've walked the code cache.

   114 void Method::deallocate_contents(ClassLoaderData* loader_data) {

   115   MetadataFactory::free_metadata(loader_data, constMethod());

   116   set_constMethod(NULL);

   117   MetadataFactory::free_metadata(loader_data, method_data());

   118   set_method_data(NULL);

   119   MetadataFactory::free_metadata(loader_data, method_counters());

   120   clear_method_counters();

   121   // The nmethod will be gone when we get here.

   122   if (code() != NULL) _code = NULL;

   123 }

   124 

   125 address Method::get_i2c_entry() {

   126   assert(adapter() != NULL, "must have");

   127   return adapter()->get_i2c_entry();

   128 }

   129 

   130 address Method::get_c2i_entry() {

   131   assert(adapter() != NULL, "must have");

   132   return adapter()->get_c2i_entry();

   133 }

   134 

   135 address Method::get_c2i_unverified_entry() {

   136   assert(adapter() != NULL, "must have");

   137   return adapter()->get_c2i_unverified_entry();

   138 }

   139 

   140 char* Method::name_and_sig_as_C_string() const {

   141   return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature());

   142 }

   143 

   144 char* Method::name_and_sig_as_C_string(char* buf, int size) const {

   145   return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature(), buf, size);

   146 }

   147 

   148 char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature) {

   149   const char* klass_name = klass->external_name();

   150   int klass_name_len  = (int)strlen(klass_name);

   151   int method_name_len = method_name->utf8_length();

   152   int len             = klass_name_len + 1 + method_name_len + signature->utf8_length();

   153   char* dest          = NEW_RESOURCE_ARRAY(char, len + 1);

   154   strcpy(dest, klass_name);

   155   dest[klass_name_len] = '.';

   156   strcpy(&dest[klass_name_len + 1], method_name->as_C_string());

   157   strcpy(&dest[klass_name_len + 1 + method_name_len], signature->as_C_string());

   158   dest[len] = 0;

   159   return dest;

   160 }

   161 

   162 char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size) {

   163   Symbol* klass_name = klass->name();

   164   klass_name->as_klass_external_name(buf, size);

   165   int len = (int)strlen(buf);

   166 

   167   if (len < size - 1) {

   168     buf[len++] = '.';

   169 

   170     method_name->as_C_string(&(buf[len]), size - len);

   171     len = (int)strlen(buf);

   172 

   173     signature->as_C_string(&(buf[len]), size - len);

   174   }

   175 

   176   return buf;

   177 }

   178 

   179 int Method::fast_exception_handler_bci_for(const methodHandle& mh, Klass* ex_klass, int throw_bci, TRAPS) {

   180   // exception table holds quadruple entries of the form (beg_bci, end_bci, handler_bci, klass_index)

   181   // access exception table

   182   ExceptionTable table(mh());

   183   int length = table.length();

   184   // iterate through all entries sequentially

   185   constantPoolHandle pool(THREAD, mh->constants());

   186   for (int i = 0; i < length; i ++) {

   187     //reacquire the table in case a GC happened

   188     ExceptionTable table(mh());

   189     int beg_bci = table.start_pc(i);

   190     int end_bci = table.end_pc(i);

   191     assert(beg_bci <= end_bci, "inconsistent exception table");

   192     if (beg_bci <= throw_bci && throw_bci < end_bci) {

   193       // exception handler bci range covers throw_bci => investigate further

   194       int handler_bci = table.handler_pc(i);

   195       int klass_index = table.catch_type_index(i);

   196       if (klass_index == 0) {

   197         return handler_bci;

   198       } else if (ex_klass == NULL) {

   199         return handler_bci;

   200       } else {

   201         // we know the exception class => get the constraint class

   202         // this may require loading of the constraint class; if verification

   203         // fails or some other exception occurs, return handler_bci

   204         Klass* k = pool->klass_at(klass_index, CHECK_(handler_bci));

   205         assert(k != NULL, "klass not loaded");

   206         if (ex_klass->is_subtype_of(k)) {

   207           return handler_bci;

   208         }

   209       }

   210     }

   211   }

   212 

   213   return -1;

   214 }

   215 

   216 void Method::mask_for(int bci, InterpreterOopMap* mask) {

   217   methodHandle h_this(Thread::current(), this);

   218   // Only GC uses the OopMapCache during thread stack root scanning

   219   // any other uses generate an oopmap but do not save it in the cache.

   220   if (Universe::heap()->is_gc_active()) {

   221     method_holder()->mask_for(h_this, bci, mask);

   222   } else {

   223     OopMapCache::compute_one_oop_map(h_this, bci, mask);

   224   }

   225   return;

   226 }

   227 

   228 

   229 int Method::bci_from(address bcp) const {

   230   if (is_native() && bcp == 0) {

   231     return 0;

   232   }

   233 #ifdef ASSERT

   234   {

   235     ResourceMark rm;

   236     assert(is_native() && bcp == code_base() || contains(bcp) || VMError::is_error_reported(),

   237            "bcp doesn't belong to this method: bcp: " INTPTR_FORMAT ", method: %s",

   238            p2i(bcp), name_and_sig_as_C_string());

   239   }

   240 #endif

   241   return bcp - code_base();

   242 }

   243 

   244 

   245 int Method::validate_bci(int bci) const {

   246   return (bci == 0 || bci < code_size()) ? bci : -1;

   247 }

   248 

   249 // Return bci if it appears to be a valid bcp

   250 // Return -1 otherwise.

   251 // Used by profiling code, when invalid data is a possibility.

   252 // The caller is responsible for validating the Method* itself.

   253 int Method::validate_bci_from_bcp(address bcp) const {

   254   // keep bci as -1 if not a valid bci

   255   int bci = -1;

   256   if (bcp == 0 || bcp == code_base()) {

   257     // code_size() may return 0 and we allow 0 here

   258     // the method may be native

   259     bci = 0;

   260   } else if (contains(bcp)) {

   261     bci = bcp - code_base();

   262   }

   263   // Assert that if we have dodged any asserts, bci is negative.

   264   assert(bci == -1 || bci == bci_from(bcp_from(bci)), "sane bci if >=0");

   265   return bci;

   266 }

   267 

   268 address Method::bcp_from(int bci) const {

   269   assert((is_native() && bci == 0) || (!is_native() && 0 <= bci && bci < code_size()),

   270          "illegal bci: %d for %s method", bci, is_native() ? "native" : "non-native");

   271   address bcp = code_base() + bci;

   272   assert(is_native() && bcp == code_base() || contains(bcp), "bcp doesn't belong to this method");

   273   return bcp;

   274 }

   275 

   276 address Method::bcp_from(address bcp) const {

   277   if (is_native() && bcp == NULL) {

   278     return code_base();

   279   } else {

   280     return bcp;

   281   }

   282 }

   283 

   284 int Method::size(bool is_native) {

   285   // If native, then include pointers for native_function and signature_handler

   286   int extra_bytes = (is_native) ? 2*sizeof(address*) : 0;

   287   int extra_words = align_up(extra_bytes, BytesPerWord) / BytesPerWord;

   288   return align_metadata_size(header_size() + extra_words);

   289 }

   290 

   291 

   292 Symbol* Method::klass_name() const {

   293   return method_holder()->name();

   294 }

   295 

   296 

   297 void Method::metaspace_pointers_do(MetaspaceClosure* it) {

   298   log_trace(cds)("Iter(Method): %p", this);

   299 

   300   it->push(&_constMethod);

   301   it->push(&_method_data);

   302   it->push(&_method_counters);

   303 }

   304 

   305 // Attempt to return method oop to original state.  Clear any pointers

   306 // (to objects outside the shared spaces).  We won't be able to predict

   307 // where they should point in a new JVM.  Further initialize some

   308 // entries now in order allow them to be write protected later.

   309 

   310 void Method::remove_unshareable_info() {

   311   unlink_method();

   312 }

   313 

   314 void Method::set_vtable_index(int index) {

   315   if (is_shared() && !MetaspaceShared::remapped_readwrite()) {

   316     // At runtime initialize_vtable is rerun as part of link_class_impl()

   317     // for a shared class loaded by the non-boot loader to obtain the loader

   318     // constraints based on the runtime classloaders' context.

   319     return; // don't write into the shared class

   320   } else {

   321     _vtable_index = index;

   322   }

   323 }

   324 

   325 void Method::set_itable_index(int index) {

   326   if (is_shared() && !MetaspaceShared::remapped_readwrite()) {

   327     // At runtime initialize_itable is rerun as part of link_class_impl()

   328     // for a shared class loaded by the non-boot loader to obtain the loader

   329     // constraints based on the runtime classloaders' context. The dumptime

   330     // itable index should be the same as the runtime index.

   331     assert(_vtable_index == itable_index_max - index,

   332            "archived itable index is different from runtime index");

   333     return; // don’t write into the shared class

   334   } else {

   335     _vtable_index = itable_index_max - index;

   336   }

   337   assert(valid_itable_index(), "");

   338 }

   339 

   340 

   341 

   342 bool Method::was_executed_more_than(int n) {

   343   // Invocation counter is reset when the Method* is compiled.

   344   // If the method has compiled code we therefore assume it has

   345   // be excuted more than n times.

   346   if (is_accessor() || is_empty_method() || (code() != NULL)) {

   347     // interpreter doesn't bump invocation counter of trivial methods

   348     // compiler does not bump invocation counter of compiled methods

   349     return true;

   350   }

   351   else if ((method_counters() != NULL &&

   352             method_counters()->invocation_counter()->carry()) ||

   353            (method_data() != NULL &&

   354             method_data()->invocation_counter()->carry())) {

   355     // The carry bit is set when the counter overflows and causes

   356     // a compilation to occur.  We don't know how many times

   357     // the counter has been reset, so we simply assume it has

   358     // been executed more than n times.

   359     return true;

   360   } else {

   361     return invocation_count() > n;

   362   }

   363 }

   364 

   365 void Method::print_invocation_count() {

   366   if (is_static()) tty->print("static ");

   367   if (is_final()) tty->print("final ");

   368   if (is_synchronized()) tty->print("synchronized ");

   369   if (is_native()) tty->print("native ");

   370   tty->print("%s::", method_holder()->external_name());

   371   name()->print_symbol_on(tty);

   372   signature()->print_symbol_on(tty);

   373 

   374   if (WizardMode) {

   375     // dump the size of the byte codes

   376     tty->print(" {%d}", code_size());

   377   }

   378   tty->cr();

   379 

   380   tty->print_cr ("  interpreter_invocation_count: %8d ", interpreter_invocation_count());

   381   tty->print_cr ("  invocation_counter:           %8d ", invocation_count());

   382   tty->print_cr ("  backedge_counter:             %8d ", backedge_count());

   383 #ifndef PRODUCT

   384   if (CountCompiledCalls) {

   385     tty->print_cr ("  compiled_invocation_count: %8d ", compiled_invocation_count());

   386   }

   387 #endif

   388 }

   389 

   390 // Build a MethodData* object to hold information about this method

   391 // collected in the interpreter.

   392 void Method::build_interpreter_method_data(const methodHandle& method, TRAPS) {

   393   // Do not profile the method if metaspace has hit an OOM previously

   394   // allocating profiling data. Callers clear pending exception so don't

   395   // add one here.

   396   if (ClassLoaderDataGraph::has_metaspace_oom()) {

   397     return;

   398   }

   399 

   400   // Grab a lock here to prevent multiple

   401   // MethodData*s from being created.

   402   MutexLocker ml(MethodData_lock, THREAD);

   403   if (method->method_data() == NULL) {

   404     ClassLoaderData* loader_data = method->method_holder()->class_loader_data();

   405     MethodData* method_data = MethodData::allocate(loader_data, method, THREAD);

   406     if (HAS_PENDING_EXCEPTION) {

   407       CompileBroker::log_metaspace_failure();

   408       ClassLoaderDataGraph::set_metaspace_oom(true);

   409       return;   // return the exception (which is cleared)

   410     }

   411 

   412     method->set_method_data(method_data);

   413     if (PrintMethodData && (Verbose || WizardMode)) {

   414       ResourceMark rm(THREAD);

   415       tty->print("build_interpreter_method_data for ");

   416       method->print_name(tty);

   417       tty->cr();

   418       // At the end of the run, the MDO, full of data, will be dumped.

   419     }

   420   }

   421 }

   422 

   423 MethodCounters* Method::build_method_counters(Method* m, TRAPS) {

   424   // Do not profile the method if metaspace has hit an OOM previously

   425   if (ClassLoaderDataGraph::has_metaspace_oom()) {

   426     return NULL;

   427   }

   428 

   429   methodHandle mh(m);

   430   MethodCounters* counters = MethodCounters::allocate(mh, THREAD);

   431   if (HAS_PENDING_EXCEPTION) {

   432     CompileBroker::log_metaspace_failure();

   433     ClassLoaderDataGraph::set_metaspace_oom(true);

   434     return NULL;   // return the exception (which is cleared)

   435   }

   436   if (!mh->init_method_counters(counters)) {

   437     MetadataFactory::free_metadata(mh->method_holder()->class_loader_data(), counters);

   438   }

   439 

   440   if (LogTouchedMethods) {

   441     mh->log_touched(CHECK_NULL);

   442   }

   443 

   444   return mh->method_counters();

   445 }

   446 

   447 void Method::cleanup_inline_caches() {

   448   // The current system doesn't use inline caches in the interpreter

   449   // => nothing to do (keep this method around for future use)

   450 }

   451 

   452 

   453 int Method::extra_stack_words() {

   454   // not an inline function, to avoid a header dependency on Interpreter

   455   return extra_stack_entries() * Interpreter::stackElementSize;

   456 }

   457 

   458 

   459 void Method::compute_size_of_parameters(Thread *thread) {

   460   ArgumentSizeComputer asc(signature());

   461   set_size_of_parameters(asc.size() + (is_static() ? 0 : 1));

   462 }

   463 

   464 BasicType Method::result_type() const {

   465   ResultTypeFinder rtf(signature());

   466   return rtf.type();

   467 }

   468 

   469 

   470 bool Method::is_empty_method() const {

   471   return  code_size() == 1

   472       && *code_base() == Bytecodes::_return;

   473 }

   474 

   475 

   476 bool Method::is_vanilla_constructor() const {

   477   // Returns true if this method is a vanilla constructor, i.e. an "<init>" "()V" method

   478   // which only calls the superclass vanilla constructor and possibly does stores of

   479   // zero constants to local fields:

   480   //

   481   //   aload_0

   482   //   invokespecial

   483   //   indexbyte1

   484   //   indexbyte2

   485   //

   486   // followed by an (optional) sequence of:

   487   //

   488   //   aload_0

   489   //   aconst_null / iconst_0 / fconst_0 / dconst_0

   490   //   putfield

   491   //   indexbyte1

   492   //   indexbyte2

   493   //

   494   // followed by:

   495   //

   496   //   return

   497 

   498   assert(name() == vmSymbols::object_initializer_name(),    "Should only be called for default constructors");

   499   assert(signature() == vmSymbols::void_method_signature(), "Should only be called for default constructors");

   500   int size = code_size();

   501   // Check if size match

   502   if (size == 0 || size % 5 != 0) return false;

   503   address cb = code_base();

   504   int last = size - 1;

   505   if (cb[0] != Bytecodes::_aload_0 || cb[1] != Bytecodes::_invokespecial || cb[last] != Bytecodes::_return) {

   506     // Does not call superclass default constructor

   507     return false;

   508   }

   509   // Check optional sequence

   510   for (int i = 4; i < last; i += 5) {

   511     if (cb[i] != Bytecodes::_aload_0) return false;

   512     if (!Bytecodes::is_zero_const(Bytecodes::cast(cb[i+1]))) return false;

   513     if (cb[i+2] != Bytecodes::_putfield) return false;

   514   }

   515   return true;

   516 }

   517 

   518 

   519 bool Method::compute_has_loops_flag() {

   520   BytecodeStream bcs(this);

   521   Bytecodes::Code bc;

   522 

   523   while ((bc = bcs.next()) >= 0) {

   524     switch( bc ) {

   525       case Bytecodes::_ifeq:

   526       case Bytecodes::_ifnull:

   527       case Bytecodes::_iflt:

   528       case Bytecodes::_ifle:

   529       case Bytecodes::_ifne:

   530       case Bytecodes::_ifnonnull:

   531       case Bytecodes::_ifgt:

   532       case Bytecodes::_ifge:

   533       case Bytecodes::_if_icmpeq:

   534       case Bytecodes::_if_icmpne:

   535       case Bytecodes::_if_icmplt:

   536       case Bytecodes::_if_icmpgt:

   537       case Bytecodes::_if_icmple:

   538       case Bytecodes::_if_icmpge:

   539       case Bytecodes::_if_acmpeq:

   540       case Bytecodes::_if_acmpne:

   541       case Bytecodes::_goto:

   542       case Bytecodes::_jsr:

   543         if( bcs.dest() < bcs.next_bci() ) _access_flags.set_has_loops();

   544         break;

   545 

   546       case Bytecodes::_goto_w:

   547       case Bytecodes::_jsr_w:

   548         if( bcs.dest_w() < bcs.next_bci() ) _access_flags.set_has_loops();

   549         break;

   550 

   551       default:

   552         break;

   553     }

   554   }

   555   _access_flags.set_loops_flag_init();

   556   return _access_flags.has_loops();

   557 }

   558 

   559 bool Method::is_final_method(AccessFlags class_access_flags) const {

   560   // or "does_not_require_vtable_entry"

   561   // default method or overpass can occur, is not final (reuses vtable entry)

   562   // private methods in classes get vtable entries for backward class compatibility.

   563   if (is_overpass() || is_default_method())  return false;

   564   return is_final() || class_access_flags.is_final();

   565 }

   566 

   567 bool Method::is_final_method() const {

   568   return is_final_method(method_holder()->access_flags());

   569 }

   570 

   571 bool Method::is_default_method() const {

   572   if (method_holder() != NULL &&

   573       method_holder()->is_interface() &&

   574       !is_abstract() && !is_private()) {

   575     return true;

   576   } else {

   577     return false;

   578   }

   579 }

   580 

   581 bool Method::can_be_statically_bound(AccessFlags class_access_flags) const {

   582   if (is_final_method(class_access_flags))  return true;

   583 #ifdef ASSERT

   584   ResourceMark rm;

   585   bool is_nonv = (vtable_index() == nonvirtual_vtable_index);

   586   if (class_access_flags.is_interface()) {

   587       assert(is_nonv == is_static() || is_nonv == is_private(),

   588              "nonvirtual unexpected for non-static, non-private: %s",

   589              name_and_sig_as_C_string());

   590   }

   591 #endif

   592   assert(valid_vtable_index() || valid_itable_index(), "method must be linked before we ask this question");

   593   return vtable_index() == nonvirtual_vtable_index;

   594 }

   595 

   596 bool Method::can_be_statically_bound() const {

   597   return can_be_statically_bound(method_holder()->access_flags());

   598 }

   599 

   600 bool Method::is_accessor() const {

   601   return is_getter() || is_setter();

   602 }

   603 

   604 bool Method::is_getter() const {

   605   if (code_size() != 5) return false;

   606   if (size_of_parameters() != 1) return false;

   607   if (java_code_at(0) != Bytecodes::_aload_0)  return false;

   608   if (java_code_at(1) != Bytecodes::_getfield) return false;

   609   switch (java_code_at(4)) {

   610     case Bytecodes::_ireturn:

   611     case Bytecodes::_lreturn:

   612     case Bytecodes::_freturn:

   613     case Bytecodes::_dreturn:

   614     case Bytecodes::_areturn:

   615       break;

   616     default:

   617       return false;

   618   }

   619   return true;

   620 }

   621 

   622 bool Method::is_setter() const {

   623   if (code_size() != 6) return false;

   624   if (java_code_at(0) != Bytecodes::_aload_0) return false;

   625   switch (java_code_at(1)) {

   626     case Bytecodes::_iload_1:

   627     case Bytecodes::_aload_1:

   628     case Bytecodes::_fload_1:

   629       if (size_of_parameters() != 2) return false;

   630       break;

   631     case Bytecodes::_dload_1:

   632     case Bytecodes::_lload_1:

   633       if (size_of_parameters() != 3) return false;

   634       break;

   635     default:

   636       return false;

   637   }

   638   if (java_code_at(2) != Bytecodes::_putfield) return false;

   639   if (java_code_at(5) != Bytecodes::_return)   return false;

   640   return true;

   641 }

   642 

   643 bool Method::is_constant_getter() const {

   644   int last_index = code_size() - 1;

   645   // Check if the first 1-3 bytecodes are a constant push

   646   // and the last bytecode is a return.

   647   return (2 <= code_size() && code_size() <= 4 &&

   648           Bytecodes::is_const(java_code_at(0)) &&

   649           Bytecodes::length_for(java_code_at(0)) == last_index &&

   650           Bytecodes::is_return(java_code_at(last_index)));

   651 }

   652 

   653 bool Method::is_initializer() const {

   654   return is_object_initializer() || is_static_initializer();

   655 }

   656 

   657 bool Method::has_valid_initializer_flags() const {

   658   return (is_static() ||

   659           method_holder()->major_version() < 51);

   660 }

   661 

   662 bool Method::is_static_initializer() const {

   663   // For classfiles version 51 or greater, ensure that the clinit method is

   664   // static.  Non-static methods with the name "<clinit>" are not static

   665   // initializers. (older classfiles exempted for backward compatibility)

   666   return name() == vmSymbols::class_initializer_name() &&

   667          has_valid_initializer_flags();

   668 }

   669 

   670 bool Method::is_object_initializer() const {

   671    return name() == vmSymbols::object_initializer_name();

   672 }

   673 

   674 objArrayHandle Method::resolved_checked_exceptions_impl(Method* method, TRAPS) {

   675   int length = method->checked_exceptions_length();

   676   if (length == 0) {  // common case

   677     return objArrayHandle(THREAD, Universe::the_empty_class_klass_array());

   678   } else {

   679     methodHandle h_this(THREAD, method);

   680     objArrayOop m_oop = oopFactory::new_objArray(SystemDictionary::Class_klass(), length, CHECK_(objArrayHandle()));

   681     objArrayHandle mirrors (THREAD, m_oop);

   682     for (int i = 0; i < length; i++) {

   683       CheckedExceptionElement* table = h_this->checked_exceptions_start(); // recompute on each iteration, not gc safe

   684       Klass* k = h_this->constants()->klass_at(table[i].class_cp_index, CHECK_(objArrayHandle()));

   685       assert(k->is_subclass_of(SystemDictionary::Throwable_klass()), "invalid exception class");

   686       mirrors->obj_at_put(i, k->java_mirror());

   687     }

   688     return mirrors;

   689   }

   690 };

   691 

   692 

   693 int Method::line_number_from_bci(int bci) const {

   694   if (bci == SynchronizationEntryBCI) bci = 0;

   695   assert(bci == 0 || 0 <= bci && bci < code_size(), "illegal bci");

   696   int best_bci  =  0;

   697   int best_line = -1;

   698 

   699   if (has_linenumber_table()) {

   700     // The line numbers are a short array of 2-tuples [start_pc, line_number].

   701     // Not necessarily sorted and not necessarily one-to-one.

   702     CompressedLineNumberReadStream stream(compressed_linenumber_table());

   703     while (stream.read_pair()) {

   704       if (stream.bci() == bci) {

   705         // perfect match

   706         return stream.line();

   707       } else {

   708         // update best_bci/line

   709         if (stream.bci() < bci && stream.bci() >= best_bci) {

   710           best_bci  = stream.bci();

   711           best_line = stream.line();

   712         }

   713       }

   714     }

   715   }

   716   return best_line;

   717 }

   718 

   719 

   720 bool Method::is_klass_loaded_by_klass_index(int klass_index) const {

   721   if( constants()->tag_at(klass_index).is_unresolved_klass() ) {

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

   723     Symbol* klass_name = constants()->klass_name_at(klass_index);

   724     Handle loader(thread, method_holder()->class_loader());

   725     Handle prot  (thread, method_holder()->protection_domain());

   726     return SystemDictionary::find(klass_name, loader, prot, thread) != NULL;

   727   } else {

   728     return true;

   729   }

   730 }

   731 

   732 

   733 bool Method::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {

   734   int klass_index = constants()->klass_ref_index_at(refinfo_index);

   735   if (must_be_resolved) {

   736     // Make sure klass is resolved in constantpool.

   737     if (constants()->tag_at(klass_index).is_unresolved_klass()) return false;

   738   }

   739   return is_klass_loaded_by_klass_index(klass_index);

   740 }

   741 

   742 

   743 void Method::set_native_function(address function, bool post_event_flag) {

   744   assert(function != NULL, "use clear_native_function to unregister natives");

   745   assert(!is_method_handle_intrinsic() || function == SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), "");

   746   address* native_function = native_function_addr();

   747 

   748   // We can see racers trying to place the same native function into place. Once

   749   // is plenty.

   750   address current = *native_function;

   751   if (current == function) return;

   752   if (post_event_flag && JvmtiExport::should_post_native_method_bind() &&

   753       function != NULL) {

   754     // native_method_throw_unsatisfied_link_error_entry() should only

   755     // be passed when post_event_flag is false.

   756     assert(function !=

   757       SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),

   758       "post_event_flag mis-match");

   759 

   760     // post the bind event, and possible change the bind function

   761     JvmtiExport::post_native_method_bind(this, &function);

   762   }

   763   *native_function = function;

   764   // This function can be called more than once. We must make sure that we always

   765   // use the latest registered method -> check if a stub already has been generated.

   766   // If so, we have to make it not_entrant.

   767   CompiledMethod* nm = code(); // Put it into local variable to guard against concurrent updates

   768   if (nm != NULL) {

   769     nm->make_not_entrant();

   770   }

   771 }

   772 

   773 

   774 bool Method::has_native_function() const {

   775   if (is_method_handle_intrinsic())

   776     return false;  // special-cased in SharedRuntime::generate_native_wrapper

   777   address func = native_function();

   778   return (func != NULL && func != SharedRuntime::native_method_throw_unsatisfied_link_error_entry());

   779 }

   780 

   781 

   782 void Method::clear_native_function() {

   783   // Note: is_method_handle_intrinsic() is allowed here.

   784   set_native_function(

   785     SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),

   786     !native_bind_event_is_interesting);

   787   clear_code();

   788 }

   789 

   790 address Method::critical_native_function() {

   791   methodHandle mh(this);

   792   return NativeLookup::lookup_critical_entry(mh);

   793 }

   794 

   795 

   796 void Method::set_signature_handler(address handler) {

   797   address* signature_handler =  signature_handler_addr();

   798   *signature_handler = handler;

   799 }

   800 

   801 

   802 void Method::print_made_not_compilable(int comp_level, bool is_osr, bool report, const char* reason) {

   803   if (PrintCompilation && report) {

   804     ttyLocker ttyl;

   805     tty->print("made not %scompilable on ", is_osr ? "OSR " : "");

   806     if (comp_level == CompLevel_all) {

   807       tty->print("all levels ");

   808     } else {

   809       tty->print("levels ");

   810       for (int i = (int)CompLevel_none; i <= comp_level; i++) {

   811         tty->print("%d ", i);

   812       }

   813     }

   814     this->print_short_name(tty);

   815     int size = this->code_size();

   816     if (size > 0) {

   817       tty->print(" (%d bytes)", size);

   818     }

   819     if (reason != NULL) {

   820       tty->print("   %s", reason);

   821     }

   822     tty->cr();

   823   }

   824   if ((TraceDeoptimization || LogCompilation) && (xtty != NULL)) {

   825     ttyLocker ttyl;

   826     xtty->begin_elem("make_not_compilable thread='" UINTX_FORMAT "' osr='%d' level='%d'",

   827                      os::current_thread_id(), is_osr, comp_level);

   828     if (reason != NULL) {

   829       xtty->print(" reason=\'%s\'", reason);

   830     }

   831     xtty->method(this);

   832     xtty->stamp();

   833     xtty->end_elem();

   834   }

   835 }

   836 

   837 bool Method::is_always_compilable() const {

   838   // Generated adapters must be compiled

   839   if (is_method_handle_intrinsic() && is_synthetic()) {

   840     assert(!is_not_c1_compilable(), "sanity check");

   841     assert(!is_not_c2_compilable(), "sanity check");

   842     return true;

   843   }

   844 

   845   return false;

   846 }

   847 

   848 bool Method::is_not_compilable(int comp_level) const {

   849   if (number_of_breakpoints() > 0)

   850     return true;

   851   if (is_always_compilable())

   852     return false;

   853   if (comp_level == CompLevel_any)

   854     return is_not_c1_compilable() || is_not_c2_compilable();

   855   if (is_c1_compile(comp_level))

   856     return is_not_c1_compilable();

   857   if (is_c2_compile(comp_level))

   858     return is_not_c2_compilable();

   859   return false;

   860 }

   861 

   862 // call this when compiler finds that this method is not compilable

   863 void Method::set_not_compilable(int comp_level, bool report, const char* reason) {

   864   if (is_always_compilable()) {

   865     // Don't mark a method which should be always compilable

   866     return;

   867   }

   868   print_made_not_compilable(comp_level, /*is_osr*/ false, report, reason);

   869   if (comp_level == CompLevel_all) {

   870     set_not_c1_compilable();

   871     set_not_c2_compilable();

   872   } else {

   873     if (is_c1_compile(comp_level))

   874       set_not_c1_compilable();

   875     if (is_c2_compile(comp_level))

   876       set_not_c2_compilable();

   877   }

   878   CompilationPolicy::policy()->disable_compilation(this);

   879   assert(!CompilationPolicy::can_be_compiled(this, comp_level), "sanity check");

   880 }

   881 

   882 bool Method::is_not_osr_compilable(int comp_level) const {

   883   if (is_not_compilable(comp_level))

   884     return true;

   885   if (comp_level == CompLevel_any)

   886     return is_not_c1_osr_compilable() || is_not_c2_osr_compilable();

   887   if (is_c1_compile(comp_level))

   888     return is_not_c1_osr_compilable();

   889   if (is_c2_compile(comp_level))

   890     return is_not_c2_osr_compilable();

   891   return false;

   892 }

   893 

   894 void Method::set_not_osr_compilable(int comp_level, bool report, const char* reason) {

   895   print_made_not_compilable(comp_level, /*is_osr*/ true, report, reason);

   896   if (comp_level == CompLevel_all) {

   897     set_not_c1_osr_compilable();

   898     set_not_c2_osr_compilable();

   899   } else {

   900     if (is_c1_compile(comp_level))

   901       set_not_c1_osr_compilable();

   902     if (is_c2_compile(comp_level))

   903       set_not_c2_osr_compilable();

   904   }

   905   CompilationPolicy::policy()->disable_compilation(this);

   906   assert(!CompilationPolicy::can_be_osr_compiled(this, comp_level), "sanity check");

   907 }

   908 

   909 // Revert to using the interpreter and clear out the nmethod

   910 void Method::clear_code(bool acquire_lock /* = true */) {

   911   MutexLockerEx pl(acquire_lock ? Patching_lock : NULL, Mutex::_no_safepoint_check_flag);

   912   // this may be NULL if c2i adapters have not been made yet

   913   // Only should happen at allocate time.

   914   if (adapter() == NULL) {

   915     _from_compiled_entry    = NULL;

   916   } else {

   917     _from_compiled_entry    = adapter()->get_c2i_entry();

   918   }

   919   OrderAccess::storestore();

   920   _from_interpreted_entry = _i2i_entry;

   921   OrderAccess::storestore();

   922   _code = NULL;

   923 }

   924 

   925 #if INCLUDE_CDS

   926 // Called by class data sharing to remove any entry points (which are not shared)

   927 void Method::unlink_method() {

   928   _code = NULL;

   929 

   930   assert(DumpSharedSpaces, "dump time only");

   931   // Set the values to what they should be at run time. Note that

   932   // this Method can no longer be executed during dump time.

   933   _i2i_entry = Interpreter::entry_for_cds_method(this);

   934   _from_interpreted_entry = _i2i_entry;

   935 

   936   if (is_native()) {

   937     *native_function_addr() = NULL;

   938     set_signature_handler(NULL);

   939   }

   940   NOT_PRODUCT(set_compiled_invocation_count(0);)

   941 

   942   CDSAdapterHandlerEntry* cds_adapter = (CDSAdapterHandlerEntry*)adapter();

   943   constMethod()->set_adapter_trampoline(cds_adapter->get_adapter_trampoline());

   944   _from_compiled_entry = cds_adapter->get_c2i_entry_trampoline();

   945   assert(*((int*)_from_compiled_entry) == 0, "must be NULL during dump time, to be initialized at run time");

   946 

   947   set_method_data(NULL);

   948   clear_method_counters();

   949 }

   950 #endif

   951 

   952 /****************************************************************************

   953 // The following illustrates how the entries work for CDS shared Methods:

   954 //

   955 // Our goal is to delay writing into a shared Method until it's compiled.

   956 // Hence, we want to determine the initial values for _i2i_entry,

   957 // _from_interpreted_entry and _from_compiled_entry during CDS dump time.

   958 //

   959 // In this example, both Methods A and B have the _i2i_entry of "zero_locals".

   960 // They also have similar signatures so that they will share the same

   961 // AdapterHandlerEntry.

   962 //

   963 // _adapter_trampoline points to a fixed location in the RW section of

   964 // the CDS archive. This location initially contains a NULL pointer. When the

   965 // first of method A or B is linked, an AdapterHandlerEntry is allocated

   966 // dynamically, and its c2i/i2c entries are generated.

   967 //

   968 // _i2i_entry and _from_interpreted_entry initially points to the same

   969 // (fixed) location in the CODE section of the CDS archive. This contains

   970 // an unconditional branch to the actual entry for "zero_locals", which is

   971 // generated at run time and may be on an arbitrary address. Thus, the

   972 // unconditional branch is also generated at run time to jump to the correct

   973 // address.

   974 //

   975 // Similarly, _from_compiled_entry points to a fixed address in the CODE

   976 // section. This address has enough space for an unconditional branch

   977 // instruction, and is initially zero-filled. After the AdapterHandlerEntry is

   978 // initialized, and the address for the actual c2i_entry is known, we emit a

   979 // branch instruction here to branch to the actual c2i_entry.

   980 //

   981 // The effect of the extra branch on the i2i and c2i entries is negligible.

   982 //

   983 // The reason for putting _adapter_trampoline in RO is many shared Methods

   984 // share the same AdapterHandlerEntry, so we can save space in the RW section

   985 // by having the extra indirection.

   986 

   987 

   988 [Method A: RW]

   989   _constMethod ----> [ConstMethod: RO]

   990                        _adapter_trampoline -----------+

   991                                                       |

   992   _i2i_entry              (same value as method B)    |

   993   _from_interpreted_entry (same value as method B)    |

   994   _from_compiled_entry    (same value as method B)    |

   995                                                       |

   996                                                       |

   997 [Method B: RW]                               +--------+

   998   _constMethod ----> [ConstMethod: RO]       |

   999                        _adapter_trampoline --+--->(AdapterHandlerEntry* ptr: RW)-+

  1000                                                                                  |

  1001                                                  +-------------------------------+

  1002                                                  |

  1003                                                  +----> [AdapterHandlerEntry] (allocated at run time)

  1004                                                               _fingerprint

  1005                                                               _c2i_entry ---------------------------------+->[c2i entry..]

  1006  _i2i_entry  -------------+                                   _i2c_entry ---------------+-> [i2c entry..] |

  1007  _from_interpreted_entry  |                                   _c2i_unverified_entry     |                 |

  1008          |                |                                                             |                 |

  1009          |                |  (_cds_entry_table: CODE)                                   |                 |

  1010          |                +->[0]: jmp _entry_table[0] --> (i2i_entry_for "zero_locals") |                 |

  1011          |                |                               (allocated at run time)       |                 |

  1012          |                |  ...                           [asm code ...]               |                 |

  1013          +-[not compiled]-+  [n]: jmp _entry_table[n]                                   |                 |

  1014          |                                                                              |                 |

  1015          |                                                                              |                 |

  1016          +-[compiled]-------------------------------------------------------------------+                 |

  1017                                                                                                           |

  1018  _from_compiled_entry------------>  (_c2i_entry_trampoline: CODE)                                         |

  1019                                     [jmp c2i_entry] ------------------------------------------------------+

  1020 

  1021 ***/

  1022 

  1023 // Called when the method_holder is getting linked. Setup entrypoints so the method

  1024 // is ready to be called from interpreter, compiler, and vtables.

  1025 void Method::link_method(const methodHandle& h_method, TRAPS) {

  1026   // If the code cache is full, we may reenter this function for the

  1027   // leftover methods that weren't linked.

  1028   if (is_shared()) {

  1029     address entry = Interpreter::entry_for_cds_method(h_method);

  1030     assert(entry != NULL && entry == _i2i_entry,

  1031            "should be correctly set during dump time");

  1032     if (adapter() != NULL) {

  1033       return;

  1034     }

  1035     assert(entry == _from_interpreted_entry,

  1036            "should be correctly set during dump time");

  1037   } else if (_i2i_entry != NULL) {

  1038     return;

  1039   }

  1040   assert( _code == NULL, "nothing compiled yet" );

  1041 

  1042   // Setup interpreter entrypoint

  1043   assert(this == h_method(), "wrong h_method()" );

  1044 

  1045   if (!is_shared()) {

  1046     assert(adapter() == NULL, "init'd to NULL");

  1047     address entry = Interpreter::entry_for_method(h_method);

  1048     assert(entry != NULL, "interpreter entry must be non-null");

  1049     // Sets both _i2i_entry and _from_interpreted_entry

  1050     set_interpreter_entry(entry);

  1051   }

  1052 

  1053   // Don't overwrite already registered native entries.

  1054   if (is_native() && !has_native_function()) {

  1055     set_native_function(

  1056       SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),

  1057       !native_bind_event_is_interesting);

  1058   }

  1059 

  1060   // Setup compiler entrypoint.  This is made eagerly, so we do not need

  1061   // special handling of vtables.  An alternative is to make adapters more

  1062   // lazily by calling make_adapter() from from_compiled_entry() for the

  1063   // normal calls.  For vtable calls life gets more complicated.  When a

  1064   // call-site goes mega-morphic we need adapters in all methods which can be

  1065   // called from the vtable.  We need adapters on such methods that get loaded

  1066   // later.  Ditto for mega-morphic itable calls.  If this proves to be a

  1067   // problem we'll make these lazily later.

  1068   (void) make_adapters(h_method, CHECK);

  1069 

  1070   // ONLY USE the h_method now as make_adapter may have blocked

  1071 

  1072 }

  1073 

  1074 address Method::make_adapters(const methodHandle& mh, TRAPS) {

  1075   // Adapters for compiled code are made eagerly here.  They are fairly

  1076   // small (generally < 100 bytes) and quick to make (and cached and shared)

  1077   // so making them eagerly shouldn't be too expensive.

  1078   AdapterHandlerEntry* adapter = AdapterHandlerLibrary::get_adapter(mh);

  1079   if (adapter == NULL ) {

  1080     if (!is_init_completed()) {

  1081       // Don't throw exceptions during VM initialization because java.lang.* classes

  1082       // might not have been initialized, causing problems when constructing the

  1083       // Java exception object.

  1084       vm_exit_during_initialization("Out of space in CodeCache for adapters");

  1085     } else {

  1086       THROW_MSG_NULL(vmSymbols::java_lang_VirtualMachineError(), "Out of space in CodeCache for adapters");

  1087     }

  1088   }

  1089 

  1090   if (mh->is_shared()) {

  1091     assert(mh->adapter() == adapter, "must be");

  1092     assert(mh->_from_compiled_entry != NULL, "must be");

  1093   } else {

  1094     mh->set_adapter_entry(adapter);

  1095     mh->_from_compiled_entry = adapter->get_c2i_entry();

  1096   }

  1097   return adapter->get_c2i_entry();

  1098 }

  1099 

  1100 void Method::restore_unshareable_info(TRAPS) {

  1101   assert(is_method() && is_valid_method(), "ensure C++ vtable is restored");

  1102 

  1103   // Since restore_unshareable_info can be called more than once for a method, don't

  1104   // redo any work.

  1105   if (adapter() == NULL) {

  1106     methodHandle mh(THREAD, this);

  1107     link_method(mh, CHECK);

  1108   }

  1109 }

  1110 

  1111 volatile address Method::from_compiled_entry_no_trampoline() const {

  1112   nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code);

  1113   if (code) {

  1114     return code->verified_entry_point();

  1115   } else {

  1116     return adapter()->get_c2i_entry();

  1117   }

  1118 }

  1119 

  1120 // The verified_code_entry() must be called when a invoke is resolved

  1121 // on this method.

  1122 

  1123 // It returns the compiled code entry point, after asserting not null.

  1124 // This function is called after potential safepoints so that nmethod

  1125 // or adapter that it points to is still live and valid.

  1126 // This function must not hit a safepoint!

  1127 address Method::verified_code_entry() {

  1128   debug_only(NoSafepointVerifier nsv;)

  1129   assert(_from_compiled_entry != NULL, "must be set");

  1130   return _from_compiled_entry;

  1131 }

  1132 

  1133 // Check that if an nmethod ref exists, it has a backlink to this or no backlink at all

  1134 // (could be racing a deopt).