hotspot/src/share/vm/oops/methodData.cpp
author goetz
Tue, 29 Apr 2014 15:17:27 +0200
changeset 24351 61b33cc6d3cf
parent 23845 ebd1fafcc362
child 24424 2658d7834c6e
permissions -rw-r--r--
8042195: Introduce umbrella header orderAccess.inline.hpp. Reviewed-by: dholmes, kvn, stefank, twisti
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
     2
 * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3696
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3696
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 3696
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    26
#include "classfile/systemDictionary.hpp"
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
    27
#include "compiler/compilerOracle.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    28
#include "interpreter/bytecode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    29
#include "interpreter/bytecodeStream.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    30
#include "interpreter/linkResolver.hpp"
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
    31
#include "memory/heapInspection.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
    32
#include "oops/methodData.hpp"
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
    33
#include "prims/jvmtiRedefineClasses.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    34
#include "runtime/compilationPolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    35
#include "runtime/deoptimization.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    36
#include "runtime/handles.inline.hpp"
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 23845
diff changeset
    37
#include "runtime/orderAccess.inline.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// DataLayout
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
// Overlay for generic profiling data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
// Some types of data layouts need a length field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
bool DataLayout::needs_array_len(u1 tag) {
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
    46
  return (tag == multi_branch_data_tag) || (tag == arg_info_data_tag) || (tag == parameters_type_data_tag);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
// Perform generic initialization of the data.  More specific
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// initialization occurs in overrides of ProfileData::post_initialize.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
void DataLayout::initialize(u1 tag, u2 bci, int cell_count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  _header._bits = (intptr_t)0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  _header._struct._tag = tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  _header._struct._bci = bci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  for (int i = 0; i < cell_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
    set_cell_at(i, (intptr_t)0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  if (needs_array_len(tag)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    set_cell_at(ArrayData::array_len_off_set, cell_count - 1); // -1 for header.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  }
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
    61
  if (tag == call_type_data_tag) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
    62
    CallTypeData::initialize(this, cell_count);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
    63
  } else if (tag == virtual_call_type_data_tag) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
    64
    VirtualCallTypeData::initialize(this, cell_count);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
    65
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
    68
void DataLayout::clean_weak_klass_links(BoolObjectClosure* cl) {
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
    69
  ResourceMark m;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
    70
  data_in()->clean_weak_klass_links(cl);
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
    71
}
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
    72
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
    73
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
// ProfileData
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
// A ProfileData object is created to refer to a section of profiling
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
// data in a structured way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
// Constructor for invalid ProfileData.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
ProfileData::ProfileData() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  _data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    85
char* ProfileData::print_data_on_helper(const MethodData* md) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    86
  DataLayout* dp  = md->extra_data_base();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    87
  DataLayout* end = md->extra_data_limit();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    88
  stringStream ss;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    89
  for (;; dp = MethodData::next_extra(dp)) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    90
    assert(dp < end, "moved past end of extra data");
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    91
    switch(dp->tag()) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    92
    case DataLayout::speculative_trap_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    93
      if (dp->bci() == bci()) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    94
        SpeculativeTrapData* data = new SpeculativeTrapData(dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    95
        int trap = data->trap_state();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    96
        char buf[100];
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    97
        ss.print("trap/");
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    98
        data->method()->print_short_name(&ss);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
    99
        ss.print("(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   100
      }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   101
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   102
    case DataLayout::bit_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   103
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   104
    case DataLayout::no_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   105
    case DataLayout::arg_info_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   106
      return ss.as_string();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   107
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   108
    default:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   109
      fatal(err_msg("unexpected tag %d", dp->tag()));
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   110
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   111
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   112
  return NULL;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   113
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   114
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   115
void ProfileData::print_data_on(outputStream* st, const MethodData* md) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   116
  print_data_on(st, print_data_on_helper(md));
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   117
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   118
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   119
void ProfileData::print_shared(outputStream* st, const char* name, const char* extra) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  st->print("bci: %d", bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  st->fill_to(tab_width_one);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  st->print("%s", name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  tab(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  int trap = trap_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  if (trap != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
    char buf[100];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    st->print("trap(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  }
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   129
  if (extra != NULL) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   130
    st->print(extra);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   131
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  int flags = data()->flags();
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   133
  if (flags != 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
    st->print("flags(%d) ", flags);
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   135
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   138
void ProfileData::tab(outputStream* st, bool first) const {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   139
  st->fill_to(first ? tab_width_one : tab_width_two);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
// BitData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
// A BitData corresponds to a one-bit flag.  This is used to indicate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
// whether a checkcast bytecode has seen a null value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   149
void BitData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   150
  print_shared(st, "BitData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
// CounterData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
// A CounterData corresponds to a simple counter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   158
void CounterData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   159
  print_shared(st, "CounterData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  st->print_cr("count(%u)", count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
// JumpData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
// A JumpData is used to access profiling information for a direct
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
// branch.  It is a counter, used for counting the number of branches,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
// plus a data displacement, used for realigning the data pointer to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
// the corresponding target bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   171
void JumpData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  assert(stream->bci() == bci(), "wrong pos");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  int target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  Bytecodes::Code c = stream->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  if (c == Bytecodes::_goto_w || c == Bytecodes::_jsr_w) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
    target = stream->dest_w();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
    target = stream->dest();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  int my_di = mdo->dp_to_di(dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  int target_di = mdo->bci_to_di(target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  int offset = target_di - my_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  set_displacement(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   186
void JumpData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   187
  print_shared(st, "JumpData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  st->print_cr("taken(%u) displacement(%d)", taken(), displacement());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   191
int TypeStackSlotEntries::compute_cell_count(Symbol* signature, bool include_receiver, int max) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   192
  // Parameter profiling include the receiver
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   193
  int args_count = include_receiver ? 1 : 0;
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   194
  ResourceMark rm;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   195
  SignatureStream ss(signature);
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   196
  args_count += ss.reference_parameter_count();
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   197
  args_count = MIN2(args_count, max);
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   198
  return args_count * per_arg_cell_count;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   199
}
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   200
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   201
int TypeEntriesAtCall::compute_cell_count(BytecodeStream* stream) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   202
  assert(Bytecodes::is_invoke(stream->code()), "should be invoke");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   203
  assert(TypeStackSlotEntries::per_arg_count() > ReturnTypeEntry::static_cell_count(), "code to test for arguments/results broken");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   204
  Bytecode_invoke inv(stream->method(), stream->bci());
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   205
  int args_cell = 0;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   206
  if (arguments_profiling_enabled()) {
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   207
    args_cell = TypeStackSlotEntries::compute_cell_count(inv.signature(), false, TypeProfileArgsLimit);
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   208
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   209
  int ret_cell = 0;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   210
  if (return_profiling_enabled() && (inv.result_type() == T_OBJECT || inv.result_type() == T_ARRAY)) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   211
    ret_cell = ReturnTypeEntry::static_cell_count();
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   212
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   213
  int header_cell = 0;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   214
  if (args_cell + ret_cell > 0) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   215
    header_cell = header_cell_count();
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   216
  }
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   217
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   218
  return header_cell + args_cell + ret_cell;
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   219
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   220
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   221
class ArgumentOffsetComputer : public SignatureInfo {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   222
private:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   223
  int _max;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   224
  GrowableArray<int> _offsets;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   225
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   226
  void set(int size, BasicType type) { _size += size; }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   227
  void do_object(int begin, int end) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   228
    if (_offsets.length() < _max) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   229
      _offsets.push(_size);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   230
    }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   231
    SignatureInfo::do_object(begin, end);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   232
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   233
  void do_array (int begin, int end) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   234
    if (_offsets.length() < _max) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   235
      _offsets.push(_size);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   236
    }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   237
    SignatureInfo::do_array(begin, end);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   238
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   239
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   240
public:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   241
  ArgumentOffsetComputer(Symbol* signature, int max)
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   242
    : SignatureInfo(signature), _max(max), _offsets(Thread::current(), max) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   243
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   244
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   245
  int total() { lazy_iterate_parameters(); return _size; }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   246
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   247
  int off_at(int i) const { return _offsets.at(i); }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   248
};
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   249
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   250
void TypeStackSlotEntries::post_initialize(Symbol* signature, bool has_receiver, bool include_receiver) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   251
  ResourceMark rm;
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   252
  int start = 0;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   253
  // Parameter profiling include the receiver
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   254
  if (include_receiver && has_receiver) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   255
    set_stack_slot(0, 0);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   256
    set_type(0, type_none());
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   257
    start += 1;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   258
  }
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   259
  ArgumentOffsetComputer aos(signature, _number_of_entries-start);
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   260
  aos.total();
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   261
  for (int i = start; i < _number_of_entries; i++) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   262
    set_stack_slot(i, aos.off_at(i-start) + (has_receiver ? 1 : 0));
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   263
    set_type(i, type_none());
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   264
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   265
}
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   266
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   267
void CallTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   268
  assert(Bytecodes::is_invoke(stream->code()), "should be invoke");
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   269
  Bytecode_invoke inv(stream->method(), stream->bci());
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   270
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   271
  SignatureStream ss(inv.signature());
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   272
  if (has_arguments()) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   273
#ifdef ASSERT
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   274
    ResourceMark rm;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   275
    int count = MIN2(ss.reference_parameter_count(), (int)TypeProfileArgsLimit);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   276
    assert(count > 0, "room for args type but none found?");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   277
    check_number_of_arguments(count);
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   278
#endif
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   279
    _args.post_initialize(inv.signature(), inv.has_receiver(), false);
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   280
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   281
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   282
  if (has_return()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   283
    assert(inv.result_type() == T_OBJECT || inv.result_type() == T_ARRAY, "room for a ret type but doesn't return obj?");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   284
    _ret.post_initialize();
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   285
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   286
}
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   287
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   288
void VirtualCallTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   289
  assert(Bytecodes::is_invoke(stream->code()), "should be invoke");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   290
  Bytecode_invoke inv(stream->method(), stream->bci());
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   291
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   292
  if (has_arguments()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   293
#ifdef ASSERT
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   294
    ResourceMark rm;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   295
    SignatureStream ss(inv.signature());
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   296
    int count = MIN2(ss.reference_parameter_count(), (int)TypeProfileArgsLimit);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   297
    assert(count > 0, "room for args type but none found?");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   298
    check_number_of_arguments(count);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   299
#endif
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   300
    _args.post_initialize(inv.signature(), inv.has_receiver(), false);
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   301
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   302
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   303
  if (has_return()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   304
    assert(inv.result_type() == T_OBJECT || inv.result_type() == T_ARRAY, "room for a ret type but doesn't return obj?");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   305
    _ret.post_initialize();
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   306
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   307
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   308
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   309
bool TypeEntries::is_loader_alive(BoolObjectClosure* is_alive_cl, intptr_t p) {
21581
73584c201e2d 8027572: assert(r != 0) failed: invalid
roland
parents: 21095
diff changeset
   310
  Klass* k = (Klass*)klass_part(p);
73584c201e2d 8027572: assert(r != 0) failed: invalid
roland
parents: 21095
diff changeset
   311
  return k != NULL && k->is_loader_alive(is_alive_cl);
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   312
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   313
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   314
void TypeStackSlotEntries::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   315
  for (int i = 0; i < _number_of_entries; i++) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   316
    intptr_t p = type(i);
21581
73584c201e2d 8027572: assert(r != 0) failed: invalid
roland
parents: 21095
diff changeset
   317
    if (!is_loader_alive(is_alive_cl, p)) {
73584c201e2d 8027572: assert(r != 0) failed: invalid
roland
parents: 21095
diff changeset
   318
      set_type(i, with_status((Klass*)NULL, p));
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   319
    }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   320
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   321
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   322
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   323
void ReturnTypeEntry::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   324
  intptr_t p = type();
21581
73584c201e2d 8027572: assert(r != 0) failed: invalid
roland
parents: 21095
diff changeset
   325
  if (!is_loader_alive(is_alive_cl, p)) {
73584c201e2d 8027572: assert(r != 0) failed: invalid
roland
parents: 21095
diff changeset
   326
    set_type(with_status((Klass*)NULL, p));
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   327
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   328
}
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   329
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   330
bool TypeEntriesAtCall::return_profiling_enabled() {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   331
  return MethodData::profile_return();
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   332
}
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   333
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   334
bool TypeEntriesAtCall::arguments_profiling_enabled() {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   335
  return MethodData::profile_arguments();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   336
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   337
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   338
void TypeEntries::print_klass(outputStream* st, intptr_t k) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   339
  if (is_type_none(k)) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   340
    st->print("none");
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   341
  } else if (is_type_unknown(k)) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   342
    st->print("unknown");
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   343
  } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   344
    valid_klass(k)->print_value_on(st);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   345
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   346
  if (was_null_seen(k)) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   347
    st->print(" (null seen)");
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   348
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   349
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   350
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   351
void TypeStackSlotEntries::print_data_on(outputStream* st) const {
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   352
  for (int i = 0; i < _number_of_entries; i++) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   353
    _pd->tab(st);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   354
    st->print("%d: stack(%u) ", i, stack_slot(i));
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   355
    print_klass(st, type(i));
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   356
    st->cr();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   357
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   358
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   359
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   360
void ReturnTypeEntry::print_data_on(outputStream* st) const {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   361
  _pd->tab(st);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   362
  print_klass(st, type());
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   363
  st->cr();
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   364
}
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   365
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   366
void CallTypeData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   367
  CounterData::print_data_on(st, extra);
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   368
  if (has_arguments()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   369
    tab(st, true);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   370
    st->print("argument types");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   371
    _args.print_data_on(st);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   372
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   373
  if (has_return()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   374
    tab(st, true);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   375
    st->print("return type");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   376
    _ret.print_data_on(st);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   377
  }
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   378
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   379
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   380
void VirtualCallTypeData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   381
  VirtualCallData::print_data_on(st, extra);
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   382
  if (has_arguments()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   383
    tab(st, true);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   384
    st->print("argument types");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   385
    _args.print_data_on(st);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   386
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   387
  if (has_return()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   388
    tab(st, true);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   389
    st->print("return type");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   390
    _ret.print_data_on(st);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   391
  }
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   392
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   393
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
// ReceiverTypeData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
// A ReceiverTypeData is used to access profiling information about a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
// dynamic type check.  It consists of a counter which counts the total times
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   399
// that the check is reached, and a series of (Klass*, count) pairs
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
// which are used to store a type profile for the receiver of the check.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   402
void ReceiverTypeData::clean_weak_klass_links(BoolObjectClosure* is_alive_cl) {
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   403
    for (uint row = 0; row < row_limit(); row++) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   404
    Klass* p = receiver(row);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   405
    if (p != NULL && !p->is_loader_alive(is_alive_cl)) {
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   406
      clear_row(row);
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   407
    }
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   408
  }
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   409
}
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   410
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   411
void ReceiverTypeData::print_receiver_data_on(outputStream* st) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  uint row;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  int entries = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  for (row = 0; row < row_limit(); row++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
    if (receiver(row) != NULL)  entries++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  st->print_cr("count(%u) entries(%u)", count(), entries);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   418
  int total = count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   419
  for (row = 0; row < row_limit(); row++) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   420
    if (receiver(row) != NULL) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   421
      total += receiver_count(row);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   422
    }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   423
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
  for (row = 0; row < row_limit(); row++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
    if (receiver(row) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
      tab(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
      receiver(row)->print_value_on(st);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
   428
      st->print_cr("(%u %4.2f)", receiver_count(row), (float) receiver_count(row) / (float) total);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
}
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   432
void ReceiverTypeData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   433
  print_shared(st, "ReceiverTypeData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  print_receiver_data_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
}
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   436
void VirtualCallData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   437
  print_shared(st, "VirtualCallData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  print_receiver_data_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
// RetData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
// A RetData is used to access profiling information for a ret bytecode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
// It is composed of a count of the number of times that the ret has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
// been executed, followed by a series of triples of the form
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
// (bci, count, di) which count the number of times that some bci was the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
// target of the ret and cache a corresponding displacement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   450
void RetData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  for (uint row = 0; row < row_limit(); row++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
    set_bci_displacement(row, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
    set_bci(row, no_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  // release so other threads see a consistent state.  bci is used as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  // a valid flag for bci_displacement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  OrderAccess::release();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
// This routine needs to atomically update the RetData structure, so the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
// caller needs to hold the RetData_lock before it gets here.  Since taking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
// the lock can block (and allow GC) and since RetData is a ProfileData is a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
// wrapper around a derived oop, taking the lock in _this_ method will
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
// basically cause the 'this' pointer's _data field to contain junk after the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
// lock.  We require the caller to take the lock before making the ProfileData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
// structure.  Currently the only caller is InterpreterRuntime::update_mdp_for_ret
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   467
address RetData::fixup_ret(int return_bci, MethodData* h_mdo) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  // First find the mdp which corresponds to the return bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  address mdp = h_mdo->bci_to_dp(return_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  // Now check to see if any of the cache slots are open.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  for (uint row = 0; row < row_limit(); row++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
    if (bci(row) == no_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
      set_bci_displacement(row, mdp - dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
      set_bci_count(row, DataLayout::counter_increment);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
      // Barrier to ensure displacement is written before the bci; allows
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
      // the interpreter to read displacement without fear of race condition.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
      release_set_bci(row, return_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  return mdp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
22836
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 17858
diff changeset
   485
#ifdef CC_INTERP
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 17858
diff changeset
   486
DataLayout* RetData::advance(MethodData *md, int bci) {
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 17858
diff changeset
   487
  return (DataLayout*) md->bci_to_dp(bci);
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 17858
diff changeset
   488
}
e7e511228518 8024468: PPC64 (part 201): cppInterpreter: implement bytecode profiling
goetz
parents: 17858
diff changeset
   489
#endif // CC_INTERP
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   491
void RetData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   492
  print_shared(st, "RetData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  uint row;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  int entries = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  for (row = 0; row < row_limit(); row++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    if (bci(row) != no_bci)  entries++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  st->print_cr("count(%u) entries(%u)", count(), entries);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  for (row = 0; row < row_limit(); row++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
    if (bci(row) != no_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
      tab(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
      st->print_cr("bci(%d: count(%u) displacement(%d))",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
                   bci(row), bci_count(row), bci_displacement(row));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
// BranchData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
// A BranchData is used to access profiling data for a two-way branch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
// It consists of taken and not_taken counts as well as a data displacement
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
// for the taken case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   515
void BranchData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  assert(stream->bci() == bci(), "wrong pos");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  int target = stream->dest();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  int my_di = mdo->dp_to_di(dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  int target_di = mdo->bci_to_di(target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
  int offset = target_di - my_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  set_displacement(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   524
void BranchData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   525
  print_shared(st, "BranchData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  st->print_cr("taken(%u) displacement(%d)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
               taken(), displacement());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  tab(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  st->print_cr("not taken(%u)", not_taken());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
// ==================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
// MultiBranchData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
// A MultiBranchData is used to access profiling information for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
// a multi-way branch (*switch bytecodes).  It consists of a series
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
// of (count, displacement) pairs, which count the number of times each
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
// case was taken and specify the data displacment for each branch target.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
int MultiBranchData::compute_cell_count(BytecodeStream* stream) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  int cell_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  if (stream->code() == Bytecodes::_tableswitch) {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   543
    Bytecode_tableswitch sw(stream->method()(), stream->bcp());
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   544
    cell_count = 1 + per_case_cell_count * (1 + sw.length()); // 1 for default
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  } else {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   546
    Bytecode_lookupswitch sw(stream->method()(), stream->bcp());
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   547
    cell_count = 1 + per_case_cell_count * (sw.number_of_pairs() + 1); // 1 for default
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  return cell_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
void MultiBranchData::post_initialize(BytecodeStream* stream,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   553
                                      MethodData* mdo) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  assert(stream->bci() == bci(), "wrong pos");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  int target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  int my_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  int target_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  int offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  if (stream->code() == Bytecodes::_tableswitch) {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   560
    Bytecode_tableswitch sw(stream->method()(), stream->bcp());
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   561
    int len = sw.length();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
    assert(array_len() == per_case_cell_count * (len + 1), "wrong len");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    for (int count = 0; count < len; count++) {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   564
      target = sw.dest_offset_at(count) + bci();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
      my_di = mdo->dp_to_di(dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
      target_di = mdo->bci_to_di(target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
      offset = target_di - my_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
      set_displacement_at(count, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    }
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   570
    target = sw.default_offset() + bci();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    my_di = mdo->dp_to_di(dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
    target_di = mdo->bci_to_di(target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
    offset = target_di - my_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
    set_default_displacement(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  } else {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   577
    Bytecode_lookupswitch sw(stream->method()(), stream->bcp());
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   578
    int npairs = sw.number_of_pairs();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
    assert(array_len() == per_case_cell_count * (npairs + 1), "wrong len");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    for (int count = 0; count < npairs; count++) {
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   581
      LookupswitchPair pair = sw.pair_at(count);
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   582
      target = pair.offset() + bci();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
      my_di = mdo->dp_to_di(dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
      target_di = mdo->bci_to_di(target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
      offset = target_di - my_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
      set_displacement_at(count, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    }
7913
dd096a83bdbb 4926272: methodOopDesc::method_from_bcp is unsafe
never
parents: 7397
diff changeset
   588
    target = sw.default_offset() + bci();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
    my_di = mdo->dp_to_di(dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
    target_di = mdo->bci_to_di(target);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
    offset = target_di - my_di;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
    set_default_displacement(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   596
void MultiBranchData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   597
  print_shared(st, "MultiBranchData", extra);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  st->print_cr("default_count(%u) displacement(%d)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
               default_count(), default_displacement());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  int cases = number_of_cases();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  for (int i = 0; i < cases; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    tab(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    st->print_cr("count(%u) displacement(%d)",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
                 count_at(i), displacement_at(i));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   608
void ArgInfoData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   609
  print_shared(st, "ArgInfoData", extra);
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   610
  int nargs = number_of_args();
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   611
  for (int i = 0; i < nargs; i++) {
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   612
    st->print("  0x%x", arg_modified(i));
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   613
  }
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   614
  st->cr();
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   615
}
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   616
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   617
int ParametersTypeData::compute_cell_count(Method* m) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   618
  if (!MethodData::profile_parameters_for_method(m)) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   619
    return 0;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   620
  }
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   621
  int max = TypeProfileParmsLimit == -1 ? INT_MAX : TypeProfileParmsLimit;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   622
  int obj_args = TypeStackSlotEntries::compute_cell_count(m->signature(), !m->is_static(), max);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   623
  if (obj_args > 0) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   624
    return obj_args + 1; // 1 cell for array len
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   625
  }
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   626
  return 0;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   627
}
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   628
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   629
void ParametersTypeData::post_initialize(BytecodeStream* stream, MethodData* mdo) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   630
  _parameters.post_initialize(mdo->method()->signature(), !mdo->method()->is_static(), true);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   631
}
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   632
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   633
bool ParametersTypeData::profiling_enabled() {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   634
  return MethodData::profile_parameters();
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   635
}
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   636
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   637
void ParametersTypeData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   638
  st->print("parameter types", extra);
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   639
  _parameters.print_data_on(st);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   640
}
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   641
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   642
void SpeculativeTrapData::print_data_on(outputStream* st, const char* extra) const {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   643
  print_shared(st, "SpeculativeTrapData", extra);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   644
  tab(st);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   645
  method()->print_short_name(st);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   646
  st->cr();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   647
}
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   648
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
// ==================================================================
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   650
// MethodData*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
//
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   652
// A MethodData* holds information which has been collected about
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
// a method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   655
MethodData* MethodData::allocate(ClassLoaderData* loader_data, methodHandle method, TRAPS) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   656
  int size = MethodData::compute_allocation_size_in_words(method);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   657
17858
c292f8791cca 8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents: 17002
diff changeset
   658
  return new (loader_data, size, false, MetaspaceObj::MethodDataType, THREAD)
c292f8791cca 8014912: Restore PrintSharedSpaces functionality after NPG
iklam
parents: 17002
diff changeset
   659
    MethodData(method(), size, CHECK_NULL);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   660
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   661
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   662
int MethodData::bytecode_cell_count(Bytecodes::Code code) {
16611
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   663
#if defined(COMPILER1) && !defined(COMPILER2)
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   664
  return no_profile_data;
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   665
#else
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
  switch (code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  case Bytecodes::_checkcast:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
  case Bytecodes::_instanceof:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
  case Bytecodes::_aastore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
    if (TypeProfileCasts) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
      return ReceiverTypeData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
      return BitData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  case Bytecodes::_invokespecial:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  case Bytecodes::_invokestatic:
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   677
    if (MethodData::profile_arguments() || MethodData::profile_return()) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   678
      return variable_cell_count;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   679
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   680
      return CounterData::static_cell_count();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   681
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  case Bytecodes::_goto:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  case Bytecodes::_goto_w:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  case Bytecodes::_jsr:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  case Bytecodes::_jsr_w:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    return JumpData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  case Bytecodes::_invokevirtual:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  case Bytecodes::_invokeinterface:
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   689
    if (MethodData::profile_arguments() || MethodData::profile_return()) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   690
      return variable_cell_count;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   691
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   692
      return VirtualCallData::static_cell_count();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   693
    }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 670
diff changeset
   694
  case Bytecodes::_invokedynamic:
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   695
    if (MethodData::profile_arguments() || MethodData::profile_return()) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   696
      return variable_cell_count;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   697
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   698
      return CounterData::static_cell_count();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   699
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  case Bytecodes::_ret:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    return RetData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  case Bytecodes::_ifeq:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  case Bytecodes::_ifne:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  case Bytecodes::_iflt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  case Bytecodes::_ifge:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  case Bytecodes::_ifgt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  case Bytecodes::_ifle:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  case Bytecodes::_if_icmpeq:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  case Bytecodes::_if_icmpne:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  case Bytecodes::_if_icmplt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  case Bytecodes::_if_icmpge:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  case Bytecodes::_if_icmpgt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  case Bytecodes::_if_icmple:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  case Bytecodes::_if_acmpeq:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  case Bytecodes::_if_acmpne:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  case Bytecodes::_ifnull:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  case Bytecodes::_ifnonnull:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    return BranchData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  case Bytecodes::_lookupswitch:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  case Bytecodes::_tableswitch:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
    return variable_cell_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  return no_profile_data;
16611
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   724
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
// Compute the size of the profiling information corresponding to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
// the current bytecode.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   729
int MethodData::compute_data_size(BytecodeStream* stream) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
  int cell_count = bytecode_cell_count(stream->code());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  if (cell_count == no_profile_data) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  if (cell_count == variable_cell_count) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   735
    switch (stream->code()) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   736
    case Bytecodes::_lookupswitch:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   737
    case Bytecodes::_tableswitch:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   738
      cell_count = MultiBranchData::compute_cell_count(stream);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   739
      break;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   740
    case Bytecodes::_invokespecial:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   741
    case Bytecodes::_invokestatic:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   742
    case Bytecodes::_invokedynamic:
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   743
      assert(MethodData::profile_arguments() || MethodData::profile_return(), "should be collecting args profile");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   744
      if (profile_arguments_for_invoke(stream->method(), stream->bci()) ||
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   745
          profile_return_for_invoke(stream->method(), stream->bci())) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   746
        cell_count = CallTypeData::compute_cell_count(stream);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   747
      } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   748
        cell_count = CounterData::static_cell_count();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   749
      }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   750
      break;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   751
    case Bytecodes::_invokevirtual:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   752
    case Bytecodes::_invokeinterface: {
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   753
      assert(MethodData::profile_arguments() || MethodData::profile_return(), "should be collecting args profile");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   754
      if (profile_arguments_for_invoke(stream->method(), stream->bci()) ||
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   755
          profile_return_for_invoke(stream->method(), stream->bci())) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   756
        cell_count = VirtualCallTypeData::compute_cell_count(stream);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   757
      } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   758
        cell_count = VirtualCallData::static_cell_count();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   759
      }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   760
      break;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   761
    }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   762
    default:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   763
      fatal("unexpected bytecode for var length profile data");
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   764
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  // Note:  cell_count might be zero, meaning that there is just
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  //        a DataLayout header, with no extra cells.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  assert(cell_count >= 0, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  return DataLayout::compute_size_in_bytes(cell_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   772
bool MethodData::is_speculative_trap_bytecode(Bytecodes::Code code) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   773
  // Bytecodes for which we may use speculation
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   774
  switch (code) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   775
  case Bytecodes::_checkcast:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   776
  case Bytecodes::_instanceof:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   777
  case Bytecodes::_aastore:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   778
  case Bytecodes::_invokevirtual:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   779
  case Bytecodes::_invokeinterface:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   780
  case Bytecodes::_if_acmpeq:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   781
  case Bytecodes::_if_acmpne:
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23491
diff changeset
   782
  case Bytecodes::_ifnull:
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23491
diff changeset
   783
  case Bytecodes::_ifnonnull:
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   784
  case Bytecodes::_invokestatic:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   785
#ifdef COMPILER2
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   786
    return UseTypeSpeculation;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   787
#endif
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   788
  default:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   789
    return false;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   790
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   791
  return false;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   792
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   793
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   794
int MethodData::compute_extra_data_count(int data_size, int empty_bc_count, bool needs_speculative_traps) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  if (ProfileTraps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
    // Assume that up to 3% of BCIs with no MDP will need to allocate one.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    int extra_data_count = (uint)(empty_bc_count * 3) / 128 + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    // If the method is large, let the extra BCIs grow numerous (to ~1%).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    int one_percent_of_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
      = (uint)data_size / (DataLayout::header_size_in_bytes()*128);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
    if (extra_data_count < one_percent_of_data)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
      extra_data_count = one_percent_of_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
    if (extra_data_count > empty_bc_count)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
      extra_data_count = empty_bc_count;  // no need for more
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   805
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   806
    // Make sure we have a minimum number of extra data slots to
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   807
    // allocate SpeculativeTrapData entries. We would want to have one
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   808
    // entry per compilation that inlines this method and for which
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   809
    // some type speculation assumption fails. So the room we need for
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   810
    // the SpeculativeTrapData entries doesn't directly depend on the
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   811
    // size of the method. Because it's hard to estimate, we reserve
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   812
    // space for an arbitrary number of entries.
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   813
    int spec_data_count = (needs_speculative_traps ? SpecTrapLimitExtraEntries : 0) *
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   814
      (SpeculativeTrapData::static_cell_count() + DataLayout::header_size_in_cells());
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   815
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   816
    return MAX2(extra_data_count, spec_data_count);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   822
// Compute the size of the MethodData* necessary to store
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
// profiling information about a given method.  Size is in bytes.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   824
int MethodData::compute_allocation_size_in_bytes(methodHandle method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  int data_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  BytecodeStream stream(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  Bytecodes::Code c;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  int empty_bc_count = 0;  // number of bytecodes lacking data
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   829
  bool needs_speculative_traps = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  while ((c = stream.next()) >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
    int size_in_bytes = compute_data_size(&stream);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    data_size += size_in_bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    if (size_in_bytes == 0)  empty_bc_count += 1;
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   834
    needs_speculative_traps = needs_speculative_traps || is_speculative_trap_bytecode(c);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  int object_size = in_bytes(data_offset()) + data_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  // Add some extra DataLayout cells (at least one) to track stray traps.
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
   839
  int extra_data_count = compute_extra_data_count(data_size, empty_bc_count, needs_speculative_traps);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  object_size += extra_data_count * DataLayout::compute_size_in_bytes(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   842
  // Add a cell to record information about modified arguments.
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   843
  int arg_size = method->size_of_parameters();
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
   844
  object_size += DataLayout::compute_size_in_bytes(arg_size+1);
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   845
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   846
  // Reserve room for an area of the MDO dedicated to profiling of
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   847
  // parameters
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   848
  int args_cell = ParametersTypeData::compute_cell_count(method());
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   849
  if (args_cell > 0) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   850
    object_size += DataLayout::compute_size_in_bytes(args_cell);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
   851
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  return object_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   855
// Compute the size of the MethodData* necessary to store
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
// profiling information about a given method.  Size is in words
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   857
int MethodData::compute_allocation_size_in_words(methodHandle method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  int byte_size = compute_allocation_size_in_bytes(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  int word_size = align_size_up(byte_size, BytesPerWord) / BytesPerWord;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  return align_object_size(word_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
// Initialize an individual data segment.  Returns the size of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
// the segment in bytes.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   865
int MethodData::initialize_data(BytecodeStream* stream,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
                                       int data_index) {
16611
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   867
#if defined(COMPILER1) && !defined(COMPILER2)
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   868
  return 0;
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   869
#else
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
  int cell_count = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  int tag = DataLayout::no_tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  DataLayout* data_layout = data_layout_at(data_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  Bytecodes::Code c = stream->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  switch (c) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  case Bytecodes::_checkcast:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  case Bytecodes::_instanceof:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  case Bytecodes::_aastore:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    if (TypeProfileCasts) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
      cell_count = ReceiverTypeData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
      tag = DataLayout::receiver_type_data_tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
      cell_count = BitData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
      tag = DataLayout::bit_data_tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  case Bytecodes::_invokespecial:
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   887
  case Bytecodes::_invokestatic: {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   888
    int counter_data_cell_count = CounterData::static_cell_count();
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   889
    if (profile_arguments_for_invoke(stream->method(), stream->bci()) ||
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   890
        profile_return_for_invoke(stream->method(), stream->bci())) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   891
      cell_count = CallTypeData::compute_cell_count(stream);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   892
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   893
      cell_count = counter_data_cell_count;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   894
    }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   895
    if (cell_count > counter_data_cell_count) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   896
      tag = DataLayout::call_type_data_tag;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   897
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   898
      tag = DataLayout::counter_data_tag;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   899
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
    break;
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   901
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
  case Bytecodes::_goto:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  case Bytecodes::_goto_w:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  case Bytecodes::_jsr:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  case Bytecodes::_jsr_w:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
    cell_count = JumpData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
    tag = DataLayout::jump_data_tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  case Bytecodes::_invokevirtual:
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   910
  case Bytecodes::_invokeinterface: {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   911
    int virtual_call_data_cell_count = VirtualCallData::static_cell_count();
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   912
    if (profile_arguments_for_invoke(stream->method(), stream->bci()) ||
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   913
        profile_return_for_invoke(stream->method(), stream->bci())) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   914
      cell_count = VirtualCallTypeData::compute_cell_count(stream);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   915
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   916
      cell_count = virtual_call_data_cell_count;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   917
    }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   918
    if (cell_count > virtual_call_data_cell_count) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   919
      tag = DataLayout::virtual_call_type_data_tag;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   920
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   921
      tag = DataLayout::virtual_call_data_tag;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   922
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
    break;
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   924
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   925
  case Bytecodes::_invokedynamic: {
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 670
diff changeset
   926
    // %%% should make a type profile for any invokedynamic that takes a ref argument
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   927
    int counter_data_cell_count = CounterData::static_cell_count();
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   928
    if (profile_arguments_for_invoke(stream->method(), stream->bci()) ||
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   929
        profile_return_for_invoke(stream->method(), stream->bci())) {
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   930
      cell_count = CallTypeData::compute_cell_count(stream);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   931
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   932
      cell_count = counter_data_cell_count;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   933
    }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   934
    if (cell_count > counter_data_cell_count) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   935
      tag = DataLayout::call_type_data_tag;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   936
    } else {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   937
      tag = DataLayout::counter_data_tag;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   938
    }
2570
ecc7862946d4 6655646: dynamic languages need dynamically linked call sites
jrose
parents: 670
diff changeset
   939
    break;
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   940
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  case Bytecodes::_ret:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
    cell_count = RetData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
    tag = DataLayout::ret_data_tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  case Bytecodes::_ifeq:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  case Bytecodes::_ifne:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  case Bytecodes::_iflt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  case Bytecodes::_ifge:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  case Bytecodes::_ifgt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  case Bytecodes::_ifle:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  case Bytecodes::_if_icmpeq:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  case Bytecodes::_if_icmpne:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  case Bytecodes::_if_icmplt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  case Bytecodes::_if_icmpge:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  case Bytecodes::_if_icmpgt:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  case Bytecodes::_if_icmple:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  case Bytecodes::_if_acmpeq:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  case Bytecodes::_if_acmpne:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
  case Bytecodes::_ifnull:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  case Bytecodes::_ifnonnull:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
    cell_count = BranchData::static_cell_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    tag = DataLayout::branch_data_tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  case Bytecodes::_lookupswitch:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  case Bytecodes::_tableswitch:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
    cell_count = MultiBranchData::compute_cell_count(stream);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
    tag = DataLayout::multi_branch_data_tag;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  assert(tag == DataLayout::multi_branch_data_tag ||
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
   971
         ((MethodData::profile_arguments() || MethodData::profile_return()) &&
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   972
          (tag == DataLayout::call_type_data_tag ||
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   973
           tag == DataLayout::counter_data_tag ||
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   974
           tag == DataLayout::virtual_call_type_data_tag ||
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
   975
           tag == DataLayout::virtual_call_data_tag)) ||
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
         cell_count == bytecode_cell_count(c), "cell counts must agree");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  if (cell_count >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
    assert(tag != DataLayout::no_tag, "bad tag");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
    assert(bytecode_has_profile(c), "agree w/ BHP");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
    data_layout->initialize(tag, stream->bci(), cell_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
    return DataLayout::compute_size_in_bytes(cell_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
    assert(!bytecode_has_profile(c), "agree w/ !BHP");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  }
16611
6807a703dd6b 7153771: array bound check elimination for c1
roland
parents: 15928
diff changeset
   986
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
// Get the data at an arbitrary (sort of) data index.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
   990
ProfileData* MethodData::data_at(int data_index) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
  if (out_of_bounds(data_index)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  DataLayout* data_layout = data_layout_at(data_index);
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   995
  return data_layout->data_in();
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   996
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   998
ProfileData* DataLayout::data_in() {
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
   999
  switch (tag()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  case DataLayout::no_tag:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  case DataLayout::bit_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1005
    return new BitData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  case DataLayout::counter_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1007
    return new CounterData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  case DataLayout::jump_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1009
    return new JumpData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
  case DataLayout::receiver_type_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1011
    return new ReceiverTypeData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  case DataLayout::virtual_call_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1013
    return new VirtualCallData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  case DataLayout::ret_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1015
    return new RetData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
  case DataLayout::branch_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1017
    return new BranchData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  case DataLayout::multi_branch_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1019
    return new MultiBranchData(this);
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1020
  case DataLayout::arg_info_data_tag:
3696
9e5d9b5e1049 4957990: Perm heap bloat in JVM
ysr
parents: 3261
diff changeset
  1021
    return new ArgInfoData(this);
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1022
  case DataLayout::call_type_data_tag:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1023
    return new CallTypeData(this);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1024
  case DataLayout::virtual_call_type_data_tag:
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1025
    return new VirtualCallTypeData(this);
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1026
  case DataLayout::parameters_type_data_tag:
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1027
    return new ParametersTypeData(this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
// Iteration over data.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1032
ProfileData* MethodData::next_data(ProfileData* current) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
  int current_index = dp_to_di(current->dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
  int next_index = current_index + current->size_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  ProfileData* next = data_at(next_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  return next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
// Give each of the data entries a chance to perform specific
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
// data initialization.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1041
void MethodData::post_initialize(BytecodeStream* stream) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  ProfileData* data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  for (data = first_data(); is_valid(data); data = next_data(data)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
    stream->set_start(data->bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
    stream->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
    data->post_initialize(stream, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  }
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1049
  if (_parameters_type_data_di != -1) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1050
    parameters_type_data()->post_initialize(NULL, this);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1051
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1054
// Initialize the MethodData* corresponding to a given method.
23201
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1055
MethodData::MethodData(methodHandle method, int size, TRAPS)
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1056
  : _extra_data_lock(Monitor::leaf, "MDO extra data lock") {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1057
  No_Safepoint_Verifier no_safepoint;  // init function atomic wrt GC
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  // Set the method back-pointer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  _method = method();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1061
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1062
  init();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  set_creation_mileage(mileage_of(method()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  // Go through the bytecodes and allocate and initialize the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
  // corresponding data cells.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  int data_size = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  int empty_bc_count = 0;  // number of bytecodes lacking data
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15437
diff changeset
  1069
  _data[0] = 0;  // apparently not set below.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  BytecodeStream stream(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  Bytecodes::Code c;
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1072
  bool needs_speculative_traps = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  while ((c = stream.next()) >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
    int size_in_bytes = initialize_data(&stream, data_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
    data_size += size_in_bytes;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
    if (size_in_bytes == 0)  empty_bc_count += 1;
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1077
    needs_speculative_traps = needs_speculative_traps || is_speculative_trap_bytecode(c);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  _data_size = data_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  int object_size = in_bytes(data_offset()) + data_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  // Add some extra DataLayout cells (at least one) to track stray traps.
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1083
  int extra_data_count = compute_extra_data_count(data_size, empty_bc_count, needs_speculative_traps);
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1084
  int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0);
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1085
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1086
  // Let's zero the space for the extra data
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1087
  Copy::zero_to_bytes(((address)_data) + data_size, extra_size);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1088
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1089
  // Add a cell to record information about modified arguments.
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1090
  // Set up _args_modified array after traps cells so that
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1091
  // the code for traps cells works.
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1092
  DataLayout *dp = data_layout_at(data_size + extra_size);
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1093
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1094
  int arg_size = method->size_of_parameters();
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1095
  dp->initialize(DataLayout::arg_info_data_tag, 0, arg_size+1);
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1096
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1097
  int arg_data_size = DataLayout::compute_size_in_bytes(arg_size+1);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1098
  object_size += extra_size + arg_data_size;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1099
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1100
  int parms_cell = ParametersTypeData::compute_cell_count(method());
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1101
  // If we are profiling parameters, we reserver an area near the end
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1102
  // of the MDO after the slots for bytecodes (because there's no bci
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1103
  // for method entry so they don't fit with the framework for the
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1104
  // profiling of bytecodes). We store the offset within the MDO of
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1105
  // this area (or -1 if no parameter is profiled)
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1106
  if (parms_cell > 0) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1107
    object_size += DataLayout::compute_size_in_bytes(parms_cell);
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1108
    _parameters_type_data_di = data_size + extra_size + arg_data_size;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1109
    DataLayout *dp = data_layout_at(data_size + extra_size + arg_data_size);
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1110
    dp->initialize(DataLayout::parameters_type_data_tag, 0, parms_cell);
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1111
  } else {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1112
    _parameters_type_data_di = -1;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1113
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  // Set an initial hint. Don't use set_hint_di() because
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  // first_di() may be out of bounds if data_size is 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  // In that situation, _hint_di is never used, but at
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
  // least well-defined.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
  _hint_di = first_di();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
  post_initialize(&stream);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1123
  set_size(object_size);
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1124
}
15928
f9d5c6e4107f 8003553: NPG: metaspace objects should be zeroed in constructors
coleenp
parents: 15437
diff changeset
  1125
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1126
void MethodData::init() {
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1127
  _invocation_counter.init();
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1128
  _backedge_counter.init();
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1129
  _invocation_counter_start = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1130
  _backedge_counter_start = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1131
  _num_loops = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1132
  _num_blocks = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1133
  _highest_comp_level = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1134
  _highest_osr_comp_level = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1135
  _would_profile = true;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1136
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1137
#if INCLUDE_RTM_OPT
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1138
  _rtm_state = NoRTM; // No RTM lock eliding by default
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1139
  if (UseRTMLocking &&
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1140
      !CompilerOracle::has_option_string(_method, "NoRTMLockEliding")) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1141
    if (CompilerOracle::has_option_string(_method, "UseRTMLockEliding") || !UseRTMDeopt) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1142
      // Generate RTM lock eliding code without abort ratio calculation code.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1143
      _rtm_state = UseRTM;
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1144
    } else if (UseRTMDeopt) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1145
      // Generate RTM lock eliding code and include abort ratio calculation
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1146
      // code if UseRTMDeopt is on.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1147
      _rtm_state = ProfileRTM;
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1148
    }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1149
  }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1150
#endif
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 23201
diff changeset
  1151
16689
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1152
  // Initialize flags and trap history.
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1153
  _nof_decompiles = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1154
  _nof_overflow_recompiles = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1155
  _nof_overflow_traps = 0;
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1156
  clear_escape_info();
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1157
  assert(sizeof(_trap_hist) % sizeof(HeapWord) == 0, "align");
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1158
  Copy::zero_to_words((HeapWord*) &_trap_hist,
efce070b8d42 8007288: Additional WB API for compiler's testing
iignatyev
parents: 16611
diff changeset
  1159
                      sizeof(_trap_hist) / sizeof(HeapWord));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
// Get a measure of how much mileage the method has on it.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1163
int MethodData::mileage_of(Method* method) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
  int mileage = 0;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1165
  if (TieredCompilation) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1166
    mileage = MAX2(method->invocation_count(), method->backedge_count());
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1167
  } else {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1168
    int iic = method->interpreter_invocation_count();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1169
    if (mileage < iic)  mileage = iic;
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1170
    MethodCounters* mcs = method->method_counters();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1171
    if (mcs != NULL) {
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1172
      InvocationCounter* ic = mcs->invocation_counter();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1173
      InvocationCounter* bc = mcs->backedge_counter();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1174
      int icval = ic->count();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1175
      if (ic->carry()) icval += CompileThreshold;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1176
      if (mileage < icval)  mileage = icval;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1177
      int bcval = bc->count();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1178
      if (bc->carry()) bcval += CompileThreshold;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1179
      if (mileage < bcval)  mileage = bcval;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16611
diff changeset
  1180
    }
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1181
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  return mileage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1185
bool MethodData::is_mature() const {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 5547
diff changeset
  1186
  return CompilationPolicy::policy()->is_mature(_method);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
// Translate a bci to its corresponding data index (di).
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1190
address MethodData::bci_to_dp(int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  ProfileData* data = data_before(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  ProfileData* prev = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
  for ( ; is_valid(data); data = next_data(data)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
    if (data->bci() >= bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
      if (data->bci() == bci)  set_hint_di(dp_to_di(data->dp()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
      else if (prev != NULL)   set_hint_di(dp_to_di(prev->dp()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
      return data->dp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
    prev = data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
  return (address)limit_data_position();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
// Translate a bci to its corresponding data, or NULL.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1206
ProfileData* MethodData::bci_to_data(int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
  ProfileData* data = data_before(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  for ( ; is_valid(data); data = next_data(data)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
    if (data->bci() == bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
      set_hint_di(dp_to_di(data->dp()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
      return data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
    } else if (data->bci() > bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
  }
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1216
  return bci_to_extra_data(bci, NULL, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1219
DataLayout* MethodData::next_extra(DataLayout* dp) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1220
  int nb_cells = 0;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1221
  switch(dp->tag()) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1222
  case DataLayout::bit_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1223
  case DataLayout::no_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1224
    nb_cells = BitData::static_cell_count();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1225
    break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1226
  case DataLayout::speculative_trap_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1227
    nb_cells = SpeculativeTrapData::static_cell_count();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1228
    break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1229
  default:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1230
    fatal(err_msg("unexpected tag %d", dp->tag()));
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1231
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1232
  return (DataLayout*)((address)dp + DataLayout::compute_size_in_bytes(nb_cells));
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1233
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1234
23201
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1235
ProfileData* MethodData::bci_to_extra_data_helper(int bci, Method* m, DataLayout*& dp, bool concurrent) {
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1236
  DataLayout* end = extra_data_limit();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1237
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1238
  for (;; dp = next_extra(dp)) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1239
    assert(dp < end, "moved past end of extra data");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
    // No need for "OrderAccess::load_acquire" ops,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
    // since the data structure is monotonic.
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1242
    switch(dp->tag()) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1243
    case DataLayout::no_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1244
      return NULL;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1245
    case DataLayout::arg_info_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1246
      dp = end;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1247
      return NULL; // ArgInfoData is at the end of extra data section.
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1248
    case DataLayout::bit_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1249
      if (m == NULL && dp->bci() == bci) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1250
        return new BitData(dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1251
      }
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1252
      break;
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1253
    case DataLayout::speculative_trap_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1254
      if (m != NULL) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1255
        SpeculativeTrapData* data = new SpeculativeTrapData(dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1256
        // data->method() may be null in case of a concurrent
23201
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1257
        // allocation. Maybe it's for the same method. Try to use that
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1258
        // entry in that case.
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1259
        if (dp->bci() == bci) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1260
          if (data->method() == NULL) {
23201
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1261
            assert(concurrent, "impossible because no concurrent allocation");
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1262
            return NULL;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1263
          } else if (data->method() == m) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1264
            return data;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1265
          }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1266
        }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1267
      }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1268
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1269
    default:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1270
      fatal(err_msg("unexpected tag %d", dp->tag()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
  }
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1273
  return NULL;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1274
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1275
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1276
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1277
// Translate a bci to its corresponding extra data, or NULL.
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1278
ProfileData* MethodData::bci_to_extra_data(int bci, Method* m, bool create_if_missing) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1279
  // This code assumes an entry for a SpeculativeTrapData is 2 cells
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1280
  assert(2*DataLayout::compute_size_in_bytes(BitData::static_cell_count()) ==
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1281
         DataLayout::compute_size_in_bytes(SpeculativeTrapData::static_cell_count()),
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1282
         "code needs to be adjusted");
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1283
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1284
  DataLayout* dp  = extra_data_base();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1285
  DataLayout* end = extra_data_limit();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1286
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1287
  // Allocation in the extra data space has to be atomic because not
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1288
  // all entries have the same size and non atomic concurrent
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1289
  // allocation would result in a corrupted extra data space.
23201
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1290
  ProfileData* result = bci_to_extra_data_helper(bci, m, dp, true);
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1291
  if (result != NULL) {
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1292
    return result;
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1293
  }
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1294
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1295
  if (create_if_missing && dp < end) {
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1296
    MutexLocker ml(&_extra_data_lock);
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1297
    // Check again now that we have the lock. Another thread may
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1298
    // have added extra data entries.
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1299
    ProfileData* result = bci_to_extra_data_helper(bci, m, dp, false);
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1300
    if (result != NULL || dp >= end) {
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1301
      return result;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1302
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1303
23201
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1304
    assert(dp->tag() == DataLayout::no_tag || (dp->tag() == DataLayout::speculative_trap_data_tag && m != NULL), "should be free");
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1305
    assert(next_extra(dp)->tag() == DataLayout::no_tag || next_extra(dp)->tag() == DataLayout::arg_info_data_tag, "should be free or arg info");
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1306
    u1 tag = m == NULL ? DataLayout::bit_data_tag : DataLayout::speculative_trap_data_tag;
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1307
    // SpeculativeTrapData is 2 slots. Make sure we have room.
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1308
    if (m != NULL && next_extra(dp)->tag() != DataLayout::no_tag) {
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1309
      return NULL;
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1310
    }
23201
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1311
    DataLayout temp;
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1312
    temp.initialize(tag, bci, 0);
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1313
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1314
    dp->set_header(temp.header());
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1315
    assert(dp->tag() == tag, "sane");
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1316
    assert(dp->bci() == bci, "no concurrent allocation");
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1317
    if (tag == DataLayout::bit_data_tag) {
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1318
      return new BitData(dp);
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1319
    } else {
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1320
      SpeculativeTrapData* data = new SpeculativeTrapData(dp);
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1321
      data->set_method(m);
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1322
      return data;
6920163f479e 8035841: assert(dp_src->tag() == dp_dst->tag()) failed: should be same tags 1 != 0 at ciMethodData.cpp:90
roland
parents: 22916
diff changeset
  1323
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1328
ArgInfoData *MethodData::arg_info() {
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1329
  DataLayout* dp    = extra_data_base();
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1330
  DataLayout* end   = extra_data_limit();
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1331
  for (; dp < end; dp = next_extra(dp)) {
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1332
    if (dp->tag() == DataLayout::arg_info_data_tag)
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1333
      return new ArgInfoData(dp);
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1334
  }
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1335
  return NULL;
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1336
}
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1337
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1338
// Printing
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1339
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1340
void MethodData::print_on(outputStream* st) const {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1341
  assert(is_methodData(), "should be method data");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1342
  st->print("method data for ");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1343
  method()->print_value_on(st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1344
  st->cr();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1345
  print_data_on(st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1346
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1347
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1348
void MethodData::print_value_on(outputStream* st) const {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1349
  assert(is_methodData(), "should be method data");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1350
  st->print("method data for ");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1351
  method()->print_value_on(st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1352
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1353
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1354
void MethodData::print_data_on(outputStream* st) const {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  ProfileData* data = first_data();
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1357
  if (_parameters_type_data_di != -1) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1358
    parameters_type_data()->print_data_on(st);
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1359
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  for ( ; is_valid(data); data = next_data(data)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
    st->print("%d", dp_to_di(data->dp()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
    st->fill_to(6);
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1363
    data->print_data_on(st, this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  }
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1365
  st->print_cr("--- Extra data:");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  DataLayout* dp    = extra_data_base();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  DataLayout* end   = extra_data_limit();
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1368
  for (;; dp = next_extra(dp)) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1369
    assert(dp < end, "moved past end of extra data");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
    // No need for "OrderAccess::load_acquire" ops,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
    // since the data structure is monotonic.
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1372
    switch(dp->tag()) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1373
    case DataLayout::no_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1374
      continue;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1375
    case DataLayout::bit_data_tag:
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1376
      data = new BitData(dp);
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1377
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1378
    case DataLayout::speculative_trap_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1379
      data = new SpeculativeTrapData(dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1380
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1381
    case DataLayout::arg_info_data_tag:
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1382
      data = new ArgInfoData(dp);
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1383
      dp = end; // ArgInfoData is at the end of extra data section.
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1384
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1385
    default:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1386
      fatal(err_msg("unexpected tag %d", dp->tag()));
218
a0e996680b05 6667615: (Escape Analysis) extend MDO to cache arguments escape state
kvn
parents: 1
diff changeset
  1387
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
    st->print("%d", dp_to_di(data->dp()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
    st->fill_to(6);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
    data->print_data_on(st);
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1391
    if (dp >= end) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
15437
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1395
#if INCLUDE_SERVICES
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1396
// Size Statistics
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1397
void MethodData::collect_statistics(KlassSizeStats *sz) const {
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1398
  int n = sz->count(this);
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1399
  sz->_method_data_bytes += n;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1400
  sz->_method_all_bytes += n;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1401
  sz->_rw_bytes += n;
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1402
}
eabd4555d072 6479360: PrintClassHistogram improvements
acorn
parents: 13728
diff changeset
  1403
#endif // INCLUDE_SERVICES
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1404
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1405
// Verification
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1406
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1407
void MethodData::verify_on(outputStream* st) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1408
  guarantee(is_methodData(), "object must be method data");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1409
  // guarantee(m->is_perm(), "should be in permspace");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1410
  this->verify_data_on(st);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1411
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1412
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 8334
diff changeset
  1413
void MethodData::verify_data_on(outputStream* st) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
  NEEDS_CLEANUP;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
  // not yet implemented.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
}
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1417
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1418
bool MethodData::profile_jsr292(methodHandle m, int bci) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1419
  if (m->is_compiled_lambda_form()) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1420
    return true;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1421
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1422
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1423
  Bytecode_invoke inv(m , bci);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1424
  return inv.is_invokedynamic() || inv.is_invokehandle();
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1425
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1426
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1427
int MethodData::profile_arguments_flag() {
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1428
  return TypeProfileLevel % 10;
20702
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1429
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1430
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1431
bool MethodData::profile_arguments() {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1432
  return profile_arguments_flag() > no_type_profile && profile_arguments_flag() <= type_profile_all;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1433
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1434
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1435
bool MethodData::profile_arguments_jsr292_only() {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1436
  return profile_arguments_flag() == type_profile_jsr292;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1437
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1438
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1439
bool MethodData::profile_all_arguments() {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1440
  return profile_arguments_flag() == type_profile_all;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1441
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1442
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1443
bool MethodData::profile_arguments_for_invoke(methodHandle m, int bci) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1444
  if (!profile_arguments()) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1445
    return false;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1446
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1447
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1448
  if (profile_all_arguments()) {
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1449
    return true;
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1450
  }
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1451
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1452
  assert(profile_arguments_jsr292_only(), "inconsistent");
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1453
  return profile_jsr292(m, bci);
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1454
}
bbe0fcde6e13 8023657: New type profiling points: arguments to call
roland
parents: 17858
diff changeset
  1455
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1456
int MethodData::profile_return_flag() {
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1457
  return (TypeProfileLevel % 100) / 10;
20709
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1458
}
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1459
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1460
bool MethodData::profile_return() {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1461
  return profile_return_flag() > no_type_profile && profile_return_flag() <= type_profile_all;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1462
}
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1463
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1464
bool MethodData::profile_return_jsr292_only() {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1465
  return profile_return_flag() == type_profile_jsr292;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1466
}
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1467
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1468
bool MethodData::profile_all_return() {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1469
  return profile_return_flag() == type_profile_all;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1470
}
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1471
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1472
bool MethodData::profile_return_for_invoke(methodHandle m, int bci) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1473
  if (!profile_return()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1474
    return false;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1475
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1476
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1477
  if (profile_all_return()) {
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1478
    return true;
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1479
  }
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1480
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1481
  assert(profile_return_jsr292_only(), "inconsistent");
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1482
  return profile_jsr292(m, bci);
034be898bf04 8026054: New type profiling points: type of return values at calls
roland
parents: 20702
diff changeset
  1483
}
21095
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1484
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1485
int MethodData::profile_parameters_flag() {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1486
  return TypeProfileLevel / 100;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1487
}
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1488
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1489
bool MethodData::profile_parameters() {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1490
  return profile_parameters_flag() > no_type_profile && profile_parameters_flag() <= type_profile_all;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1491
}
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1492
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1493
bool MethodData::profile_parameters_jsr292_only() {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1494
  return profile_parameters_flag() == type_profile_jsr292;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1495
}
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1496
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1497
bool MethodData::profile_all_parameters() {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1498
  return profile_parameters_flag() == type_profile_all;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1499
}
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1500
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1501
bool MethodData::profile_parameters_for_method(methodHandle m) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1502
  if (!profile_parameters()) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1503
    return false;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1504
  }
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1505
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1506
  if (profile_all_parameters()) {
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1507
    return true;
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1508
  }
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1509
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1510
  assert(profile_parameters_jsr292_only(), "inconsistent");
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1511
  return m->is_compiled_lambda_form();
1a04f7b3946e 8026251: New type profiling points: parameters to methods
roland
parents: 20709
diff changeset
  1512
}
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1513
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1514
void MethodData::clean_extra_data_helper(DataLayout* dp, int shift, bool reset) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1515
  if (shift == 0) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1516
    return;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1517
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1518
  if (!reset) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1519
    // Move all cells of trap entry at dp left by "shift" cells
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1520
    intptr_t* start = (intptr_t*)dp;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1521
    intptr_t* end = (intptr_t*)next_extra(dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1522
    for (intptr_t* ptr = start; ptr < end; ptr++) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1523
      *(ptr-shift) = *ptr;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1524
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1525
  } else {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1526
    // Reset "shift" cells stopping at dp
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1527
    intptr_t* start = ((intptr_t*)dp) - shift;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1528
    intptr_t* end = (intptr_t*)dp;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1529
    for (intptr_t* ptr = start; ptr < end; ptr++) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1530
      *ptr = 0;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1531
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1532
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1533
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1534
23845
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1535
class CleanExtraDataClosure : public StackObj {
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1536
public:
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1537
  virtual bool is_live(Method* m) = 0;
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1538
};
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1539
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1540
// Check for entries that reference an unloaded method
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1541
class CleanExtraDataKlassClosure : public CleanExtraDataClosure {
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1542
private:
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1543
  BoolObjectClosure* _is_alive;
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1544
public:
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1545
  CleanExtraDataKlassClosure(BoolObjectClosure* is_alive) : _is_alive(is_alive) {}
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1546
  bool is_live(Method* m) {
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1547
    return m->method_holder()->is_loader_alive(_is_alive);
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1548
  }
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1549
};
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1550
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1551
// Check for entries that reference a redefined method
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1552
class CleanExtraDataMethodClosure : public CleanExtraDataClosure {
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1553
public:
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1554
  CleanExtraDataMethodClosure() {}
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1555
  bool is_live(Method* m) {
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1556
    return m->on_stack();
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1557
  }
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1558
};
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1559
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1560
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1561
// Remove SpeculativeTrapData entries that reference an unloaded or
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1562
// redefined method
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1563
void MethodData::clean_extra_data(CleanExtraDataClosure* cl) {
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1564
  DataLayout* dp  = extra_data_base();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1565
  DataLayout* end = extra_data_limit();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1566
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1567
  int shift = 0;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1568
  for (; dp < end; dp = next_extra(dp)) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1569
    switch(dp->tag()) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1570
    case DataLayout::speculative_trap_data_tag: {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1571
      SpeculativeTrapData* data = new SpeculativeTrapData(dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1572
      Method* m = data->method();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1573
      assert(m != NULL, "should have a method");
23845
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1574
      if (!cl->is_live(m)) {
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1575
        // "shift" accumulates the number of cells for dead
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1576
        // SpeculativeTrapData entries that have been seen so
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1577
        // far. Following entries must be shifted left by that many
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1578
        // cells to remove the dead SpeculativeTrapData entries.
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1579
        shift += (int)((intptr_t*)next_extra(dp) - (intptr_t*)dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1580
      } else {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1581
        // Shift this entry left if it follows dead
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1582
        // SpeculativeTrapData entries
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1583
        clean_extra_data_helper(dp, shift);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1584
      }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1585
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1586
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1587
    case DataLayout::bit_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1588
      // Shift this entry left if it follows dead SpeculativeTrapData
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1589
      // entries
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1590
      clean_extra_data_helper(dp, shift);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1591
      continue;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1592
    case DataLayout::no_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1593
    case DataLayout::arg_info_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1594
      // We are at end of the live trap entries. The previous "shift"
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1595
      // cells contain entries that are either dead or were shifted
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1596
      // left. They need to be reset to no_tag
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1597
      clean_extra_data_helper(dp, shift, true);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1598
      return;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1599
    default:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1600
      fatal(err_msg("unexpected tag %d", dp->tag()));
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1601
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1602
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1603
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1604
23845
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1605
// Verify there's no unloaded or redefined method referenced by a
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1606
// SpeculativeTrapData entry
23845
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1607
void MethodData::verify_extra_data_clean(CleanExtraDataClosure* cl) {
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1608
#ifdef ASSERT
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1609
  DataLayout* dp  = extra_data_base();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1610
  DataLayout* end = extra_data_limit();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1611
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1612
  for (; dp < end; dp = next_extra(dp)) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1613
    switch(dp->tag()) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1614
    case DataLayout::speculative_trap_data_tag: {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1615
      SpeculativeTrapData* data = new SpeculativeTrapData(dp);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1616
      Method* m = data->method();
23845
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1617
      assert(m != NULL && cl->is_live(m), "Method should exist");
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1618
      break;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1619
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1620
    case DataLayout::bit_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1621
      continue;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1622
    case DataLayout::no_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1623
    case DataLayout::arg_info_data_tag:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1624
      return;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1625
    default:
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1626
      fatal(err_msg("unexpected tag %d", dp->tag()));
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1627
    }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1628
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1629
#endif
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1630
}
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1631
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1632
void MethodData::clean_method_data(BoolObjectClosure* is_alive) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1633
  for (ProfileData* data = first_data();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1634
       is_valid(data);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1635
       data = next_data(data)) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1636
    data->clean_weak_klass_links(is_alive);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1637
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1638
  ParametersTypeData* parameters = parameters_type_data();
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1639
  if (parameters != NULL) {
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1640
    parameters->clean_weak_klass_links(is_alive);
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1641
  }
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1642
23845
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1643
  CleanExtraDataKlassClosure cl(is_alive);
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1644
  clean_extra_data(&cl);
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1645
  verify_extra_data_clean(&cl);
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22851
diff changeset
  1646
}
23845
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1647
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1648
void MethodData::clean_weak_method_links() {
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1649
  for (ProfileData* data = first_data();
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1650
       is_valid(data);
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1651
       data = next_data(data)) {
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1652
    data->clean_weak_method_links();
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1653
  }
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1654
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1655
  CleanExtraDataMethodClosure cl;
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1656
  clean_extra_data(&cl);
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1657
  verify_extra_data_clean(&cl);
ebd1fafcc362 8038636: speculative traps break when classes are redefined
roland
parents: 23526
diff changeset
  1658
}