rev 1083 : code cache unloading for webrev 091214

   1 /*
   2  * Copyright 1997-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  20  * CA 95054 USA or visit www.sun.com if you need additional information or
  21  * have any questions.
  22  *
  23  */
  24 
  25 # include "incls/_precompiled.incl"
  26 # include "incls/_methodOop.cpp.incl"
  27 
  28 
  29 // Implementation of methodOopDesc
  30 
  31 address methodOopDesc::get_i2c_entry() {
  32   assert(_adapter != NULL, "must have");
  33   return _adapter->get_i2c_entry();
  34 }
  35 
  36 address methodOopDesc::get_c2i_entry() {
  37   assert(_adapter != NULL, "must have");
  38   return _adapter->get_c2i_entry();
  39 }
  40 
  41 address methodOopDesc::get_c2i_unverified_entry() {
  42   assert(_adapter != NULL, "must have");
  43   return _adapter->get_c2i_unverified_entry();
  44 }
  45 
  46 char* methodOopDesc::name_and_sig_as_C_string() {
  47   return name_and_sig_as_C_string(Klass::cast(constants()->pool_holder()), name(), signature());
  48 }
  49 
  50 char* methodOopDesc::name_and_sig_as_C_string(char* buf, int size) {
  51   return name_and_sig_as_C_string(Klass::cast(constants()->pool_holder()), name(), signature(), buf, size);
  52 }
  53 
  54 char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, symbolOop method_name, symbolOop signature) {
  55   const char* klass_name = klass->external_name();
  56   int klass_name_len  = (int)strlen(klass_name);
  57   int method_name_len = method_name->utf8_length();
  58   int len             = klass_name_len + 1 + method_name_len + signature->utf8_length();
  59   char* dest          = NEW_RESOURCE_ARRAY(char, len + 1);
  60   strcpy(dest, klass_name);
  61   dest[klass_name_len] = '.';
  62   strcpy(&dest[klass_name_len + 1], method_name->as_C_string());
  63   strcpy(&dest[klass_name_len + 1 + method_name_len], signature->as_C_string());
  64   dest[len] = 0;
  65   return dest;
  66 }
  67 
  68 char* methodOopDesc::name_and_sig_as_C_string(Klass* klass, symbolOop method_name, symbolOop signature, char* buf, int size) {
  69   symbolOop klass_name = klass->name();
  70   klass_name->as_klass_external_name(buf, size);
  71   int len = (int)strlen(buf);
  72 
  73   if (len < size - 1) {
  74     buf[len++] = '.';
  75 
  76     method_name->as_C_string(&(buf[len]), size - len);
  77     len = (int)strlen(buf);
  78 
  79     signature->as_C_string(&(buf[len]), size - len);
  80   }
  81 
  82   return buf;
  83 }
  84 
  85 int  methodOopDesc::fast_exception_handler_bci_for(KlassHandle ex_klass, int throw_bci, TRAPS) {
  86   // exception table holds quadruple entries of the form (beg_bci, end_bci, handler_bci, klass_index)
  87   const int beg_bci_offset     = 0;
  88   const int end_bci_offset     = 1;
  89   const int handler_bci_offset = 2;
  90   const int klass_index_offset = 3;
  91   const int entry_size         = 4;
  92   // access exception table
  93   typeArrayHandle table (THREAD, constMethod()->exception_table());
  94   int length = table->length();
  95   assert(length % entry_size == 0, "exception table format has changed");
  96   // iterate through all entries sequentially
  97   constantPoolHandle pool(THREAD, constants());
  98   for (int i = 0; i < length; i += entry_size) {
  99     int beg_bci = table->int_at(i + beg_bci_offset);
 100     int end_bci = table->int_at(i + end_bci_offset);
 101     assert(beg_bci <= end_bci, "inconsistent exception table");
 102     if (beg_bci <= throw_bci && throw_bci < end_bci) {
 103       // exception handler bci range covers throw_bci => investigate further
 104       int handler_bci = table->int_at(i + handler_bci_offset);
 105       int klass_index = table->int_at(i + klass_index_offset);
 106       if (klass_index == 0) {
 107         return handler_bci;
 108       } else if (ex_klass.is_null()) {
 109         return handler_bci;
 110       } else {
 111         // we know the exception class => get the constraint class
 112         // this may require loading of the constraint class; if verification
 113         // fails or some other exception occurs, return handler_bci
 114         klassOop k = pool->klass_at(klass_index, CHECK_(handler_bci));
 115         KlassHandle klass = KlassHandle(THREAD, k);
 116         assert(klass.not_null(), "klass not loaded");
 117         if (ex_klass->is_subtype_of(klass())) {
 118           return handler_bci;
 119         }
 120       }
 121     }
 122   }
 123 
 124   return -1;
 125 }
 126 
 127 methodOop methodOopDesc::method_from_bcp(address bcp) {
 128   debug_only(static int count = 0; count++);
 129   assert(Universe::heap()->is_in_permanent(bcp), "bcp not in perm_gen");
 130   // TO DO: this may be unsafe in some configurations
 131   HeapWord* p = Universe::heap()->block_start(bcp);
 132   assert(Universe::heap()->block_is_obj(p), "must be obj");
 133   assert(oop(p)->is_constMethod(), "not a method");
 134   return constMethodOop(p)->method();
 135 }
 136 
 137 
 138 void methodOopDesc::mask_for(int bci, InterpreterOopMap* mask) {
 139 
 140   Thread* myThread    = Thread::current();
 141   methodHandle h_this(myThread, this);
 142 #ifdef ASSERT
 143   bool has_capability = myThread->is_VM_thread() ||
 144                         myThread->is_ConcurrentGC_thread() ||
 145                         myThread->is_GC_task_thread();
 146 
 147   if (!has_capability) {
 148     if (!VerifyStack && !VerifyLastFrame) {
 149       // verify stack calls this outside VM thread
 150       warning("oopmap should only be accessed by the "
 151               "VM, GC task or CMS threads (or during debugging)");
 152       InterpreterOopMap local_mask;
 153       instanceKlass::cast(method_holder())->mask_for(h_this, bci, &local_mask);
 154       local_mask.print();
 155     }
 156   }
 157 #endif
 158   instanceKlass::cast(method_holder())->mask_for(h_this, bci, mask);
 159   return;
 160 }
 161 
 162 
 163 int methodOopDesc::bci_from(address bcp) const {
 164   assert(is_native() && bcp == code_base() || contains(bcp) || is_error_reported(), "bcp doesn't belong to this method");
 165   return bcp - code_base();
 166 }
 167 
 168 
 169 // Return (int)bcx if it appears to be a valid BCI.
 170 // Return bci_from((address)bcx) if it appears to be a valid BCP.
 171 // Return -1 otherwise.
 172 // Used by profiling code, when invalid data is a possibility.
 173 // The caller is responsible for validating the methodOop itself.
 174 int methodOopDesc::validate_bci_from_bcx(intptr_t bcx) const {
 175   // keep bci as -1 if not a valid bci
 176   int bci = -1;
 177   if (bcx == 0 || (address)bcx == code_base()) {
 178     // code_size() may return 0 and we allow 0 here
 179     // the method may be native
 180     bci = 0;
 181   } else if (frame::is_bci(bcx)) {
 182     if (bcx < code_size()) {
 183       bci = (int)bcx;
 184     }
 185   } else if (contains((address)bcx)) {
 186     bci = (address)bcx - code_base();
 187   }
 188   // Assert that if we have dodged any asserts, bci is negative.
 189   assert(bci == -1 || bci == bci_from(bcp_from(bci)), "sane bci if >=0");
 190   return bci;
 191 }
 192 
 193 address methodOopDesc::bcp_from(int bci) const {
 194   assert((is_native() && bci == 0)  || (!is_native() && 0 <= bci && bci < code_size()), "illegal bci");
 195   address bcp = code_base() + bci;
 196   assert(is_native() && bcp == code_base() || contains(bcp), "bcp doesn't belong to this method");
 197   return bcp;
 198 }
 199 
 200 
 201 int methodOopDesc::object_size(bool is_native) {
 202   // If native, then include pointers for native_function and signature_handler
 203   int extra_bytes = (is_native) ? 2*sizeof(address*) : 0;
 204   int extra_words = align_size_up(extra_bytes, BytesPerWord) / BytesPerWord;
 205   return align_object_size(header_size() + extra_words);
 206 }
 207 
 208 
 209 symbolOop methodOopDesc::klass_name() const {
 210   klassOop k = method_holder();
 211   assert(k->is_klass(), "must be klass");
 212   instanceKlass* ik = (instanceKlass*) k->klass_part();
 213   return ik->name();
 214 }
 215 
 216 
 217 void methodOopDesc::set_interpreter_kind() {
 218   int kind = Interpreter::method_kind(methodOop(this));
 219   assert(kind != Interpreter::invalid,
 220          "interpreter entry must be valid");
 221   set_interpreter_kind(kind);
 222 }
 223 
 224 
 225 // Attempt to return method oop to original state.  Clear any pointers
 226 // (to objects outside the shared spaces).  We won't be able to predict
 227 // where they should point in a new JVM.  Further initialize some
 228 // entries now in order allow them to be write protected later.
 229 
 230 void methodOopDesc::remove_unshareable_info() {
 231   unlink_method();
 232   set_interpreter_kind();
 233 }
 234 
 235 
 236 bool methodOopDesc::was_executed_more_than(int n) const {
 237   // Invocation counter is reset when the methodOop is compiled.
 238   // If the method has compiled code we therefore assume it has
 239   // be excuted more than n times.
 240   if (is_accessor() || is_empty_method() || (code() != NULL)) {
 241     // interpreter doesn't bump invocation counter of trivial methods
 242     // compiler does not bump invocation counter of compiled methods
 243     return true;
 244   } else if (_invocation_counter.carry()) {
 245     // The carry bit is set when the counter overflows and causes
 246     // a compilation to occur.  We don't know how many times
 247     // the counter has been reset, so we simply assume it has
 248     // been executed more than n times.
 249     return true;
 250   } else {
 251     return invocation_count() > n;
 252   }
 253 }
 254 
 255 #ifndef PRODUCT
 256 void methodOopDesc::print_invocation_count() const {
 257   if (is_static()) tty->print("static ");
 258   if (is_final()) tty->print("final ");
 259   if (is_synchronized()) tty->print("synchronized ");
 260   if (is_native()) tty->print("native ");
 261   method_holder()->klass_part()->name()->print_symbol_on(tty);
 262   tty->print(".");
 263   name()->print_symbol_on(tty);
 264   signature()->print_symbol_on(tty);
 265 
 266   if (WizardMode) {
 267     // dump the size of the byte codes
 268     tty->print(" {%d}", code_size());
 269   }
 270   tty->cr();
 271 
 272   tty->print_cr ("  interpreter_invocation_count: %8d ", interpreter_invocation_count());
 273   tty->print_cr ("  invocation_counter:           %8d ", invocation_count());
 274   tty->print_cr ("  backedge_counter:             %8d ", backedge_count());
 275   if (CountCompiledCalls) {
 276     tty->print_cr ("  compiled_invocation_count: %8d ", compiled_invocation_count());
 277   }
 278 
 279 }
 280 #endif
 281 
 282 // Build a methodDataOop object to hold information about this method
 283 // collected in the interpreter.
 284 void methodOopDesc::build_interpreter_method_data(methodHandle method, TRAPS) {
 285   // Grab a lock here to prevent multiple
 286   // methodDataOops from being created.
 287   MutexLocker ml(MethodData_lock, THREAD);
 288   if (method->method_data() == NULL) {
 289     methodDataOop method_data = oopFactory::new_methodData(method, CHECK);
 290     method->set_method_data(method_data);
 291     if (PrintMethodData && (Verbose || WizardMode)) {
 292       ResourceMark rm(THREAD);
 293       tty->print("build_interpreter_method_data for ");
 294       method->print_name(tty);
 295       tty->cr();
 296       // At the end of the run, the MDO, full of data, will be dumped.
 297     }
 298   }
 299 }
 300 
 301 void methodOopDesc::cleanup_inline_caches() {
 302   // The current system doesn't use inline caches in the interpreter
 303   // => nothing to do (keep this method around for future use)
 304 }
 305 
 306 
 307 int methodOopDesc::extra_stack_words() {
 308   // not an inline function, to avoid a header dependency on Interpreter
 309   return extra_stack_entries() * Interpreter::stackElementSize();
 310 }
 311 
 312 
 313 void methodOopDesc::compute_size_of_parameters(Thread *thread) {
 314   symbolHandle h_signature(thread, signature());
 315   ArgumentSizeComputer asc(h_signature);
 316   set_size_of_parameters(asc.size() + (is_static() ? 0 : 1));
 317 }
 318 
 319 #ifdef CC_INTERP
 320 void methodOopDesc::set_result_index(BasicType type)          {
 321   _result_index = Interpreter::BasicType_as_index(type);
 322 }
 323 #endif
 324 
 325 BasicType methodOopDesc::result_type() const {
 326   ResultTypeFinder rtf(signature());
 327   return rtf.type();
 328 }
 329 
 330 
 331 bool methodOopDesc::is_empty_method() const {
 332   return  code_size() == 1
 333       && *code_base() == Bytecodes::_return;
 334 }
 335 
 336 
 337 bool methodOopDesc::is_vanilla_constructor() const {
 338   // Returns true if this method is a vanilla constructor, i.e. an "<init>" "()V" method
 339   // which only calls the superclass vanilla constructor and possibly does stores of
 340   // zero constants to local fields:
 341   //
 342   //   aload_0
 343   //   invokespecial
 344   //   indexbyte1
 345   //   indexbyte2
 346   //
 347   // followed by an (optional) sequence of:
 348   //
 349   //   aload_0
 350   //   aconst_null / iconst_0 / fconst_0 / dconst_0
 351   //   putfield
 352   //   indexbyte1
 353   //   indexbyte2
 354   //
 355   // followed by:
 356   //
 357   //   return
 358 
 359   assert(name() == vmSymbols::object_initializer_name(),    "Should only be called for default constructors");
 360   assert(signature() == vmSymbols::void_method_signature(), "Should only be called for default constructors");
 361   int size = code_size();
 362   // Check if size match
 363   if (size == 0 || size % 5 != 0) return false;
 364   address cb = code_base();
 365   int last = size - 1;
 366   if (cb[0] != Bytecodes::_aload_0 || cb[1] != Bytecodes::_invokespecial || cb[last] != Bytecodes::_return) {
 367     // Does not call superclass default constructor
 368     return false;
 369   }
 370   // Check optional sequence
 371   for (int i = 4; i < last; i += 5) {
 372     if (cb[i] != Bytecodes::_aload_0) return false;
 373     if (!Bytecodes::is_zero_const(Bytecodes::cast(cb[i+1]))) return false;
 374     if (cb[i+2] != Bytecodes::_putfield) return false;
 375   }
 376   return true;
 377 }
 378 
 379 
 380 bool methodOopDesc::compute_has_loops_flag() {
 381   BytecodeStream bcs(methodOop(this));
 382   Bytecodes::Code bc;
 383 
 384   while ((bc = bcs.next()) >= 0) {
 385     switch( bc ) {
 386       case Bytecodes::_ifeq:
 387       case Bytecodes::_ifnull:
 388       case Bytecodes::_iflt:
 389       case Bytecodes::_ifle:
 390       case Bytecodes::_ifne:
 391       case Bytecodes::_ifnonnull:
 392       case Bytecodes::_ifgt:
 393       case Bytecodes::_ifge:
 394       case Bytecodes::_if_icmpeq:
 395       case Bytecodes::_if_icmpne:
 396       case Bytecodes::_if_icmplt:
 397       case Bytecodes::_if_icmpgt:
 398       case Bytecodes::_if_icmple:
 399       case Bytecodes::_if_icmpge:
 400       case Bytecodes::_if_acmpeq:
 401       case Bytecodes::_if_acmpne:
 402       case Bytecodes::_goto:
 403       case Bytecodes::_jsr:
 404         if( bcs.dest() < bcs.next_bci() ) _access_flags.set_has_loops();
 405         break;
 406 
 407       case Bytecodes::_goto_w:
 408       case Bytecodes::_jsr_w:
 409         if( bcs.dest_w() < bcs.next_bci() ) _access_flags.set_has_loops();
 410         break;
 411     }
 412   }
 413   _access_flags.set_loops_flag_init();
 414   return _access_flags.has_loops();
 415 }
 416 
 417 
 418 bool methodOopDesc::is_final_method() const {
 419   // %%% Should return true for private methods also,
 420   // since there is no way to override them.
 421   return is_final() || Klass::cast(method_holder())->is_final();
 422 }
 423 
 424 
 425 bool methodOopDesc::is_strict_method() const {
 426   return is_strict();
 427 }
 428 
 429 
 430 bool methodOopDesc::can_be_statically_bound() const {
 431   if (is_final_method())  return true;
 432   return vtable_index() == nonvirtual_vtable_index;
 433 }
 434 
 435 
 436 bool methodOopDesc::is_accessor() const {
 437   if (code_size() != 5) return false;
 438   if (size_of_parameters() != 1) return false;
 439   methodOop m = (methodOop)this;  // pass to code_at() to avoid method_from_bcp
 440   if (Bytecodes::java_code_at(code_base()+0, m) != Bytecodes::_aload_0 ) return false;
 441   if (Bytecodes::java_code_at(code_base()+1, m) != Bytecodes::_getfield) return false;
 442   if (Bytecodes::java_code_at(code_base()+4, m) != Bytecodes::_areturn &&
 443       Bytecodes::java_code_at(code_base()+4, m) != Bytecodes::_ireturn ) return false;
 444   return true;
 445 }
 446 
 447 
 448 bool methodOopDesc::is_initializer() const {
 449   return name() == vmSymbols::object_initializer_name() || name() == vmSymbols::class_initializer_name();
 450 }
 451 
 452 
 453 objArrayHandle methodOopDesc::resolved_checked_exceptions_impl(methodOop this_oop, TRAPS) {
 454   int length = this_oop->checked_exceptions_length();
 455   if (length == 0) {  // common case
 456     return objArrayHandle(THREAD, Universe::the_empty_class_klass_array());
 457   } else {
 458     methodHandle h_this(THREAD, this_oop);
 459     objArrayOop m_oop = oopFactory::new_objArray(SystemDictionary::class_klass(), length, CHECK_(objArrayHandle()));
 460     objArrayHandle mirrors (THREAD, m_oop);
 461     for (int i = 0; i < length; i++) {
 462       CheckedExceptionElement* table = h_this->checked_exceptions_start(); // recompute on each iteration, not gc safe
 463       klassOop k = h_this->constants()->klass_at(table[i].class_cp_index, CHECK_(objArrayHandle()));
 464       assert(Klass::cast(k)->is_subclass_of(SystemDictionary::throwable_klass()), "invalid exception class");
 465       mirrors->obj_at_put(i, Klass::cast(k)->java_mirror());
 466     }
 467     return mirrors;
 468   }
 469 };
 470 
 471 
 472 int methodOopDesc::line_number_from_bci(int bci) const {
 473   if (bci == SynchronizationEntryBCI) bci = 0;
 474   assert(bci == 0 || 0 <= bci && bci < code_size(), "illegal bci");
 475   int best_bci  =  0;
 476   int best_line = -1;
 477 
 478   if (has_linenumber_table()) {
 479     // The line numbers are a short array of 2-tuples [start_pc, line_number].
 480     // Not necessarily sorted and not necessarily one-to-one.
 481     CompressedLineNumberReadStream stream(compressed_linenumber_table());
 482     while (stream.read_pair()) {
 483       if (stream.bci() == bci) {
 484         // perfect match
 485         return stream.line();
 486       } else {
 487         // update best_bci/line
 488         if (stream.bci() < bci && stream.bci() >= best_bci) {
 489           best_bci  = stream.bci();
 490           best_line = stream.line();
 491         }
 492       }
 493     }
 494   }
 495   return best_line;
 496 }
 497 
 498 
 499 bool methodOopDesc::is_klass_loaded_by_klass_index(int klass_index) const {
 500   if( _constants->tag_at(klass_index).is_unresolved_klass() ) {
 501     Thread *thread = Thread::current();
 502     symbolHandle klass_name(thread, _constants->klass_name_at(klass_index));
 503     Handle loader(thread, instanceKlass::cast(method_holder())->class_loader());
 504     Handle prot  (thread, Klass::cast(method_holder())->protection_domain());
 505     return SystemDictionary::find(klass_name, loader, prot, thread) != NULL;
 506   } else {
 507     return true;
 508   }
 509 }
 510 
 511 
 512 bool methodOopDesc::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
 513   int klass_index = _constants->klass_ref_index_at(refinfo_index);
 514   if (must_be_resolved) {
 515     // Make sure klass is resolved in constantpool.
 516     if (constants()->tag_at(klass_index).is_unresolved_klass()) return false;
 517   }
 518   return is_klass_loaded_by_klass_index(klass_index);
 519 }
 520 
 521 
 522 void methodOopDesc::set_native_function(address function, bool post_event_flag) {
 523   assert(function != NULL, "use clear_native_function to unregister natives");
 524   address* native_function = native_function_addr();
 525 
 526   // We can see racers trying to place the same native function into place. Once
 527   // is plenty.
 528   address current = *native_function;
 529   if (current == function) return;
 530   if (post_event_flag && JvmtiExport::should_post_native_method_bind() &&
 531       function != NULL) {
 532     // native_method_throw_unsatisfied_link_error_entry() should only
 533     // be passed when post_event_flag is false.
 534     assert(function !=
 535       SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
 536       "post_event_flag mis-match");
 537 
 538     // post the bind event, and possible change the bind function
 539     JvmtiExport::post_native_method_bind(this, &function);
 540   }
 541   *native_function = function;
 542   // This function can be called more than once. We must make sure that we always
 543   // use the latest registered method -> check if a stub already has been generated.
 544   // If so, we have to make it not_entrant.
 545   nmethod* nm = code(); // Put it into local variable to guard against concurrent updates
 546   if (nm != NULL) {
 547     nm->make_not_entrant();
 548   }
 549 }
 550 
 551 
 552 bool methodOopDesc::has_native_function() const {
 553   address func = native_function();
 554   return (func != NULL && func != SharedRuntime::native_method_throw_unsatisfied_link_error_entry());
 555 }
 556 
 557 
 558 void methodOopDesc::clear_native_function() {
 559   set_native_function(
 560     SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
 561     !native_bind_event_is_interesting);
 562   clear_code();
 563 }
 564 
 565 
 566 void methodOopDesc::set_signature_handler(address handler) {
 567   address* signature_handler =  signature_handler_addr();
 568   *signature_handler = handler;
 569 }
 570 
 571 
 572 bool methodOopDesc::is_not_compilable(int comp_level) const {
 573   if (is_method_handle_invoke()) {
 574     // compilers must recognize this method specially, or not at all
 575     return true;
 576   }
 577 
 578   methodDataOop mdo = method_data();
 579   if (mdo != NULL
 580       && (uint)mdo->decompile_count() > (uint)PerMethodRecompilationCutoff) {
 581     // Since (uint)-1 is large, -1 really means 'no cutoff'.
 582     return true;
 583   }
 584 #ifdef COMPILER2
 585   if (is_tier1_compile(comp_level)) {
 586     if (is_not_tier1_compilable()) {
 587       return true;
 588     }
 589   }
 590 #endif // COMPILER2
 591   return (_invocation_counter.state() == InvocationCounter::wait_for_nothing)
 592           || (number_of_breakpoints() > 0);
 593 }
 594 
 595 // call this when compiler finds that this method is not compilable
 596 void methodOopDesc::set_not_compilable(int comp_level) {
 597   if ((TraceDeoptimization || LogCompilation) && (xtty != NULL)) {
 598     ttyLocker ttyl;
 599     xtty->begin_elem("make_not_compilable thread='%d'", (int) os::current_thread_id());
 600     xtty->method(methodOop(this));
 601     xtty->stamp();
 602     xtty->end_elem();
 603   }
 604 #ifdef COMPILER2
 605   if (is_tier1_compile(comp_level)) {
 606     set_not_tier1_compilable();
 607     return;
 608   }
 609 #endif /* COMPILER2 */
 610   assert(comp_level == CompLevel_highest_tier, "unexpected compilation level");
 611   invocation_counter()->set_state(InvocationCounter::wait_for_nothing);
 612   backedge_counter()->set_state(InvocationCounter::wait_for_nothing);
 613 }
 614 
 615 // Clear the code ptr during emergency code cache sweeping
 616 // It will be restored if it is actually called
 617 void methodOopDesc::clear_code_hedge() {
 618   // should guarantee at safepoint
 619   nmethod* tmp = code();
 620   clear_code();
 621   _saved_code = tmp;
 622   assert( ! _saved_code->is_osr_method(), "should not get here for osr" );  
 623 }
 624 
 625 // Revert to using the interpreter and clear out the nmethod
 626 void methodOopDesc::clear_code() {
 627 
 628   // this may be NULL if c2i adapters have not been made yet
 629   // Only should happen at allocate time.
 630   if (_adapter == NULL) {
 631     _from_compiled_entry    = NULL;
 632   } else {
 633     _from_compiled_entry    = _adapter->get_c2i_entry();
 634   }
 635   OrderAccess::storestore();
 636   _from_interpreted_entry = _i2i_entry;
 637   OrderAccess::storestore();
 638   _code = NULL;
 639   _saved_code = NULL;
 640 }
 641 
 642 // Called by class data sharing to remove any entry points (which are not shared)
 643 void methodOopDesc::unlink_method() {
 644   _code = NULL;
 645   _i2i_entry = NULL;
 646   _from_interpreted_entry = NULL;
 647   if (is_native()) {
 648     *native_function_addr() = NULL;
 649     set_signature_handler(NULL);
 650   }
 651   NOT_PRODUCT(set_compiled_invocation_count(0);)
 652   invocation_counter()->reset();
 653   backedge_counter()->reset();
 654   _adapter = NULL;
 655   _from_compiled_entry = NULL;
 656   assert(_method_data == NULL, "unexpected method data?");
 657   set_method_data(NULL);
 658   set_interpreter_throwout_count(0);
 659   set_interpreter_invocation_count(0);
 660   _highest_tier_compile = CompLevel_none;
 661 }
 662 
 663 // Called when the method_holder is getting linked. Setup entrypoints so the method
 664 // is ready to be called from interpreter, compiler, and vtables.
 665 void methodOopDesc::link_method(methodHandle h_method, TRAPS) {
 666   assert(_i2i_entry == NULL, "should only be called once");
 667   assert(_adapter == NULL, "init'd to NULL" );
 668   assert( _code == NULL, "nothing compiled yet" );
 669 
 670   // Setup interpreter entrypoint
 671   assert(this == h_method(), "wrong h_method()" );
 672   address entry = Interpreter::entry_for_method(h_method);
 673   assert(entry != NULL, "interpreter entry must be non-null");
 674   // Sets both _i2i_entry and _from_interpreted_entry
 675   set_interpreter_entry(entry);
 676   if (is_native() && !is_method_handle_invoke()) {
 677     set_native_function(
 678       SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
 679       !native_bind_event_is_interesting);
 680   }
 681 
 682   // Setup compiler entrypoint.  This is made eagerly, so we do not need
 683   // special handling of vtables.  An alternative is to make adapters more
 684   // lazily by calling make_adapter() from from_compiled_entry() for the
 685   // normal calls.  For vtable calls life gets more complicated.  When a
 686   // call-site goes mega-morphic we need adapters in all methods which can be
 687   // called from the vtable.  We need adapters on such methods that get loaded
 688   // later.  Ditto for mega-morphic itable calls.  If this proves to be a
 689   // problem we'll make these lazily later.
 690   (void) make_adapters(h_method, CHECK);
 691 
 692   // ONLY USE the h_method now as make_adapter may have blocked
 693 
 694 }
 695 
 696 address methodOopDesc::make_adapters(methodHandle mh, TRAPS) {
 697   // Adapters for compiled code are made eagerly here.  They are fairly
 698   // small (generally < 100 bytes) and quick to make (and cached and shared)
 699   // so making them eagerly shouldn't be too expensive.
 700   AdapterHandlerEntry* adapter = AdapterHandlerLibrary::get_adapter(mh);
 701   if (adapter == NULL ) {
 702     THROW_0(vmSymbols::java_lang_OutOfMemoryError());
 703   }
 704 
 705   mh->set_adapter_entry(adapter);
 706   mh->_from_compiled_entry = adapter->get_c2i_entry();
 707   return adapter->get_c2i_entry();
 708 }
 709 
 710 // The verified_code_entry() must be called when a invoke is resolved
 711 // on this method.
 712 
 713 // It returns the compiled code entry point, after asserting not null.
 714 // This function is called after potential safepoints so that nmethod
 715 // or adapter that it points to is still live and valid.
 716 // This function must not hit a safepoint!
 717 address methodOopDesc::verified_code_entry() {
 718   debug_only(No_Safepoint_Verifier nsv;)
 719   nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code);
 720   nmethod *saved_code = (nmethod *)OrderAccess::load_ptr_acquire(&_saved_code);
 721   if (( code == NULL) && (saved_code != NULL) && (saved_code->is_in_use())) {
 722     methodHandle method(this);
 723     assert(UseCodeCacheFlushing, "UseCodeCacheFlushing should be on");
 724     assert( ! saved_code->is_osr_method(), "should not get here for osr" );
 725     set_code( method, saved_code );
 726   }
 727   
 728   assert(_from_compiled_entry != NULL, "must be set");
 729   return _from_compiled_entry;
 730 }
 731 
 732 // Check that if an nmethod ref exists, it has a backlink to this or no backlink at all
 733 // (could be racing a deopt).
 734 // Not inline to avoid circular ref.
 735 bool methodOopDesc::check_code() const {
 736   // cached in a register or local.  There's a race on the value of the field.
 737   nmethod *code = (nmethod *)OrderAccess::load_ptr_acquire(&_code);
 738   return code == NULL || (code->method() == NULL) || (code->method() == (methodOop)this && !code->is_osr_method());
 739 }
 740 
 741 // Install compiled code.  Instantly it can execute.
 742 void methodOopDesc::set_code(methodHandle mh, nmethod *code) {
 743   assert( code, "use clear_code to remove code" );
 744   assert( mh->check_code(), "" );
 745 
 746   guarantee(mh->adapter() != NULL, "Adapter blob must already exist!");
 747 
 748   mh->set_saved_code(NULL);
 749 
 750   // These writes must happen in this order, because the interpreter will
 751   // directly jump to from_interpreted_entry which jumps to an i2c adapter
 752   // which jumps to _from_compiled_entry.
 753   mh->_code = code;             // Assign before allowing compiled code to exec
 754 
 755   int comp_level = code->comp_level();
 756   // In theory there could be a race here. In practice it is unlikely
 757   // and not worth worrying about.
 758   if (comp_level > highest_tier_compile()) {
 759     set_highest_tier_compile(comp_level);
 760   }
 761 
 762   OrderAccess::storestore();
 763   mh->_from_compiled_entry = code->verified_entry_point();
 764   OrderAccess::storestore();
 765   // Instantly compiled code can execute.
 766   mh->_from_interpreted_entry = mh->get_i2c_entry();
 767 
 768 }
 769 
 770 
 771 bool methodOopDesc::is_overridden_in(klassOop k) const {
 772   instanceKlass* ik = instanceKlass::cast(k);
 773 
 774   if (ik->is_interface()) return false;
 775 
 776   // If method is an interface, we skip it - except if it
 777   // is a miranda method
 778   if (instanceKlass::cast(method_holder())->is_interface()) {
 779     // Check that method is not a miranda method
 780     if (ik->lookup_method(name(), signature()) == NULL) {
 781       // No implementation exist - so miranda method
 782       return false;
 783     }
 784     return true;
 785   }
 786 
 787   assert(ik->is_subclass_of(method_holder()), "should be subklass");
 788   assert(ik->vtable() != NULL, "vtable should exist");
 789   if (vtable_index() == nonvirtual_vtable_index) {
 790     return false;
 791   } else {
 792     methodOop vt_m = ik->method_at_vtable(vtable_index());
 793     return vt_m != methodOop(this);
 794   }
 795 }
 796 
 797 
 798 // give advice about whether this methodOop should be cached or not
 799 bool methodOopDesc::should_not_be_cached() const {
 800   if (is_old()) {
 801     // This method has been redefined. It is either EMCP or obsolete
 802     // and we don't want to cache it because that would pin the method
 803     // down and prevent it from being collectible if and when it
 804     // finishes executing.
 805     return true;
 806   }
 807 
 808   if (mark()->should_not_be_cached()) {
 809     // It is either not safe or not a good idea to cache this
 810     // method at this time because of the state of the embedded
 811     // markOop. See markOop.cpp for the gory details.
 812     return true;
 813   }
 814 
 815   // caching this method should be just fine
 816   return false;
 817 }
 818 
 819 // Constant pool structure for invoke methods:
 820 enum {
 821   _imcp_invoke_name = 1,        // utf8: 'invoke'
 822   _imcp_invoke_signature,       // utf8: (variable symbolOop)
 823   _imcp_method_type_value,      // string: (variable java/dyn/MethodType, sic)
 824   _imcp_limit
 825 };
 826 
 827 oop methodOopDesc::method_handle_type() const {
 828   if (!is_method_handle_invoke()) { assert(false, "caller resp."); return NULL; }
 829   oop mt = constants()->resolved_string_at(_imcp_method_type_value);
 830   assert(mt->klass() == SystemDictionary::MethodType_klass(), "");
 831   return mt;
 832 }
 833 
 834 jint* methodOopDesc::method_type_offsets_chain() {
 835   static jint pchase[] = { -1, -1, -1 };
 836   if (pchase[0] == -1) {
 837     jint step0 = in_bytes(constants_offset());
 838     jint step1 = (constantPoolOopDesc::header_size() + _imcp_method_type_value) * HeapWordSize;
 839     // do this in reverse to avoid races:
 840     OrderAccess::release_store(&pchase[1], step1);
 841     OrderAccess::release_store(&pchase[0], step0);
 842   }
 843   return pchase;
 844 }
 845 
 846 methodHandle methodOopDesc::make_invoke_method(KlassHandle holder,
 847                                                symbolHandle signature,
 848                                                Handle method_type, TRAPS) {
 849   methodHandle empty;
 850 
 851   assert(holder() == SystemDictionary::MethodHandle_klass(),
 852          "must be a JSR 292 magic type");
 853 
 854   if (TraceMethodHandles) {
 855     tty->print("Creating invoke method for ");
 856     signature->print_value();
 857     tty->cr();
 858   }
 859 
 860   constantPoolHandle cp;
 861   {
 862     constantPoolOop cp_oop = oopFactory::new_constantPool(_imcp_limit, IsSafeConc, CHECK_(empty));
 863     cp = constantPoolHandle(THREAD, cp_oop);
 864   }
 865   cp->symbol_at_put(_imcp_invoke_name,       vmSymbols::invoke_name());
 866   cp->symbol_at_put(_imcp_invoke_signature,  signature());
 867   cp->string_at_put(_imcp_method_type_value, vmSymbols::void_signature());
 868   cp->set_pool_holder(holder());
 869 
 870   // set up the fancy stuff:
 871   cp->pseudo_string_at_put(_imcp_method_type_value, method_type());
 872   methodHandle m;
 873   {
 874     int flags_bits = (JVM_MH_INVOKE_BITS | JVM_ACC_PUBLIC | JVM_ACC_FINAL);
 875     methodOop m_oop = oopFactory::new_method(0, accessFlags_from(flags_bits),
 876                                              0, 0, 0, IsSafeConc, CHECK_(empty));
 877     m = methodHandle(THREAD, m_oop);
 878   }
 879   m->set_constants(cp());
 880   m->set_name_index(_imcp_invoke_name);
 881   m->set_signature_index(_imcp_invoke_signature);
 882   assert(m->name() == vmSymbols::invoke_name(), "");
 883   assert(m->signature() == signature(), "");
 884 #ifdef CC_INTERP
 885   ResultTypeFinder rtf(signature());
 886   m->set_result_index(rtf.type());
 887 #endif
 888   m->compute_size_of_parameters(THREAD);
 889   m->set_exception_table(Universe::the_empty_int_array());
 890 
 891   // Finally, set up its entry points.
 892   assert(m->method_handle_type() == method_type(), "");
 893   assert(m->can_be_statically_bound(), "");
 894   m->set_vtable_index(methodOopDesc::nonvirtual_vtable_index);
 895   m->link_method(m, CHECK_(empty));
 896 
 897 #ifdef ASSERT
 898   // Make sure the pointer chase works.
 899   address p = (address) m();
 900   for (jint* pchase = method_type_offsets_chain(); (*pchase) != -1; pchase++) {
 901     p = *(address*)(p + (*pchase));
 902   }
 903   assert((oop)p == method_type(), "pointer chase is correct");
 904 #endif
 905 
 906   if (TraceMethodHandles && (Verbose || WizardMode))
 907     m->print_on(tty);
 908 
 909   return m;
 910 }
 911 
 912 
 913 
 914 methodHandle methodOopDesc:: clone_with_new_data(methodHandle m, u_char* new_code, int new_code_length,
 915                                                 u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPS) {
 916   // Code below does not work for native methods - they should never get rewritten anyway
 917   assert(!m->is_native(), "cannot rewrite native methods");
 918   // Allocate new methodOop
 919   AccessFlags flags = m->access_flags();
 920   int checked_exceptions_len = m->checked_exceptions_length();
 921   int localvariable_len = m->localvariable_table_length();
 922   // Allocate newm_oop with the is_conc_safe parameter set
 923   // to IsUnsafeConc to indicate that newm_oop is not yet
 924   // safe for concurrent processing by a GC.
 925   methodOop newm_oop = oopFactory::new_method(new_code_length,
 926                                               flags,
 927                                               new_compressed_linenumber_size,
 928                                               localvariable_len,
 929                                               checked_exceptions_len,
 930                                               IsUnsafeConc,
 931                                               CHECK_(methodHandle()));
 932   methodHandle newm (THREAD, newm_oop);
 933   int new_method_size = newm->method_size();
 934   // Create a shallow copy of methodOopDesc part, but be careful to preserve the new constMethodOop
 935   constMethodOop newcm = newm->constMethod();
 936   int new_const_method_size = newm->constMethod()->object_size();
 937 
 938   memcpy(newm(), m(), sizeof(methodOopDesc));
 939   // Create shallow copy of constMethodOopDesc, but be careful to preserve the methodOop
 940   // is_conc_safe is set to false because that is the value of
 941   // is_conc_safe initialzied into newcm and the copy should
 942   // not overwrite that value.  During the window during which it is
 943   // tagged as unsafe, some extra work could be needed during precleaning
 944   // or concurrent marking but those phases will be correct.  Setting and
 945   // resetting is done in preference to a careful copying into newcm to
 946   // avoid having to know the precise layout of a constMethodOop.
 947   m->constMethod()->set_is_conc_safe(false);
 948   memcpy(newcm, m->constMethod(), sizeof(constMethodOopDesc));
 949   m->constMethod()->set_is_conc_safe(true);
 950   // Reset correct method/const method, method size, and parameter info
 951   newcm->set_method(newm());
 952   newm->set_constMethod(newcm);
 953   assert(newcm->method() == newm(), "check");
 954   newm->constMethod()->set_code_size(new_code_length);
 955   newm->constMethod()->set_constMethod_size(new_const_method_size);
 956   newm->set_method_size(new_method_size);
 957   assert(newm->code_size() == new_code_length, "check");
 958   assert(newm->checked_exceptions_length() == checked_exceptions_len, "check");
 959   assert(newm->localvariable_table_length() == localvariable_len, "check");
 960   // Copy new byte codes
 961   memcpy(newm->code_base(), new_code, new_code_length);
 962   // Copy line number table
 963   if (new_compressed_linenumber_size > 0) {
 964     memcpy(newm->compressed_linenumber_table(),
 965            new_compressed_linenumber_table,
 966            new_compressed_linenumber_size);
 967   }
 968   // Copy checked_exceptions
 969   if (checked_exceptions_len > 0) {
 970     memcpy(newm->checked_exceptions_start(),
 971            m->checked_exceptions_start(),
 972            checked_exceptions_len * sizeof(CheckedExceptionElement));
 973   }
 974   // Copy local variable number table
 975   if (localvariable_len > 0) {
 976     memcpy(newm->localvariable_table_start(),
 977            m->localvariable_table_start(),
 978            localvariable_len * sizeof(LocalVariableTableElement));
 979   }
 980 
 981   // Only set is_conc_safe to true when changes to newcm are
 982   // complete.
 983   newcm->set_is_conc_safe(true);
 984   return newm;
 985 }
 986 
 987 vmSymbols::SID methodOopDesc::klass_id_for_intrinsics(klassOop holder) {
 988   // if loader is not the default loader (i.e., != NULL), we can't know the intrinsics
 989   // because we are not loading from core libraries
 990   if (instanceKlass::cast(holder)->class_loader() != NULL)
 991     return vmSymbols::NO_SID;   // regardless of name, no intrinsics here
 992 
 993   // see if the klass name is well-known:
 994   symbolOop klass_name = instanceKlass::cast(holder)->name();
 995   return vmSymbols::find_sid(klass_name);
 996 }
 997 
 998 void methodOopDesc::init_intrinsic_id() {
 999   assert(_intrinsic_id == vmIntrinsics::_none, "do this just once");
1000   const uintptr_t max_id_uint = right_n_bits((int)(sizeof(_intrinsic_id) * BitsPerByte));
1001   assert((uintptr_t)vmIntrinsics::ID_LIMIT <= max_id_uint, "else fix size");
1002 
1003   // the klass name is well-known:
1004   vmSymbols::SID klass_id = klass_id_for_intrinsics(method_holder());
1005   assert(klass_id != vmSymbols::NO_SID, "caller responsibility");
1006 
1007   // ditto for method and signature:
1008   vmSymbols::SID  name_id = vmSymbols::find_sid(name());
1009   if (name_id  == vmSymbols::NO_SID)  return;
1010   vmSymbols::SID   sig_id = vmSymbols::find_sid(signature());
1011   if (sig_id   == vmSymbols::NO_SID)  return;
1012   jshort flags = access_flags().as_short();
1013 
1014   vmIntrinsics::ID id = vmIntrinsics::find_id(klass_id, name_id, sig_id, flags);
1015   if (id != vmIntrinsics::_none) {
1016     set_intrinsic_id(id);
1017     return;
1018   }
1019 
1020   // A few slightly irregular cases:
1021   switch (klass_id) {
1022   case vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_StrictMath):
1023     // Second chance: check in regular Math.
1024     switch (name_id) {
1025     case vmSymbols::VM_SYMBOL_ENUM_NAME(min_name):
1026     case vmSymbols::VM_SYMBOL_ENUM_NAME(max_name):
1027     case vmSymbols::VM_SYMBOL_ENUM_NAME(sqrt_name):
1028       // pretend it is the corresponding method in the non-strict class:
1029       klass_id = vmSymbols::VM_SYMBOL_ENUM_NAME(java_lang_Math);
1030       id = vmIntrinsics::find_id(klass_id, name_id, sig_id, flags);
1031       break;
1032     }
1033   }
1034 
1035   if (id != vmIntrinsics::_none) {
1036     // Set up its iid.  It is an alias method.
1037     set_intrinsic_id(id);
1038     return;
1039   }
1040 }
1041 
1042 // These two methods are static since a GC may move the methodOopDesc
1043 bool methodOopDesc::load_signature_classes(methodHandle m, TRAPS) {
1044   bool sig_is_loaded = true;
1045   Handle class_loader(THREAD, instanceKlass::cast(m->method_holder())->class_loader());
1046   Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain());
1047   symbolHandle signature(THREAD, m->signature());
1048   for(SignatureStream ss(signature); !ss.is_done(); ss.next()) {
1049     if (ss.is_object()) {
1050       symbolOop sym = ss.as_symbol(CHECK_(false));
1051       symbolHandle name (THREAD, sym);
1052       klassOop klass = SystemDictionary::resolve_or_null(name, class_loader,
1053                                              protection_domain, THREAD);
1054       // We are loading classes eagerly. If a ClassNotFoundException or
1055       // a LinkageError was generated, be sure to ignore it.
1056       if (HAS_PENDING_EXCEPTION) {
1057         if (PENDING_EXCEPTION->is_a(SystemDictionary::classNotFoundException_klass()) ||
1058             PENDING_EXCEPTION->is_a(SystemDictionary::linkageError_klass())) {
1059           CLEAR_PENDING_EXCEPTION;
1060         } else {
1061           return false;
1062         }
1063       }
1064       if( klass == NULL) { sig_is_loaded = false; }
1065     }
1066   }
1067   return sig_is_loaded;
1068 }
1069 
1070 bool methodOopDesc::has_unloaded_classes_in_signature(methodHandle m, TRAPS) {
1071   Handle class_loader(THREAD, instanceKlass::cast(m->method_holder())->class_loader());
1072   Handle protection_domain(THREAD, Klass::cast(m->method_holder())->protection_domain());
1073   symbolHandle signature(THREAD, m->signature());
1074   for(SignatureStream ss(signature); !ss.is_done(); ss.next()) {
1075     if (ss.type() == T_OBJECT) {
1076       symbolHandle name(THREAD, ss.as_symbol_or_null());
1077       if (name() == NULL) return true;
1078       klassOop klass = SystemDictionary::find(name, class_loader, protection_domain, THREAD);
1079       if (klass == NULL) return true;
1080     }
1081   }
1082   return false;
1083 }
1084 
1085 // Exposed so field engineers can debug VM
1086 void methodOopDesc::print_short_name(outputStream* st) {
1087   ResourceMark rm;
1088 #ifdef PRODUCT
1089   st->print(" %s::", method_holder()->klass_part()->external_name());
1090 #else
1091   st->print(" %s::", method_holder()->klass_part()->internal_name());
1092 #endif
1093   name()->print_symbol_on(st);
1094   if (WizardMode) signature()->print_symbol_on(st);
1095 }
1096 
1097 
1098 extern "C" {
1099   static int method_compare(methodOop* a, methodOop* b) {
1100     return (*a)->name()->fast_compare((*b)->name());
1101   }
1102 
1103   // Prevent qsort from reordering a previous valid sort by
1104   // considering the address of the methodOops if two methods
1105   // would otherwise compare as equal.  Required to preserve
1106   // optimal access order in the shared archive.  Slower than
1107   // method_compare, only used for shared archive creation.
1108   static int method_compare_idempotent(methodOop* a, methodOop* b) {
1109     int i = method_compare(a, b);
1110     if (i != 0) return i;
1111     return ( a < b ? -1 : (a == b ? 0 : 1));
1112   }
1113 
1114   typedef int (*compareFn)(const void*, const void*);
1115 }
1116 
1117 
1118 // This is only done during class loading, so it is OK to assume method_idnum matches the methods() array
1119 static void reorder_based_on_method_index(objArrayOop methods,
1120                                           objArrayOop annotations,
1121                                           GrowableArray<oop>* temp_array) {
1122   if (annotations == NULL) {
1123     return;
1124   }
1125 
1126   int length = methods->length();
1127   int i;
1128   // Copy to temp array
1129   temp_array->clear();
1130   for (i = 0; i < length; i++) {
1131     temp_array->append(annotations->obj_at(i));
1132   }
1133 
1134   // Copy back using old method indices
1135   for (i = 0; i < length; i++) {
1136     methodOop m = (methodOop) methods->obj_at(i);
1137     annotations->obj_at_put(i, temp_array->at(m->method_idnum()));
1138   }
1139 }
1140 
1141 
1142 // This is only done during class loading, so it is OK to assume method_idnum matches the methods() array
1143 void methodOopDesc::sort_methods(objArrayOop methods,
1144                                  objArrayOop methods_annotations,
1145                                  objArrayOop methods_parameter_annotations,
1146                                  objArrayOop methods_default_annotations,
1147                                  bool idempotent) {
1148   int length = methods->length();
1149   if (length > 1) {
1150     bool do_annotations = false;
1151     if (methods_annotations != NULL ||
1152         methods_parameter_annotations != NULL ||
1153         methods_default_annotations != NULL) {
1154       do_annotations = true;
1155     }
1156     if (do_annotations) {
1157       // Remember current method ordering so we can reorder annotations
1158       for (int i = 0; i < length; i++) {
1159         methodOop m = (methodOop) methods->obj_at(i);
1160         m->set_method_idnum(i);
1161       }
1162     }
1163 
1164     // Use a simple bubble sort for small number of methods since
1165     // qsort requires a functional pointer call for each comparison.
1166     if (UseCompressedOops || length < 8) {
1167       bool sorted = true;
1168       for (int i=length-1; i>0; i--) {
1169         for (int j=0; j<i; j++) {
1170           methodOop m1 = (methodOop)methods->obj_at(j);
1171           methodOop m2 = (methodOop)methods->obj_at(j+1);
1172           if ((uintptr_t)m1->name() > (uintptr_t)m2->name()) {
1173             methods->obj_at_put(j, m2);
1174             methods->obj_at_put(j+1, m1);
1175             sorted = false;
1176           }
1177         }
1178         if (sorted) break;
1179           sorted = true;
1180       }
1181     } else {
1182       // XXX This doesn't work for UseCompressedOops because the compare fn
1183       // will have to decode the methodOop anyway making it not much faster
1184       // than above.
1185       compareFn compare = (compareFn) (idempotent ? method_compare_idempotent : method_compare);
1186       qsort(methods->base(), length, heapOopSize, compare);
1187     }
1188 
1189     // Sort annotations if necessary
1190     assert(methods_annotations == NULL           || methods_annotations->length() == methods->length(), "");
1191     assert(methods_parameter_annotations == NULL || methods_parameter_annotations->length() == methods->length(), "");
1192     assert(methods_default_annotations == NULL   || methods_default_annotations->length() == methods->length(), "");
1193     if (do_annotations) {
1194       ResourceMark rm;
1195       // Allocate temporary storage
1196       GrowableArray<oop>* temp_array = new GrowableArray<oop>(length);
1197       reorder_based_on_method_index(methods, methods_annotations, temp_array);
1198       reorder_based_on_method_index(methods, methods_parameter_annotations, temp_array);
1199       reorder_based_on_method_index(methods, methods_default_annotations, temp_array);
1200     }
1201 
1202     // Reset method ordering
1203     for (int i = 0; i < length; i++) {
1204       methodOop m = (methodOop) methods->obj_at(i);
1205       m->set_method_idnum(i);
1206     }
1207   }
1208 }
1209 
1210 
1211 //-----------------------------------------------------------------------------------
1212 // Non-product code
1213 
1214 #ifndef PRODUCT
1215 class SignatureTypePrinter : public SignatureTypeNames {
1216  private:
1217   outputStream* _st;
1218   bool _use_separator;
1219 
1220   void type_name(const char* name) {
1221     if (_use_separator) _st->print(", ");
1222     _st->print(name);
1223     _use_separator = true;
1224   }
1225 
1226  public:
1227   SignatureTypePrinter(symbolHandle signature, outputStream* st) : SignatureTypeNames(signature) {
1228     _st = st;
1229     _use_separator = false;
1230   }
1231 
1232   void print_parameters()              { _use_separator = false; iterate_parameters(); }
1233   void print_returntype()              { _use_separator = false; iterate_returntype(); }
1234 };
1235 
1236 
1237 void methodOopDesc::print_name(outputStream* st) {
1238   Thread *thread = Thread::current();
1239   ResourceMark rm(thread);
1240   SignatureTypePrinter sig(signature(), st);
1241   st->print("%s ", is_static() ? "static" : "virtual");
1242   sig.print_returntype();
1243   st->print(" %s.", method_holder()->klass_part()->internal_name());
1244   name()->print_symbol_on(st);
1245   st->print("(");
1246   sig.print_parameters();
1247   st->print(")");
1248 }
1249 
1250 
1251 void methodOopDesc::print_codes_on(outputStream* st) const {
1252   print_codes_on(0, code_size(), st);
1253 }
1254 
1255 void methodOopDesc::print_codes_on(int from, int to, outputStream* st) const {
1256   Thread *thread = Thread::current();
1257   ResourceMark rm(thread);
1258   methodHandle mh (thread, (methodOop)this);
1259   BytecodeStream s(mh);
1260   s.set_interval(from, to);
1261   BytecodeTracer::set_closure(BytecodeTracer::std_closure());
1262   while (s.next() >= 0) BytecodeTracer::trace(mh, s.bcp(), st);
1263 }
1264 #endif // not PRODUCT
1265 
1266 
1267 // Simple compression of line number tables. We use a regular compressed stream, except that we compress deltas
1268 // between (bci,line) pairs since they are smaller. If (bci delta, line delta) fits in (5-bit unsigned, 3-bit unsigned)
1269 // we save it as one byte, otherwise we write a 0xFF escape character and use regular compression. 0x0 is used
1270 // as end-of-stream terminator.
1271 
1272 void CompressedLineNumberWriteStream::write_pair_regular(int bci_delta, int line_delta) {
1273   // bci and line number does not compress into single byte.
1274   // Write out escape character and use regular compression for bci and line number.
1275   write_byte((jubyte)0xFF);
1276   write_signed_int(bci_delta);
1277   write_signed_int(line_delta);
1278 }
1279 
1280 // See comment in methodOop.hpp which explains why this exists.
1281 #if defined(_M_AMD64) && MSC_VER >= 1400
1282 #pragma optimize("", off)
1283 void CompressedLineNumberWriteStream::write_pair(int bci, int line) {
1284   write_pair_inline(bci, line);
1285 }
1286 #pragma optimize("", on)
1287 #endif
1288 
1289 CompressedLineNumberReadStream::CompressedLineNumberReadStream(u_char* buffer) : CompressedReadStream(buffer) {
1290   _bci = 0;
1291   _line = 0;
1292 };
1293 
1294 
1295 bool CompressedLineNumberReadStream::read_pair() {
1296   jubyte next = read_byte();
1297   // Check for terminator
1298   if (next == 0) return false;
1299   if (next == 0xFF) {
1300     // Escape character, regular compression used
1301     _bci  += read_signed_int();
1302     _line += read_signed_int();
1303   } else {
1304     // Single byte compression used
1305     _bci  += next >> 3;
1306     _line += next & 0x7;
1307   }
1308   return true;
1309 }
1310 
1311 
1312 Bytecodes::Code methodOopDesc::orig_bytecode_at(int bci) {
1313   BreakpointInfo* bp = instanceKlass::cast(method_holder())->breakpoints();
1314   for (; bp != NULL; bp = bp->next()) {
1315     if (bp->match(this, bci)) {
1316       return bp->orig_bytecode();
1317     }
1318   }
1319   ShouldNotReachHere();
1320   return Bytecodes::_shouldnotreachhere;
1321 }
1322 
1323 void methodOopDesc::set_orig_bytecode_at(int bci, Bytecodes::Code code) {
1324   assert(code != Bytecodes::_breakpoint, "cannot patch breakpoints this way");
1325   BreakpointInfo* bp = instanceKlass::cast(method_holder())->breakpoints();
1326   for (; bp != NULL; bp = bp->next()) {
1327     if (bp->match(this, bci)) {
1328       bp->set_orig_bytecode(code);
1329       // and continue, in case there is more than one
1330     }
1331   }
1332 }
1333 
1334 void methodOopDesc::set_breakpoint(int bci) {
1335   instanceKlass* ik = instanceKlass::cast(method_holder());
1336   BreakpointInfo *bp = new BreakpointInfo(this, bci);
1337   bp->set_next(ik->breakpoints());
1338   ik->set_breakpoints(bp);
1339   // do this last:
1340   bp->set(this);
1341 }
1342 
1343 static void clear_matches(methodOop m, int bci) {
1344   instanceKlass* ik = instanceKlass::cast(m->method_holder());
1345   BreakpointInfo* prev_bp = NULL;
1346   BreakpointInfo* next_bp;
1347   for (BreakpointInfo* bp = ik->breakpoints(); bp != NULL; bp = next_bp) {
1348     next_bp = bp->next();
1349     // bci value of -1 is used to delete all breakpoints in method m (ex: clear_all_breakpoint).
1350     if (bci >= 0 ? bp->match(m, bci) : bp->match(m)) {
1351       // do this first:
1352       bp->clear(m);
1353       // unhook it
1354       if (prev_bp != NULL)
1355         prev_bp->set_next(next_bp);
1356       else
1357         ik->set_breakpoints(next_bp);
1358       delete bp;
1359       // When class is redefined JVMTI sets breakpoint in all versions of EMCP methods
1360       // at same location. So we have multiple matching (method_index and bci)
1361       // BreakpointInfo nodes in BreakpointInfo list. We should just delete one
1362       // breakpoint for clear_breakpoint request and keep all other method versions
1363       // BreakpointInfo for future clear_breakpoint request.
1364       // bcivalue of -1 is used to clear all breakpoints (see clear_all_breakpoints)
1365       // which is being called when class is unloaded. We delete all the Breakpoint
1366       // information for all versions of method. We may not correctly restore the original
1367       // bytecode in all method versions, but that is ok. Because the class is being unloaded
1368       // so these methods won't be used anymore.
1369       if (bci >= 0) {
1370         break;
1371       }
1372     } else {
1373       // This one is a keeper.
1374       prev_bp = bp;
1375     }
1376   }
1377 }
1378 
1379 void methodOopDesc::clear_breakpoint(int bci) {
1380   assert(bci >= 0, "");
1381   clear_matches(this, bci);
1382 }
1383 
1384 void methodOopDesc::clear_all_breakpoints() {
1385   clear_matches(this, -1);
1386 }
1387 
1388 
1389 BreakpointInfo::BreakpointInfo(methodOop m, int bci) {
1390   _bci = bci;
1391   _name_index = m->name_index();
1392   _signature_index = m->signature_index();
1393   _orig_bytecode = (Bytecodes::Code) *m->bcp_from(_bci);
1394   if (_orig_bytecode == Bytecodes::_breakpoint)
1395     _orig_bytecode = m->orig_bytecode_at(_bci);
1396   _next = NULL;
1397 }
1398 
1399 void BreakpointInfo::set(methodOop method) {
1400 #ifdef ASSERT
1401   {
1402     Bytecodes::Code code = (Bytecodes::Code) *method->bcp_from(_bci);
1403     if (code == Bytecodes::_breakpoint)
1404       code = method->orig_bytecode_at(_bci);
1405     assert(orig_bytecode() == code, "original bytecode must be the same");
1406   }
1407 #endif
1408   *method->bcp_from(_bci) = Bytecodes::_breakpoint;
1409   method->incr_number_of_breakpoints();
1410   SystemDictionary::notice_modification();
1411   {
1412     // Deoptimize all dependents on this method
1413     Thread *thread = Thread::current();
1414     HandleMark hm(thread);
1415     methodHandle mh(thread, method);
1416     Universe::flush_dependents_on_method(mh);
1417   }
1418 }
1419 
1420 void BreakpointInfo::clear(methodOop method) {
1421   *method->bcp_from(_bci) = orig_bytecode();
1422   assert(method->number_of_breakpoints() > 0, "must not go negative");
1423   method->decr_number_of_breakpoints();
1424 }
--- EOF ---