1 /*

     2  * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "classfile/systemDictionary.hpp"

    27 #include "interpreter/bytecode.hpp"

    28 #include "interpreter/bytecodeStream.hpp"

    29 #include "interpreter/linkResolver.hpp"

    30 #include "oops/methodData.hpp"

    31 #include "prims/jvmtiRedefineClasses.hpp"

    32 #include "runtime/compilationPolicy.hpp"

    33 #include "runtime/deoptimization.hpp"

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

    35 

    36 // ==================================================================

    37 // DataLayout

    38 //

    39 // Overlay for generic profiling data.

    40 

    41 // Some types of data layouts need a length field.

    42 bool DataLayout::needs_array_len(u1 tag) {

    43   return (tag == multi_branch_data_tag) || (tag == arg_info_data_tag);

    44 }

    45 

    46 // Perform generic initialization of the data.  More specific

    47 // initialization occurs in overrides of ProfileData::post_initialize.

    48 void DataLayout::initialize(u1 tag, u2 bci, int cell_count) {

    49   _header._bits = (intptr_t)0;

    50   _header._struct._tag = tag;

    51   _header._struct._bci = bci;

    52   for (int i = 0; i < cell_count; i++) {

    53     set_cell_at(i, (intptr_t)0);

    54   }

    55   if (needs_array_len(tag)) {

    56     set_cell_at(ArrayData::array_len_off_set, cell_count - 1); // -1 for header.

    57   }

    58 }

    59 

    60 void DataLayout::clean_weak_klass_links(BoolObjectClosure* cl) {

    61   ResourceMark m;

    62   data_in()->clean_weak_klass_links(cl);

    63 }

    64 

    65 

    66 // ==================================================================

    67 // ProfileData

    68 //

    69 // A ProfileData object is created to refer to a section of profiling

    70 // data in a structured way.

    71 

    72 // Constructor for invalid ProfileData.

    73 ProfileData::ProfileData() {

    74   _data = NULL;

    75 }

    76 

    77 #ifndef PRODUCT

    78 void ProfileData::print_shared(outputStream* st, const char* name) {

    79   st->print("bci: %d", bci());

    80   st->fill_to(tab_width_one);

    81   st->print("%s", name);

    82   tab(st);

    83   int trap = trap_state();

    84   if (trap != 0) {

    85     char buf[100];

    86     st->print("trap(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));

    87   }

    88   int flags = data()->flags();

    89   if (flags != 0)

    90     st->print("flags(%d) ", flags);

    91 }

    92 

    93 void ProfileData::tab(outputStream* st) {

    94   st->fill_to(tab_width_two);

    95 }

    96 #endif // !PRODUCT

    97 

    98 // ==================================================================

    99 // BitData

   100 //

   101 // A BitData corresponds to a one-bit flag.  This is used to indicate

   102 // whether a checkcast bytecode has seen a null value.

   103 

   104 

   105 #ifndef PRODUCT

   106 void BitData::print_data_on(outputStream* st) {

   107   print_shared(st, "BitData");

   108 }

   109 #endif // !PRODUCT

   110 

   111 // ==================================================================

   112 // CounterData

   113 //

   114 // A CounterData corresponds to a simple counter.

   115 

   116 #ifndef PRODUCT

   117 void CounterData::print_data_on(outputStream* st) {

   118   print_shared(st, "CounterData");

   119   st->print_cr("count(%u)", count());

   120 }

   121 #endif // !PRODUCT

   122 

   123 // ==================================================================

   124 // JumpData

   125 //

   126 // A JumpData is used to access profiling information for a direct

   127 // branch.  It is a counter, used for counting the number of branches,

   128 // plus a data displacement, used for realigning the data pointer to

   129 // the corresponding target bci.

   130 

   131 void JumpData::post_initialize(BytecodeStream* stream, MethodData* mdo) {

   132   assert(stream->bci() == bci(), "wrong pos");

   133   int target;

   134   Bytecodes::Code c = stream->code();

   135   if (c == Bytecodes::_goto_w || c == Bytecodes::_jsr_w) {

   136     target = stream->dest_w();

   137   } else {

   138     target = stream->dest();

   139   }

   140   int my_di = mdo->dp_to_di(dp());

   141   int target_di = mdo->bci_to_di(target);

   142   int offset = target_di - my_di;

   143   set_displacement(offset);

   144 }

   145 

   146 #ifndef PRODUCT

   147 void JumpData::print_data_on(outputStream* st) {

   148   print_shared(st, "JumpData");

   149   st->print_cr("taken(%u) displacement(%d)", taken(), displacement());

   150 }

   151 #endif // !PRODUCT

   152 

   153 // ==================================================================

   154 // ReceiverTypeData

   155 //

   156 // A ReceiverTypeData is used to access profiling information about a

   157 // dynamic type check.  It consists of a counter which counts the total times

   158 // that the check is reached, and a series of (Klass*, count) pairs

   159 // which are used to store a type profile for the receiver of the check.

   160 

   161 void ReceiverTypeData::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {

   162     for (uint row = 0; row < row_limit(); row++) {

   163     Klass* p = receiver(row);

   164     if (p != NULL && !p->is_loader_alive(is_alive_cl)) {

   165       clear_row(row);

   166     }

   167   }

   168 }

   169 

   170 #ifndef PRODUCT

   171 void ReceiverTypeData::print_receiver_data_on(outputStream* st) {

   172   uint row;

   173   int entries = 0;

   174   for (row = 0; row < row_limit(); row++) {

   175     if (receiver(row) != NULL)  entries++;

   176   }

   177   st->print_cr("count(%u) entries(%u)", count(), entries);

   178   int total = count();

   179   for (row = 0; row < row_limit(); row++) {

   180     if (receiver(row) != NULL) {

   181       total += receiver_count(row);

   182     }

   183   }

   184   for (row = 0; row < row_limit(); row++) {

   185     if (receiver(row) != NULL) {

   186       tab(st);

   187       receiver(row)->print_value_on(st);

   188       st->print_cr("(%u %4.2f)", receiver_count(row), (float) receiver_count(row) / (float) total);

   189     }

   190   }

   191 }

   192 void ReceiverTypeData::print_data_on(outputStream* st) {

   193   print_shared(st, "ReceiverTypeData");

   194   print_receiver_data_on(st);

   195 }

   196 void VirtualCallData::print_data_on(outputStream* st) {

   197   print_shared(st, "VirtualCallData");

   198   print_receiver_data_on(st);

   199 }

   200 #endif // !PRODUCT

   201 

   202 // ==================================================================

   203 // RetData

   204 //

   205 // A RetData is used to access profiling information for a ret bytecode.

   206 // It is composed of a count of the number of times that the ret has

   207 // been executed, followed by a series of triples of the form

   208 // (bci, count, di) which count the number of times that some bci was the

   209 // target of the ret and cache a corresponding displacement.

   210 

   211 void RetData::post_initialize(BytecodeStream* stream, MethodData* mdo) {

   212   for (uint row = 0; row < row_limit(); row++) {

   213     set_bci_displacement(row, -1);

   214     set_bci(row, no_bci);

   215   }

   216   // release so other threads see a consistent state.  bci is used as

   217   // a valid flag for bci_displacement.

   218   OrderAccess::release();

   219 }

   220 

   221 // This routine needs to atomically update the RetData structure, so the

   222 // caller needs to hold the RetData_lock before it gets here.  Since taking

   223 // the lock can block (and allow GC) and since RetData is a ProfileData is a

   224 // wrapper around a derived oop, taking the lock in _this_ method will

   225 // basically cause the 'this' pointer's _data field to contain junk after the

   226 // lock.  We require the caller to take the lock before making the ProfileData

   227 // structure.  Currently the only caller is InterpreterRuntime::update_mdp_for_ret

   228 address RetData::fixup_ret(int return_bci, MethodData* h_mdo) {

   229   // First find the mdp which corresponds to the return bci.

   230   address mdp = h_mdo->bci_to_dp(return_bci);

   231 

   232   // Now check to see if any of the cache slots are open.

   233   for (uint row = 0; row < row_limit(); row++) {

   234     if (bci(row) == no_bci) {

   235       set_bci_displacement(row, mdp - dp());

   236       set_bci_count(row, DataLayout::counter_increment);

   237       // Barrier to ensure displacement is written before the bci; allows

   238       // the interpreter to read displacement without fear of race condition.

   239       release_set_bci(row, return_bci);

   240       break;

   241     }

   242   }

   243   return mdp;

   244 }

   245 

   246 

   247 #ifndef PRODUCT

   248 void RetData::print_data_on(outputStream* st) {

   249   print_shared(st, "RetData");

   250   uint row;

   251   int entries = 0;

   252   for (row = 0; row < row_limit(); row++) {

   253     if (bci(row) != no_bci)  entries++;

   254   }

   255   st->print_cr("count(%u) entries(%u)", count(), entries);

   256   for (row = 0; row < row_limit(); row++) {

   257     if (bci(row) != no_bci) {

   258       tab(st);

   259       st->print_cr("bci(%d: count(%u) displacement(%d))",

   260                    bci(row), bci_count(row), bci_displacement(row));

   261     }

   262   }

   263 }

   264 #endif // !PRODUCT

   265 

   266 // ==================================================================

   267 // BranchData

   268 //

   269 // A BranchData is used to access profiling data for a two-way branch.

   270 // It consists of taken and not_taken counts as well as a data displacement

   271 // for the taken case.

   272 

   273 void BranchData::post_initialize(BytecodeStream* stream, MethodData* mdo) {

   274   assert(stream->bci() == bci(), "wrong pos");

   275   int target = stream->dest();

   276   int my_di = mdo->dp_to_di(dp());

   277   int target_di = mdo->bci_to_di(target);

   278   int offset = target_di - my_di;

   279   set_displacement(offset);

   280 }

   281 

   282 #ifndef PRODUCT

   283 void BranchData::print_data_on(outputStream* st) {

   284   print_shared(st, "BranchData");

   285   st->print_cr("taken(%u) displacement(%d)",

   286                taken(), displacement());

   287   tab(st);

   288   st->print_cr("not taken(%u)", not_taken());

   289 }

   290 #endif

   291 

   292 // ==================================================================

   293 // MultiBranchData

   294 //

   295 // A MultiBranchData is used to access profiling information for

   296 // a multi-way branch (*switch bytecodes).  It consists of a series

   297 // of (count, displacement) pairs, which count the number of times each

   298 // case was taken and specify the data displacment for each branch target.

   299 

   300 int MultiBranchData::compute_cell_count(BytecodeStream* stream) {

   301   int cell_count = 0;

   302   if (stream->code() == Bytecodes::_tableswitch) {

   303     Bytecode_tableswitch sw(stream->method()(), stream->bcp());

   304     cell_count = 1 + per_case_cell_count * (1 + sw.length()); // 1 for default

   305   } else {

   306     Bytecode_lookupswitch sw(stream->method()(), stream->bcp());

   307     cell_count = 1 + per_case_cell_count * (sw.number_of_pairs() + 1); // 1 for default

   308   }

   309   return cell_count;

   310 }

   311 

   312 void MultiBranchData::post_initialize(BytecodeStream* stream,

   313                                       MethodData* mdo) {

   314   assert(stream->bci() == bci(), "wrong pos");

   315   int target;

   316   int my_di;

   317   int target_di;

   318   int offset;

   319   if (stream->code() == Bytecodes::_tableswitch) {

   320     Bytecode_tableswitch sw(stream->method()(), stream->bcp());

   321     int len = sw.length();

   322     assert(array_len() == per_case_cell_count * (len + 1), "wrong len");

   323     for (int count = 0; count < len; count++) {

   324       target = sw.dest_offset_at(count) + bci();

   325       my_di = mdo->dp_to_di(dp());

   326       target_di = mdo->bci_to_di(target);

   327       offset = target_di - my_di;

   328       set_displacement_at(count, offset);

   329     }

   330     target = sw.default_offset() + bci();

   331     my_di = mdo->dp_to_di(dp());

   332     target_di = mdo->bci_to_di(target);

   333     offset = target_di - my_di;

   334     set_default_displacement(offset);

   335 

   336   } else {

   337     Bytecode_lookupswitch sw(stream->method()(), stream->bcp());

   338     int npairs = sw.number_of_pairs();

   339     assert(array_len() == per_case_cell_count * (npairs + 1), "wrong len");

   340     for (int count = 0; count < npairs; count++) {

   341       LookupswitchPair pair = sw.pair_at(count);

   342       target = pair.offset() + bci();

   343       my_di = mdo->dp_to_di(dp());

   344       target_di = mdo->bci_to_di(target);

   345       offset = target_di - my_di;

   346       set_displacement_at(count, offset);

   347     }

   348     target = sw.default_offset() + bci();

   349     my_di = mdo->dp_to_di(dp());

   350     target_di = mdo->bci_to_di(target);

   351     offset = target_di - my_di;

   352     set_default_displacement(offset);

   353   }

   354 }

   355 

   356 #ifndef PRODUCT

   357 void MultiBranchData::print_data_on(outputStream* st) {

   358   print_shared(st, "MultiBranchData");

   359   st->print_cr("default_count(%u) displacement(%d)",

   360                default_count(), default_displacement());

   361   int cases = number_of_cases();

   362   for (int i = 0; i < cases; i++) {

   363     tab(st);

   364     st->print_cr("count(%u) displacement(%d)",

   365                  count_at(i), displacement_at(i));

   366   }

   367 }

   368 #endif

   369 

   370 #ifndef PRODUCT

   371 void ArgInfoData::print_data_on(outputStream* st) {

   372   print_shared(st, "ArgInfoData");

   373   int nargs = number_of_args();

   374   for (int i = 0; i < nargs; i++) {

   375     st->print("  0x%x", arg_modified(i));

   376   }

   377   st->cr();

   378 }

   379 

   380 #endif

   381 // ==================================================================

   382 // MethodData*

   383 //

   384 // A MethodData* holds information which has been collected about

   385 // a method.

   386 

   387 MethodData* MethodData::allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS) {

   388   int size = MethodData::compute_allocation_size_in_words(method);

   389 

   390   return new (loader_data, size, false, THREAD) MethodData(method(), size, CHECK_NULL);

   391 }

   392 

   393 int MethodData::bytecode_cell_count(Bytecodes::Code code) {

   394   switch (code) {

   395   case Bytecodes::_checkcast:

   396   case Bytecodes::_instanceof:

   397   case Bytecodes::_aastore:

   398     if (TypeProfileCasts) {

   399       return ReceiverTypeData::static_cell_count();

   400     } else {

   401       return BitData::static_cell_count();

   402     }

   403   case Bytecodes::_invokespecial:

   404   case Bytecodes::_invokestatic:

   405     return CounterData::static_cell_count();

   406   case Bytecodes::_goto:

   407   case Bytecodes::_goto_w:

   408   case Bytecodes::_jsr:

   409   case Bytecodes::_jsr_w:

   410     return JumpData::static_cell_count();

   411   case Bytecodes::_invokevirtual:

   412   case Bytecodes::_invokeinterface:

   413     return VirtualCallData::static_cell_count();

   414   case Bytecodes::_invokedynamic:

   415     return CounterData::static_cell_count();

   416   case Bytecodes::_ret:

   417     return RetData::static_cell_count();

   418   case Bytecodes::_ifeq:

   419   case Bytecodes::_ifne:

   420   case Bytecodes::_iflt:

   421   case Bytecodes::_ifge:

   422   case Bytecodes::_ifgt:

   423   case Bytecodes::_ifle:

   424   case Bytecodes::_if_icmpeq:

   425   case Bytecodes::_if_icmpne:

   426   case Bytecodes::_if_icmplt:

   427   case Bytecodes::_if_icmpge:

   428   case Bytecodes::_if_icmpgt:

   429   case Bytecodes::_if_icmple:

   430   case Bytecodes::_if_acmpeq:

   431   case Bytecodes::_if_acmpne:

   432   case Bytecodes::_ifnull:

   433   case Bytecodes::_ifnonnull:

   434     return BranchData::static_cell_count();

   435   case Bytecodes::_lookupswitch:

   436   case Bytecodes::_tableswitch:

   437     return variable_cell_count;

   438   }

   439   return no_profile_data;

   440 }

   441 

   442 // Compute the size of the profiling information corresponding to

   443 // the current bytecode.

   444 int MethodData::compute_data_size(BytecodeStream* stream) {

   445   int cell_count = bytecode_cell_count(stream->code());

   446   if (cell_count == no_profile_data) {

   447     return 0;

   448   }

   449   if (cell_count == variable_cell_count) {

   450     cell_count = MultiBranchData::compute_cell_count(stream);

   451   }

   452   // Note:  cell_count might be zero, meaning that there is just

   453   //        a DataLayout header, with no extra cells.

   454   assert(cell_count >= 0, "sanity");

   455   return DataLayout::compute_size_in_bytes(cell_count);

   456 }

   457 

   458 int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) {

   459   if (ProfileTraps) {

   460     // Assume that up to 3% of BCIs with no MDP will need to allocate one.

   461     int extra_data_count = (uint)(empty_bc_count * 3) / 128 + 1;

   462     // If the method is large, let the extra BCIs grow numerous (to ~1%).

   463     int one_percent_of_data

   464       = (uint)data_size / (DataLayout::header_size_in_bytes()*128);

   465     if (extra_data_count < one_percent_of_data)

   466       extra_data_count = one_percent_of_data;

   467     if (extra_data_count > empty_bc_count)

   468       extra_data_count = empty_bc_count;  // no need for more

   469     return extra_data_count;

   470   } else {

   471     return 0;

   472   }

   473 }

   474 

   475 // Compute the size of the MethodData* necessary to store

   476 // profiling information about a given method.  Size is in bytes.

   477 int MethodData::compute_allocation_size_in_bytes(methodHandle method) {

   478   int data_size = 0;

   479   BytecodeStream stream(method);

   480   Bytecodes::Code c;

   481   int empty_bc_count = 0;  // number of bytecodes lacking data

   482   while ((c = stream.next()) >= 0) {

   483     int size_in_bytes = compute_data_size(&stream);

   484     data_size += size_in_bytes;

   485     if (size_in_bytes == 0)  empty_bc_count += 1;

   486   }

   487   int object_size = in_bytes(data_offset()) + data_size;

   488 

   489   // Add some extra DataLayout cells (at least one) to track stray traps.

   490   int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);

   491   object_size += extra_data_count * DataLayout::compute_size_in_bytes(0);

   492 

   493   // Add a cell to record information about modified arguments.

   494   int arg_size = method->size_of_parameters();

   495   object_size += DataLayout::compute_size_in_bytes(arg_size+1);

   496   return object_size;

   497 }

   498 

   499 // Compute the size of the MethodData* necessary to store

   500 // profiling information about a given method.  Size is in words

   501 int MethodData::compute_allocation_size_in_words(methodHandle method) {

   502   int byte_size = compute_allocation_size_in_bytes(method);

   503   int word_size = align_size_up(byte_size, BytesPerWord) / BytesPerWord;

   504   return align_object_size(word_size);

   505 }

   506 

   507 // Initialize an individual data segment.  Returns the size of

   508 // the segment in bytes.

   509 int MethodData::initialize_data(BytecodeStream* stream,

   510                                        int data_index) {

   511   int cell_count = -1;

   512   int tag = DataLayout::no_tag;

   513   DataLayout* data_layout = data_layout_at(data_index);

   514   Bytecodes::Code c = stream->code();

   515   switch (c) {

   516   case Bytecodes::_checkcast:

   517   case Bytecodes::_instanceof:

   518   case Bytecodes::_aastore:

   519     if (TypeProfileCasts) {

   520       cell_count = ReceiverTypeData::static_cell_count();

   521       tag = DataLayout::receiver_type_data_tag;

   522     } else {

   523       cell_count = BitData::static_cell_count();

   524       tag = DataLayout::bit_data_tag;

   525     }

   526     break;

   527   case Bytecodes::_invokespecial:

   528   case Bytecodes::_invokestatic:

   529     cell_count = CounterData::static_cell_count();

   530     tag = DataLayout::counter_data_tag;

   531     break;

   532   case Bytecodes::_goto:

   533   case Bytecodes::_goto_w:

   534   case Bytecodes::_jsr:

   535   case Bytecodes::_jsr_w:

   536     cell_count = JumpData::static_cell_count();

   537     tag = DataLayout::jump_data_tag;

   538     break;

   539   case Bytecodes::_invokevirtual:

   540   case Bytecodes::_invokeinterface:

   541     cell_count = VirtualCallData::static_cell_count();

   542     tag = DataLayout::virtual_call_data_tag;

   543     break;

   544   case Bytecodes::_invokedynamic:

   545     // %%% should make a type profile for any invokedynamic that takes a ref argument

   546     cell_count = CounterData::static_cell_count();

   547     tag = DataLayout::counter_data_tag;

   548     break;

   549   case Bytecodes::_ret:

   550     cell_count = RetData::static_cell_count();

   551     tag = DataLayout::ret_data_tag;

   552     break;

   553   case Bytecodes::_ifeq:

   554   case Bytecodes::_ifne:

   555   case Bytecodes::_iflt:

   556   case Bytecodes::_ifge:

   557   case Bytecodes::_ifgt:

   558   case Bytecodes::_ifle:

   559   case Bytecodes::_if_icmpeq:

   560   case Bytecodes::_if_icmpne:

   561   case Bytecodes::_if_icmplt:

   562   case Bytecodes::_if_icmpge:

   563   case Bytecodes::_if_icmpgt:

   564   case Bytecodes::_if_icmple:

   565   case Bytecodes::_if_acmpeq:

   566   case Bytecodes::_if_acmpne:

   567   case Bytecodes::_ifnull:

   568   case Bytecodes::_ifnonnull:

   569     cell_count = BranchData::static_cell_count();

   570     tag = DataLayout::branch_data_tag;

   571     break;

   572   case Bytecodes::_lookupswitch:

   573   case Bytecodes::_tableswitch:

   574     cell_count = MultiBranchData::compute_cell_count(stream);

   575     tag = DataLayout::multi_branch_data_tag;

   576     break;

   577   }

   578   assert(tag == DataLayout::multi_branch_data_tag ||

   579          cell_count == bytecode_cell_count(c), "cell counts must agree");

   580   if (cell_count >= 0) {

   581     assert(tag != DataLayout::no_tag, "bad tag");

   582     assert(bytecode_has_profile(c), "agree w/ BHP");

   583     data_layout->initialize(tag, stream->bci(), cell_count);

   584     return DataLayout::compute_size_in_bytes(cell_count);

   585   } else {

   586     assert(!bytecode_has_profile(c), "agree w/ !BHP");

   587     return 0;

   588   }

   589 }

   590 

   591 // Get the data at an arbitrary (sort of) data index.

   592 ProfileData* MethodData::data_at(int data_index) const {

   593   if (out_of_bounds(data_index)) {

   594     return NULL;

   595   }

   596   DataLayout* data_layout = data_layout_at(data_index);

   597   return data_layout->data_in();

   598 }

   599 

   600 ProfileData* DataLayout::data_in() {

   601   switch (tag()) {

   602   case DataLayout::no_tag:

   603   default:

   604     ShouldNotReachHere();

   605     return NULL;

   606   case DataLayout::bit_data_tag:

   607     return new BitData(this);

   608   case DataLayout::counter_data_tag:

   609     return new CounterData(this);

   610   case DataLayout::jump_data_tag:

   611     return new JumpData(this);

   612   case DataLayout::receiver_type_data_tag:

   613     return new ReceiverTypeData(this);

   614   case DataLayout::virtual_call_data_tag:

   615     return new VirtualCallData(this);

   616   case DataLayout::ret_data_tag:

   617     return new RetData(this);

   618   case DataLayout::branch_data_tag:

   619     return new BranchData(this);

   620   case DataLayout::multi_branch_data_tag:

   621     return new MultiBranchData(this);

   622   case DataLayout::arg_info_data_tag:

   623     return new ArgInfoData(this);

   624   };

   625 }

   626 

   627 // Iteration over data.

   628 ProfileData* MethodData::next_data(ProfileData* current) const {

   629   int current_index = dp_to_di(current->dp());

   630   int next_index = current_index + current->size_in_bytes();

   631   ProfileData* next = data_at(next_index);

   632   return next;

   633 }

   634 

   635 // Give each of the data entries a chance to perform specific

   636 // data initialization.

   637 void MethodData::post_initialize(BytecodeStream* stream) {

   638   ResourceMark rm;

   639   ProfileData* data;

   640   for (data = first_data(); is_valid(data); data = next_data(data)) {

   641     stream->set_start(data->bci());

   642     stream->next();

   643     data->post_initialize(stream, this);

   644   }

   645 }

   646 

   647 // Initialize the MethodData* corresponding to a given method.

   648 MethodData::MethodData(methodHandle method, int size, TRAPS) {

   649   No_Safepoint_Verifier no_safepoint;  // init function atomic wrt GC

   650   ResourceMark rm;

   651   // Set the method back-pointer.

   652   _method = method();

   653 

   654   if (TieredCompilation) {

   655     _invocation_counter.init();

   656     _backedge_counter.init();

   657     _invocation_counter_start = 0;

   658     _backedge_counter_start = 0;

   659     _num_loops = 0;

   660     _num_blocks = 0;

   661     _highest_comp_level = 0;

   662     _highest_osr_comp_level = 0;

   663     _would_profile = true;

   664   }

   665   set_creation_mileage(mileage_of(method()));

   666 

   667   // Initialize flags and trap history.

   668   _nof_decompiles = 0;

   669   _nof_overflow_recompiles = 0;

   670   _nof_overflow_traps = 0;

   671   assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align");

   672   Copy::zero_to_words((HeapWord*) &_trap_hist,

   673                       sizeof(_trap_hist) / sizeof(HeapWord));

   674 

   675   // Go through the bytecodes and allocate and initialize the

   676   // corresponding data cells.

   677   int data_size = 0;

   678   int empty_bc_count = 0;  // number of bytecodes lacking data

   679   BytecodeStream stream(method);

   680   Bytecodes::Code c;

   681   while ((c = stream.next()) >= 0) {

   682     int size_in_bytes = initialize_data(&stream, data_size);

   683     data_size += size_in_bytes;

   684     if (size_in_bytes == 0)  empty_bc_count += 1;

   685   }

   686   _data_size = data_size;

   687   int object_size = in_bytes(data_offset()) + data_size;

   688 

   689   // Add some extra DataLayout cells (at least one) to track stray traps.

   690   int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);

   691   int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0);

   692 

   693   // Add a cell to record information about modified arguments.

   694   // Set up _args_modified array after traps cells so that

   695   // the code for traps cells works.

   696   DataLayout *dp = data_layout_at(data_size + extra_size);

   697 

   698   int arg_size = method->size_of_parameters();

   699   dp->initialize(DataLayout::arg_info_data_tag, 0, arg_size+1);

   700 

   701   object_size += extra_size + DataLayout::compute_size_in_bytes(arg_size+1);

   702 

   703   // Set an initial hint. Don't use set_hint_di() because

   704   // first_di() may be out of bounds if data_size is 0.

   705   // In that situation, _hint_di is never used, but at

   706   // least well-defined.

   707   _hint_di = first_di();

   708 

   709   post_initialize(&stream);

   710 

   711   set_size(object_size);

   712 }

   713 

   714 // Get a measure of how much mileage the method has on it.

   715 int MethodData::mileage_of(Method* method) {

   716   int mileage = 0;

   717   if (TieredCompilation) {

   718     mileage = MAX2(method->invocation_count(), method->backedge_count());

   719   } else {

   720     int iic = method->interpreter_invocation_count();

   721     if (mileage < iic)  mileage = iic;

   722     InvocationCounter* ic = method->invocation_counter();

   723     InvocationCounter* bc = method->backedge_counter();

   724     int icval = ic->count();

   725     if (ic->carry()) icval += CompileThreshold;

   726     if (mileage < icval)  mileage = icval;

   727     int bcval = bc->count();

   728     if (bc->carry()) bcval += CompileThreshold;

   729     if (mileage < bcval)  mileage = bcval;

   730   }

   731   return mileage;

   732 }

   733 

   734 bool MethodData::is_mature() const {

   735   return CompilationPolicy::policy()->is_mature(_method);

   736 }

   737 

   738 // Translate a bci to its corresponding data index (di).

   739 address MethodData::bci_to_dp(int bci) {

   740   ResourceMark rm;

   741   ProfileData* data = data_before(bci);

   742   ProfileData* prev = NULL;

   743   for ( ; is_valid(data); data = next_data(data)) {

   744     if (data->bci() >= bci) {

   745       if (data->bci() == bci)  set_hint_di(dp_to_di(data->dp()));

   746       else if (prev != NULL)   set_hint_di(dp_to_di(prev->dp()));

   747       return data->dp();

   748     }

   749     prev = data;

   750   }

   751   return (address)limit_data_position();

   752 }

   753 

   754 // Translate a bci to its corresponding data, or NULL.

   755 ProfileData* MethodData::bci_to_data(int bci) {

   756   ProfileData* data = data_before(bci);

   757   for ( ; is_valid(data); data = next_data(data)) {

   758     if (data->bci() == bci) {

   759       set_hint_di(dp_to_di(data->dp()));

   760       return data;

   761     } else if (data->bci() > bci) {

   762       break;

   763     }

   764   }

   765   return bci_to_extra_data(bci, false);

   766 }

   767 

   768 // Translate a bci to its corresponding extra data, or NULL.

   769 ProfileData* MethodData::bci_to_extra_data(int bci, bool create_if_missing) {

   770   DataLayout* dp    = extra_data_base();

   771   DataLayout* end   = extra_data_limit();

   772   DataLayout* avail = NULL;

   773   for (; dp < end; dp = next_extra(dp)) {

   774     // No need for "OrderAccess::load_acquire" ops,

   775     // since the data structure is monotonic.

   776     if (dp->tag() == DataLayout::no_tag)  break;

   777     if (dp->tag() == DataLayout::arg_info_data_tag) {

   778       dp = end; // ArgInfoData is at the end of extra data section.

   779       break;

   780     }

   781     if (dp->bci() == bci) {

   782       assert(dp->tag() == DataLayout::bit_data_tag, "sane");

   783       return new BitData(dp);

   784     }

   785   }

   786   if (create_if_missing && dp < end) {

   787     // Allocate this one.  There is no mutual exclusion,

   788     // so two threads could allocate different BCIs to the

   789     // same data layout.  This means these extra data

   790     // records, like most other MDO contents, must not be

   791     // trusted too much.

   792     DataLayout temp;

   793     temp.initialize(DataLayout::bit_data_tag, bci, 0);

   794     dp->release_set_header(temp.header());

   795     assert(dp->tag() == DataLayout::bit_data_tag, "sane");

   796     //NO: assert(dp->bci() == bci, "no concurrent allocation");

   797     return new BitData(dp);

   798   }

   799   return NULL;

   800 }

   801 

   802 ArgInfoData *MethodData::arg_info() {

   803   DataLayout* dp    = extra_data_base();

   804   DataLayout* end   = extra_data_limit();

   805   for (; dp < end; dp = next_extra(dp)) {

   806     if (dp->tag() == DataLayout::arg_info_data_tag)

   807       return new ArgInfoData(dp);

   808   }

   809   return NULL;

   810 }

   811 

   812 // Printing

   813 

   814 #ifndef PRODUCT

   815 

   816 void MethodData::print_on(outputStream* st) const {

   817   assert(is_methodData(), "should be method data");

   818   st->print("method data for ");

   819   method()->print_value_on(st);

   820   st->cr();

   821   print_data_on(st);

   822 }

   823 

   824 #endif //PRODUCT

   825 

   826 void MethodData::print_value_on(outputStream* st) const {

   827   assert(is_methodData(), "should be method data");

   828   st->print("method data for ");

   829   method()->print_value_on(st);

   830 }

   831 

   832 #ifndef PRODUCT

   833 void MethodData::print_data_on(outputStream* st) const {

   834   ResourceMark rm;

   835   ProfileData* data = first_data();

   836   for ( ; is_valid(data); data = next_data(data)) {

   837     st->print("%d", dp_to_di(data->dp()));

   838     st->fill_to(6);

   839     data->print_data_on(st);

   840   }

   841   st->print_cr("--- Extra data:");

   842   DataLayout* dp    = extra_data_base();

   843   DataLayout* end   = extra_data_limit();

   844   for (; dp < end; dp = next_extra(dp)) {

   845     // No need for "OrderAccess::load_acquire" ops,

   846     // since the data structure is monotonic.

   847     if (dp->tag() == DataLayout::no_tag)  continue;

   848     if (dp->tag() == DataLayout::bit_data_tag) {

   849       data = new BitData(dp);

   850     } else {

   851       assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo");

   852       data = new ArgInfoData(dp);

   853       dp = end; // ArgInfoData is at the end of extra data section.

   854     }

   855     st->print("%d", dp_to_di(data->dp()));

   856     st->fill_to(6);

   857     data->print_data_on(st);

   858   }

   859 }

   860 #endif

   861 

   862 

   863 // Verification

   864 

   865 void MethodData::verify_on(outputStream* st) {

   866   guarantee(is_methodData(), "object must be method data");

   867   // guarantee(m->is_perm(), "should be in permspace");

   868   this->verify_data_on(st);

   869 }

   870 

   871 void MethodData::verify_data_on(outputStream* st) {

   872   NEEDS_CLEANUP;

   873   // not yet implemented.

   874 }