hotspot/src/share/vm/opto/parseHelper.cpp
author duke
Sat, 01 Dec 2007 00:00:00 +0000
changeset 1 489c9b5090e2
child 590 2954744d7bba
permissions -rw-r--r--
Initial load
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 1998-2007 Sun Microsystems, Inc.  All Rights Reserved.
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
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "incls/_parseHelper.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
//------------------------------make_dtrace_method_entry_exit ----------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
// Dtrace -- record entry or exit of a method if compiled with dtrace support
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
void GraphKit::make_dtrace_method_entry_exit(ciMethod* method, bool is_entry) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
  const TypeFunc *call_type    = OptoRuntime::dtrace_method_entry_exit_Type();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
  address         call_address = is_entry ? CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
                                            CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
  const char     *call_name    = is_entry ? "dtrace_method_entry" : "dtrace_method_exit";
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  // Get base of thread-local storage area
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
  Node* thread = _gvn.transform( new (C, 1) ThreadLocalNode() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  // Get method
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  const TypeInstPtr* method_type = TypeInstPtr::make(TypePtr::Constant, method->klass(), true, method, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  Node *method_node = _gvn.transform( new (C, 1) ConPNode(method_type) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  kill_dead_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  // For some reason, this call reads only raw memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  make_runtime_call(RC_LEAF | RC_NARROW_MEM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
                    call_type, call_address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
                    call_name, raw_adr_type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
                    thread, method_node);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
//------------------------------do_checkcast-----------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
void Parse::do_checkcast() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  bool will_link;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  ciKlass* klass = iter().get_klass(will_link);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  Node *obj = peek();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  // Throw uncommon trap if class is not loaded or the value we are casting
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  // _from_ is not loaded, and value is not null.  If the value _is_ NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  // then the checkcast does nothing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  const TypeInstPtr *tp = _gvn.type(obj)->isa_instptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  if (!will_link || (tp && !tp->is_loaded())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    if (C->log() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
      if (!will_link) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
        C->log()->elem("assert_null reason='checkcast' klass='%d'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
                       C->log()->identify(klass));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
      if (tp && !tp->is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
        // %%% Cannot happen?
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
        C->log()->elem("assert_null reason='checkcast source' klass='%d'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
                       C->log()->identify(tp->klass()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    do_null_assert(obj, T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    assert( stopped() || _gvn.type(peek())->higher_equal(TypePtr::NULL_PTR), "what's left behind is null" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    if (!stopped()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
      profile_null_checkcast();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  Node *res = gen_checkcast(obj, makecon(TypeKlassPtr::make(klass)) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  // Pop from stack AFTER gen_checkcast because it can uncommon trap and
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // the debug info has to be correct.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  push(res);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
//------------------------------do_instanceof----------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
void Parse::do_instanceof() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  if (stopped())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  // We would like to return false if class is not loaded, emitting a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  // dependency, but Java requires instanceof to load its operand.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  // Throw uncommon trap if class is not loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
  bool will_link;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
  ciKlass* klass = iter().get_klass(will_link);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  if (!will_link) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    if (C->log() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
      C->log()->elem("assert_null reason='instanceof' klass='%d'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
                     C->log()->identify(klass));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    do_null_assert(peek(), T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    assert( stopped() || _gvn.type(peek())->higher_equal(TypePtr::NULL_PTR), "what's left behind is null" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    if (!stopped()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
      // The object is now known to be null.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
      // Shortcut the effect of gen_instanceof and return "false" directly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
      pop();                   // pop the null
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
      push(_gvn.intcon(0));    // push false answer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  // Push the bool result back on stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  push( gen_instanceof( pop(), makecon(TypeKlassPtr::make(klass)) ) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
//------------------------------array_store_check------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
// pull array from stack and check that the store is valid
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
void Parse::array_store_check() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  // Shorthand access to array store elements
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  Node *obj = stack(_sp-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  Node *idx = stack(_sp-2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  Node *ary = stack(_sp-3);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  if (_gvn.type(obj) == TypePtr::NULL_PTR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
    // There's never a type check on null values.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
    // This cutout lets us avoid the uncommon_trap(Reason_array_check)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
    // below, which turns into a performance liability if the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    // gen_checkcast folds up completely.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  // Extract the array klass type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  int klass_offset = oopDesc::klass_offset_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  Node* p = basic_plus_adr( ary, ary, klass_offset );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  // p's type is array-of-OOPS plus klass_offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  Node* array_klass = _gvn.transform(new (C, 3) LoadKlassNode(0, immutable_memory(), p, TypeInstPtr::KLASS));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // Get the array klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  const TypeKlassPtr *tak = _gvn.type(array_klass)->is_klassptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // array_klass's type is generally INexact array-of-oop.  Heroically
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // cast the array klass to EXACT array and uncommon-trap if the cast
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // fails.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  bool always_see_exact_class = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  if (MonomorphicArrayCheck
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
      && !too_many_traps(Deoptimization::Reason_array_check)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    always_see_exact_class = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
    // (If no MDO at all, hope for the best, until a trap actually occurs.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  // Is the array klass is exactly its defined type?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  if (always_see_exact_class && !tak->klass_is_exact()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
    // Make a constant out of the inexact array klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    const TypeKlassPtr *extak = tak->cast_to_exactness(true)->is_klassptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    Node* con = makecon(extak);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
    Node* cmp = _gvn.transform(new (C, 3) CmpPNode( array_klass, con ));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    Node* bol = _gvn.transform(new (C, 2) BoolNode( cmp, BoolTest::eq ));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
    Node* ctrl= control();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
    { BuildCutout unless(this, bol, PROB_MAX);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
      uncommon_trap(Deoptimization::Reason_array_check,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
                    Deoptimization::Action_maybe_recompile,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
                    tak->klass());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
    if (stopped()) {          // MUST uncommon-trap?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
      set_control(ctrl);      // Then Don't Do It, just fall into the normal checking
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
    } else {                  // Cast array klass to exactness:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
      // Use the exact constant value we know it is.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
      replace_in_map(array_klass,con);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
      CompileLog* log = C->log();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
      if (log != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
        log->elem("cast_up reason='monomorphic_array' from='%d' to='(exact)'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
                  log->identify(tak->klass()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      array_klass = con;      // Use cast value moving forward
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // Come here for polymorphic array klasses
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  // Extract the array element class
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  int element_klass_offset = objArrayKlass::element_klass_offset_in_bytes() + sizeof(oopDesc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  Node *p2 = basic_plus_adr(array_klass, array_klass, element_klass_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  Node *a_e_klass = _gvn.transform(new (C, 3) LoadKlassNode(0, immutable_memory(), p2, tak));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
  // Check (the hard way) and throw if not a subklass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  // Result is ignored, we just need the CFG effects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  gen_checkcast( obj, a_e_klass );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
//------------------------------do_new-----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
void Parse::do_new() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  kill_dead_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  bool will_link;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  ciInstanceKlass* klass = iter().get_klass(will_link)->as_instance_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  assert(will_link, "_new: typeflow responsibility");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  // Should initialize, or throw an InstantiationError?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  if (!klass->is_initialized() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
      klass->is_abstract() || klass->is_interface() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
      klass->name() == ciSymbol::java_lang_Class() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
      iter().is_unresolved_klass()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    uncommon_trap(Deoptimization::Reason_uninitialized,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
                  Deoptimization::Action_reinterpret,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
                  klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  Node* kls = makecon(TypeKlassPtr::make(klass));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  Node* obj = new_instance(kls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // Push resultant oop onto stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  push(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
//------------------------------dump_map_adr_mem-------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
// Debug dump of the mapping from address types to MergeMemNode indices.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
void Parse::dump_map_adr_mem() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  tty->print_cr("--- Mapping from address types to memory Nodes ---");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  MergeMemNode *mem = map() == NULL ? NULL : (map()->memory()->is_MergeMem() ?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
                                      map()->memory()->as_MergeMem() : NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  for (uint i = 0; i < (uint)C->num_alias_types(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    C->alias_type(i)->print_on(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    tty->print("\t");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    // Node mapping, if any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    if (mem && i < mem->req() && mem->in(i) && mem->in(i) != mem->empty_memory()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
      mem->in(i)->dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
      tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
// parser methods for profiling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
//----------------------test_counter_against_threshold ------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
void Parse::test_counter_against_threshold(Node* cnt, int limit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  // Test the counter against the limit and uncommon trap if greater.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  // This code is largely copied from the range check code in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  // array_addressing()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
  // Test invocation count vs threshold
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  Node *threshold = makecon(TypeInt::make(limit));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  Node *chk   = _gvn.transform( new (C, 3) CmpUNode( cnt, threshold) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  BoolTest::mask btest = BoolTest::lt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  Node *tst   = _gvn.transform( new (C, 2) BoolNode( chk, btest) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  // Branch to failure if threshold exceeded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  { BuildCutout unless(this, tst, PROB_ALWAYS);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    uncommon_trap(Deoptimization::Reason_age,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
                  Deoptimization::Action_maybe_recompile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
//----------------------increment_and_test_invocation_counter-------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
void Parse::increment_and_test_invocation_counter(int limit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  if (!count_invocations()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  // Get the methodOop node.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  const TypePtr* adr_type = TypeOopPtr::make_from_constant(method());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  Node *methodOop_node = makecon(adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
  // Load the interpreter_invocation_counter from the methodOop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  int offset = methodOopDesc::interpreter_invocation_counter_offset_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  Node* adr_node = basic_plus_adr(methodOop_node, methodOop_node, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  Node* cnt = make_load(NULL, adr_node, TypeInt::INT, T_INT, adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  test_counter_against_threshold(cnt, limit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  // Add one to the counter and store
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  Node* incr = _gvn.transform(new (C, 3) AddINode(cnt, _gvn.intcon(1)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  store_to_memory( NULL, adr_node, incr, T_INT, adr_type );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
//----------------------------method_data_addressing---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
Node* Parse::method_data_addressing(ciMethodData* md, ciProfileData* data, ByteSize counter_offset, Node* idx, uint stride) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  // Get offset within methodDataOop of the data array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  ByteSize data_offset = methodDataOopDesc::data_offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  // Get cell offset of the ProfileData within data array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  int cell_offset = md->dp_to_di(data->dp());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  // Add in counter_offset, the # of bytes into the ProfileData of counter or flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  int offset = in_bytes(data_offset) + cell_offset + in_bytes(counter_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  const TypePtr* adr_type = TypeOopPtr::make_from_constant(md);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  Node* mdo = makecon(adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  Node* ptr = basic_plus_adr(mdo, mdo, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  if (stride != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    Node* str = _gvn.MakeConX(stride);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
    Node* scale = _gvn.transform( new (C, 3) MulXNode( idx, str ) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
    ptr   = _gvn.transform( new (C, 4) AddPNode( mdo, ptr, scale ) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  return ptr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
//--------------------------increment_md_counter_at----------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
void Parse::increment_md_counter_at(ciMethodData* md, ciProfileData* data, ByteSize counter_offset, Node* idx, uint stride) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  Node* adr_node = method_data_addressing(md, data, counter_offset, idx, stride);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  const TypePtr* adr_type = _gvn.type(adr_node)->is_ptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  Node* cnt  = make_load(NULL, adr_node, TypeInt::INT, T_INT, adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  Node* incr = _gvn.transform(new (C, 3) AddINode(cnt, _gvn.intcon(DataLayout::counter_increment)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  store_to_memory(NULL, adr_node, incr, T_INT, adr_type );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
//--------------------------test_for_osr_md_counter_at-------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
void Parse::test_for_osr_md_counter_at(ciMethodData* md, ciProfileData* data, ByteSize counter_offset, int limit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  Node* adr_node = method_data_addressing(md, data, counter_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  const TypePtr* adr_type = _gvn.type(adr_node)->is_ptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  Node* cnt  = make_load(NULL, adr_node, TypeInt::INT, T_INT, adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  test_counter_against_threshold(cnt, limit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
//-------------------------------set_md_flag_at--------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
void Parse::set_md_flag_at(ciMethodData* md, ciProfileData* data, int flag_constant) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  Node* adr_node = method_data_addressing(md, data, DataLayout::flags_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  const TypePtr* adr_type = _gvn.type(adr_node)->is_ptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
  Node* flags = make_load(NULL, adr_node, TypeInt::BYTE, T_BYTE, adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  Node* incr = _gvn.transform(new (C, 3) OrINode(flags, _gvn.intcon(flag_constant)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  store_to_memory(NULL, adr_node, incr, T_BYTE, adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
//----------------------------profile_taken_branch-----------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
void Parse::profile_taken_branch(int target_bci, bool force_update) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // This is a potential osr_site if we have a backedge.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  int cur_bci = bci();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  bool osr_site =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    (target_bci <= cur_bci) && count_invocations() && UseOnStackReplacement;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // If we are going to OSR, restart at the target bytecode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  set_bci(target_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  // To do: factor out the the limit calculations below. These duplicate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
  // the similar limit calculations in the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  if (method_data_update() || force_update) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    assert(md != NULL, "expected valid ciMethodData");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    ciProfileData* data = md->bci_to_data(cur_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
    assert(data->is_JumpData(), "need JumpData for taken branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
    increment_md_counter_at(md, data, JumpData::taken_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  // In the new tiered system this is all we need to do. In the old
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  // (c2 based) tiered sytem we must do the code below.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
#ifndef TIERED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  if (method_data_update()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
    ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
    if (osr_site) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
      ciProfileData* data = md->bci_to_data(cur_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
      int limit = (CompileThreshold
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
                   * (OnStackReplacePercentage - InterpreterProfilePercentage)) / 100;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
      test_for_osr_md_counter_at(md, data, JumpData::taken_offset(), limit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    // With method data update off, use the invocation counter to trigger an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    // OSR compilation, as done in the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    if (osr_site) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
      int limit = (CompileThreshold * OnStackReplacePercentage) / 100;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
      increment_and_test_invocation_counter(limit);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
#endif // TIERED
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  // Restore the original bytecode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  set_bci(cur_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
//--------------------------profile_not_taken_branch---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
void Parse::profile_not_taken_branch(bool force_update) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  if (method_data_update() || force_update) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    assert(md != NULL, "expected valid ciMethodData");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
    ciProfileData* data = md->bci_to_data(bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
    assert(data->is_BranchData(), "need BranchData for not taken branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
    increment_md_counter_at(md, data, BranchData::not_taken_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
//---------------------------------profile_call--------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
void Parse::profile_call(Node* receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  if (!method_data_update()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  profile_generic_call();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  switch (bc()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  case Bytecodes::_invokevirtual:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  case Bytecodes::_invokeinterface:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
    profile_receiver_type(receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  case Bytecodes::_invokestatic:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  case Bytecodes::_invokespecial:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  default: fatal("unexpected call bytecode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
//------------------------------profile_generic_call---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
void Parse::profile_generic_call() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  assert(method_data_update(), "must be generating profile code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  assert(md != NULL, "expected valid ciMethodData");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  ciProfileData* data = md->bci_to_data(bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  assert(data->is_CounterData(), "need CounterData for not taken branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  increment_md_counter_at(md, data, CounterData::count_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
//-----------------------------profile_receiver_type---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
void Parse::profile_receiver_type(Node* receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  assert(method_data_update(), "must be generating profile code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  // Skip if we aren't tracking receivers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  if (TypeProfileWidth < 1) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
  ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  assert(md != NULL, "expected valid ciMethodData");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  ciProfileData* data = md->bci_to_data(bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  assert(data->is_ReceiverTypeData(), "need ReceiverTypeData here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  ciReceiverTypeData* rdata = (ciReceiverTypeData*)data->as_ReceiverTypeData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  Node* method_data = method_data_addressing(md, rdata, in_ByteSize(0));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  // Using an adr_type of TypePtr::BOTTOM to work around anti-dep problems.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  // A better solution might be to use TypeRawPtr::BOTTOM with RC_NARROW_MEM.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  make_runtime_call(RC_LEAF, OptoRuntime::profile_receiver_type_Type(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
                    CAST_FROM_FN_PTR(address,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
                                     OptoRuntime::profile_receiver_type_C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
                    "profile_receiver_type_C",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
                    TypePtr::BOTTOM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
                    method_data, receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
//---------------------------------profile_ret---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
void Parse::profile_ret(int target_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  if (!method_data_update()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  // Skip if we aren't tracking ret targets
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  if (TypeProfileWidth < 1) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  assert(md != NULL, "expected valid ciMethodData");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  ciProfileData* data = md->bci_to_data(bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  assert(data->is_RetData(), "need RetData for ret");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  ciRetData* ret_data = (ciRetData*)data->as_RetData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  // Look for the target_bci is already in the table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  uint row;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  bool table_full = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  for (row = 0; row < ret_data->row_limit(); row++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    int key = ret_data->bci(row);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    table_full &= (key != RetData::no_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
    if (key == target_bci) break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  if (row >= ret_data->row_limit()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
    // The target_bci was not found in the table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
    if (!table_full) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
      // XXX: Make slow call to update RetData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  // the target_bci is already in the table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  increment_md_counter_at(md, data, RetData::bci_count_offset(row));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
//--------------------------profile_null_checkcast----------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
void Parse::profile_null_checkcast() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  // Set the null-seen flag, done in conjunction with the usual null check. We
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  // never unset the flag, so this is a one-way switch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  if (!method_data_update()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  assert(md != NULL, "expected valid ciMethodData");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  ciProfileData* data = md->bci_to_data(bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  assert(data->is_BitData(), "need BitData for checkcast");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  set_md_flag_at(md, data, BitData::null_seen_byte_constant());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
//-----------------------------profile_switch_case-----------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
void Parse::profile_switch_case(int table_index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  if (!method_data_update()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  ciMethodData* md = method()->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  assert(md != NULL, "expected valid ciMethodData");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  ciProfileData* data = md->bci_to_data(bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  assert(data->is_MultiBranchData(), "need MultiBranchData for switch case");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  if (table_index >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    increment_md_counter_at(md, data, MultiBranchData::case_count_offset(table_index));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    increment_md_counter_at(md, data, MultiBranchData::default_count_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
}