1 /*

     2  * Copyright (c) 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 "gc/shared/gcLocker.hpp"

    27 #include "memory/allocation.hpp"

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

    29 #include "oops/method.hpp"

    30 #include "oops/symbol.hpp"

    31 #include "prims/resolvedMethodTable.hpp"

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

    33 #include "runtime/mutexLocker.hpp"

    34 #include "utilities/hashtable.inline.hpp"

    35 #include "utilities/macros.hpp"

    36 #if INCLUDE_ALL_GCS

    37 #include "gc/g1/g1SATBCardTableModRefBS.hpp"

    38 #endif

    39 

    40 

    41 ResolvedMethodTable::ResolvedMethodTable()

    42   : Hashtable<oop, mtClass>(_table_size, sizeof(ResolvedMethodEntry)) { }

    43 

    44 oop ResolvedMethodTable::lookup(int index, unsigned int hash, Method* method) {

    45   for (ResolvedMethodEntry* p = bucket(index); p != NULL; p = p->next()) {

    46     if (p->hash() == hash) {

    47       oop target = p->literal();

    48       // The method is in the table as a target already

    49       if (java_lang_invoke_ResolvedMethodName::vmtarget(target) == method) {

    50         ResourceMark rm;

    51         log_debug(membername, table) ("ResolvedMethod entry found for %s index %d",

    52                                        method->name_and_sig_as_C_string(), index);

    53         return target;

    54       }

    55     }

    56   }

    57   return NULL;

    58 }

    59 

    60 unsigned int ResolvedMethodTable::compute_hash(Method* method) {

    61   unsigned int name_hash = method->name()->identity_hash();

    62   unsigned int signature_hash = method->signature()->identity_hash();

    63   return name_hash ^ signature_hash;

    64 }

    65 

    66 

    67 oop ResolvedMethodTable::lookup(Method* method) {

    68   unsigned int hash = compute_hash(method);

    69   int index = hash_to_index(hash);

    70   return lookup(index, hash, method);

    71 }

    72 

    73 // Tell the GC that this oop was looked up in the table

    74 static void ensure_oop_alive(oop mname) {

    75   // A lookup in the ResolvedMethodTable could return an object that was previously

    76   // considered dead. The SATB part of G1 needs to get notified about this

    77   // potential resurrection, otherwise the marking might not find the object.

    78 #if INCLUDE_ALL_GCS

    79   if (UseG1GC && mname != NULL) {

    80     G1SATBCardTableModRefBS::enqueue(mname);

    81   }

    82 #endif

    83 }

    84 

    85 oop ResolvedMethodTable::basic_add(Method* method, oop rmethod_name) {

    86   assert_locked_or_safepoint(ResolvedMethodTable_lock);

    87 

    88   unsigned int hash = compute_hash(method);

    89   int index = hash_to_index(hash);

    90 

    91   // One was added while aquiring the lock

    92   oop entry = lookup(index, hash, method);

    93   if (entry != NULL) {

    94     ensure_oop_alive(entry);

    95     return entry;

    96   }

    97 

    98   ResolvedMethodEntry* p = (ResolvedMethodEntry*) Hashtable<oop, mtClass>::new_entry(hash, rmethod_name);

    99   Hashtable<oop, mtClass>::add_entry(index, p);

   100   ResourceMark rm;

   101   log_debug(membername, table) ("ResolvedMethod entry added for %s index %d",

   102                                  method->name_and_sig_as_C_string(), index);

   103   return p->literal();

   104 }

   105 

   106 ResolvedMethodTable* ResolvedMethodTable::_the_table = NULL;

   107 

   108 oop ResolvedMethodTable::find_method(Method* method) {

   109   oop entry = _the_table->lookup(method);

   110   ensure_oop_alive(entry);

   111   return entry;

   112 }

   113 

   114 oop ResolvedMethodTable::add_method(Handle resolved_method_name) {

   115   MutexLocker ml(ResolvedMethodTable_lock);

   116   DEBUG_ONLY(NoSafepointVerifier nsv);

   117 

   118   // Check if method has been redefined while taking out ResolvedMethodTable_lock, if so

   119   // use new method.

   120   Method* method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(resolved_method_name());

   121   assert(method->is_method(), "must be method");

   122   if (method->is_old()) {

   123     // Replace method with redefined version

   124     InstanceKlass* holder = method->method_holder();

   125     method = holder->method_with_idnum(method->method_idnum());

   126     java_lang_invoke_ResolvedMethodName::set_vmtarget(resolved_method_name(), method);

   127   }

   128   // Set flag in class to indicate this InstanceKlass has entries in the table

   129   // to avoid walking table during redefinition if none of the redefined classes

   130   // have any membernames in the table.

   131   method->method_holder()->set_has_resolved_methods();

   132 

   133   return _the_table->basic_add(method, resolved_method_name());

   134 }

   135 

   136 // Removing entries

   137 int ResolvedMethodTable::_oops_removed = 0;

   138 int ResolvedMethodTable::_oops_counted = 0;

   139 

   140 // Serially invoke removed unused oops from the table.

   141 // This is done late during GC.

   142 void ResolvedMethodTable::unlink(BoolObjectClosure* is_alive) {

   143   _oops_removed = 0;

   144   _oops_counted = 0;

   145   for (int i = 0; i < _the_table->table_size(); ++i) {

   146     ResolvedMethodEntry** p = _the_table->bucket_addr(i);

   147     ResolvedMethodEntry* entry = _the_table->bucket(i);

   148     while (entry != NULL) {

   149       _oops_counted++;

   150       if (is_alive->do_object_b(entry->literal())) {

   151         p = entry->next_addr();

   152       } else {

   153         _oops_removed++;

   154         if (log_is_enabled(Debug, membername, table)) {

   155           Method* m = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(entry->literal());

   156           ResourceMark rm;

   157           log_debug(membername, table) ("ResolvedMethod entry removed for %s index %d",

   158                                            m->name_and_sig_as_C_string(), i);

   159         }

   160         *p = entry->next();

   161         _the_table->free_entry(entry);

   162       }

   163       // get next entry

   164       entry = (ResolvedMethodEntry*)HashtableEntry<oop, mtClass>::make_ptr(*p);

   165     }

   166   }

   167   log_debug(membername, table) ("ResolvedMethod entries counted %d removed %d",

   168                                 _oops_counted, _oops_removed);

   169 }

   170 

   171 // Serially invoke "f->do_oop" on the locations of all oops in the table.

   172 void ResolvedMethodTable::oops_do(OopClosure* f) {

   173   for (int i = 0; i < _the_table->table_size(); ++i) {

   174     ResolvedMethodEntry* entry = _the_table->bucket(i);

   175     while (entry != NULL) {

   176       f->do_oop(entry->literal_addr());

   177       entry = entry->next();

   178     }

   179   }

   180 }

   181 

   182 #ifndef PRODUCT

   183 void ResolvedMethodTable::print() {

   184   for (int i = 0; i < table_size(); ++i) {

   185     ResolvedMethodEntry* entry = bucket(i);

   186     while (entry != NULL) {

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

   188       oop rmethod_name = entry->literal();

   189       rmethod_name->print();

   190       Method* m = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(rmethod_name);

   191       m->print();

   192       entry = entry->next();

   193     }

   194   }

   195 }

   196 #endif // PRODUCT

   197 

   198 #if INCLUDE_JVMTI

   199 // It is called at safepoint only for RedefineClasses

   200 void ResolvedMethodTable::adjust_method_entries(bool * trace_name_printed) {

   201   assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");

   202   // For each entry in RMT, change to new method

   203   for (int i = 0; i < _the_table->table_size(); ++i) {

   204     ResolvedMethodEntry* entry = _the_table->bucket(i);

   205     while (entry != NULL) {

   206 

   207       oop mem_name = entry->literal();

   208       Method* old_method = (Method*)java_lang_invoke_ResolvedMethodName::vmtarget(mem_name);

   209 

   210       if (old_method->is_old()) {

   211 

   212         if (old_method->is_deleted()) {

   213           // leave deleted method in ResolvedMethod for now (this is a bug that we don't mark

   214           // these on_stack)

   215           continue;

   216         }

   217 

   218         InstanceKlass* holder = old_method->method_holder();

   219         Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());

   220         assert(holder == new_method->method_holder(), "call after swapping redefined guts");

   221         assert(new_method != NULL, "method_with_idnum() should not be NULL");

   222         assert(old_method != new_method, "sanity check");

   223 

   224         java_lang_invoke_ResolvedMethodName::set_vmtarget(mem_name, new_method);

   225 

   226         ResourceMark rm;

   227         if (!(*trace_name_printed)) {

   228           log_info(redefine, class, update)("adjust: name=%s", old_method->method_holder()->external_name());

   229            *trace_name_printed = true;

   230         }

   231         log_debug(redefine, class, update, constantpool)

   232           ("ResolvedMethod method update: %s(%s)",

   233            new_method->name()->as_C_string(), new_method->signature()->as_C_string());

   234       }

   235       entry = entry->next();

   236     }

   237   }

   238 }

   239 #endif // INCLUDE_JVMTI