1 /*

     2  * Copyright (c) 1998, 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 "code/codeBlob.hpp"

    27 #include "code/codeCache.hpp"

    28 #include "code/relocInfo.hpp"

    29 #include "compiler/disassembler.hpp"

    30 #include "interpreter/bytecode.hpp"

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

    32 #include "memory/heap.hpp"

    33 #include "memory/resourceArea.hpp"

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

    35 #include "prims/forte.hpp"

    36 #include "prims/jvm.h"

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

    38 #include "runtime/interfaceSupport.hpp"

    39 #include "runtime/mutexLocker.hpp"

    40 #include "runtime/safepoint.hpp"

    41 #include "runtime/sharedRuntime.hpp"

    42 #include "runtime/vframe.hpp"

    43 #include "services/memoryService.hpp"

    44 #include "utilities/align.hpp"

    45 #ifdef COMPILER1

    46 #include "c1/c1_Runtime1.hpp"

    47 #endif

    48 

    49 const char* CodeBlob::compiler_name() const {

    50   return compilertype2name(_type);

    51 }

    52 

    53 unsigned int CodeBlob::align_code_offset(int offset) {

    54   // align the size to CodeEntryAlignment

    55   return

    56     ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1))

    57     - (int)CodeHeap::header_size();

    58 }

    59 

    60 

    61 // This must be consistent with the CodeBlob constructor's layout actions.

    62 unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) {

    63   unsigned int size = header_size;

    64   size += align_up(cb->total_relocation_size(), oopSize);

    65   // align the size to CodeEntryAlignment

    66   size = align_code_offset(size);

    67   size += align_up(cb->total_content_size(), oopSize);

    68   size += align_up(cb->total_oop_size(), oopSize);

    69   size += align_up(cb->total_metadata_size(), oopSize);

    70   return size;

    71 }

    72 

    73 CodeBlob::CodeBlob(const char* name, CompilerType type, const CodeBlobLayout& layout, int frame_complete_offset, int frame_size, ImmutableOopMapSet* oop_maps, bool caller_must_gc_arguments) :

    74   _name(name),

    75   _size(layout.size()),

    76   _header_size(layout.header_size()),

    77   _frame_complete_offset(frame_complete_offset),

    78   _data_offset(layout.data_offset()),

    79   _frame_size(frame_size),

    80   _strings(CodeStrings()),

    81   _oop_maps(oop_maps),

    82   _caller_must_gc_arguments(caller_must_gc_arguments),

    83   _code_begin(layout.code_begin()),

    84   _code_end(layout.code_end()),

    85   _data_end(layout.data_end()),

    86   _relocation_begin(layout.relocation_begin()),

    87   _relocation_end(layout.relocation_end()),

    88   _content_begin(layout.content_begin()),

    89   _type(type)

    90 {

    91   assert(is_aligned(layout.size(),            oopSize), "unaligned size");

    92   assert(is_aligned(layout.header_size(),     oopSize), "unaligned size");

    93   assert(is_aligned(layout.relocation_size(), oopSize), "unaligned size");

    94   assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()");

    95 #ifdef COMPILER1

    96   // probably wrong for tiered

    97   assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");

    98 #endif // COMPILER1

    99 }

   100 

   101 CodeBlob::CodeBlob(const char* name, CompilerType type, const CodeBlobLayout& layout, CodeBuffer* cb, int frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments) :

   102   _name(name),

   103   _size(layout.size()),

   104   _header_size(layout.header_size()),

   105   _frame_complete_offset(frame_complete_offset),

   106   _data_offset(layout.data_offset()),

   107   _frame_size(frame_size),

   108   _strings(CodeStrings()),

   109   _caller_must_gc_arguments(caller_must_gc_arguments),

   110   _code_begin(layout.code_begin()),

   111   _code_end(layout.code_end()),

   112   _data_end(layout.data_end()),

   113   _relocation_begin(layout.relocation_begin()),

   114   _relocation_end(layout.relocation_end()),

   115   _content_begin(layout.content_begin()),

   116   _type(type)

   117 {

   118   assert(is_aligned(_size,        oopSize), "unaligned size");

   119   assert(is_aligned(_header_size, oopSize), "unaligned size");

   120   assert(_data_offset <= _size, "codeBlob is too small");

   121   assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()");

   122 

   123   set_oop_maps(oop_maps);

   124 #ifdef COMPILER1

   125   // probably wrong for tiered

   126   assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");

   127 #endif // COMPILER1

   128 }

   129 

   130 

   131 // Creates a simple CodeBlob. Sets up the size of the different regions.

   132 RuntimeBlob::RuntimeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size)

   133   : CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, locs_size, size), frame_complete, 0, NULL, false /* caller_must_gc_arguments */)

   134 {

   135   assert(is_aligned(locs_size, oopSize), "unaligned size");

   136 }

   137 

   138 

   139 // Creates a RuntimeBlob from a CodeBuffer

   140 // and copy code and relocation info.

   141 RuntimeBlob::RuntimeBlob(

   142   const char* name,

   143   CodeBuffer* cb,

   144   int         header_size,

   145   int         size,

   146   int         frame_complete,

   147   int         frame_size,

   148   OopMapSet*  oop_maps,

   149   bool        caller_must_gc_arguments

   150 ) : CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, cb), cb, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) {

   151   cb->copy_code_and_locs_to(this);

   152 }

   153 

   154 void CodeBlob::flush() {

   155   if (_oop_maps) {

   156     FREE_C_HEAP_ARRAY(unsigned char, _oop_maps);

   157     _oop_maps = NULL;

   158   }

   159   _strings.free();

   160 }

   161 

   162 void CodeBlob::set_oop_maps(OopMapSet* p) {

   163   // Danger Will Robinson! This method allocates a big

   164   // chunk of memory, its your job to free it.

   165   if (p != NULL) {

   166     _oop_maps = ImmutableOopMapSet::build_from(p);

   167   } else {

   168     _oop_maps = NULL;

   169   }

   170 }

   171 

   172 

   173 void RuntimeBlob::trace_new_stub(RuntimeBlob* stub, const char* name1, const char* name2) {

   174   // Do not hold the CodeCache lock during name formatting.

   175   assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub");

   176 

   177   if (stub != NULL) {

   178     char stub_id[256];

   179     assert(strlen(name1) + strlen(name2) < sizeof(stub_id), "");

   180     jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2);

   181     if (PrintStubCode) {

   182       ttyLocker ttyl;

   183       tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub);

   184       Disassembler::decode(stub->code_begin(), stub->code_end());

   185       tty->cr();

   186     }

   187     Forte::register_stub(stub_id, stub->code_begin(), stub->code_end());

   188 

   189     if (JvmtiExport::should_post_dynamic_code_generated()) {

   190       const char* stub_name = name2;

   191       if (name2[0] == '\0')  stub_name = name1;

   192       JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end());

   193     }

   194   }

   195 

   196   // Track memory usage statistic after releasing CodeCache_lock

   197   MemoryService::track_code_cache_memory_usage();

   198 }

   199 

   200 const ImmutableOopMap* CodeBlob::oop_map_for_return_address(address return_address) {

   201   assert(_oop_maps != NULL, "nope");

   202   return _oop_maps->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin());

   203 }

   204 

   205 void CodeBlob::print_code() {

   206   ResourceMark m;

   207   Disassembler::decode(this, tty);

   208 }

   209 

   210 //----------------------------------------------------------------------------------------------------

   211 // Implementation of BufferBlob

   212 

   213 

   214 BufferBlob::BufferBlob(const char* name, int size)

   215 : RuntimeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0)

   216 {}

   217 

   218 BufferBlob* BufferBlob::create(const char* name, int buffer_size) {

   219   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   220 

   221   BufferBlob* blob = NULL;

   222   unsigned int size = sizeof(BufferBlob);

   223   // align the size to CodeEntryAlignment

   224   size = CodeBlob::align_code_offset(size);

   225   size += align_up(buffer_size, oopSize);

   226   assert(name != NULL, "must provide a name");

   227   {

   228     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   229     blob = new (size) BufferBlob(name, size);

   230   }

   231   // Track memory usage statistic after releasing CodeCache_lock

   232   MemoryService::track_code_cache_memory_usage();

   233 

   234   return blob;

   235 }

   236 

   237 

   238 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb)

   239   : RuntimeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL)

   240 {}

   241 

   242 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) {

   243   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   244 

   245   BufferBlob* blob = NULL;

   246   unsigned int size = CodeBlob::allocation_size(cb, sizeof(BufferBlob));

   247   assert(name != NULL, "must provide a name");

   248   {

   249     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   250     blob = new (size) BufferBlob(name, size, cb);

   251   }

   252   // Track memory usage statistic after releasing CodeCache_lock

   253   MemoryService::track_code_cache_memory_usage();

   254 

   255   return blob;

   256 }

   257 

   258 void* BufferBlob::operator new(size_t s, unsigned size) throw() {

   259   return CodeCache::allocate(size, CodeBlobType::NonNMethod);

   260 }

   261 

   262 void BufferBlob::free(BufferBlob *blob) {

   263   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   264   blob->flush();

   265   {

   266     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   267     CodeCache::free((RuntimeBlob*)blob);

   268   }

   269   // Track memory usage statistic after releasing CodeCache_lock

   270   MemoryService::track_code_cache_memory_usage();

   271 }

   272 

   273 

   274 //----------------------------------------------------------------------------------------------------

   275 // Implementation of AdapterBlob

   276 

   277 AdapterBlob::AdapterBlob(int size, CodeBuffer* cb) :

   278   BufferBlob("I2C/C2I adapters", size, cb) {

   279   CodeCache::commit(this);

   280 }

   281 

   282 AdapterBlob* AdapterBlob::create(CodeBuffer* cb) {

   283   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   284 

   285   AdapterBlob* blob = NULL;

   286   unsigned int size = CodeBlob::allocation_size(cb, sizeof(AdapterBlob));

   287   {

   288     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   289     blob = new (size) AdapterBlob(size, cb);

   290   }

   291   // Track memory usage statistic after releasing CodeCache_lock

   292   MemoryService::track_code_cache_memory_usage();

   293 

   294   return blob;

   295 }

   296 

   297 

   298 //----------------------------------------------------------------------------------------------------

   299 // Implementation of MethodHandlesAdapterBlob

   300 

   301 MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) {

   302   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   303 

   304   MethodHandlesAdapterBlob* blob = NULL;

   305   unsigned int size = sizeof(MethodHandlesAdapterBlob);

   306   // align the size to CodeEntryAlignment

   307   size = CodeBlob::align_code_offset(size);

   308   size += align_up(buffer_size, oopSize);

   309   {

   310     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   311     blob = new (size) MethodHandlesAdapterBlob(size);

   312     if (blob == NULL) {

   313       vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "CodeCache: no room for method handle adapter blob");

   314     }

   315   }

   316   // Track memory usage statistic after releasing CodeCache_lock

   317   MemoryService::track_code_cache_memory_usage();

   318 

   319   return blob;

   320 }

   321 

   322 //----------------------------------------------------------------------------------------------------

   323 // Implementation of RuntimeStub

   324 

   325 RuntimeStub::RuntimeStub(

   326   const char* name,

   327   CodeBuffer* cb,

   328   int         size,

   329   int         frame_complete,

   330   int         frame_size,

   331   OopMapSet*  oop_maps,

   332   bool        caller_must_gc_arguments

   333 )

   334 : RuntimeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments)

   335 {

   336 }

   337 

   338 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name,

   339                                            CodeBuffer* cb,

   340                                            int frame_complete,

   341                                            int frame_size,

   342                                            OopMapSet* oop_maps,

   343                                            bool caller_must_gc_arguments)

   344 {

   345   RuntimeStub* stub = NULL;

   346   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   347   {

   348     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   349     unsigned int size = CodeBlob::allocation_size(cb, sizeof(RuntimeStub));

   350     stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments);

   351   }

   352 

   353   trace_new_stub(stub, "RuntimeStub - ", stub_name);

   354 

   355   return stub;

   356 }

   357 

   358 

   359 void* RuntimeStub::operator new(size_t s, unsigned size) throw() {

   360   void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod);

   361   if (!p) fatal("Initial size of CodeCache is too small");

   362   return p;

   363 }

   364 

   365 // operator new shared by all singletons:

   366 void* SingletonBlob::operator new(size_t s, unsigned size) throw() {

   367   void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod);

   368   if (!p) fatal("Initial size of CodeCache is too small");

   369   return p;

   370 }

   371 

   372 

   373 //----------------------------------------------------------------------------------------------------

   374 // Implementation of DeoptimizationBlob

   375 

   376 DeoptimizationBlob::DeoptimizationBlob(

   377   CodeBuffer* cb,

   378   int         size,

   379   OopMapSet*  oop_maps,

   380   int         unpack_offset,

   381   int         unpack_with_exception_offset,

   382   int         unpack_with_reexecution_offset,

   383   int         frame_size

   384 )

   385 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps)

   386 {

   387   _unpack_offset           = unpack_offset;

   388   _unpack_with_exception   = unpack_with_exception_offset;

   389   _unpack_with_reexecution = unpack_with_reexecution_offset;

   390 #ifdef COMPILER1

   391   _unpack_with_exception_in_tls   = -1;

   392 #endif

   393 }

   394 

   395 

   396 DeoptimizationBlob* DeoptimizationBlob::create(

   397   CodeBuffer* cb,

   398   OopMapSet*  oop_maps,

   399   int        unpack_offset,

   400   int        unpack_with_exception_offset,

   401   int        unpack_with_reexecution_offset,

   402   int        frame_size)

   403 {

   404   DeoptimizationBlob* blob = NULL;

   405   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   406   {

   407     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   408     unsigned int size = CodeBlob::allocation_size(cb, sizeof(DeoptimizationBlob));

   409     blob = new (size) DeoptimizationBlob(cb,

   410                                          size,

   411                                          oop_maps,

   412                                          unpack_offset,

   413                                          unpack_with_exception_offset,

   414                                          unpack_with_reexecution_offset,

   415                                          frame_size);

   416   }

   417 

   418   trace_new_stub(blob, "DeoptimizationBlob");

   419 

   420   return blob;

   421 }

   422 

   423 

   424 //----------------------------------------------------------------------------------------------------

   425 // Implementation of UncommonTrapBlob

   426 

   427 #ifdef COMPILER2

   428 UncommonTrapBlob::UncommonTrapBlob(

   429   CodeBuffer* cb,

   430   int         size,

   431   OopMapSet*  oop_maps,

   432   int         frame_size

   433 )

   434 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps)

   435 {}

   436 

   437 

   438 UncommonTrapBlob* UncommonTrapBlob::create(

   439   CodeBuffer* cb,

   440   OopMapSet*  oop_maps,

   441   int        frame_size)

   442 {

   443   UncommonTrapBlob* blob = NULL;

   444   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   445   {

   446     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   447     unsigned int size = CodeBlob::allocation_size(cb, sizeof(UncommonTrapBlob));

   448     blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size);

   449   }

   450 

   451   trace_new_stub(blob, "UncommonTrapBlob");

   452 

   453   return blob;

   454 }

   455 

   456 

   457 #endif // COMPILER2

   458 

   459 

   460 //----------------------------------------------------------------------------------------------------

   461 // Implementation of ExceptionBlob

   462 

   463 #ifdef COMPILER2

   464 ExceptionBlob::ExceptionBlob(

   465   CodeBuffer* cb,

   466   int         size,

   467   OopMapSet*  oop_maps,

   468   int         frame_size

   469 )

   470 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps)

   471 {}

   472 

   473 

   474 ExceptionBlob* ExceptionBlob::create(

   475   CodeBuffer* cb,

   476   OopMapSet*  oop_maps,

   477   int         frame_size)

   478 {

   479   ExceptionBlob* blob = NULL;

   480   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   481   {

   482     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   483     unsigned int size = CodeBlob::allocation_size(cb, sizeof(ExceptionBlob));

   484     blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size);

   485   }

   486 

   487   trace_new_stub(blob, "ExceptionBlob");

   488 

   489   return blob;

   490 }

   491 

   492 

   493 #endif // COMPILER2

   494 

   495 

   496 //----------------------------------------------------------------------------------------------------

   497 // Implementation of SafepointBlob

   498 

   499 SafepointBlob::SafepointBlob(

   500   CodeBuffer* cb,

   501   int         size,

   502   OopMapSet*  oop_maps,

   503   int         frame_size

   504 )

   505 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps)

   506 {}

   507 

   508 

   509 SafepointBlob* SafepointBlob::create(

   510   CodeBuffer* cb,

   511   OopMapSet*  oop_maps,

   512   int         frame_size)

   513 {

   514   SafepointBlob* blob = NULL;

   515   ThreadInVMfromUnknown __tiv;  // get to VM state in case we block on CodeCache_lock

   516   {

   517     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

   518     unsigned int size = CodeBlob::allocation_size(cb, sizeof(SafepointBlob));

   519     blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size);

   520   }

   521 

   522   trace_new_stub(blob, "SafepointBlob");

   523 

   524   return blob;

   525 }

   526 

   527 

   528 //----------------------------------------------------------------------------------------------------

   529 // Verification and printing

   530 

   531 void CodeBlob::print_on(outputStream* st) const {

   532   st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", p2i(this));

   533   st->print_cr("Framesize: %d", _frame_size);

   534 }

   535 

   536 void CodeBlob::print_value_on(outputStream* st) const {

   537   st->print_cr("[CodeBlob]");

   538 }

   539 

   540 void RuntimeBlob::verify() {

   541   ShouldNotReachHere();

   542 }

   543 

   544 void BufferBlob::verify() {

   545   // unimplemented

   546 }

   547 

   548 void BufferBlob::print_on(outputStream* st) const {

   549   RuntimeBlob::print_on(st);

   550   print_value_on(st);

   551 }

   552 

   553 void BufferBlob::print_value_on(outputStream* st) const {

   554   st->print_cr("BufferBlob (" INTPTR_FORMAT  ") used for %s", p2i(this), name());

   555 }

   556 

   557 void RuntimeStub::verify() {

   558   // unimplemented

   559 }

   560 

   561 void RuntimeStub::print_on(outputStream* st) const {

   562   ttyLocker ttyl;

   563   RuntimeBlob::print_on(st);

   564   st->print("Runtime Stub (" INTPTR_FORMAT "): ", p2i(this));

   565   st->print_cr("%s", name());

   566   Disassembler::decode((RuntimeBlob*)this, st);

   567 }

   568 

   569 void RuntimeStub::print_value_on(outputStream* st) const {

   570   st->print("RuntimeStub (" INTPTR_FORMAT "): ", p2i(this)); st->print("%s", name());

   571 }

   572 

   573 void SingletonBlob::verify() {

   574   // unimplemented

   575 }

   576 

   577 void SingletonBlob::print_on(outputStream* st) const {

   578   ttyLocker ttyl;

   579   RuntimeBlob::print_on(st);

   580   st->print_cr("%s", name());

   581   Disassembler::decode((RuntimeBlob*)this, st);

   582 }

   583 

   584 void SingletonBlob::print_value_on(outputStream* st) const {

   585   st->print_cr("%s", name());

   586 }

   587 

   588 void DeoptimizationBlob::print_value_on(outputStream* st) const {

   589   st->print_cr("Deoptimization (frame not available)");

   590 }