1 /*

     2  * Copyright (c) 1999, 2011, 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 "jvmci/jvmciEnv.hpp"

    27 #include "classfile/javaAssertions.hpp"

    28 #include "classfile/systemDictionary.hpp"

    29 #include "classfile/vmSymbols.hpp"

    30 #include "code/codeCache.hpp"

    31 #include "code/scopeDesc.hpp"

    32 #include "runtime/sweeper.hpp"

    33 #include "compiler/compileBroker.hpp"

    34 #include "compiler/compileLog.hpp"

    35 #include "compiler/compilerOracle.hpp"

    36 #include "interpreter/linkResolver.hpp"

    37 #include "memory/allocation.inline.hpp"

    38 #include "memory/oopFactory.hpp"

    39 #include "memory/universe.inline.hpp"

    40 #include "oops/methodData.hpp"

    41 #include "oops/objArrayKlass.hpp"

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

    43 #include "prims/jvmtiExport.hpp"

    44 #include "runtime/init.hpp"

    45 #include "runtime/reflection.hpp"

    46 #include "runtime/sharedRuntime.hpp"

    47 #include "utilities/dtrace.hpp"

    48 #include "jvmci/jvmciRuntime.hpp"

    49 #include "jvmci/jvmciJavaClasses.hpp"

    50 

    51 JVMCIEnv::JVMCIEnv(CompileTask* task, int system_dictionary_modification_counter) {

    52   _task = task;

    53   _system_dictionary_modification_counter = system_dictionary_modification_counter;

    54   {

    55     // Get Jvmti capabilities under lock to get consistent values.

    56     MutexLocker mu(JvmtiThreadState_lock);

    57     _jvmti_can_hotswap_or_post_breakpoint = JvmtiExport::can_hotswap_or_post_breakpoint();

    58     _jvmti_can_access_local_variables     = JvmtiExport::can_access_local_variables();

    59     _jvmti_can_post_on_exceptions         = JvmtiExport::can_post_on_exceptions();

    60   }

    61 }

    62 

    63 // ------------------------------------------------------------------

    64 // Note: the logic of this method should mirror the logic of

    65 // constantPoolOopDesc::verify_constant_pool_resolve.

    66 bool JVMCIEnv::check_klass_accessibility(KlassHandle accessing_klass, KlassHandle resolved_klass) {

    67   if (accessing_klass->oop_is_objArray()) {

    68     accessing_klass = ObjArrayKlass::cast(accessing_klass())->bottom_klass();

    69   }

    70   if (!accessing_klass->oop_is_instance()) {

    71     return true;

    72   }

    73 

    74   if (resolved_klass->oop_is_objArray()) {

    75     // Find the element klass, if this is an array.

    76     resolved_klass = ObjArrayKlass::cast(resolved_klass())->bottom_klass();

    77   }

    78   if (resolved_klass->oop_is_instance()) {

    79     return Reflection::verify_class_access(accessing_klass(), resolved_klass(), true);

    80   }

    81   return true;

    82 }

    83 

    84 // ------------------------------------------------------------------

    85 KlassHandle JVMCIEnv::get_klass_by_name_impl(KlassHandle& accessing_klass,

    86                                           constantPoolHandle& cpool,

    87                                           Symbol* sym,

    88                                           bool require_local) {

    89   JVMCI_EXCEPTION_CONTEXT;

    90 

    91   // Now we need to check the SystemDictionary

    92   if (sym->byte_at(0) == 'L' &&

    93     sym->byte_at(sym->utf8_length()-1) == ';') {

    94     // This is a name from a signature.  Strip off the trimmings.

    95     // Call recursive to keep scope of strippedsym.

    96     TempNewSymbol strippedsym = SymbolTable::new_symbol(sym->as_utf8()+1,

    97                     sym->utf8_length()-2,

    98                     CHECK_(KlassHandle()));

    99     return get_klass_by_name_impl(accessing_klass, cpool, strippedsym, require_local);

   100   }

   101 

   102   Handle loader(THREAD, (oop)NULL);

   103   Handle domain(THREAD, (oop)NULL);

   104   if (!accessing_klass.is_null()) {

   105     loader = Handle(THREAD, accessing_klass->class_loader());

   106     domain = Handle(THREAD, accessing_klass->protection_domain());

   107   }

   108 

   109   KlassHandle found_klass;

   110   {

   111     ttyUnlocker ttyul;  // release tty lock to avoid ordering problems

   112     MutexLocker ml(Compile_lock);

   113     Klass*  kls;

   114     if (!require_local) {

   115       kls = SystemDictionary::find_constrained_instance_or_array_klass(sym, loader, CHECK_(KlassHandle()));

   116     } else {

   117       kls = SystemDictionary::find_instance_or_array_klass(sym, loader, domain, CHECK_(KlassHandle()));

   118     }

   119     found_klass = KlassHandle(THREAD, kls);

   120   }

   121 

   122   // If we fail to find an array klass, look again for its element type.

   123   // The element type may be available either locally or via constraints.

   124   // In either case, if we can find the element type in the system dictionary,

   125   // we must build an array type around it.  The CI requires array klasses

   126   // to be loaded if their element klasses are loaded, except when memory

   127   // is exhausted.

   128   if (sym->byte_at(0) == '[' &&

   129       (sym->byte_at(1) == '[' || sym->byte_at(1) == 'L')) {

   130     // We have an unloaded array.

   131     // Build it on the fly if the element class exists.

   132     TempNewSymbol elem_sym = SymbolTable::new_symbol(sym->as_utf8()+1,

   133                                                  sym->utf8_length()-1,

   134                                                  CHECK_(KlassHandle()));

   135 

   136     // Get element Klass recursively.

   137     KlassHandle elem_klass =

   138       get_klass_by_name_impl(accessing_klass,

   139                              cpool,

   140                              elem_sym,

   141                              require_local);

   142     if (!elem_klass.is_null()) {

   143       // Now make an array for it

   144       return elem_klass->array_klass(CHECK_(KlassHandle()));

   145     }

   146   }

   147 

   148   if (found_klass.is_null() && !cpool.is_null() && cpool->has_preresolution()) {

   149     // Look inside the constant pool for pre-resolved class entries.

   150     for (int i = cpool->length() - 1; i >= 1; i--) {

   151       if (cpool->tag_at(i).is_klass()) {

   152         Klass*  kls = cpool->resolved_klass_at(i);

   153         if (kls->name() == sym) {

   154           return kls;

   155         }

   156       }

   157     }

   158   }

   159 

   160   return found_klass();

   161 }

   162 

   163 // ------------------------------------------------------------------

   164 KlassHandle JVMCIEnv::get_klass_by_name(KlassHandle& accessing_klass,

   165                                   Symbol* klass_name,

   166                                   bool require_local) {

   167   ResourceMark rm;

   168   constantPoolHandle cpool;

   169   return get_klass_by_name_impl(accessing_klass,

   170                                                  cpool,

   171                                                  klass_name,

   172                                                  require_local);

   173 }

   174 

   175 // ------------------------------------------------------------------

   176 // Implementation of get_klass_by_index.

   177 KlassHandle JVMCIEnv::get_klass_by_index_impl(constantPoolHandle& cpool,

   178                                         int index,

   179                                         bool& is_accessible,

   180                                         KlassHandle& accessor) {

   181   JVMCI_EXCEPTION_CONTEXT;

   182   KlassHandle klass (THREAD, ConstantPool::klass_at_if_loaded(cpool, index));

   183   Symbol* klass_name = NULL;

   184   if (klass.is_null()) {

   185     klass_name = cpool->klass_name_at(index);

   186   }

   187 

   188   if (klass.is_null()) {

   189     // Not found in constant pool.  Use the name to do the lookup.

   190     KlassHandle k = get_klass_by_name_impl(accessor,

   191                                         cpool,

   192                                         klass_name,

   193                                         false);

   194     // Calculate accessibility the hard way.

   195     if (k.is_null()) {

   196       is_accessible = false;

   197     } else if (k->class_loader() != accessor->class_loader() &&

   198                get_klass_by_name_impl(accessor, cpool, k->name(), true).is_null()) {

   199       // Loaded only remotely.  Not linked yet.

   200       is_accessible = false;

   201     } else {

   202       // Linked locally, and we must also check public/private, etc.

   203       is_accessible = check_klass_accessibility(accessor, k);

   204     }

   205     if (!is_accessible) {

   206       return KlassHandle();

   207     }

   208     return k;

   209   }

   210 

   211   // It is known to be accessible, since it was found in the constant pool.

   212   is_accessible = true;

   213   return klass;

   214 }

   215 

   216 // ------------------------------------------------------------------

   217 // Get a klass from the constant pool.

   218 KlassHandle JVMCIEnv::get_klass_by_index(constantPoolHandle& cpool,

   219                                    int index,

   220                                    bool& is_accessible,

   221                                    KlassHandle& accessor) {

   222   ResourceMark rm;

   223   KlassHandle result = get_klass_by_index_impl(cpool, index, is_accessible, accessor);

   224   return result;

   225 }

   226 

   227 // ------------------------------------------------------------------

   228 // Implementation of get_field_by_index.

   229 //

   230 // Implementation note: the results of field lookups are cached

   231 // in the accessor klass.

   232 void JVMCIEnv::get_field_by_index_impl(instanceKlassHandle& klass, fieldDescriptor& field_desc,

   233                                         int index) {

   234   JVMCI_EXCEPTION_CONTEXT;

   235 

   236   assert(klass->is_linked(), "must be linked before using its constant-pool");

   237 

   238   constantPoolHandle cpool(thread, klass->constants());

   239 

   240   // Get the field's name, signature, and type.

   241   Symbol* name  = cpool->name_ref_at(index);

   242 

   243   int nt_index = cpool->name_and_type_ref_index_at(index);

   244   int sig_index = cpool->signature_ref_index_at(nt_index);

   245   Symbol* signature = cpool->symbol_at(sig_index);

   246 

   247   // Get the field's declared holder.

   248   int holder_index = cpool->klass_ref_index_at(index);

   249   bool holder_is_accessible;

   250   KlassHandle declared_holder = get_klass_by_index(cpool, holder_index,

   251                                                holder_is_accessible,

   252                                                klass);

   253 

   254   // The declared holder of this field may not have been loaded.

   255   // Bail out with partial field information.

   256   if (!holder_is_accessible) {

   257     return;

   258   }

   259 

   260 

   261   // Perform the field lookup.

   262   Klass*  canonical_holder =

   263     InstanceKlass::cast(declared_holder())->find_field(name, signature, &field_desc);

   264   if (canonical_holder == NULL) {

   265     return;

   266   }

   267 

   268   assert(canonical_holder == field_desc.field_holder(), "just checking");

   269 }

   270 

   271 // ------------------------------------------------------------------

   272 // Get a field by index from a klass's constant pool.

   273 void JVMCIEnv::get_field_by_index(instanceKlassHandle& accessor, fieldDescriptor& fd, int index) {

   274   ResourceMark rm;

   275   return get_field_by_index_impl(accessor, fd, index);

   276 }

   277 

   278 // ------------------------------------------------------------------

   279 // Perform an appropriate method lookup based on accessor, holder,

   280 // name, signature, and bytecode.

   281 methodHandle JVMCIEnv::lookup_method(instanceKlassHandle& h_accessor,

   282                                instanceKlassHandle& h_holder,

   283                                Symbol*       name,

   284                                Symbol*       sig,

   285                                Bytecodes::Code bc) {

   286   JVMCI_EXCEPTION_CONTEXT;

   287   LinkResolver::check_klass_accessability(h_accessor, h_holder, KILL_COMPILE_ON_FATAL_(NULL));

   288   methodHandle dest_method;

   289   LinkInfo link_info(h_holder, name, sig, h_accessor, /*check_access*/true);

   290   switch (bc) {

   291   case Bytecodes::_invokestatic:

   292     dest_method =

   293       LinkResolver::resolve_static_call_or_null(link_info);

   294     break;

   295   case Bytecodes::_invokespecial:

   296     dest_method =

   297       LinkResolver::resolve_special_call_or_null(link_info);

   298     break;

   299   case Bytecodes::_invokeinterface:

   300     dest_method =

   301       LinkResolver::linktime_resolve_interface_method_or_null(link_info);

   302     break;

   303   case Bytecodes::_invokevirtual:

   304     dest_method =

   305       LinkResolver::linktime_resolve_virtual_method_or_null(link_info);

   306     break;

   307   default: ShouldNotReachHere();

   308   }

   309 

   310   return dest_method;

   311 }

   312 

   313 

   314 // ------------------------------------------------------------------

   315 methodHandle JVMCIEnv::get_method_by_index_impl(constantPoolHandle& cpool,

   316                                           int index, Bytecodes::Code bc,

   317                                           instanceKlassHandle& accessor) {

   318   if (bc == Bytecodes::_invokedynamic) {

   319     ConstantPoolCacheEntry* cpce = cpool->invokedynamic_cp_cache_entry_at(index);

   320     bool is_resolved = !cpce->is_f1_null();

   321     if (is_resolved) {

   322       // Get the invoker Method* from the constant pool.

   323       // (The appendix argument, if any, will be noted in the method's signature.)

   324       Method* adapter = cpce->f1_as_method();

   325       return methodHandle(adapter);

   326     }

   327 

   328     return NULL;

   329   }

   330 

   331   int holder_index = cpool->klass_ref_index_at(index);

   332   bool holder_is_accessible;

   333   KlassHandle holder = get_klass_by_index_impl(cpool, holder_index, holder_is_accessible, accessor);

   334 

   335   // Get the method's name and signature.

   336   Symbol* name_sym = cpool->name_ref_at(index);

   337   Symbol* sig_sym  = cpool->signature_ref_at(index);

   338 

   339   if (cpool->has_preresolution()

   340       || (holder() == SystemDictionary::MethodHandle_klass() &&

   341           MethodHandles::is_signature_polymorphic_name(holder(), name_sym))) {

   342     // Short-circuit lookups for JSR 292-related call sites.

   343     // That is, do not rely only on name-based lookups, because they may fail

   344     // if the names are not resolvable in the boot class loader (7056328).

   345     switch (bc) {

   346     case Bytecodes::_invokevirtual:

   347     case Bytecodes::_invokeinterface:

   348     case Bytecodes::_invokespecial:

   349     case Bytecodes::_invokestatic:

   350       {

   351         Method* m = ConstantPool::method_at_if_loaded(cpool, index);

   352         if (m != NULL) {

   353           return m;

   354         }

   355       }

   356       break;

   357     }

   358   }

   359 

   360   if (holder_is_accessible) { // Our declared holder is loaded.

   361     instanceKlassHandle lookup = get_instance_klass_for_declared_method_holder(holder);

   362     methodHandle m = lookup_method(accessor, lookup, name_sym, sig_sym, bc);

   363     if (!m.is_null() &&

   364         (bc == Bytecodes::_invokestatic

   365          ?  InstanceKlass::cast(m->method_holder())->is_not_initialized()

   366          : !InstanceKlass::cast(m->method_holder())->is_loaded())) {

   367       m = NULL;

   368     }

   369     if (!m.is_null()) {

   370       // We found the method.

   371       return m;

   372     }

   373   }

   374 

   375   // Either the declared holder was not loaded, or the method could

   376   // not be found.

   377 

   378   return NULL;

   379 }

   380 

   381 // ------------------------------------------------------------------

   382 instanceKlassHandle JVMCIEnv::get_instance_klass_for_declared_method_holder(KlassHandle& method_holder) {

   383   // For the case of <array>.clone(), the method holder can be an ArrayKlass*

   384   // instead of an InstanceKlass*.  For that case simply pretend that the

   385   // declared holder is Object.clone since that's where the call will bottom out.

   386   if (method_holder->oop_is_instance()) {

   387     return instanceKlassHandle(method_holder());

   388   } else if (method_holder->oop_is_array()) {

   389     return instanceKlassHandle(SystemDictionary::Object_klass());

   390   } else {

   391     ShouldNotReachHere();

   392   }

   393   return NULL;

   394 }

   395 

   396 

   397 // ------------------------------------------------------------------

   398 methodHandle JVMCIEnv::get_method_by_index(constantPoolHandle& cpool,

   399                                      int index, Bytecodes::Code bc,

   400                                      instanceKlassHandle& accessor) {

   401   ResourceMark rm;

   402   return get_method_by_index_impl(cpool, index, bc, accessor);

   403 }

   404 

   405 // ------------------------------------------------------------------

   406 // Check for changes to the system dictionary during compilation

   407 // class loads, evolution, breakpoints

   408 JVMCIEnv::CodeInstallResult JVMCIEnv::check_for_system_dictionary_modification(Dependencies* dependencies, Handle compiled_code,

   409                                                                                JVMCIEnv* env, char** failure_detail) {

   410   // If JVMTI capabilities were enabled during compile, the compilation is invalidated.

   411   if (env != NULL) {

   412     if (!env->_jvmti_can_hotswap_or_post_breakpoint && JvmtiExport::can_hotswap_or_post_breakpoint()) {

   413       *failure_detail = (char*) "Hotswapping or breakpointing was enabled during compilation";

   414       return JVMCIEnv::dependencies_failed;

   415     }

   416   }

   417 

   418   // Dependencies must be checked when the system dictionary changes

   419   // or if we don't know whether it has changed (i.e., env == NULL).

   420   // In debug mode, always check dependencies.

   421   bool counter_changed = env != NULL && env->_system_dictionary_modification_counter != SystemDictionary::number_of_modifications();

   422   bool verify_deps = env == NULL || trueInDebug || JavaAssertions::enabled(SystemDictionary::HotSpotInstalledCode_klass()->name()->as_C_string(), true);

   423   if (!counter_changed && !verify_deps) {

   424     return JVMCIEnv::ok;

   425   }

   426 

   427   for (Dependencies::DepStream deps(dependencies); deps.next(); ) {

   428     Klass* witness = deps.check_dependency();

   429     if (witness != NULL) {

   430       // Use a fixed size buffer to prevent the string stream from

   431       // resizing in the context of an inner resource mark.

   432       char* buffer = NEW_RESOURCE_ARRAY(char, O_BUFLEN);

   433       stringStream st(buffer, O_BUFLEN);

   434       deps.print_dependency(witness, true, &st);

   435       *failure_detail = st.as_string();

   436       if (env == NULL || counter_changed) {

   437         return JVMCIEnv::dependencies_failed;

   438       } else {

   439         // The dependencies were invalid at the time of installation

   440         // without any intervening modification of the system

   441         // dictionary.  That means they were invalidly constructed.

   442         return JVMCIEnv::dependencies_invalid;

   443       }

   444     }

   445     if (LogCompilation) {

   446       deps.log_dependency();

   447     }

   448   }

   449 

   450   return JVMCIEnv::ok;

   451 }

   452 

   453 // ------------------------------------------------------------------

   454 JVMCIEnv::CodeInstallResult JVMCIEnv::register_method(

   455                                 methodHandle& method,

   456                                 nmethod*& nm,

   457                                 int entry_bci,

   458                                 CodeOffsets* offsets,

   459                                 int orig_pc_offset,

   460                                 CodeBuffer* code_buffer,

   461                                 int frame_words,

   462                                 OopMapSet* oop_map_set,

   463                                 ExceptionHandlerTable* handler_table,

   464                                 AbstractCompiler* compiler,

   465                                 DebugInformationRecorder* debug_info,

   466                                 Dependencies* dependencies,

   467                                 JVMCIEnv* env,

   468                                 int compile_id,

   469                                 bool has_unsafe_access,

   470                                 bool has_wide_vector,

   471                                 Handle installed_code,

   472                                 Handle compiled_code,

   473                                 Handle speculation_log) {

   474   JVMCI_EXCEPTION_CONTEXT;

   475   nm = NULL;

   476   int comp_level = CompLevel_full_optimization;

   477   char* failure_detail = NULL;

   478   JVMCIEnv::CodeInstallResult result;

   479   {

   480     // To prevent compile queue updates.

   481     MutexLocker locker(MethodCompileQueue_lock, THREAD);

   482 

   483     // Prevent SystemDictionary::add_to_hierarchy from running

   484     // and invalidating our dependencies until we install this method.

   485     MutexLocker ml(Compile_lock);

   486 

   487     // Encode the dependencies now, so we can check them right away.

   488     dependencies->encode_content_bytes();

   489 

   490     // Check for {class loads, evolution, breakpoints} during compilation

   491     result = check_for_system_dictionary_modification(dependencies, compiled_code, env, &failure_detail);

   492     if (result != JVMCIEnv::ok) {

   493       // While not a true deoptimization, it is a preemptive decompile.

   494       MethodData* mdp = method()->method_data();

   495       if (mdp != NULL) {

   496         mdp->inc_decompile_count();

   497         if (mdp->decompile_count() > (uint)PerMethodRecompilationCutoff) {

   498           // TODO (chaeubl) enable this in the fastdebug build only once we are more stable

   499           ResourceMark m;

   500           tty->print_cr("WARN: endless recompilation of %s. Method was set to not compilable.", method()->name_and_sig_as_C_string());

   501           //ShouldNotReachHere();

   502         }

   503       }

   504 

   505       // All buffers in the CodeBuffer are allocated in the CodeCache.

   506       // If the code buffer is created on each compile attempt

   507       // as in C2, then it must be freed.

   508       //code_buffer->free_blob();

   509     } else {

   510       ImplicitExceptionTable implicit_tbl;

   511       nm =  nmethod::new_nmethod(method,

   512                                  compile_id,

   513                                  entry_bci,

   514                                  offsets,

   515                                  orig_pc_offset,

   516                                  debug_info, dependencies, code_buffer,

   517                                  frame_words, oop_map_set,

   518                                  handler_table, &implicit_tbl,

   519                                  compiler, comp_level, installed_code, speculation_log);

   520 

   521       // Free codeBlobs

   522       //code_buffer->free_blob();

   523       if (nm == NULL) {

   524         // The CodeCache is full.  Print out warning and disable compilation.

   525         {

   526           MutexUnlocker ml(Compile_lock);

   527           MutexUnlocker locker(MethodCompileQueue_lock);

   528           CompileBroker::handle_full_code_cache(CodeCache::get_code_blob_type(comp_level));

   529         }

   530       } else {

   531         nm->set_has_unsafe_access(has_unsafe_access);

   532         nm->set_has_wide_vectors(has_wide_vector);

   533 

   534         // Record successful registration.

   535         // (Put nm into the task handle *before* publishing to the Java heap.)

   536         CompileTask* task = env == NULL ? NULL : env->task();

   537         if (task != NULL)  task->set_code(nm);

   538 

   539         if (installed_code->is_a(HotSpotNmethod::klass()) && HotSpotNmethod::isDefault(installed_code())) {

   540           if (entry_bci == InvocationEntryBci) {

   541             if (TieredCompilation) {

   542               // If there is an old version we're done with it

   543               nmethod* old = method->code();

   544               if (TraceMethodReplacement && old != NULL) {

   545                 ResourceMark rm;

   546                 char *method_name = method->name_and_sig_as_C_string();

   547                 tty->print_cr("Replacing method %s", method_name);

   548               }

   549               if (old != NULL ) {

   550                 old->make_not_entrant();

   551               }

   552             }

   553             if (TraceNMethodInstalls) {

   554               ResourceMark rm;

   555               char *method_name = method->name_and_sig_as_C_string();

   556               ttyLocker ttyl;

   557               tty->print_cr("Installing method (%d) %s [entry point: %p]",

   558                             comp_level,

   559                             method_name, nm->entry_point());

   560             }

   561             // Allow the code to be executed

   562             method->set_code(method, nm);

   563           } else {

   564             if (TraceNMethodInstalls ) {

   565               ResourceMark rm;

   566               char *method_name = method->name_and_sig_as_C_string();

   567               ttyLocker ttyl;

   568               tty->print_cr("Installing osr method (%d) %s @ %d",

   569                             comp_level,

   570                             method_name,

   571                             entry_bci);

   572             }

   573             InstanceKlass::cast(method->method_holder())->add_osr_nmethod(nm);

   574           }

   575         }

   576       }

   577       result = nm != NULL ? JVMCIEnv::ok :JVMCIEnv::cache_full;

   578     }

   579   }

   580 

   581   // String creation must be done outside lock

   582   if (failure_detail != NULL) {

   583     // A failure to allocate the string is silently ignored.

   584     Handle message = java_lang_String::create_from_str(failure_detail, THREAD);

   585     HotSpotCompiledNmethod::set_installationFailureMessage(compiled_code, message());

   586   }

   587 

   588   // JVMTI -- compiled method notification (must be done outside lock)

   589   if (nm != NULL) {

   590     nm->post_compiled_method_load_event();

   591   }

   592 

   593   return result;

   594 }

   595