hotspot/src/share/vm/opto/macro.cpp
author alanb
Mon, 24 Nov 2014 18:11:25 +0000
changeset 27757 0317e4973b42
parent 26180 2fbed11af70e
child 27637 cf68c0af6882
child 27625 07829380b8cd
permissions -rw-r--r--
8065720: (ch) AbstractInterruptibleChannel.end sets interrupted to null Reviewed-by: psandoz, chegar
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
25926
486f1571b70f 8054081: Crashes with assert "modified node is not on IGVN._worklist"
thartmann
parents: 25913
diff changeset
     2
 * Copyright (c) 2005, 2014, 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: 5251
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5251
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: 5251
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: 6177
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    26
#include "compiler/compileLog.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    27
#include "libadt/vectset.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    28
#include "opto/addnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    29
#include "opto/callnode.hpp"
23528
8f1a7f5e8066 8001532: C2 node files refactoring
morris
parents: 23491
diff changeset
    30
#include "opto/castnode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    31
#include "opto/cfgnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    32
#include "opto/compile.hpp"
23528
8f1a7f5e8066 8001532: C2 node files refactoring
morris
parents: 23491
diff changeset
    33
#include "opto/convertnode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    34
#include "opto/locknode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    35
#include "opto/loopnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    36
#include "opto/macro.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    37
#include "opto/memnode.hpp"
23528
8f1a7f5e8066 8001532: C2 node files refactoring
morris
parents: 23491
diff changeset
    38
#include "opto/narrowptrnode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    39
#include "opto/node.hpp"
23528
8f1a7f5e8066 8001532: C2 node files refactoring
morris
parents: 23491
diff changeset
    40
#include "opto/opaquenode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    41
#include "opto/phaseX.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    42
#include "opto/rootnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    43
#include "opto/runtime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    44
#include "opto/subnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    45
#include "opto/type.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6177
diff changeset
    46
#include "runtime/sharedRuntime.hpp"
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
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
// Replace any references to "oldref" in inputs to "use" with "newref".
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
// Returns the number of replacements made.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
int PhaseMacroExpand::replace_input(Node *use, Node *oldref, Node *newref) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  int nreplacements = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  uint req = use->req();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  for (uint j = 0; j < use->len(); j++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
    Node *uin = use->in(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    if (uin == oldref) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
      if (j < req)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
        use->set_req(j, newref);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
      else
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
        use->set_prec(j, newref);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
      nreplacements++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
    } else if (j >= req && uin == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  return nreplacements;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
void PhaseMacroExpand::copy_call_debug_info(CallNode *oldcall, CallNode * newcall) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  // Copy debug information and adjust JVMState information
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  uint old_dbg_start = oldcall->tf()->domain()->cnt();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  uint new_dbg_start = newcall->tf()->domain()->cnt();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  int jvms_adj  = new_dbg_start - old_dbg_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  assert (new_dbg_start == newcall->req(), "argument count mismatch");
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    77
19708
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
    78
  // SafePointScalarObject node could be referenced several times in debug info.
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
    79
  // Use Dict to record cloned nodes.
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    80
  Dict* sosn_map = new Dict(cmpkey,hashkey);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  for (uint i = old_dbg_start; i < oldcall->req(); i++) {
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    82
    Node* old_in = oldcall->in(i);
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    83
    // Clone old SafePointScalarObjectNodes, adjusting their field contents.
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
    84
    if (old_in != NULL && old_in->is_SafePointScalarObject()) {
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    85
      SafePointScalarObjectNode* old_sosn = old_in->as_SafePointScalarObject();
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    86
      uint old_unique = C->unique();
19708
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
    87
      Node* new_in = old_sosn->clone(sosn_map);
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
    88
      if (old_unique != C->unique()) { // New node?
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
    89
        new_in->set_req(0, C->root()); // reset control edge
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    90
        new_in = transform_later(new_in); // Register new node.
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    91
      }
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    92
      old_in = new_in;
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    93
    }
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    94
    newcall->add_req(old_in);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  }
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
    96
26180
2fbed11af70e 8055153: nsk/stress/jck60/jck60014 crashes on sparc
roland
parents: 26166
diff changeset
    97
  // JVMS may be shared so clone it before we modify it
2fbed11af70e 8055153: nsk/stress/jck60/jck60014 crashes on sparc
roland
parents: 26166
diff changeset
    98
  newcall->set_jvms(oldcall->jvms() != NULL ? oldcall->jvms()->clone_deep(C) : NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  for (JVMState *jvms = newcall->jvms(); jvms != NULL; jvms = jvms->caller()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    jvms->set_map(newcall);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    jvms->set_locoff(jvms->locoff()+jvms_adj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    jvms->set_stkoff(jvms->stkoff()+jvms_adj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
    jvms->set_monoff(jvms->monoff()+jvms_adj);
236
9a04268c8eea 6671807: (Escape Analysis) Add new ideal node to represent the state of a scalarized object at a safepoint
kvn
parents: 1
diff changeset
   104
    jvms->set_scloff(jvms->scloff()+jvms_adj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
    jvms->set_endoff(jvms->endoff()+jvms_adj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   109
Node* PhaseMacroExpand::opt_bits_test(Node* ctrl, Node* region, int edge, Node* word, int mask, int bits, bool return_fast_path) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   110
  Node* cmp;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   111
  if (mask != 0) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   112
    Node* and_node = transform_later(new AndXNode(word, MakeConX(mask)));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   113
    cmp = transform_later(new CmpXNode(and_node, MakeConX(bits)));
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   114
  } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   115
    cmp = word;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   116
  }
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   117
  Node* bol = transform_later(new BoolNode(cmp, BoolTest::ne));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   118
  IfNode* iff = new IfNode( ctrl, bol, PROB_MIN, COUNT_UNKNOWN );
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   119
  transform_later(iff);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   121
  // Fast path taken.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   122
  Node *fast_taken = transform_later(new IfFalseNode(iff));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  // Fast path not-taken, i.e. slow path
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   125
  Node *slow_taken = transform_later(new IfTrueNode(iff));
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   126
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   127
  if (return_fast_path) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   128
    region->init_req(edge, slow_taken); // Capture slow-control
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   129
    return fast_taken;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   130
  } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   131
    region->init_req(edge, fast_taken); // Capture fast-control
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   132
    return slow_taken;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
   133
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
//--------------------copy_predefined_input_for_runtime_call--------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
void PhaseMacroExpand::copy_predefined_input_for_runtime_call(Node * ctrl, CallNode* oldcall, CallNode* call) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  // Set fixed predefined input arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  call->init_req( TypeFunc::Control, ctrl );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  call->init_req( TypeFunc::I_O    , oldcall->in( TypeFunc::I_O) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  call->init_req( TypeFunc::Memory , oldcall->in( TypeFunc::Memory ) ); // ?????
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  call->init_req( TypeFunc::ReturnAdr, oldcall->in( TypeFunc::ReturnAdr ) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
  call->init_req( TypeFunc::FramePtr, oldcall->in( TypeFunc::FramePtr ) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
//------------------------------make_slow_call---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
CallNode* PhaseMacroExpand::make_slow_call(CallNode *oldcall, const TypeFunc* slow_call_type, address slow_call, const char* leaf_name, Node* slow_path, Node* parm0, Node* parm1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  // Slow-path call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
 CallNode *call = leaf_name
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   151
   ? (CallNode*)new CallLeafNode      ( slow_call_type, slow_call, leaf_name, TypeRawPtr::BOTTOM )
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   152
   : (CallNode*)new CallStaticJavaNode( slow_call_type, slow_call, OptoRuntime::stub_name(slow_call), oldcall->jvms()->bci(), TypeRawPtr::BOTTOM );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // Slow path call has no side-effects, uses few values
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  copy_predefined_input_for_runtime_call(slow_path, oldcall, call );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  if (parm0 != NULL)  call->init_req(TypeFunc::Parms+0, parm0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  if (parm1 != NULL)  call->init_req(TypeFunc::Parms+1, parm1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  copy_call_debug_info(oldcall, call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  call->set_cnt(PROB_UNLIKELY_MAG(4));  // Same effect as RC_UNCOMMON.
5901
c046f8e9c52b 6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents: 5889
diff changeset
   160
  _igvn.replace_node(oldcall, call);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  transform_later(call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  return call;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
void PhaseMacroExpand::extract_call_projections(CallNode *call) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  _fallthroughproj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  _fallthroughcatchproj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  _ioproj_fallthrough = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  _ioproj_catchall = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  _catchallcatchproj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  _memproj_fallthrough = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  _memproj_catchall = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  _resproj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  for (DUIterator_Fast imax, i = call->fast_outs(imax); i < imax; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
    ProjNode *pn = call->fast_out(i)->as_Proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    switch (pn->_con) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
      case TypeFunc::Control:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
      {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
        // For Control (fallthrough) and I_O (catch_all_index) we have CatchProj -> Catch -> Proj
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
        _fallthroughproj = pn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
        DUIterator_Fast jmax, j = pn->fast_outs(jmax);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
        const Node *cn = pn->fast_out(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
        if (cn->is_Catch()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
          ProjNode *cpn = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
          for (DUIterator_Fast kmax, k = cn->fast_outs(kmax); k < kmax; k++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
            cpn = cn->fast_out(k)->as_Proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
            assert(cpn->is_CatchProj(), "must be a CatchProjNode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
            if (cpn->_con == CatchProjNode::fall_through_index)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
              _fallthroughcatchproj = cpn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
            else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
              assert(cpn->_con == CatchProjNode::catch_all_index, "must be correct index.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
              _catchallcatchproj = cpn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
      case TypeFunc::I_O:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
        if (pn->_is_io_use)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
          _ioproj_catchall = pn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
          _ioproj_fallthrough = pn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
      case TypeFunc::Memory:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
        if (pn->_is_io_use)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
          _memproj_catchall = pn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
          _memproj_fallthrough = pn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
      case TypeFunc::Parms:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
        _resproj = pn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
      default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
        assert(false, "unexpected projection from allocation node.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   221
// Eliminate a card mark sequence.  p2x is a ConvP2XNode
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   222
void PhaseMacroExpand::eliminate_card_mark(Node* p2x) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   223
  assert(p2x->Opcode() == Op_CastP2X, "ConvP2XNode required");
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   224
  if (!UseG1GC) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   225
    // vanilla/CMS post barrier
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   226
    Node *shift = p2x->unique_out();
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   227
    Node *addp = shift->unique_out();
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   228
    for (DUIterator_Last jmin, j = addp->last_outs(jmin); j >= jmin; --j) {
9331
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   229
      Node *mem = addp->last_out(j);
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   230
      if (UseCondCardMark && mem->is_Load()) {
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   231
        assert(mem->Opcode() == Op_LoadB, "unexpected code shape");
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   232
        // The load is checking if the card has been written so
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   233
        // replace it with zero to fold the test.
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   234
        _igvn.replace_node(mem, intcon(0));
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   235
        continue;
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   236
      }
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   237
      assert(mem->is_Store(), "store required");
9a575ce594ed 7029167: add support for conditional card marks
never
parents: 7724
diff changeset
   238
      _igvn.replace_node(mem, mem->in(MemNode::Memory));
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   239
    }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   240
  } else {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   241
    // G1 pre/post barriers
11724
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   242
    assert(p2x->outcnt() <= 2, "expects 1 or 2 users: Xor and URShift nodes");
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   243
    // It could be only one user, URShift node, in Object.clone() instrinsic
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   244
    // but the new allocation is passed to arraycopy stub and it could not
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   245
    // be scalar replaced. So we don't check the case.
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   246
11724
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   247
    // An other case of only one user (Xor) is when the value check for NULL
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   248
    // in G1 post barrier is folded after CCP so the code which used URShift
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   249
    // is removed.
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   250
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   251
    // Take Region node before eliminating post barrier since it also
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   252
    // eliminates CastP2X node when it has only one user.
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   253
    Node* this_region = p2x->in(0);
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   254
    assert(this_region != NULL, "");
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   255
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   256
    // Remove G1 post barrier.
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   257
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   258
    // Search for CastP2X->Xor->URShift->Cmp path which
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   259
    // checks if the store done to a different from the value's region.
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   260
    // And replace Cmp with #0 (false) to collapse G1 post barrier.
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   261
    Node* xorx = NULL;
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   262
    for (DUIterator_Fast imax, i = p2x->fast_outs(imax); i < imax; i++) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   263
      Node* u = p2x->fast_out(i);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   264
      if (u->Opcode() == Op_XorX) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   265
        xorx = u;
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   266
        break;
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   267
      }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   268
    }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   269
    assert(xorx != NULL, "missing G1 post barrier");
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   270
    Node* shift = xorx->unique_out();
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   271
    Node* cmpx = shift->unique_out();
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   272
    assert(cmpx->is_Cmp() && cmpx->unique_out()->is_Bool() &&
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   273
    cmpx->unique_out()->as_Bool()->_test._test == BoolTest::ne,
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   274
    "missing region check in G1 post barrier");
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   275
    _igvn.replace_node(cmpx, makecon(TypeInt::CC_EQ));
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   276
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   277
    // Remove G1 pre barrier.
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   278
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   279
    // Search "if (marking != 0)" check and set it to "false".
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   280
    // There is no G1 pre barrier if previous stored value is NULL
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   281
    // (for example, after initialization).
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   282
    if (this_region->is_Region() && this_region->req() == 3) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   283
      int ind = 1;
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   284
      if (!this_region->in(ind)->is_IfFalse()) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   285
        ind = 2;
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   286
      }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   287
      if (this_region->in(ind)->is_IfFalse()) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   288
        Node* bol = this_region->in(ind)->in(0)->in(1);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   289
        assert(bol->is_Bool(), "");
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   290
        cmpx = bol->in(1);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   291
        if (bol->as_Bool()->_test._test == BoolTest::ne &&
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   292
            cmpx->is_Cmp() && cmpx->in(2) == intcon(0) &&
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   293
            cmpx->in(1)->is_Load()) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   294
          Node* adr = cmpx->in(1)->as_Load()->in(MemNode::Address);
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   295
          const int marking_offset = in_bytes(JavaThread::satb_mark_queue_offset() +
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   296
                                              PtrQueue::byte_offset_of_active());
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   297
          if (adr->is_AddP() && adr->in(AddPNode::Base) == top() &&
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   298
              adr->in(AddPNode::Address)->Opcode() == Op_ThreadLocal &&
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   299
              adr->in(AddPNode::Offset) == MakeConX(marking_offset)) {
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   300
            _igvn.replace_node(cmpx, makecon(TypeInt::CC_EQ));
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   301
          }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   302
        }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   303
      }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   304
    }
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   305
    // Now CastP2X can be removed since it is used only on dead path
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   306
    // which currently still alive until igvn optimize it.
11724
1500e51fdcbf 7143491: G1 C2 CTW: assert(p2x->outcnt() == 2) failed: expects 2 users: Xor and URShift nodes
kvn
parents: 11460
diff changeset
   307
    assert(p2x->outcnt() == 0 || p2x->unique_out()->Opcode() == Op_URShiftX, "");
3268
f034e0c86895 6851742: (EA) allocation elimination doesn't work with UseG1GC
kvn
parents: 2867
diff changeset
   308
    _igvn.replace_node(p2x, top());
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   309
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   310
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   311
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   312
// Search for a memory operation for the specified memory slice.
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   313
static Node *scan_mem_chain(Node *mem, int alias_idx, int offset, Node *start_mem, Node *alloc, PhaseGVN *phase) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   314
  Node *orig_mem = mem;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   315
  Node *alloc_mem = alloc->in(TypeFunc::Memory);
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   316
  const TypeOopPtr *tinst = phase->C->get_adr_type(alias_idx)->isa_oopptr();
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   317
  while (true) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   318
    if (mem == alloc_mem || mem == start_mem ) {
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2127
diff changeset
   319
      return mem;  // hit one of our sentinels
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   320
    } else if (mem->is_MergeMem()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   321
      mem = mem->as_MergeMem()->memory_at(alias_idx);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   322
    } else if (mem->is_Proj() && mem->as_Proj()->_con == TypeFunc::Memory) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   323
      Node *in = mem->in(0);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   324
      // we can safely skip over safepoints, calls, locks and membars because we
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   325
      // already know that the object is safe to eliminate.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   326
      if (in->is_Initialize() && in->as_Initialize()->allocation() == alloc) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   327
        return in;
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   328
      } else if (in->is_Call()) {
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   329
        CallNode *call = in->as_Call();
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   330
        if (!call->may_modify(tinst, phase)) {
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   331
          mem = call->in(TypeFunc::Memory);
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   332
        }
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   333
        mem = in->in(TypeFunc::Memory);
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   334
      } else if (in->is_MemBar()) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   335
        mem = in->in(TypeFunc::Memory);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   336
      } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   337
        assert(false, "unexpected projection");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   338
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   339
    } else if (mem->is_Store()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   340
      const TypePtr* atype = mem->as_Store()->adr_type();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   341
      int adr_idx = Compile::current()->get_alias_index(atype);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   342
      if (adr_idx == alias_idx) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   343
        assert(atype->isa_oopptr(), "address type must be oopptr");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   344
        int adr_offset = atype->offset();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   345
        uint adr_iid = atype->is_oopptr()->instance_id();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   346
        // Array elements references have the same alias_idx
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   347
        // but different offset and different instance_id.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   348
        if (adr_offset == offset && adr_iid == alloc->_idx)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   349
          return mem;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   350
      } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   351
        assert(adr_idx == Compile::AliasIdxRaw, "address must match or be raw");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   352
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   353
      mem = mem->in(MemNode::Memory);
4470
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   354
    } else if (mem->is_ClearArray()) {
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   355
      if (!ClearArrayNode::step_through(&mem, alloc->_idx, phase)) {
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   356
        // Can not bypass initialization of the instance
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   357
        // we are looking.
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   358
        debug_only(intptr_t offset;)
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   359
        assert(alloc == AllocateNode::Ideal_allocation(mem->in(3), phase, offset), "sanity");
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   360
        InitializeNode* init = alloc->as_Allocate()->initialization();
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   361
        // We are looking for stored value, return Initialize node
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   362
        // or memory edge from Allocate node.
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   363
        if (init != NULL)
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   364
          return init;
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   365
        else
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   366
          return alloc->in(TypeFunc::Memory); // It will produce zero value (see callers).
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   367
      }
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   368
      // Otherwise skip it (the call updated 'mem' value).
2110
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   369
    } else if (mem->Opcode() == Op_SCMemProj) {
15242
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   370
      mem = mem->in(0);
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   371
      Node* adr = NULL;
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   372
      if (mem->is_LoadStore()) {
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   373
        adr = mem->in(MemNode::Address);
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   374
      } else {
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   375
        assert(mem->Opcode() == Op_EncodeISOArray, "sanity");
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   376
        adr = mem->in(3); // Destination array
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   377
      }
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   378
      const TypePtr* atype = adr->bottom_type()->is_ptr();
2110
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   379
      int adr_idx = Compile::current()->get_alias_index(atype);
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   380
      if (adr_idx == alias_idx) {
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   381
        assert(false, "Object is not scalar replaceable if a LoadStore node access its field");
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   382
        return NULL;
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   383
      }
15242
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   384
      mem = mem->in(MemNode::Memory);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   385
    } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   386
      return mem;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   387
    }
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   388
    assert(mem != orig_mem, "dead memory loop");
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   389
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   390
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   391
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   392
//
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   393
// Given a Memory Phi, compute a value Phi containing the values from stores
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   394
// on the input paths.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   395
// Note: this function is recursive, its depth is limied by the "level" argument
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   396
// Returns the computed Phi, or NULL if it cannot compute it.
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   397
Node *PhaseMacroExpand::value_from_mem_phi(Node *mem, BasicType ft, const Type *phi_type, const TypeOopPtr *adr_t, Node *alloc, Node_Stack *value_phis, int level) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   398
  assert(mem->is_Phi(), "sanity");
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   399
  int alias_idx = C->get_alias_index(adr_t);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   400
  int offset = adr_t->offset();
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   401
  int instance_id = adr_t->instance_id();
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   402
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   403
  // Check if an appropriate value phi already exists.
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   404
  Node* region = mem->in(0);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   405
  for (DUIterator_Fast kmax, k = region->fast_outs(kmax); k < kmax; k++) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   406
    Node* phi = region->fast_out(k);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   407
    if (phi->is_Phi() && phi != mem &&
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   408
        phi->as_Phi()->is_same_inst_field(phi_type, instance_id, alias_idx, offset)) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   409
      return phi;
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   410
    }
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   411
  }
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   412
  // Check if an appropriate new value phi already exists.
10011
e8b38f7b9959 7044738: Loop unroll optimization causes incorrect result
kvn
parents: 9977
diff changeset
   413
  Node* new_phi = value_phis->find(mem->_idx);
e8b38f7b9959 7044738: Loop unroll optimization causes incorrect result
kvn
parents: 9977
diff changeset
   414
  if (new_phi != NULL)
e8b38f7b9959 7044738: Loop unroll optimization causes incorrect result
kvn
parents: 9977
diff changeset
   415
    return new_phi;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   416
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   417
  if (level <= 0) {
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   418
    return NULL; // Give up: phi tree too deep
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   419
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   420
  Node *start_mem = C->start()->proj_out(TypeFunc::Memory);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   421
  Node *alloc_mem = alloc->in(TypeFunc::Memory);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   422
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   423
  uint length = mem->req();
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 12958
diff changeset
   424
  GrowableArray <Node *> values(length, length, NULL, false);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   425
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   426
  // create a new Phi for the value
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   427
  PhiNode *phi = new PhiNode(mem->in(0), phi_type, NULL, instance_id, alias_idx, offset);
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   428
  transform_later(phi);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   429
  value_phis->push(phi, mem->_idx);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   430
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   431
  for (uint j = 1; j < length; j++) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   432
    Node *in = mem->in(j);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   433
    if (in == NULL || in->is_top()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   434
      values.at_put(j, in);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   435
    } else  {
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   436
      Node *val = scan_mem_chain(in, alias_idx, offset, start_mem, alloc, &_igvn);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   437
      if (val == start_mem || val == alloc_mem) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   438
        // hit a sentinel, return appropriate 0 value
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   439
        values.at_put(j, _igvn.zerocon(ft));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   440
        continue;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   441
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   442
      if (val->is_Initialize()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   443
        val = val->as_Initialize()->find_captured_store(offset, type2aelembytes(ft), &_igvn);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   444
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   445
      if (val == NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   446
        return NULL;  // can't find a value on this path
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   447
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   448
      if (val == mem) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   449
        values.at_put(j, mem);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   450
      } else if (val->is_Store()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   451
        values.at_put(j, val->in(MemNode::ValueIn));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   452
      } else if(val->is_Proj() && val->in(0) == alloc) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   453
        values.at_put(j, _igvn.zerocon(ft));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   454
      } else if (val->is_Phi()) {
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   455
        val = value_from_mem_phi(val, ft, phi_type, adr_t, alloc, value_phis, level-1);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   456
        if (val == NULL) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   457
          return NULL;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   458
        }
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   459
        values.at_put(j, val);
2110
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   460
      } else if (val->Opcode() == Op_SCMemProj) {
15242
695bb216be99 6896617: Optimize sun.nio.cs.ISO_8859_1$Encode.encodeArrayLoop() on x86
kvn
parents: 14623
diff changeset
   461
        assert(val->in(0)->is_LoadStore() || val->in(0)->Opcode() == Op_EncodeISOArray, "sanity");
2110
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   462
        assert(false, "Object is not scalar replaceable if a LoadStore node access its field");
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   463
        return NULL;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   464
      } else {
2110
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   465
#ifdef ASSERT
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   466
        val->dump();
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   467
        assert(false, "unknown node on this path");
2110
40e42c95ac39 6802499: EA: assert(false,"unknown node on this path")
kvn
parents: 2029
diff changeset
   468
#endif
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   469
        return NULL;  // unknown node on this path
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   470
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   471
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   472
  }
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   473
  // Set Phi's inputs
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   474
  for (uint j = 1; j < length; j++) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   475
    if (values.at(j) == mem) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   476
      phi->init_req(j, phi);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   477
    } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   478
      phi->init_req(j, values.at(j));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   479
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   480
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   481
  return phi;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   482
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   483
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   484
// Search the last value stored into the object's field.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   485
Node *PhaseMacroExpand::value_from_mem(Node *sfpt_mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, Node *alloc) {
769
78e5090c7a20 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 767
diff changeset
   486
  assert(adr_t->is_known_instance_field(), "instance required");
78e5090c7a20 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 767
diff changeset
   487
  int instance_id = adr_t->instance_id();
78e5090c7a20 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 767
diff changeset
   488
  assert((uint)instance_id == alloc->_idx, "wrong allocation");
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   489
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   490
  int alias_idx = C->get_alias_index(adr_t);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   491
  int offset = adr_t->offset();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   492
  Node *start_mem = C->start()->proj_out(TypeFunc::Memory);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   493
  Node *alloc_ctrl = alloc->in(TypeFunc::Control);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   494
  Node *alloc_mem = alloc->in(TypeFunc::Memory);
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   495
  Arena *a = Thread::current()->resource_area();
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   496
  VectorSet visited(a);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   497
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   498
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   499
  bool done = sfpt_mem == alloc_mem;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   500
  Node *mem = sfpt_mem;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   501
  while (!done) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   502
    if (visited.test_set(mem->_idx)) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   503
      return NULL;  // found a loop, give up
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   504
    }
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   505
    mem = scan_mem_chain(mem, alias_idx, offset, start_mem, alloc, &_igvn);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   506
    if (mem == start_mem || mem == alloc_mem) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   507
      done = true;  // hit a sentinel, return appropriate 0 value
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   508
    } else if (mem->is_Initialize()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   509
      mem = mem->as_Initialize()->find_captured_store(offset, type2aelembytes(ft), &_igvn);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   510
      if (mem == NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   511
        done = true; // Something go wrong.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   512
      } else if (mem->is_Store()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   513
        const TypePtr* atype = mem->as_Store()->adr_type();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   514
        assert(C->get_alias_index(atype) == Compile::AliasIdxRaw, "store is correct memory slice");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   515
        done = true;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   516
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   517
    } else if (mem->is_Store()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   518
      const TypeOopPtr* atype = mem->as_Store()->adr_type()->isa_oopptr();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   519
      assert(atype != NULL, "address type must be oopptr");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   520
      assert(C->get_alias_index(atype) == alias_idx &&
769
78e5090c7a20 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 767
diff changeset
   521
             atype->is_known_instance_field() && atype->offset() == offset &&
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   522
             atype->instance_id() == instance_id, "store is correct memory slice");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   523
      done = true;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   524
    } else if (mem->is_Phi()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   525
      // try to find a phi's unique input
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   526
      Node *unique_input = NULL;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   527
      Node *top = C->top();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   528
      for (uint i = 1; i < mem->req(); i++) {
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   529
        Node *n = scan_mem_chain(mem->in(i), alias_idx, offset, start_mem, alloc, &_igvn);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   530
        if (n == NULL || n == top || n == mem) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   531
          continue;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   532
        } else if (unique_input == NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   533
          unique_input = n;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   534
        } else if (unique_input != n) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   535
          unique_input = top;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   536
          break;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   537
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   538
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   539
      if (unique_input != NULL && unique_input != top) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   540
        mem = unique_input;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   541
      } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   542
        done = true;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   543
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   544
    } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   545
      assert(false, "unexpected node");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   546
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   547
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   548
  if (mem != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   549
    if (mem == start_mem || mem == alloc_mem) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   550
      // hit a sentinel, return appropriate 0 value
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   551
      return _igvn.zerocon(ft);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   552
    } else if (mem->is_Store()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   553
      return mem->in(MemNode::ValueIn);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   554
    } else if (mem->is_Phi()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   555
      // attempt to produce a Phi reflecting the values on the input paths of the Phi
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   556
      Node_Stack value_phis(a, 8);
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   557
      Node * phi = value_from_mem_phi(mem, ft, ftype, adr_t, alloc, &value_phis, ValueSearchLimit);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   558
      if (phi != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   559
        return phi;
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   560
      } else {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   561
        // Kill all new Phis
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   562
        while(value_phis.is_nonempty()) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   563
          Node* n = value_phis.node();
5901
c046f8e9c52b 6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents: 5889
diff changeset
   564
          _igvn.replace_node(n, C->top());
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   565
          value_phis.pop();
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 781
diff changeset
   566
        }
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   567
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   568
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   569
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   570
  // Something go wrong.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   571
  return NULL;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   572
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   573
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   574
// Check the possibility of scalar replacement.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   575
bool PhaseMacroExpand::can_eliminate_allocation(AllocateNode *alloc, GrowableArray <SafePointNode *>& safepoints) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   576
  //  Scan the uses of the allocation to check for anything that would
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   577
  //  prevent us from eliminating it.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   578
  NOT_PRODUCT( const char* fail_eliminate = NULL; )
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   579
  DEBUG_ONLY( Node* disq_node = NULL; )
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   580
  bool  can_eliminate = true;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   581
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   582
  Node* res = alloc->result_cast();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   583
  const TypeOopPtr* res_type = NULL;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   584
  if (res == NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   585
    // All users were eliminated.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   586
  } else if (!res->is_CheckCastPP()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   587
    NOT_PRODUCT(fail_eliminate = "Allocation does not have unique CheckCastPP";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   588
    can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   589
  } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   590
    res_type = _igvn.type(res)->isa_oopptr();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   591
    if (res_type == NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   592
      NOT_PRODUCT(fail_eliminate = "Neither instance or array allocation";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   593
      can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   594
    } else if (res_type->isa_aryptr()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   595
      int length = alloc->in(AllocateNode::ALength)->find_int_con(-1);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   596
      if (length < 0) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   597
        NOT_PRODUCT(fail_eliminate = "Array's size is not constant";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   598
        can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   599
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   600
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   601
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   602
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   603
  if (can_eliminate && res != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   604
    for (DUIterator_Fast jmax, j = res->fast_outs(jmax);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   605
                               j < jmax && can_eliminate; j++) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   606
      Node* use = res->fast_out(j);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   607
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   608
      if (use->is_AddP()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   609
        const TypePtr* addp_type = _igvn.type(use)->is_ptr();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   610
        int offset = addp_type->offset();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   611
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   612
        if (offset == Type::OffsetTop || offset == Type::OffsetBot) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   613
          NOT_PRODUCT(fail_eliminate = "Undefined field referrence";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   614
          can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   615
          break;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   616
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   617
        for (DUIterator_Fast kmax, k = use->fast_outs(kmax);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   618
                                   k < kmax && can_eliminate; k++) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   619
          Node* n = use->fast_out(k);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   620
          if (!n->is_Store() && n->Opcode() != Op_CastP2X) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   621
            DEBUG_ONLY(disq_node = n;)
961
7fb3b13d4205 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 955
diff changeset
   622
            if (n->is_Load() || n->is_LoadStore()) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   623
              NOT_PRODUCT(fail_eliminate = "Field load";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   624
            } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   625
              NOT_PRODUCT(fail_eliminate = "Not store field referrence";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   626
            }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   627
            can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   628
          }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   629
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   630
      } else if (use->is_SafePoint()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   631
        SafePointNode* sfpt = use->as_SafePoint();
594
9f4474e5dbaf 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents: 589
diff changeset
   632
        if (sfpt->is_Call() && sfpt->as_Call()->has_non_debug_use(res)) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   633
          // Object is passed as argument.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   634
          DEBUG_ONLY(disq_node = use;)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   635
          NOT_PRODUCT(fail_eliminate = "Object is passed as argument";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   636
          can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   637
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   638
        Node* sfptMem = sfpt->memory();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   639
        if (sfptMem == NULL || sfptMem->is_top()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   640
          DEBUG_ONLY(disq_node = use;)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   641
          NOT_PRODUCT(fail_eliminate = "NULL or TOP memory";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   642
          can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   643
        } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   644
          safepoints.append_if_missing(sfpt);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   645
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   646
      } else if (use->Opcode() != Op_CastP2X) { // CastP2X is used by card mark
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   647
        if (use->is_Phi()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   648
          if (use->outcnt() == 1 && use->unique_out()->Opcode() == Op_Return) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   649
            NOT_PRODUCT(fail_eliminate = "Object is return value";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   650
          } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   651
            NOT_PRODUCT(fail_eliminate = "Object is referenced by Phi";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   652
          }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   653
          DEBUG_ONLY(disq_node = use;)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   654
        } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   655
          if (use->Opcode() == Op_Return) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   656
            NOT_PRODUCT(fail_eliminate = "Object is return value";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   657
          }else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   658
            NOT_PRODUCT(fail_eliminate = "Object is referenced by node";)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   659
          }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   660
          DEBUG_ONLY(disq_node = use;)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   661
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   662
        can_eliminate = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   663
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   664
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   665
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   666
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   667
#ifndef PRODUCT
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   668
  if (PrintEliminateAllocations) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   669
    if (can_eliminate) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   670
      tty->print("Scalar ");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   671
      if (res == NULL)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   672
        alloc->dump();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   673
      else
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   674
        res->dump();
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   675
    } else if (alloc->_is_scalar_replaceable) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   676
      tty->print("NotScalar (%s)", fail_eliminate);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   677
      if (res == NULL)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   678
        alloc->dump();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   679
      else
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   680
        res->dump();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   681
#ifdef ASSERT
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   682
      if (disq_node != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   683
          tty->print("  >>>> ");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   684
          disq_node->dump();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   685
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   686
#endif /*ASSERT*/
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   687
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   688
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   689
#endif
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   690
  return can_eliminate;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   691
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   692
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   693
// Do scalar replacement.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   694
bool PhaseMacroExpand::scalar_replacement(AllocateNode *alloc, GrowableArray <SafePointNode *>& safepoints) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   695
  GrowableArray <SafePointNode *> safepoints_done;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   696
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   697
  ciKlass* klass = NULL;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   698
  ciInstanceKlass* iklass = NULL;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   699
  int nfields = 0;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   700
  int array_base;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   701
  int element_size;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   702
  BasicType basic_elem_type;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   703
  ciType* elem_type;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   704
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   705
  Node* res = alloc->result_cast();
25935
59b08808cb9c 8046698: assert(false) failed: only Initialize or AddP expected macro.cpp:943
roland
parents: 25926
diff changeset
   706
  assert(res == NULL || res->is_CheckCastPP(), "unexpected AllocateNode result");
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   707
  const TypeOopPtr* res_type = NULL;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   708
  if (res != NULL) { // Could be NULL when there are no users
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   709
    res_type = _igvn.type(res)->isa_oopptr();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   710
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   711
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   712
  if (res != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   713
    klass = res_type->klass();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   714
    if (res_type->isa_instptr()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   715
      // find the fields of the class which will be needed for safepoint debug information
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   716
      assert(klass->is_instance_klass(), "must be an instance klass.");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   717
      iklass = klass->as_instance_klass();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   718
      nfields = iklass->nof_nonstatic_fields();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   719
    } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   720
      // find the array's elements which will be needed for safepoint debug information
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   721
      nfields = alloc->in(AllocateNode::ALength)->find_int_con(-1);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   722
      assert(klass->is_array_klass() && nfields >= 0, "must be an array klass.");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   723
      elem_type = klass->as_array_klass()->element_type();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   724
      basic_elem_type = elem_type->basic_type();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   725
      array_base = arrayOopDesc::base_offset_in_bytes(basic_elem_type);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   726
      element_size = type2aelembytes(basic_elem_type);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   727
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   728
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   729
  //
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   730
  // Process the safepoint uses
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   731
  //
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   732
  while (safepoints.length() > 0) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   733
    SafePointNode* sfpt = safepoints.pop();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   734
    Node* mem = sfpt->memory();
19708
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
   735
    assert(sfpt->jvms() != NULL, "missed JVMS");
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
   736
    // Fields of scalar objs are referenced only at the end
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
   737
    // of regular debuginfo at the last (youngest) JVMS.
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
   738
    // Record relative start index.
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
   739
    uint first_ind = (sfpt->req() - sfpt->jvms()->scloff());
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   740
    SafePointScalarObjectNode* sobj = new SafePointScalarObjectNode(res_type,
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   741
#ifdef ASSERT
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   742
                                                 alloc,
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   743
#endif
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   744
                                                 first_ind, nfields);
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
   745
    sobj->init_req(0, C->root());
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   746
    transform_later(sobj);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   747
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   748
    // Scan object's fields adding an input to the safepoint for each field.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   749
    for (int j = 0; j < nfields; j++) {
1068
720698d9c89b 6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents: 961
diff changeset
   750
      intptr_t offset;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   751
      ciField* field = NULL;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   752
      if (iklass != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   753
        field = iklass->nonstatic_field_at(j);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   754
        offset = field->offset();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   755
        elem_type = field->type();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   756
        basic_elem_type = field->layout_type();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   757
      } else {
1068
720698d9c89b 6741738: TypePtr::add_offset() set incorrect offset when the add overflows
kvn
parents: 961
diff changeset
   758
        offset = array_base + j * (intptr_t)element_size;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   759
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   760
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   761
      const Type *field_type;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   762
      // The next code is taken from Parse::do_get_xxx().
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   763
      if (basic_elem_type == T_OBJECT || basic_elem_type == T_ARRAY) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   764
        if (!elem_type->is_loaded()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   765
          field_type = TypeInstPtr::BOTTOM;
6177
12835feea156 6969569: assert(is_static() && is_constant()) failed: illegal call to constant_value()
kvn
parents: 5901
diff changeset
   766
        } else if (field != NULL && field->is_constant() && field->is_static()) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   767
          // This can happen if the constant oop is non-perm.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   768
          ciObject* con = field->constant_value().as_object();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   769
          // Do not "join" in the previous type; it doesn't add value,
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   770
          // and may yield a vacuous result if the field is of interface type.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   771
          field_type = TypeOopPtr::make_from_constant(con)->isa_oopptr();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   772
          assert(field_type != NULL, "field singleton type must be consistent");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   773
        } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   774
          field_type = TypeOopPtr::make_from_klass(elem_type->as_klass());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   775
        }
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   776
        if (UseCompressedOops) {
767
64fb1fd7186d 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 762
diff changeset
   777
          field_type = field_type->make_narrowoop();
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   778
          basic_elem_type = T_NARROWOOP;
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   779
        }
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   780
      } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   781
        field_type = Type::get_const_basic_type(basic_elem_type);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   782
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   783
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   784
      const TypeOopPtr *field_addr_type = res_type->add_offset(offset)->isa_oopptr();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   785
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   786
      Node *field_val = value_from_mem(mem, basic_elem_type, field_type, field_addr_type, alloc);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   787
      if (field_val == NULL) {
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
   788
        // We weren't able to find a value for this field,
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
   789
        // give up on eliminating this allocation.
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
   790
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
   791
        // Remove any extra entries we added to the safepoint.
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   792
        uint last = sfpt->req() - 1;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   793
        for (int k = 0;  k < j; k++) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   794
          sfpt->del_req(last--);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   795
        }
25926
486f1571b70f 8054081: Crashes with assert "modified node is not on IGVN._worklist"
thartmann
parents: 25913
diff changeset
   796
        _igvn._worklist.push(sfpt);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   797
        // rollback processed safepoints
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   798
        while (safepoints_done.length() > 0) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   799
          SafePointNode* sfpt_done = safepoints_done.pop();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   800
          // remove any extra entries we added to the safepoint
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   801
          last = sfpt_done->req() - 1;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   802
          for (int k = 0;  k < nfields; k++) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   803
            sfpt_done->del_req(last--);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   804
          }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   805
          JVMState *jvms = sfpt_done->jvms();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   806
          jvms->set_endoff(sfpt_done->req());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   807
          // Now make a pass over the debug information replacing any references
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   808
          // to SafePointScalarObjectNode with the allocated object.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   809
          int start = jvms->debug_start();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   810
          int end   = jvms->debug_end();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   811
          for (int i = start; i < end; i++) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   812
            if (sfpt_done->in(i)->is_SafePointScalarObject()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   813
              SafePointScalarObjectNode* scobj = sfpt_done->in(i)->as_SafePointScalarObject();
19708
64e8c91f5f3e 8012972: Incremental Inlining should support scalar replaced object in debug info
kvn
parents: 17384
diff changeset
   814
              if (scobj->first_index(jvms) == sfpt_done->req() &&
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   815
                  scobj->n_fields() == (uint)nfields) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   816
                assert(scobj->alloc() == alloc, "sanity");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   817
                sfpt_done->set_req(i, res);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   818
              }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   819
            }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   820
          }
25926
486f1571b70f 8054081: Crashes with assert "modified node is not on IGVN._worklist"
thartmann
parents: 25913
diff changeset
   821
          _igvn._worklist.push(sfpt_done);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   822
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   823
#ifndef PRODUCT
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   824
        if (PrintEliminateAllocations) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   825
          if (field != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   826
            tty->print("=== At SafePoint node %d can't find value of Field: ",
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   827
                       sfpt->_idx);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   828
            field->print();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   829
            int field_idx = C->get_alias_index(field_addr_type);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   830
            tty->print(" (alias_idx=%d)", field_idx);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   831
          } else { // Array's element
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   832
            tty->print("=== At SafePoint node %d can't find value of array element [%d]",
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   833
                       sfpt->_idx, j);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   834
          }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   835
          tty->print(", which prevents elimination of: ");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   836
          if (res == NULL)
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   837
            alloc->dump();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   838
          else
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   839
            res->dump();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   840
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   841
#endif
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   842
        return false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   843
      }
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   844
      if (UseCompressedOops && field_type->isa_narrowoop()) {
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   845
        // Enable "DecodeN(EncodeP(Allocate)) --> Allocate" transformation
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   846
        // to be able scalar replace the allocation.
767
64fb1fd7186d 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 762
diff changeset
   847
        if (field_val->is_EncodeP()) {
64fb1fd7186d 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 762
diff changeset
   848
          field_val = field_val->in(1);
64fb1fd7186d 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 762
diff changeset
   849
        } else {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
   850
          field_val = transform_later(new DecodeNNode(field_val, field_val->get_ptr_type()));
767
64fb1fd7186d 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 762
diff changeset
   851
        }
371
1aacedc9db7c 6689060: Escape Analysis does not work with Compressed Oops
kvn
parents: 360
diff changeset
   852
      }
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   853
      sfpt->add_req(field_val);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   854
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   855
    JVMState *jvms = sfpt->jvms();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   856
    jvms->set_endoff(sfpt->req());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   857
    // Now make a pass over the debug information replacing any references
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   858
    // to the allocated object with "sobj"
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   859
    int start = jvms->debug_start();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   860
    int end   = jvms->debug_end();
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   861
    sfpt->replace_edges_in_range(res, sobj, start, end);
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 24923
diff changeset
   862
    _igvn._worklist.push(sfpt);
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   863
    safepoints_done.append_if_missing(sfpt); // keep it for rollback
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   864
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   865
  return true;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   866
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   867
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   868
// Process users of eliminated allocation.
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   869
void PhaseMacroExpand::process_users_of_allocation(CallNode *alloc) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   870
  Node* res = alloc->result_cast();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   871
  if (res != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   872
    for (DUIterator_Last jmin, j = res->last_outs(jmin); j >= jmin; ) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   873
      Node *use = res->last_out(j);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   874
      uint oc1 = res->outcnt();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   875
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   876
      if (use->is_AddP()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   877
        for (DUIterator_Last kmin, k = use->last_outs(kmin); k >= kmin; ) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   878
          Node *n = use->last_out(k);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   879
          uint oc2 = use->outcnt();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   880
          if (n->is_Store()) {
4470
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   881
#ifdef ASSERT
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   882
            // Verify that there is no dependent MemBarVolatile nodes,
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   883
            // they should be removed during IGVN, see MemBarNode::Ideal().
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   884
            for (DUIterator_Fast pmax, p = n->fast_outs(pmax);
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   885
                                       p < pmax; p++) {
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   886
              Node* mb = n->fast_out(p);
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   887
              assert(mb->is_Initialize() || !mb->is_MemBar() ||
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   888
                     mb->req() <= MemBarNode::Precedent ||
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   889
                     mb->in(MemBarNode::Precedent) != n,
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   890
                     "MemBarVolatile should be eliminated for non-escaping object");
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   891
            }
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
   892
#endif
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   893
            _igvn.replace_node(n, n->in(MemNode::Memory));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   894
          } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   895
            eliminate_card_mark(n);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   896
          }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   897
          k -= (oc2 - use->outcnt());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   898
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   899
      } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   900
        eliminate_card_mark(use);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   901
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   902
      j -= (oc1 - res->outcnt());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   903
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   904
    assert(res->outcnt() == 0, "all uses of allocated objects must be deleted");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   905
    _igvn.remove_dead_node(res);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   906
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   907
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   908
  //
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   909
  // Process other users of allocation's projections
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   910
  //
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   911
  if (_resproj != NULL && _resproj->outcnt() != 0) {
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   912
    // First disconnect stores captured by Initialize node.
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   913
    // If Initialize node is eliminated first in the following code,
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   914
    // it will kill such stores and DUIterator_Last will assert.
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   915
    for (DUIterator_Fast jmax, j = _resproj->fast_outs(jmax);  j < jmax; j++) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   916
      Node *use = _resproj->fast_out(j);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   917
      if (use->is_AddP()) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   918
        // raw memory addresses used only by the initialization
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   919
        _igvn.replace_node(use, C->top());
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   920
        --j; --jmax;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   921
      }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   922
    }
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   923
    for (DUIterator_Last jmin, j = _resproj->last_outs(jmin); j >= jmin; ) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   924
      Node *use = _resproj->last_out(j);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   925
      uint oc1 = _resproj->outcnt();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   926
      if (use->is_Initialize()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   927
        // Eliminate Initialize node.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   928
        InitializeNode *init = use->as_Initialize();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   929
        assert(init->outcnt() <= 2, "only a control and memory projection expected");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   930
        Node *ctrl_proj = init->proj_out(TypeFunc::Control);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   931
        if (ctrl_proj != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   932
           assert(init->in(TypeFunc::Control) == _fallthroughcatchproj, "allocation control projection");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   933
          _igvn.replace_node(ctrl_proj, _fallthroughcatchproj);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   934
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   935
        Node *mem_proj = init->proj_out(TypeFunc::Memory);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   936
        if (mem_proj != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   937
          Node *mem = init->in(TypeFunc::Memory);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   938
#ifdef ASSERT
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   939
          if (mem->is_MergeMem()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   940
            assert(mem->in(TypeFunc::Memory) == _memproj_fallthrough, "allocation memory projection");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   941
          } else {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   942
            assert(mem == _memproj_fallthrough, "allocation memory projection");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   943
          }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   944
#endif
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   945
          _igvn.replace_node(mem_proj, mem);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   946
        }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   947
      } else  {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   948
        assert(false, "only Initialize or AddP expected");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   949
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   950
      j -= (oc1 - _resproj->outcnt());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   951
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   952
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   953
  if (_fallthroughcatchproj != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   954
    _igvn.replace_node(_fallthroughcatchproj, alloc->in(TypeFunc::Control));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   955
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   956
  if (_memproj_fallthrough != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   957
    _igvn.replace_node(_memproj_fallthrough, alloc->in(TypeFunc::Memory));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   958
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   959
  if (_memproj_catchall != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   960
    _igvn.replace_node(_memproj_catchall, C->top());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   961
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   962
  if (_ioproj_fallthrough != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   963
    _igvn.replace_node(_ioproj_fallthrough, alloc->in(TypeFunc::I_O));
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   964
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   965
  if (_ioproj_catchall != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   966
    _igvn.replace_node(_ioproj_catchall, C->top());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   967
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   968
  if (_catchallcatchproj != NULL) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   969
    _igvn.replace_node(_catchallcatchproj, C->top());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   970
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   971
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   972
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   973
bool PhaseMacroExpand::eliminate_allocate_node(AllocateNode *alloc) {
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   974
  if (!EliminateAllocations || !alloc->_is_non_escaping) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   975
    return false;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   976
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   977
  Node* klass = alloc->in(AllocateNode::KlassNode);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   978
  const TypeKlassPtr* tklass = _igvn.type(klass)->is_klassptr();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   979
  Node* res = alloc->result_cast();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   980
  // Eliminate boxing allocations which are not used
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   981
  // regardless scalar replacable status.
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   982
  bool boxing_alloc = C->eliminate_boxing() &&
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   983
                      tklass->klass()->is_instance_klass()  &&
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   984
                      tklass->klass()->as_instance_klass()->is_box_klass();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   985
  if (!alloc->_is_scalar_replaceable && (!boxing_alloc || (res != NULL))) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   986
    return false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   987
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   988
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   989
  extract_call_projections(alloc);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   990
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   991
  GrowableArray <SafePointNode *> safepoints;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   992
  if (!can_eliminate_allocation(alloc, safepoints)) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   993
    return false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   994
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
   995
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   996
  if (!alloc->_is_scalar_replaceable) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   997
    assert(res == NULL, "sanity");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   998
    // We can only eliminate allocation if all debug info references
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
   999
    // are already replaced with SafePointScalarObject because
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1000
    // we can't search for a fields value without instance_id.
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1001
    if (safepoints.length() > 0) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1002
      return false;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1003
    }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1004
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1005
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1006
  if (!scalar_replacement(alloc, safepoints)) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1007
    return false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1008
  }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1009
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1010
  CompileLog* log = C->log();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1011
  if (log != NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1012
    log->head("eliminate_allocation type='%d'",
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1013
              log->identify(tklass->klass()));
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1014
    JVMState* p = alloc->jvms();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1015
    while (p != NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1016
      log->elem("jvms bci='%d' method='%d'", p->bci(), log->identify(p->method()));
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1017
      p = p->caller();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1018
    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1019
    log->tail("eliminate_allocation");
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1020
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1021
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1022
  process_users_of_allocation(alloc);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1023
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1024
#ifndef PRODUCT
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1025
  if (PrintEliminateAllocations) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1026
    if (alloc->is_AllocateArray())
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1027
      tty->print_cr("++++ Eliminated: %d AllocateArray", alloc->_idx);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1028
    else
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1029
      tty->print_cr("++++ Eliminated: %d Allocate", alloc->_idx);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  1030
  }
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1031
#endif
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1032
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1033
  return true;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1034
}
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  1035
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1036
bool PhaseMacroExpand::eliminate_boxing_node(CallStaticJavaNode *boxing) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1037
  // EA should remove all uses of non-escaping boxing node.
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1038
  if (!C->eliminate_boxing() || boxing->proj_out(TypeFunc::Parms) != NULL) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1039
    return false;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1040
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1041
25935
59b08808cb9c 8046698: assert(false) failed: only Initialize or AddP expected macro.cpp:943
roland
parents: 25926
diff changeset
  1042
  assert(boxing->result_cast() == NULL, "unexpected boxing node result");
59b08808cb9c 8046698: assert(false) failed: only Initialize or AddP expected macro.cpp:943
roland
parents: 25926
diff changeset
  1043
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1044
  extract_call_projections(boxing);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1045
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1046
  const TypeTuple* r = boxing->tf()->range();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1047
  assert(r->cnt() > TypeFunc::Parms, "sanity");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1048
  const TypeInstPtr* t = r->field_at(TypeFunc::Parms)->isa_instptr();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1049
  assert(t != NULL, "sanity");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1050
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1051
  CompileLog* log = C->log();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1052
  if (log != NULL) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1053
    log->head("eliminate_boxing type='%d'",
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1054
              log->identify(t->klass()));
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1055
    JVMState* p = boxing->jvms();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1056
    while (p != NULL) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1057
      log->elem("jvms bci='%d' method='%d'", p->bci(), log->identify(p->method()));
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1058
      p = p->caller();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1059
    }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1060
    log->tail("eliminate_boxing");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1061
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1062
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1063
  process_users_of_allocation(boxing);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1064
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1065
#ifndef PRODUCT
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1066
  if (PrintEliminateAllocations) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1067
    tty->print("++++ Eliminated: %d ", boxing->_idx);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1068
    boxing->method()->print_short_name(tty);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1069
    tty->cr();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1070
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1071
#endif
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1072
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1073
  return true;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  1074
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
//---------------------------set_eden_pointers-------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
void PhaseMacroExpand::set_eden_pointers(Node* &eden_top_adr, Node* &eden_end_adr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  if (UseTLAB) {                // Private allocation: load from TLS
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1079
    Node* thread = transform_later(new ThreadLocalNode());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
    int tlab_top_offset = in_bytes(JavaThread::tlab_top_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
    int tlab_end_offset = in_bytes(JavaThread::tlab_end_offset());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
    eden_top_adr = basic_plus_adr(top()/*not oop*/, thread, tlab_top_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
    eden_end_adr = basic_plus_adr(top()/*not oop*/, thread, tlab_end_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  } else {                      // Shared allocation: load from globals
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
    CollectedHeap* ch = Universe::heap();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
    address top_adr = (address)ch->top_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
    address end_adr = (address)ch->end_addr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
    eden_top_adr = makecon(TypeRawPtr::make(top_adr));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
    eden_end_adr = basic_plus_adr(eden_top_adr, end_adr - top_adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
Node* PhaseMacroExpand::make_load(Node* ctl, Node* mem, Node* base, int offset, const Type* value_type, BasicType bt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  Node* adr = basic_plus_adr(base, offset);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  1096
  const TypePtr* adr_type = adr->bottom_type()->is_ptr();
22845
d8812d0ff387 8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents: 19979
diff changeset
  1097
  Node* value = LoadNode::make(_igvn, ctl, mem, adr, adr_type, value_type, bt, MemNode::unordered);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  transform_later(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  return value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
Node* PhaseMacroExpand::make_store(Node* ctl, Node* mem, Node* base, int offset, Node* value, BasicType bt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
  Node* adr = basic_plus_adr(base, offset);
22845
d8812d0ff387 8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents: 19979
diff changeset
  1105
  mem = StoreNode::make(_igvn, ctl, mem, adr, NULL, value, bt, MemNode::unordered);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
  transform_later(mem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  return mem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
//                              A L L O C A T I O N
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
// Allocation attempts to be fast in the case of frequent small objects.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
// It breaks down like this:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
// 1) Size in doublewords is computed.  This is a constant for objects and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
// variable for most arrays.  Doubleword units are used to avoid size
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
// overflow of huge doubleword arrays.  We need doublewords in the end for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
// rounding.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
// 2) Size is checked for being 'too large'.  Too-large allocations will go
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
// the slow path into the VM.  The slow path can throw any required
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
// exceptions, and does all the special checks for very large arrays.  The
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
// size test can constant-fold away for objects.  For objects with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
// finalizers it constant-folds the otherway: you always go slow with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
// finalizers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
// 3) If NOT using TLABs, this is the contended loop-back point.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
// Load-Locked the heap top.  If using TLABs normal-load the heap top.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
// 4) Check that heap top + size*8 < max.  If we fail go the slow ` route.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
// NOTE: "top+size*8" cannot wrap the 4Gig line!  Here's why: for largish
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
// "size*8" we always enter the VM, where "largish" is a constant picked small
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
// enough that there's always space between the eden max and 4Gig (old space is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
// there so it's quite large) and large enough that the cost of entering the VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
// is dwarfed by the cost to initialize the space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
// 5) If NOT using TLABs, Store-Conditional the adjusted heap top back
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
// down.  If contended, repeat at step 3.  If using TLABs normal-store
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
// adjusted heap top back down; there is no contention.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
// 6) If !ZeroTLAB then Bulk-clear the object/array.  Fill in klass & mark
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
// fields.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
// 7) Merge with the slow-path; cast the raw memory pointer to the correct
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
// oop flavor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
// FastAllocateSizeLimit value is in DOUBLEWORDS.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
// Allocations bigger than this always go the slow route.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
// This value must be small enough that allocation attempts that need to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
// trigger exceptions go the slow route.  Also, it must be small enough so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
// that heap_top + size_in_bytes does not wrap around the 4Gig limit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
//=============================================================================j//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
// %%% Here is an old comment from parseHelper.cpp; is it outdated?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
// The allocator will coalesce int->oop copies away.  See comment in
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
// coalesce.cpp about how this works.  It depends critically on the exact
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
// code shape produced here, so if you are changing this code shape
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
// make sure the GC info for the heap-top is correct in and around the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
// slow-path call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
void PhaseMacroExpand::expand_allocate_common(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
            AllocateNode* alloc, // allocation node to be expanded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
            Node* length,  // array length for an array allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
            const TypeFunc* slow_call_type, // Type of slow call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
            address slow_call_address  // Address of slow call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
    )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  Node* ctrl = alloc->in(TypeFunc::Control);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  Node* mem  = alloc->in(TypeFunc::Memory);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
  Node* i_o  = alloc->in(TypeFunc::I_O);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  Node* size_in_bytes     = alloc->in(AllocateNode::AllocSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
  Node* klass_node        = alloc->in(AllocateNode::KlassNode);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  Node* initial_slow_test = alloc->in(AllocateNode::InitialTest);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
  assert(ctrl != NULL, "must have control");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
  // We need a Region and corresponding Phi's to merge the slow-path and fast-path results.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
  // they will not be used if "always_slow" is set
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  enum { slow_result_path = 1, fast_result_path = 2 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  Node *result_region;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  Node *result_phi_rawmem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  Node *result_phi_rawoop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
  Node *result_phi_i_o;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  // The initial slow comparison is a size check, the comparison
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  // we want to do is a BoolTest::gt
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  bool always_slow = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
  int tv = _igvn.find_int_con(initial_slow_test, -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
  if (tv >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
    always_slow = (tv == 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
    initial_slow_test = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
    initial_slow_test = BoolNode::make_predicate(initial_slow_test, &_igvn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2532
diff changeset
  1199
  if (C->env()->dtrace_alloc_probes() ||
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1200
      !UseTLAB && (!Universe::heap()->supports_inline_contig_alloc() ||
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1201
                   (UseConcMarkSweepGC && CMSIncrementalMode))) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
    // Force slow-path allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
    always_slow = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
    initial_slow_test = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1207
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  enum { too_big_or_final_path = 1, need_gc_path = 2 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
  Node *slow_region = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  Node *toobig_false = ctrl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
  assert (initial_slow_test == NULL || !always_slow, "arguments must be consistent");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  // generate the initial test if necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
  if (initial_slow_test != NULL ) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1215
    slow_region = new RegionNode(3);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
    // Now make the initial failure test.  Usually a too-big test but
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
    // might be a TRUE for finalizers or a fancy class check for
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
    // newInstance0.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1220
    IfNode *toobig_iff = new IfNode(ctrl, initial_slow_test, PROB_MIN, COUNT_UNKNOWN);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
    transform_later(toobig_iff);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
    // Plug the failing-too-big test into the slow-path region
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1223
    Node *toobig_true = new IfTrueNode( toobig_iff );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
    transform_later(toobig_true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
    slow_region    ->init_req( too_big_or_final_path, toobig_true );
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1226
    toobig_false = new IfFalseNode( toobig_iff );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
    transform_later(toobig_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
  } else {         // No initial test, just fall into next case
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
    toobig_false = ctrl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
    debug_only(slow_region = NodeSentinel);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  Node *slow_mem = mem;  // save the current memory state for slow path
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  // generate the fast allocation code unless we know that the initial test will always go slow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  if (!always_slow) {
2029
4ba79339bc0c 6799693: Server compiler leads to data corruption when expression throws an Exception
kvn
parents: 1677
diff changeset
  1236
    // Fast path modifies only raw memory.
4ba79339bc0c 6799693: Server compiler leads to data corruption when expression throws an Exception
kvn
parents: 1677
diff changeset
  1237
    if (mem->is_MergeMem()) {
4ba79339bc0c 6799693: Server compiler leads to data corruption when expression throws an Exception
kvn
parents: 1677
diff changeset
  1238
      mem = mem->as_MergeMem()->memory_at(Compile::AliasIdxRaw);
4ba79339bc0c 6799693: Server compiler leads to data corruption when expression throws an Exception
kvn
parents: 1677
diff changeset
  1239
    }
4ba79339bc0c 6799693: Server compiler leads to data corruption when expression throws an Exception
kvn
parents: 1677
diff changeset
  1240
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1241
    Node* eden_top_adr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1242
    Node* eden_end_adr;
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1243
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1244
    set_eden_pointers(eden_top_adr, eden_end_adr);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1245
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1246
    // Load Eden::end.  Loop invariant and hoisted.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1247
    //
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1248
    // Note: We set the control input on "eden_end" and "old_eden_top" when using
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1249
    //       a TLAB to work around a bug where these values were being moved across
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1250
    //       a safepoint.  These are not oops, so they cannot be include in the oop
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1251
    //       map, but they can be changed by a GC.   The proper way to fix this would
1374
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1252
    //       be to set the raw memory state when generating a  SafepointNode.  However
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1253
    //       this will require extensive changes to the loop optimization in order to
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1254
    //       prevent a degradation of the optimization.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1255
    //       See comment in memnode.hpp, around line 227 in class LoadPNode.
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1256
    Node *eden_end = make_load(ctrl, mem, eden_end_adr, 0, TypeRawPtr::BOTTOM, T_ADDRESS);
4c24294029a9 6711316: Open source the Garbage-First garbage collector
ysr
parents: 371
diff changeset
  1257
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
    // allocate the Region and Phi nodes for the result
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1259
    result_region = new RegionNode(3);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1260
    result_phi_rawmem = new PhiNode(result_region, Type::MEMORY, TypeRawPtr::BOTTOM);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1261
    result_phi_rawoop = new PhiNode(result_region, TypeRawPtr::BOTTOM);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1262
    result_phi_i_o    = new PhiNode(result_region, Type::ABIO); // I/O is used for Prefetch
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
    // We need a Region for the loop-back contended case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
    enum { fall_in_path = 1, contended_loopback_path = 2 };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
    Node *contended_region;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
    Node *contended_phi_rawmem;
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1268
    if (UseTLAB) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
      contended_region = toobig_false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
      contended_phi_rawmem = mem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
    } else {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1272
      contended_region = new RegionNode(3);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1273
      contended_phi_rawmem = new PhiNode(contended_region, Type::MEMORY, TypeRawPtr::BOTTOM);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
      // Now handle the passing-too-big test.  We fall into the contended
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
      // loop-back merge point.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1276
      contended_region    ->init_req(fall_in_path, toobig_false);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1277
      contended_phi_rawmem->init_req(fall_in_path, mem);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
      transform_later(contended_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
      transform_later(contended_phi_rawmem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
    // Load(-locked) the heap top.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
    // See note above concerning the control input when using a TLAB
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
    Node *old_eden_top = UseTLAB
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1285
      ? new LoadPNode      (ctrl, contended_phi_rawmem, eden_top_adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, MemNode::unordered)
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1286
      : new LoadPLockedNode(contended_region, contended_phi_rawmem, eden_top_adr, MemNode::acquire);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
    transform_later(old_eden_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
    // Add to heap top to get a new heap top
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1290
    Node *new_eden_top = new AddPNode(top(), old_eden_top, size_in_bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
    transform_later(new_eden_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
    // Check for needing a GC; compare against heap end
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1293
    Node *needgc_cmp = new CmpPNode(new_eden_top, eden_end);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
    transform_later(needgc_cmp);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1295
    Node *needgc_bol = new BoolNode(needgc_cmp, BoolTest::ge);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
    transform_later(needgc_bol);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1297
    IfNode *needgc_iff = new IfNode(contended_region, needgc_bol, PROB_UNLIKELY_MAG(4), COUNT_UNKNOWN);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
    transform_later(needgc_iff);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
    // Plug the failing-heap-space-need-gc test into the slow-path region
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1301
    Node *needgc_true = new IfTrueNode(needgc_iff);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
    transform_later(needgc_true);
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1303
    if (initial_slow_test) {
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1304
      slow_region->init_req(need_gc_path, needgc_true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
      // This completes all paths into the slow merge point
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
      transform_later(slow_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
    } else {                      // No initial slow path needed!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
      // Just fall from the need-GC path straight into the VM call.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1309
      slow_region = needgc_true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
    // No need for a GC.  Setup for the Store-Conditional
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1312
    Node *needgc_false = new IfFalseNode(needgc_iff);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
    transform_later(needgc_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
    // Grab regular I/O before optional prefetch may change it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
    // Slow-path does no I/O so just set it to the original I/O.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1317
    result_phi_i_o->init_req(slow_result_path, i_o);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
    i_o = prefetch_allocation(i_o, needgc_false, contended_phi_rawmem,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
                              old_eden_top, new_eden_top, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1322
    // Name successful fast-path variables
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1323
    Node* fast_oop = old_eden_top;
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1324
    Node* fast_oop_ctrl;
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1325
    Node* fast_oop_rawmem;
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1326
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
    // Store (-conditional) the modified eden top back down.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
    // StorePConditional produces flags for a test PLUS a modified raw
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
    // memory state.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1330
    if (UseTLAB) {
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1331
      Node* store_eden_top =
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1332
        new StorePNode(needgc_false, contended_phi_rawmem, eden_top_adr,
22845
d8812d0ff387 8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents: 19979
diff changeset
  1333
                              TypeRawPtr::BOTTOM, new_eden_top, MemNode::unordered);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
      transform_later(store_eden_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
      fast_oop_ctrl = needgc_false; // No contention, so this is the fast path
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1336
      fast_oop_rawmem = store_eden_top;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
    } else {
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1338
      Node* store_eden_top =
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1339
        new StorePConditionalNode(needgc_false, contended_phi_rawmem, eden_top_adr,
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1340
                                         new_eden_top, fast_oop/*old_eden_top*/);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
      transform_later(store_eden_top);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1342
      Node *contention_check = new BoolNode(store_eden_top, BoolTest::ne);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
      transform_later(contention_check);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1344
      store_eden_top = new SCMemProjNode(store_eden_top);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
      transform_later(store_eden_top);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
      // If not using TLABs, check to see if there was contention.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1348
      IfNode *contention_iff = new IfNode (needgc_false, contention_check, PROB_MIN, COUNT_UNKNOWN);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
      transform_later(contention_iff);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1350
      Node *contention_true = new IfTrueNode(contention_iff);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
      transform_later(contention_true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
      // If contention, loopback and try again.
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1353
      contended_region->init_req(contended_loopback_path, contention_true);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1354
      contended_phi_rawmem->init_req(contended_loopback_path, store_eden_top);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
      // Fast-path succeeded with no contention!
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1357
      Node *contention_false = new IfFalseNode(contention_iff);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
      transform_later(contention_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
      fast_oop_ctrl = contention_false;
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1360
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1361
      // Bump total allocated bytes for this thread
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1362
      Node* thread = new ThreadLocalNode();
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1363
      transform_later(thread);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1364
      Node* alloc_bytes_adr = basic_plus_adr(top()/*not oop*/, thread,
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1365
                                             in_bytes(JavaThread::allocated_bytes_offset()));
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1366
      Node* alloc_bytes = make_load(fast_oop_ctrl, store_eden_top, alloc_bytes_adr,
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1367
                                    0, TypeLong::LONG, T_LONG);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1368
#ifdef _LP64
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1369
      Node* alloc_size = size_in_bytes;
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1370
#else
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1371
      Node* alloc_size = new ConvI2LNode(size_in_bytes);
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1372
      transform_later(alloc_size);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1373
#endif
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1374
      Node* new_alloc_bytes = new AddLNode(alloc_bytes, alloc_size);
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1375
      transform_later(new_alloc_bytes);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1376
      fast_oop_rawmem = make_store(fast_oop_ctrl, store_eden_top, alloc_bytes_adr,
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1377
                                   0, new_alloc_bytes, T_LONG);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1380
    InitializeNode* init = alloc->initialization();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
    fast_oop_rawmem = initialize_object(alloc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
                                        fast_oop_ctrl, fast_oop_rawmem, fast_oop,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
                                        klass_node, length, size_in_bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1385
    // If initialization is performed by an array copy, any required
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1386
    // MemBarStoreStore was already added. If the object does not
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1387
    // escape no need for a MemBarStoreStore. Otherwise we need a
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1388
    // MemBarStoreStore so that stores that initialize this object
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1389
    // can't be reordered with a subsequent store that makes this
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1390
    // object accessible by other threads.
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1391
    if (init == NULL || (!init->is_complete_with_arraycopy() && !init->does_not_escape())) {
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1392
      if (init == NULL || init->req() < InitializeNode::RawStores) {
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1393
        // No InitializeNode or no stores captured by zeroing
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1394
        // elimination. Simply add the MemBarStoreStore after object
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1395
        // initialization.
15874
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15242
diff changeset
  1396
        MemBarNode* mb = MemBarNode::make(C, Op_MemBarStoreStore, Compile::AliasIdxBot);
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1397
        transform_later(mb);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1398
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1399
        mb->init_req(TypeFunc::Memory, fast_oop_rawmem);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1400
        mb->init_req(TypeFunc::Control, fast_oop_ctrl);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1401
        fast_oop_ctrl = new ProjNode(mb,TypeFunc::Control);
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1402
        transform_later(fast_oop_ctrl);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1403
        fast_oop_rawmem = new ProjNode(mb,TypeFunc::Memory);
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1404
        transform_later(fast_oop_rawmem);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1405
      } else {
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1406
        // Add the MemBarStoreStore after the InitializeNode so that
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1407
        // all stores performing the initialization that were moved
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1408
        // before the InitializeNode happen before the storestore
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1409
        // barrier.
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1410
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1411
        Node* init_ctrl = init->proj_out(TypeFunc::Control);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1412
        Node* init_mem = init->proj_out(TypeFunc::Memory);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1413
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1414
        MemBarNode* mb = MemBarNode::make(C, Op_MemBarStoreStore, Compile::AliasIdxBot);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1415
        transform_later(mb);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1416
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1417
        Node* ctrl = new ProjNode(init,TypeFunc::Control);
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1418
        transform_later(ctrl);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1419
        Node* mem = new ProjNode(init,TypeFunc::Memory);
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1420
        transform_later(mem);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1421
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1422
        // The MemBarStoreStore depends on control and memory coming
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1423
        // from the InitializeNode
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1424
        mb->init_req(TypeFunc::Memory, mem);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1425
        mb->init_req(TypeFunc::Control, ctrl);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1426
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1427
        ctrl = new ProjNode(mb,TypeFunc::Control);
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1428
        transform_later(ctrl);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1429
        mem = new ProjNode(mb,TypeFunc::Memory);
11431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1430
        transform_later(mem);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1431
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1432
        // All nodes that depended on the InitializeNode for control
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1433
        // and memory must now depend on the MemBarNode that itself
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1434
        // depends on the InitializeNode
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1435
        _igvn.replace_node(init_ctrl, ctrl);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1436
        _igvn.replace_node(init_mem, mem);
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1437
      }
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1438
    }
5ca3a19e559a 7121140: Allocation paths require explicit memory synchronization operations for RMO systems
roland
parents: 11430
diff changeset
  1439
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2532
diff changeset
  1440
    if (C->env()->dtrace_extended_probes()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
      // Slow-path call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
      int size = TypeFunc::Parms + 2;
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1443
      CallLeafNode *call = new CallLeafNode(OptoRuntime::dtrace_object_alloc_Type(),
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1444
                                            CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc_base),
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1445
                                            "dtrace_object_alloc",
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1446
                                            TypeRawPtr::BOTTOM);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
      // Get base of thread-local storage area
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1449
      Node* thread = new ThreadLocalNode();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
      transform_later(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
      call->init_req(TypeFunc::Parms+0, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
      call->init_req(TypeFunc::Parms+1, fast_oop);
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1454
      call->init_req(TypeFunc::Control, fast_oop_ctrl);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1455
      call->init_req(TypeFunc::I_O    , top()); // does no i/o
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1456
      call->init_req(TypeFunc::Memory , fast_oop_rawmem);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1457
      call->init_req(TypeFunc::ReturnAdr, alloc->in(TypeFunc::ReturnAdr));
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1458
      call->init_req(TypeFunc::FramePtr, alloc->in(TypeFunc::FramePtr));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
      transform_later(call);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1460
      fast_oop_ctrl = new ProjNode(call,TypeFunc::Control);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1461
      transform_later(fast_oop_ctrl);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1462
      fast_oop_rawmem = new ProjNode(call,TypeFunc::Memory);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
      transform_later(fast_oop_rawmem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1466
    // Plug in the successful fast-path into the result merge point
7724
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1467
    result_region    ->init_req(fast_result_path, fast_oop_ctrl);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1468
    result_phi_rawoop->init_req(fast_result_path, fast_oop);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1469
    result_phi_i_o   ->init_req(fast_result_path, i_o);
a92d706dbdd5 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 7397
diff changeset
  1470
    result_phi_rawmem->init_req(fast_result_path, fast_oop_rawmem);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
    slow_region = ctrl;
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1473
    result_phi_i_o = i_o; // Rename it to use in the following code.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1474
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1476
  // Generate slow-path call
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1477
  CallNode *call = new CallStaticJavaNode(slow_call_type, slow_call_address,
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 13728
diff changeset
  1478
                               OptoRuntime::stub_name(slow_call_address),
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 13728
diff changeset
  1479
                               alloc->jvms()->bci(),
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 13728
diff changeset
  1480
                               TypePtr::BOTTOM);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1481
  call->init_req( TypeFunc::Control, slow_region );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1482
  call->init_req( TypeFunc::I_O    , top() )     ;   // does no i/o
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1483
  call->init_req( TypeFunc::Memory , slow_mem ); // may gc ptrs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1484
  call->init_req( TypeFunc::ReturnAdr, alloc->in(TypeFunc::ReturnAdr) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
  call->init_req( TypeFunc::FramePtr, alloc->in(TypeFunc::FramePtr) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
  call->init_req(TypeFunc::Parms+0, klass_node);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
  if (length != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1489
    call->init_req(TypeFunc::Parms+1, length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1491
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1492
  // Copy debug information and adjust JVMState information, then replace
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1493
  // allocate node with the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
  copy_call_debug_info((CallNode *) alloc,  call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1495
  if (!always_slow) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
    call->set_cnt(PROB_UNLIKELY_MAG(4));  // Same effect as RC_UNCOMMON.
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1497
  } else {
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1498
    // Hook i_o projection to avoid its elimination during allocation
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1499
    // replacement (when only a slow call is generated).
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1500
    call->set_req(TypeFunc::I_O, result_phi_i_o);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
  }
5901
c046f8e9c52b 6677629: PhaseIterGVN::subsume_node() should call hash_delete() and add_users_to_worklist()
kvn
parents: 5889
diff changeset
  1502
  _igvn.replace_node(alloc, call);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1503
  transform_later(call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1504
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1505
  // Identify the output projections from the allocate node and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1506
  // adjust any references to them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1507
  // The control and io projections look like:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1508
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
  //        v---Proj(ctrl) <-----+   v---CatchProj(ctrl)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
  //  Allocate                   Catch
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
  //        ^---Proj(io) <-------+   ^---CatchProj(io)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
  //  We are interested in the CatchProj nodes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
  extract_call_projections(call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1517
  // An allocate node has separate memory projections for the uses on
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1518
  // the control and i_o paths. Replace the control memory projection with
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1519
  // result_phi_rawmem (unless we are only generating a slow call when
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1520
  // both memory projections are combined)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
  if (!always_slow && _memproj_fallthrough != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
    for (DUIterator_Fast imax, i = _memproj_fallthrough->fast_outs(imax); i < imax; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
      Node *use = _memproj_fallthrough->fast_out(i);
12958
009b6c9586d8 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node*, int, Node*) where applicable
kvn
parents: 11724
diff changeset
  1524
      _igvn.rehash_node_delayed(use);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
      imax -= replace_input(use, _memproj_fallthrough, result_phi_rawmem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
      // back up iterator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
      --i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
  }
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1530
  // Now change uses of _memproj_catchall to use _memproj_fallthrough and delete
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1531
  // _memproj_catchall so we end up with a call that has only 1 memory projection.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
  if (_memproj_catchall != NULL ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
    if (_memproj_fallthrough == NULL) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1534
      _memproj_fallthrough = new ProjNode(call, TypeFunc::Memory);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
      transform_later(_memproj_fallthrough);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    for (DUIterator_Fast imax, i = _memproj_catchall->fast_outs(imax); i < imax; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
      Node *use = _memproj_catchall->fast_out(i);
12958
009b6c9586d8 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node*, int, Node*) where applicable
kvn
parents: 11724
diff changeset
  1539
      _igvn.rehash_node_delayed(use);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
      imax -= replace_input(use, _memproj_catchall, _memproj_fallthrough);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
      // back up iterator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
      --i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
    }
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1544
    assert(_memproj_catchall->outcnt() == 0, "all uses must be deleted");
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1545
    _igvn.remove_dead_node(_memproj_catchall);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1548
  // An allocate node has separate i_o projections for the uses on the control
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1549
  // and i_o paths. Always replace the control i_o projection with result i_o
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1550
  // otherwise incoming i_o become dead when only a slow call is generated
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1551
  // (it is different from memory projections where both projections are
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1552
  // combined in such case).
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1553
  if (_ioproj_fallthrough != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
    for (DUIterator_Fast imax, i = _ioproj_fallthrough->fast_outs(imax); i < imax; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
      Node *use = _ioproj_fallthrough->fast_out(i);
12958
009b6c9586d8 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node*, int, Node*) where applicable
kvn
parents: 11724
diff changeset
  1556
      _igvn.rehash_node_delayed(use);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
      imax -= replace_input(use, _ioproj_fallthrough, result_phi_i_o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
      // back up iterator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
      --i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
  }
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1562
  // Now change uses of _ioproj_catchall to use _ioproj_fallthrough and delete
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1563
  // _ioproj_catchall so we end up with a call that has only 1 i_o projection.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
  if (_ioproj_catchall != NULL ) {
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1565
    if (_ioproj_fallthrough == NULL) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1566
      _ioproj_fallthrough = new ProjNode(call, TypeFunc::I_O);
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1567
      transform_later(_ioproj_fallthrough);
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1568
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
    for (DUIterator_Fast imax, i = _ioproj_catchall->fast_outs(imax); i < imax; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
      Node *use = _ioproj_catchall->fast_out(i);
12958
009b6c9586d8 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node*, int, Node*) where applicable
kvn
parents: 11724
diff changeset
  1571
      _igvn.rehash_node_delayed(use);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
      imax -= replace_input(use, _ioproj_catchall, _ioproj_fallthrough);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
      // back up iterator
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
      --i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
    }
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1576
    assert(_ioproj_catchall->outcnt() == 0, "all uses must be deleted");
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1577
    _igvn.remove_dead_node(_ioproj_catchall);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
  // if we generated only a slow call, we are done
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1581
  if (always_slow) {
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1582
    // Now we can unhook i_o.
11437
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1583
    if (result_phi_i_o->outcnt() > 1) {
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1584
      call->set_req(TypeFunc::I_O, top());
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1585
    } else {
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1586
      assert(result_phi_i_o->unique_ctrl_out() == call, "");
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1587
      // Case of new array with negative size known during compilation.
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1588
      // AllocateArrayNode::Ideal() optimization disconnect unreachable
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1589
      // following code since call to runtime will throw exception.
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1590
      // As result there will be no users of i_o after the call.
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1591
      // Leave i_o attached to this call to avoid problems in preceding graph.
2fa33fde54b9 7125879: assert(proj != NULL) failed: must be found
kvn
parents: 11435
diff changeset
  1592
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
    return;
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11431
diff changeset
  1594
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
  if (_fallthroughcatchproj != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
    ctrl = _fallthroughcatchproj->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
    transform_later(ctrl);
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  1600
    _igvn.replace_node(_fallthroughcatchproj, result_region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
    ctrl = top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
  Node *slow_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
  if (_resproj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
    // no uses of the allocation result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
    slow_result = top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
    slow_result = _resproj->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
    transform_later(slow_result);
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  1611
    _igvn.replace_node(_resproj, result_phi_rawoop);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  // Plug slow-path into result merge point
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1615
  result_region    ->init_req( slow_result_path, ctrl );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
  result_phi_rawoop->init_req( slow_result_path, slow_result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
  result_phi_rawmem->init_req( slow_result_path, _memproj_fallthrough );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1618
  transform_later(result_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1619
  transform_later(result_phi_rawoop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
  transform_later(result_phi_rawmem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  transform_later(result_phi_i_o);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
  // This completes all paths into the result merge point
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1626
// Helper for PhaseMacroExpand::expand_allocate_common.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1627
// Initializes the newly-allocated storage.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1628
Node*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1629
PhaseMacroExpand::initialize_object(AllocateNode* alloc,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1630
                                    Node* control, Node* rawmem, Node* object,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1631
                                    Node* klass_node, Node* length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
                                    Node* size_in_bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
  InitializeNode* init = alloc->initialization();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
  // Store the klass & mark bits
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
  Node* mark_node = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
  // For now only enable fast locking for non-array types
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
  if (UseBiasedLocking && (length == NULL)) {
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11191
diff changeset
  1638
    mark_node = make_load(control, rawmem, klass_node, in_bytes(Klass::prototype_header_offset()), TypeRawPtr::BOTTOM, T_ADDRESS);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
    mark_node = makecon(TypeRawPtr::make((address)markOopDesc::prototype()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
  rawmem = make_store(control, rawmem, object, oopDesc::mark_offset_in_bytes(), mark_node, T_ADDRESS);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 246
diff changeset
  1643
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1644
  rawmem = make_store(control, rawmem, object, oopDesc::klass_offset_in_bytes(), klass_node, T_METADATA);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
  int header_size = alloc->minimum_header_size();  // conservatively small
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
  // Array length
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
  if (length != NULL) {         // Arrays need length field
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
    rawmem = make_store(control, rawmem, object, arrayOopDesc::length_offset_in_bytes(), length, T_INT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
    // conservatively small header size:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 246
diff changeset
  1651
    header_size = arrayOopDesc::base_offset_in_bytes(T_BYTE);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
    ciKlass* k = _igvn.type(klass_node)->is_klassptr()->klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
    if (k->is_array_klass())    // we know the exact header size in most cases:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
      header_size = Klass::layout_helper_header_size(k->layout_helper());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
  // Clear the object body, if necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
  if (init == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
    // The init has somehow disappeared; be cautious and clear everything.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
    // This can happen if a node is allocated but an uncommon trap occurs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
    // immediately.  In this case, the Initialize gets associated with the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
    // trap, and may be placed in a different (outer) loop, if the Allocate
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
    // is in a loop.  If (this is rare) the inner loop gets unrolled, then
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
    // there can be two Allocates to one Initialize.  The answer in all these
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
    // edge cases is safety first.  It is always safe to clear immediately
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
    // within an Allocate, and then (maybe or maybe not) clear some more later.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
    if (!ZeroTLAB)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
      rawmem = ClearArrayNode::clear_memory(control, rawmem, object,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
                                            header_size, size_in_bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
                                            &_igvn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
    if (!init->is_complete()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
      // Try to win by zeroing only what the init does not store.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
      // We can also try to do some peephole optimizations,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
      // such as combining some adjacent subword stores.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
      rawmem = init->complete_stores(control, rawmem, object,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
                                     header_size, size_in_bytes, &_igvn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
    // We have no more use for this link, since the AllocateNode goes away:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
    init->set_req(InitializeNode::RawAddress, top());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
    // (If we keep the link, it just confuses the register allocator,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
    // who thinks he sees a real use of the address by the membar.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  return rawmem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
// Generate prefetch instructions for next allocations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
Node* PhaseMacroExpand::prefetch_allocation(Node* i_o, Node*& needgc_false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
                                        Node*& contended_phi_rawmem,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
                                        Node* old_eden_top, Node* new_eden_top,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
                                        Node* length) {
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1694
   enum { fall_in_path = 1, pf_path = 2 };
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
   if( UseTLAB && AllocatePrefetchStyle == 2 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
      // Generate prefetch allocation with watermark check.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
      // As an allocation hits the watermark, we will prefetch starting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
      // at a "distance" away from watermark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1700
      Node *pf_region = new RegionNode(3);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1701
      Node *pf_phi_rawmem = new PhiNode( pf_region, Type::MEMORY,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
                                                TypeRawPtr::BOTTOM );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
      // I/O is used for Prefetch
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1704
      Node *pf_phi_abio = new PhiNode( pf_region, Type::ABIO );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1706
      Node *thread = new ThreadLocalNode();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
      transform_later(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1709
      Node *eden_pf_adr = new AddPNode( top()/*not oop*/, thread,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
                   _igvn.MakeConX(in_bytes(JavaThread::tlab_pf_top_offset())) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
      transform_later(eden_pf_adr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1713
      Node *old_pf_wm = new LoadPNode(needgc_false,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
                                   contended_phi_rawmem, eden_pf_adr,
22845
d8812d0ff387 8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents: 19979
diff changeset
  1715
                                   TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM,
d8812d0ff387 8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents: 19979
diff changeset
  1716
                                   MemNode::unordered);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1717
      transform_later(old_pf_wm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
      // check against new_eden_top
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1720
      Node *need_pf_cmp = new CmpPNode( new_eden_top, old_pf_wm );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
      transform_later(need_pf_cmp);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1722
      Node *need_pf_bol = new BoolNode( need_pf_cmp, BoolTest::ge );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
      transform_later(need_pf_bol);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1724
      IfNode *need_pf_iff = new IfNode( needgc_false, need_pf_bol,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
                                       PROB_UNLIKELY_MAG(4), COUNT_UNKNOWN );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
      transform_later(need_pf_iff);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
      // true node, add prefetchdistance
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1729
      Node *need_pf_true = new IfTrueNode( need_pf_iff );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
      transform_later(need_pf_true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1732
      Node *need_pf_false = new IfFalseNode( need_pf_iff );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
      transform_later(need_pf_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1735
      Node *new_pf_wmt = new AddPNode( top(), old_pf_wm,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
                                    _igvn.MakeConX(AllocatePrefetchDistance) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
      transform_later(new_pf_wmt );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
      new_pf_wmt->set_req(0, need_pf_true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1740
      Node *store_new_wmt = new StorePNode(need_pf_true,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
                                       contended_phi_rawmem, eden_pf_adr,
22845
d8812d0ff387 8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents: 19979
diff changeset
  1742
                                       TypeRawPtr::BOTTOM, new_pf_wmt,
d8812d0ff387 8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents: 19979
diff changeset
  1743
                                       MemNode::unordered);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
      transform_later(store_new_wmt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1745
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1746
      // adding prefetches
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1747
      pf_phi_abio->init_req( fall_in_path, i_o );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1748
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1749
      Node *prefetch_adr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1750
      Node *prefetch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1751
      uint lines = AllocatePrefetchDistance / AllocatePrefetchStepSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1752
      uint step_size = AllocatePrefetchStepSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1753
      uint distance = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1754
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
      for ( uint i = 0; i < lines; i++ ) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1756
        prefetch_adr = new AddPNode( old_pf_wm, new_pf_wmt,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
                                            _igvn.MakeConX(distance) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1758
        transform_later(prefetch_adr);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1759
        prefetch = new PrefetchAllocationNode( i_o, prefetch_adr );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1760
        transform_later(prefetch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
        distance += step_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1762
        i_o = prefetch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
      pf_phi_abio->set_req( pf_path, i_o );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
      pf_region->init_req( fall_in_path, need_pf_false );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
      pf_region->init_req( pf_path, need_pf_true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1769
      pf_phi_rawmem->init_req( fall_in_path, contended_phi_rawmem );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
      pf_phi_rawmem->init_req( pf_path, store_new_wmt );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
      transform_later(pf_region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1773
      transform_later(pf_phi_rawmem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
      transform_later(pf_phi_abio);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
      needgc_false = pf_region;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
      contended_phi_rawmem = pf_phi_rawmem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
      i_o = pf_phi_abio;
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1779
   } else if( UseTLAB && AllocatePrefetchStyle == 3 ) {
10267
8bdeec886dc4 7079329: Adjust allocation prefetching for T4
kvn
parents: 10262
diff changeset
  1780
      // Insert a prefetch for each allocation.
8bdeec886dc4 7079329: Adjust allocation prefetching for T4
kvn
parents: 10262
diff changeset
  1781
      // This code is used for Sparc with BIS.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1782
      Node *pf_region = new RegionNode(3);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1783
      Node *pf_phi_rawmem = new PhiNode( pf_region, Type::MEMORY,
13895
f6dfe4123709 7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents: 13728
diff changeset
  1784
                                             TypeRawPtr::BOTTOM );
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 24923
diff changeset
  1785
      transform_later(pf_region);
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1786
10267
8bdeec886dc4 7079329: Adjust allocation prefetching for T4
kvn
parents: 10262
diff changeset
  1787
      // Generate several prefetch instructions.
8bdeec886dc4 7079329: Adjust allocation prefetching for T4
kvn
parents: 10262
diff changeset
  1788
      uint lines = (length != NULL) ? AllocatePrefetchLines : AllocateInstancePrefetchLines;
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1789
      uint step_size = AllocatePrefetchStepSize;
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1790
      uint distance = AllocatePrefetchDistance;
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1791
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1792
      // Next cache address.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1793
      Node *cache_adr = new AddPNode(old_eden_top, old_eden_top,
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1794
                                            _igvn.MakeConX(distance));
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1795
      transform_later(cache_adr);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1796
      cache_adr = new CastP2XNode(needgc_false, cache_adr);
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1797
      transform_later(cache_adr);
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1798
      Node* mask = _igvn.MakeConX(~(intptr_t)(step_size-1));
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1799
      cache_adr = new AndXNode(cache_adr, mask);
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1800
      transform_later(cache_adr);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1801
      cache_adr = new CastX2PNode(cache_adr);
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1802
      transform_later(cache_adr);
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1803
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1804
      // Prefetch
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1805
      Node *prefetch = new PrefetchAllocationNode( contended_phi_rawmem, cache_adr );
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1806
      prefetch->set_req(0, needgc_false);
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1807
      transform_later(prefetch);
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1808
      contended_phi_rawmem = prefetch;
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1809
      Node *prefetch_adr;
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1810
      distance = step_size;
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1811
      for ( uint i = 1; i < lines; i++ ) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1812
        prefetch_adr = new AddPNode( cache_adr, cache_adr,
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1813
                                            _igvn.MakeConX(distance) );
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1814
        transform_later(prefetch_adr);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1815
        prefetch = new PrefetchAllocationNode( contended_phi_rawmem, prefetch_adr );
5251
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1816
        transform_later(prefetch);
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1817
        distance += step_size;
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1818
        contended_phi_rawmem = prefetch;
f86f7a86d761 6940726: Use BIS instruction for allocation prefetch on Sparc
kvn
parents: 4470
diff changeset
  1819
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
   } else if( AllocatePrefetchStyle > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
      // Insert a prefetch for each allocation only on the fast-path
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
      Node *prefetch_adr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
      Node *prefetch;
10267
8bdeec886dc4 7079329: Adjust allocation prefetching for T4
kvn
parents: 10262
diff changeset
  1824
      // Generate several prefetch instructions.
8bdeec886dc4 7079329: Adjust allocation prefetching for T4
kvn
parents: 10262
diff changeset
  1825
      uint lines = (length != NULL) ? AllocatePrefetchLines : AllocateInstancePrefetchLines;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
      uint step_size = AllocatePrefetchStepSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
      uint distance = AllocatePrefetchDistance;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
      for ( uint i = 0; i < lines; i++ ) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1829
        prefetch_adr = new AddPNode( old_eden_top, new_eden_top,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
                                            _igvn.MakeConX(distance) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
        transform_later(prefetch_adr);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  1832
        prefetch = new PrefetchAllocationNode( i_o, prefetch_adr );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1833
        // Do not let it float too high, since if eden_top == eden_end,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
        // both might be null.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
        if( i == 0 ) { // Set control for first prefetch, next follows it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
          prefetch->init_req(0, needgc_false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
        transform_later(prefetch);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
        distance += step_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
        i_o = prefetch;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
   return i_o;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
void PhaseMacroExpand::expand_allocate(AllocateNode *alloc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
  expand_allocate_common(alloc, NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
                         OptoRuntime::new_instance_Type(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
                         OptoRuntime::new_instance_Java());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
void PhaseMacroExpand::expand_allocate_array(AllocateArrayNode *alloc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
  Node* length = alloc->in(AllocateNode::ALength);
10566
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1855
  InitializeNode* init = alloc->initialization();
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1856
  Node* klass_node = alloc->in(AllocateNode::KlassNode);
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1857
  ciKlass* k = _igvn.type(klass_node)->is_klassptr()->klass();
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1858
  address slow_call_address;  // Address of slow call
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1859
  if (init != NULL && init->is_complete_with_arraycopy() &&
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1860
      k->is_type_array_klass()) {
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1861
    // Don't zero type array during slow allocation in VM since
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1862
    // it will be initialized later by arraycopy in compiled code.
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1863
    slow_call_address = OptoRuntime::new_array_nozero_Java();
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1864
  } else {
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1865
    slow_call_address = OptoRuntime::new_array_Java();
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1866
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
  expand_allocate_common(alloc, length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
                         OptoRuntime::new_array_Type(),
10566
630c177ec580 7081933: Use zeroing elimination optimization for large array
kvn
parents: 10267
diff changeset
  1869
                         slow_call_address);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1872
//-------------------mark_eliminated_box----------------------------------
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1873
//
9977
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1874
// During EA obj may point to several objects but after few ideal graph
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1875
// transformations (CCP) it may point to only one non escaping object
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1876
// (but still using phi), corresponding locks and unlocks will be marked
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1877
// for elimination. Later obj could be replaced with a new node (new phi)
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1878
// and which does not have escape information. And later after some graph
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1879
// reshape other locks and unlocks (which were not marked for elimination
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1880
// before) are connected to this new obj (phi) but they still will not be
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1881
// marked for elimination since new obj has no escape information.
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1882
// Mark all associated (same box and obj) lock and unlock nodes for
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1883
// elimination if some of them marked already.
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1884
void PhaseMacroExpand::mark_eliminated_box(Node* oldbox, Node* obj) {
11460
06e676d0b512 7129618: assert(obj_node->eqv_uncast(obj),"");
kvn
parents: 11458
diff changeset
  1885
  if (oldbox->as_BoxLock()->is_eliminated())
06e676d0b512 7129618: assert(obj_node->eqv_uncast(obj),"");
kvn
parents: 11458
diff changeset
  1886
    return; // This BoxLock node was processed already.
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1887
11460
06e676d0b512 7129618: assert(obj_node->eqv_uncast(obj),"");
kvn
parents: 11458
diff changeset
  1888
  // New implementation (EliminateNestedLocks) has separate BoxLock
06e676d0b512 7129618: assert(obj_node->eqv_uncast(obj),"");
kvn
parents: 11458
diff changeset
  1889
  // node for each locked region so mark all associated locks/unlocks as
06e676d0b512 7129618: assert(obj_node->eqv_uncast(obj),"");
kvn
parents: 11458
diff changeset
  1890
  // eliminated even if different objects are referenced in one locked region
06e676d0b512 7129618: assert(obj_node->eqv_uncast(obj),"");
kvn
parents: 11458
diff changeset
  1891
  // (for example, OSR compilation of nested loop inside locked scope).
06e676d0b512 7129618: assert(obj_node->eqv_uncast(obj),"");
kvn
parents: 11458
diff changeset
  1892
  if (EliminateNestedLocks ||
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1893
      oldbox->as_BoxLock()->is_simple_lock_region(NULL, obj)) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1894
    // Box is used only in one lock region. Mark this box as eliminated.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1895
    _igvn.hash_delete(oldbox);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1896
    oldbox->as_BoxLock()->set_eliminated(); // This changes box's hash value
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1897
    _igvn.hash_insert(oldbox);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1898
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1899
    for (uint i = 0; i < oldbox->outcnt(); i++) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1900
      Node* u = oldbox->raw_out(i);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1901
      if (u->is_AbstractLock() && !u->as_AbstractLock()->is_non_esc_obj()) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1902
        AbstractLockNode* alock = u->as_AbstractLock();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1903
        // Check lock's box since box could be referenced by Lock's debug info.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1904
        if (alock->box_node() == oldbox) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1905
          // Mark eliminated all related locks and unlocks.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1906
          alock->set_non_esc_obj();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1907
        }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1908
      }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1909
    }
9977
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1910
    return;
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  1911
  }
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1912
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1913
  // Create new "eliminated" BoxLock node and use it in monitor debug info
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1914
  // instead of oldbox for the same object.
11458
5ba160829cef 7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents: 11446
diff changeset
  1915
  BoxLockNode* newbox = oldbox->clone()->as_BoxLock();
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1916
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1917
  // Note: BoxLock node is marked eliminated only here and it is used
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1918
  // to indicate that all associated lock and unlock nodes are marked
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1919
  // for elimination.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1920
  newbox->set_eliminated();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1921
  transform_later(newbox);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1922
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1923
  // Replace old box node with new box for all users of the same object.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1924
  for (uint i = 0; i < oldbox->outcnt();) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1925
    bool next_edge = true;
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1926
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1927
    Node* u = oldbox->raw_out(i);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1928
    if (u->is_AbstractLock()) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1929
      AbstractLockNode* alock = u->as_AbstractLock();
11446
fd87432a895b 7128352: assert(obj_node == obj) failed
kvn
parents: 11445
diff changeset
  1930
      if (alock->box_node() == oldbox && alock->obj_node()->eqv_uncast(obj)) {
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1931
        // Replace Box and mark eliminated all related locks and unlocks.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1932
        alock->set_non_esc_obj();
12958
009b6c9586d8 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node*, int, Node*) where applicable
kvn
parents: 11724
diff changeset
  1933
        _igvn.rehash_node_delayed(alock);
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1934
        alock->set_box_node(newbox);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1935
        next_edge = false;
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1936
      }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1937
    }
11446
fd87432a895b 7128352: assert(obj_node == obj) failed
kvn
parents: 11445
diff changeset
  1938
    if (u->is_FastLock() && u->as_FastLock()->obj_node()->eqv_uncast(obj)) {
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1939
      FastLockNode* flock = u->as_FastLock();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1940
      assert(flock->box_node() == oldbox, "sanity");
12958
009b6c9586d8 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node*, int, Node*) where applicable
kvn
parents: 11724
diff changeset
  1941
      _igvn.rehash_node_delayed(flock);
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1942
      flock->set_box_node(newbox);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1943
      next_edge = false;
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1944
    }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1945
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1946
    // Replace old box in monitor debug info.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1947
    if (u->is_SafePoint() && u->as_SafePoint()->jvms()) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1948
      SafePointNode* sfn = u->as_SafePoint();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1949
      JVMState* youngest_jvms = sfn->jvms();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1950
      int max_depth = youngest_jvms->depth();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1951
      for (int depth = 1; depth <= max_depth; depth++) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1952
        JVMState* jvms = youngest_jvms->of_depth(depth);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1953
        int num_mon  = jvms->nof_monitors();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1954
        // Loop over monitors
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1955
        for (int idx = 0; idx < num_mon; idx++) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1956
          Node* obj_node = sfn->monitor_obj(jvms, idx);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1957
          Node* box_node = sfn->monitor_box(jvms, idx);
11446
fd87432a895b 7128352: assert(obj_node == obj) failed
kvn
parents: 11445
diff changeset
  1958
          if (box_node == oldbox && obj_node->eqv_uncast(obj)) {
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1959
            int j = jvms->monitor_box_offset(idx);
12958
009b6c9586d8 7173340: C2: code cleanup: use PhaseIterGVN::replace_edge(Node*, int, Node*) where applicable
kvn
parents: 11724
diff changeset
  1960
            _igvn.replace_input_of(u, j, newbox);
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1961
            next_edge = false;
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1962
          }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1963
        }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1964
      }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1965
    }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1966
    if (next_edge) i++;
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1967
  }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1968
}
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1969
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1970
//-----------------------mark_eliminated_locking_nodes-----------------------
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1971
void PhaseMacroExpand::mark_eliminated_locking_nodes(AbstractLockNode *alock) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1972
  if (EliminateNestedLocks) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1973
    if (alock->is_nested()) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1974
       assert(alock->box_node()->as_BoxLock()->is_eliminated(), "sanity");
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1975
       return;
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1976
    } else if (!alock->is_non_esc_obj()) { // Not eliminated or coarsened
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1977
      // Only Lock node has JVMState needed here.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1978
      if (alock->jvms() != NULL && alock->as_Lock()->is_nested_lock_region()) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1979
        // Mark eliminated related nested locks and unlocks.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1980
        Node* obj = alock->obj_node();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1981
        BoxLockNode* box_node = alock->box_node()->as_BoxLock();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1982
        assert(!box_node->is_eliminated(), "should not be marked yet");
9977
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1983
        // Note: BoxLock node is marked eliminated only here
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1984
        // and it is used to indicate that all associated lock
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  1985
        // and unlock nodes are marked for elimination.
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1986
        box_node->set_eliminated(); // Box's hash is always NO_HASH here
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1987
        for (uint i = 0; i < box_node->outcnt(); i++) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1988
          Node* u = box_node->raw_out(i);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1989
          if (u->is_AbstractLock()) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1990
            alock = u->as_AbstractLock();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1991
            if (alock->box_node() == box_node) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1992
              // Verify that this Box is referenced only by related locks.
11446
fd87432a895b 7128352: assert(obj_node == obj) failed
kvn
parents: 11445
diff changeset
  1993
              assert(alock->obj_node()->eqv_uncast(obj), "");
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1994
              // Mark all related locks and unlocks.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1995
              alock->set_nested();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1996
            }
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  1997
          }
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1998
        }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  1999
      }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2000
      return;
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2001
    }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2002
    // Process locks for non escaping object
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2003
    assert(alock->is_non_esc_obj(), "");
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2004
  } // EliminateNestedLocks
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2005
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2006
  if (alock->is_non_esc_obj()) { // Lock is used for non escaping object
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2007
    // Look for all locks of this object and mark them and
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2008
    // corresponding BoxLock nodes as eliminated.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2009
    Node* obj = alock->obj_node();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2010
    for (uint j = 0; j < obj->outcnt(); j++) {
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2011
      Node* o = obj->raw_out(j);
11446
fd87432a895b 7128352: assert(obj_node == obj) failed
kvn
parents: 11445
diff changeset
  2012
      if (o->is_AbstractLock() &&
fd87432a895b 7128352: assert(obj_node == obj) failed
kvn
parents: 11445
diff changeset
  2013
          o->as_AbstractLock()->obj_node()->eqv_uncast(obj)) {
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2014
        alock = o->as_AbstractLock();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2015
        Node* box = alock->box_node();
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2016
        // Replace old box node with new eliminated box for all users
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2017
        // of the same object and mark related locks as eliminated.
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2018
        mark_eliminated_box(box, obj);
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2019
      }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2020
    }
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2021
  }
9977
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2022
}
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2023
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2024
// we have determined that this lock/unlock can be eliminated, we simply
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2025
// eliminate the node without expanding it.
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2026
//
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2027
// Note:  The membar's associated with the lock/unlock are currently not
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2028
//        eliminated.  This should be investigated as a future enhancement.
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2029
//
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2030
bool PhaseMacroExpand::eliminate_locking_node(AbstractLockNode *alock) {
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2031
9977
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2032
  if (!alock->is_eliminated()) {
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2033
    return false;
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2034
  }
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2035
#ifdef ASSERT
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2036
  if (!alock->is_coarsened()) {
9977
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2037
    // Check that new "eliminated" BoxLock node is created.
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2038
    BoxLockNode* oldbox = alock->box_node()->as_BoxLock();
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2039
    assert(oldbox->is_eliminated(), "should be done already");
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2040
  }
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2041
#endif
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2042
  CompileLog* log = C->log();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2043
  if (log != NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2044
    log->head("eliminate_lock lock='%d'",
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2045
              alock->is_Lock());
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2046
    JVMState* p = alock->jvms();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2047
    while (p != NULL) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2048
      log->elem("jvms bci='%d' method='%d'", p->bci(), log->identify(p->method()));
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2049
      p = p->caller();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2050
    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2051
    log->tail("eliminate_lock");
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2052
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3268
diff changeset
  2053
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2054
  #ifndef PRODUCT
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2055
  if (PrintEliminateLocks) {
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2056
    if (alock->is_Lock()) {
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2057
      tty->print_cr("++++ Eliminated: %d Lock", alock->_idx);
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2058
    } else {
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2059
      tty->print_cr("++++ Eliminated: %d Unlock", alock->_idx);
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2060
    }
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2061
  }
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2062
  #endif
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2063
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2064
  Node* mem  = alock->in(TypeFunc::Memory);
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2065
  Node* ctrl = alock->in(TypeFunc::Control);
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2066
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2067
  extract_call_projections(alock);
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2068
  // There are 2 projections from the lock.  The lock node will
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2069
  // be deleted when its last use is subsumed below.
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2070
  assert(alock->outcnt() == 2 &&
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2071
         _fallthroughproj != NULL &&
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2072
         _memproj_fallthrough != NULL,
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2073
         "Unexpected projections from Lock/Unlock");
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2074
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2075
  Node* fallthroughproj = _fallthroughproj;
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2076
  Node* memproj_fallthrough = _memproj_fallthrough;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2077
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2078
  // The memory projection from a lock/unlock is RawMem
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2079
  // The input to a Lock is merged memory, so extract its RawMem input
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2080
  // (unless the MergeMem has been optimized away.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2081
  if (alock->is_Lock()) {
10262
c5f62d314bee 7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents: 10011
diff changeset
  2082
    // Seach for MemBarAcquireLock node and delete it also.
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2083
    MemBarNode* membar = fallthroughproj->unique_ctrl_out()->as_MemBar();
10262
c5f62d314bee 7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents: 10011
diff changeset
  2084
    assert(membar != NULL && membar->Opcode() == Op_MemBarAcquireLock, "");
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2085
    Node* ctrlproj = membar->proj_out(TypeFunc::Control);
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2086
    Node* memproj = membar->proj_out(TypeFunc::Memory);
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2087
    _igvn.replace_node(ctrlproj, fallthroughproj);
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2088
    _igvn.replace_node(memproj, memproj_fallthrough);
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2089
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2090
    // Delete FastLock node also if this Lock node is unique user
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2091
    // (a loop peeling may clone a Lock node).
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2092
    Node* flock = alock->as_Lock()->fastlock_node();
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2093
    if (flock->outcnt() == 1) {
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2094
      assert(flock->unique_out() == alock, "sanity");
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2095
      _igvn.replace_node(flock, top());
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2096
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2097
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2098
10262
c5f62d314bee 7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents: 10011
diff changeset
  2099
  // Seach for MemBarReleaseLock node and delete it also.
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2100
  if (alock->is_Unlock() && ctrl != NULL && ctrl->is_Proj() &&
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2101
      ctrl->in(0)->is_MemBar()) {
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2102
    MemBarNode* membar = ctrl->in(0)->as_MemBar();
10262
c5f62d314bee 7074017: Introduce MemBarAcquireLock/MemBarReleaseLock nodes for monitor enter/exit code paths
roland
parents: 10011
diff changeset
  2103
    assert(membar->Opcode() == Op_MemBarReleaseLock &&
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2104
           mem->is_Proj() && membar == mem->in(0), "");
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2105
    _igvn.replace_node(fallthroughproj, ctrl);
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2106
    _igvn.replace_node(memproj_fallthrough, mem);
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2107
    fallthroughproj = ctrl;
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2108
    memproj_fallthrough = mem;
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2109
    ctrl = membar->in(TypeFunc::Control);
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2110
    mem  = membar->in(TypeFunc::Memory);
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2111
  }
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2112
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2113
  _igvn.replace_node(fallthroughproj, ctrl);
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2114
  _igvn.replace_node(memproj_fallthrough, mem);
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2115
  return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2118
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
//------------------------------expand_lock_node----------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2121
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
  Node* ctrl = lock->in(TypeFunc::Control);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
  Node* mem = lock->in(TypeFunc::Memory);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
  Node* obj = lock->obj_node();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
  Node* box = lock->box_node();
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2126
  Node* flock = lock->fastlock_node();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
11458
5ba160829cef 7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents: 11446
diff changeset
  2128
  assert(!box->as_BoxLock()->is_eliminated(), "sanity");
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2129
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
  // Make the merge point
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2131
  Node *region;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2132
  Node *mem_phi;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2133
  Node *slow_path;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2134
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2135
  if (UseOptoBiasInlining) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2136
    /*
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2127
diff changeset
  2137
     *  See the full description in MacroAssembler::biased_locking_enter().
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2138
     *
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2139
     *  if( (mark_word & biased_lock_mask) == biased_lock_pattern ) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2140
     *    // The object is biased.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2141
     *    proto_node = klass->prototype_header;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2142
     *    o_node = thread | proto_node;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2143
     *    x_node = o_node ^ mark_word;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2144
     *    if( (x_node & ~age_mask) == 0 ) { // Biased to the current thread ?
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2145
     *      // Done.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2146
     *    } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2147
     *      if( (x_node & biased_lock_mask) != 0 ) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2148
     *        // The klass's prototype header is no longer biased.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2149
     *        cas(&mark_word, mark_word, proto_node)
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2150
     *        goto cas_lock;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2151
     *      } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2152
     *        // The klass's prototype header is still biased.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2153
     *        if( (x_node & epoch_mask) != 0 ) { // Expired epoch?
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2154
     *          old = mark_word;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2155
     *          new = o_node;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2156
     *        } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2157
     *          // Different thread or anonymous biased.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2158
     *          old = mark_word & (epoch_mask | age_mask | biased_lock_mask);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2159
     *          new = thread | old;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2160
     *        }
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2161
     *        // Try to rebias.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2162
     *        if( cas(&mark_word, old, new) == 0 ) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2163
     *          // Done.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2164
     *        } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2165
     *          goto slow_path; // Failed.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2166
     *        }
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2167
     *      }
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2168
     *    }
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2169
     *  } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2170
     *    // The object is not biased.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2171
     *    cas_lock:
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2172
     *    if( FastLock(obj) == 0 ) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2173
     *      // Done.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2174
     *    } else {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2175
     *      slow_path:
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2176
     *      OptoRuntime::complete_monitor_locking_Java(obj);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2177
     *    }
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2178
     *  }
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2179
     */
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2180
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2181
    region  = new RegionNode(5);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2182
    // create a Phi for the memory state
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2183
    mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2184
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2185
    Node* fast_lock_region  = new RegionNode(3);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2186
    Node* fast_lock_mem_phi = new PhiNode( fast_lock_region, Type::MEMORY, TypeRawPtr::BOTTOM);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2187
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2188
    // First, check mark word for the biased lock pattern.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2189
    Node* mark_node = make_load(ctrl, mem, obj, oopDesc::mark_offset_in_bytes(), TypeX_X, TypeX_X->basic_type());
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2190
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2191
    // Get fast path - mark word has the biased lock pattern.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2192
    ctrl = opt_bits_test(ctrl, fast_lock_region, 1, mark_node,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2193
                         markOopDesc::biased_lock_mask_in_place,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2194
                         markOopDesc::biased_lock_pattern, true);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2195
    // fast_lock_region->in(1) is set to slow path.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2196
    fast_lock_mem_phi->init_req(1, mem);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2197
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2198
    // Now check that the lock is biased to the current thread and has
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2199
    // the same epoch and bias as Klass::_prototype_header.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2200
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2201
    // Special-case a fresh allocation to avoid building nodes:
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2202
    Node* klass_node = AllocateNode::Ideal_klass(obj, &_igvn);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2203
    if (klass_node == NULL) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2204
      Node* k_adr = basic_plus_adr(obj, oopDesc::klass_offset_in_bytes());
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2205
      klass_node = transform_later( LoadKlassNode::make(_igvn, mem, k_adr, _igvn.type(k_adr)->is_ptr()) );
1677
f632e4c20c3e 6782820: Server VM fails with "unhandled implicit exception in compiled code"
kvn
parents: 1613
diff changeset
  2206
#ifdef _LP64
19979
ebe1dbb6e1aa 8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents: 19708
diff changeset
  2207
      if (UseCompressedClassPointers && klass_node->is_DecodeNKlass()) {
1677
f632e4c20c3e 6782820: Server VM fails with "unhandled implicit exception in compiled code"
kvn
parents: 1613
diff changeset
  2208
        assert(klass_node->in(1)->Opcode() == Op_LoadNKlass, "sanity");
f632e4c20c3e 6782820: Server VM fails with "unhandled implicit exception in compiled code"
kvn
parents: 1613
diff changeset
  2209
        klass_node->in(1)->init_req(0, ctrl);
f632e4c20c3e 6782820: Server VM fails with "unhandled implicit exception in compiled code"
kvn
parents: 1613
diff changeset
  2210
      } else
f632e4c20c3e 6782820: Server VM fails with "unhandled implicit exception in compiled code"
kvn
parents: 1613
diff changeset
  2211
#endif
f632e4c20c3e 6782820: Server VM fails with "unhandled implicit exception in compiled code"
kvn
parents: 1613
diff changeset
  2212
      klass_node->init_req(0, ctrl);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2213
    }
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11191
diff changeset
  2214
    Node *proto_node = make_load(ctrl, mem, klass_node, in_bytes(Klass::prototype_header_offset()), TypeX_X, TypeX_X->basic_type());
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2215
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2216
    Node* thread = transform_later(new ThreadLocalNode());
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2217
    Node* cast_thread = transform_later(new CastP2XNode(ctrl, thread));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2218
    Node* o_node = transform_later(new OrXNode(cast_thread, proto_node));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2219
    Node* x_node = transform_later(new XorXNode(o_node, mark_node));
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2220
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2221
    // Get slow path - mark word does NOT match the value.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2222
    Node* not_biased_ctrl =  opt_bits_test(ctrl, region, 3, x_node,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2223
                                      (~markOopDesc::age_mask_in_place), 0);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2224
    // region->in(3) is set to fast path - the object is biased to the current thread.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2225
    mem_phi->init_req(3, mem);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2226
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2227
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2228
    // Mark word does NOT match the value (thread | Klass::_prototype_header).
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2229
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2231
    // First, check biased pattern.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2232
    // Get fast path - _prototype_header has the same biased lock pattern.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2233
    ctrl =  opt_bits_test(not_biased_ctrl, fast_lock_region, 2, x_node,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2234
                          markOopDesc::biased_lock_mask_in_place, 0, true);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2235
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2236
    not_biased_ctrl = fast_lock_region->in(2); // Slow path
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2237
    // fast_lock_region->in(2) - the prototype header is no longer biased
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2238
    // and we have to revoke the bias on this object.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2239
    // We are going to try to reset the mark of this object to the prototype
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2240
    // value and fall through to the CAS-based locking scheme.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2241
    Node* adr = basic_plus_adr(obj, oopDesc::mark_offset_in_bytes());
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2242
    Node* cas = new StoreXConditionalNode(not_biased_ctrl, mem, adr,
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2243
                                          proto_node, mark_node);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2244
    transform_later(cas);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2245
    Node* proj = transform_later(new SCMemProjNode(cas));
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2246
    fast_lock_mem_phi->init_req(2, proj);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2247
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2248
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2249
    // Second, check epoch bits.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2250
    Node* rebiased_region  = new RegionNode(3);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2251
    Node* old_phi = new PhiNode( rebiased_region, TypeX_X);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2252
    Node* new_phi = new PhiNode( rebiased_region, TypeX_X);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2253
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2254
    // Get slow path - mark word does NOT match epoch bits.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2255
    Node* epoch_ctrl =  opt_bits_test(ctrl, rebiased_region, 1, x_node,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2256
                                      markOopDesc::epoch_mask_in_place, 0);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2257
    // The epoch of the current bias is not valid, attempt to rebias the object
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2258
    // toward the current thread.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2259
    rebiased_region->init_req(2, epoch_ctrl);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2260
    old_phi->init_req(2, mark_node);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2261
    new_phi->init_req(2, o_node);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2262
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2263
    // rebiased_region->in(1) is set to fast path.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2264
    // The epoch of the current bias is still valid but we know
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2265
    // nothing about the owner; it might be set or it might be clear.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2266
    Node* cmask   = MakeConX(markOopDesc::biased_lock_mask_in_place |
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2267
                             markOopDesc::age_mask_in_place |
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2268
                             markOopDesc::epoch_mask_in_place);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2269
    Node* old = transform_later(new AndXNode(mark_node, cmask));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2270
    cast_thread = transform_later(new CastP2XNode(ctrl, thread));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2271
    Node* new_mark = transform_later(new OrXNode(cast_thread, old));
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2272
    old_phi->init_req(1, old);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2273
    new_phi->init_req(1, new_mark);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2274
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2275
    transform_later(rebiased_region);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2276
    transform_later(old_phi);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2277
    transform_later(new_phi);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2278
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2279
    // Try to acquire the bias of the object using an atomic operation.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2280
    // If this fails we will go in to the runtime to revoke the object's bias.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2281
    cas = new StoreXConditionalNode(rebiased_region, mem, adr, new_phi, old_phi);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2282
    transform_later(cas);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2283
    proj = transform_later(new SCMemProjNode(cas));
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2284
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2285
    // Get slow path - Failed to CAS.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2286
    not_biased_ctrl = opt_bits_test(rebiased_region, region, 4, cas, 0, 0);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2287
    mem_phi->init_req(4, proj);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2288
    // region->in(4) is set to fast path - the object is rebiased to the current thread.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2289
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2290
    // Failed to CAS.
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2291
    slow_path  = new RegionNode(3);
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2292
    Node *slow_mem = new PhiNode( slow_path, Type::MEMORY, TypeRawPtr::BOTTOM);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2293
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2294
    slow_path->init_req(1, not_biased_ctrl); // Capture slow-control
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2295
    slow_mem->init_req(1, proj);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2296
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2297
    // Call CAS-based locking scheme (FastLock node).
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2298
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2299
    transform_later(fast_lock_region);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2300
    transform_later(fast_lock_mem_phi);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2301
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2302
    // Get slow path - FastLock failed to lock the object.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2303
    ctrl = opt_bits_test(fast_lock_region, region, 2, flock, 0, 0);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2304
    mem_phi->init_req(2, fast_lock_mem_phi);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2305
    // region->in(2) is set to fast path - the object is locked to the current thread.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2306
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2307
    slow_path->init_req(2, ctrl); // Capture slow-control
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2308
    slow_mem->init_req(2, fast_lock_mem_phi);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2309
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2310
    transform_later(slow_path);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2311
    transform_later(slow_mem);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2312
    // Reset lock's memory edge.
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2313
    lock->set_req(TypeFunc::Memory, slow_mem);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2314
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2315
  } else {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2316
    region  = new RegionNode(3);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2317
    // create a Phi for the memory state
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2318
    mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2319
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2320
    // Optimize test; set region slot 2
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2321
    slow_path = opt_bits_test(ctrl, region, 2, flock, 0, 0);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2322
    mem_phi->init_req(2, mem);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2323
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
  // Make slow path call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2326
  CallNode *call = make_slow_call( (CallNode *) lock, OptoRuntime::complete_monitor_enter_Type(), OptoRuntime::complete_monitor_locking_Java(), NULL, slow_path, obj, box );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2327
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2328
  extract_call_projections(call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2329
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2330
  // Slow path can only throw asynchronous exceptions, which are always
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2331
  // de-opted.  So the compiler thinks the slow-call can never throw an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2332
  // exception.  If it DOES throw an exception we would need the debug
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2333
  // info removed first (since if it throws there is no monitor).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2334
  assert ( _ioproj_fallthrough == NULL && _ioproj_catchall == NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2335
           _memproj_catchall == NULL && _catchallcatchproj == NULL, "Unexpected projection from Lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
  // Capture slow path
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
  // disconnect fall-through projection from call and create a new one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
  // hook up users of fall-through projection to region
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
  Node *slow_ctrl = _fallthroughproj->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
  transform_later(slow_ctrl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
  _igvn.hash_delete(_fallthroughproj);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 13969
diff changeset
  2343
  _fallthroughproj->disconnect_inputs(NULL, C);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2344
  region->init_req(1, slow_ctrl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2345
  // region inputs are now complete
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
  transform_later(region);
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2347
  _igvn.replace_node(_fallthroughproj, region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2348
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2349
  Node *memproj = transform_later(new ProjNode(call, TypeFunc::Memory));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2350
  mem_phi->init_req(1, memproj );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2351
  transform_later(mem_phi);
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2352
  _igvn.replace_node(_memproj_fallthrough, mem_phi);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
//------------------------------expand_unlock_node----------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
void PhaseMacroExpand::expand_unlock_node(UnlockNode *unlock) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
239
fb31825d5444 6672848: (Escape Analysis) improve lock elimination with EA
kvn
parents: 236
diff changeset
  2358
  Node* ctrl = unlock->in(TypeFunc::Control);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
  Node* mem = unlock->in(TypeFunc::Memory);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2360
  Node* obj = unlock->obj_node();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
  Node* box = unlock->box_node();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
11458
5ba160829cef 7128355: assert(!nocreate) failed: Cannot build a phi for a block already parsed
kvn
parents: 11446
diff changeset
  2363
  assert(!box->as_BoxLock()->is_eliminated(), "sanity");
11445
3c768dca60f5 7125896: Eliminate nested locks
kvn
parents: 11437
diff changeset
  2364
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
  // No need for a null check on unlock
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
  // Make the merge point
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2368
  Node *region;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2369
  Node *mem_phi;
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2370
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2371
  if (UseOptoBiasInlining) {
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2372
    // Check for biased locking unlock case, which is a no-op.
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2127
diff changeset
  2373
    // See the full description in MacroAssembler::biased_locking_exit().
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2374
    region  = new RegionNode(4);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2375
    // create a Phi for the memory state
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2376
    mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2377
    mem_phi->init_req(3, mem);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2378
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2379
    Node* mark_node = make_load(ctrl, mem, obj, oopDesc::mark_offset_in_bytes(), TypeX_X, TypeX_X->basic_type());
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2380
    ctrl = opt_bits_test(ctrl, region, 3, mark_node,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2381
                         markOopDesc::biased_lock_mask_in_place,
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2382
                         markOopDesc::biased_lock_pattern);
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2383
  } else {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2384
    region  = new RegionNode(3);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2385
    // create a Phi for the memory state
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2386
    mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2387
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2388
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2389
  FastUnlockNode *funlock = new FastUnlockNode( ctrl, obj, box );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
  funlock = transform_later( funlock )->as_FastUnlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2391
  // Optimize test; set region slot 2
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1394
diff changeset
  2392
  Node *slow_path = opt_bits_test(ctrl, region, 2, funlock, 0, 0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
  CallNode *call = make_slow_call( (CallNode *) unlock, OptoRuntime::complete_monitor_exit_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::complete_monitor_unlocking_C), "complete_monitor_unlocking_C", slow_path, obj, box );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
  extract_call_projections(call);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2398
  assert ( _ioproj_fallthrough == NULL && _ioproj_catchall == NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2399
           _memproj_catchall == NULL && _catchallcatchproj == NULL, "Unexpected projection from Lock");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2400
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2401
  // No exceptions for unlocking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2402
  // Capture slow path
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2403
  // disconnect fall-through projection from call and create a new one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2404
  // hook up users of fall-through projection to region
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2405
  Node *slow_ctrl = _fallthroughproj->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2406
  transform_later(slow_ctrl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2407
  _igvn.hash_delete(_fallthroughproj);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 13969
diff changeset
  2408
  _fallthroughproj->disconnect_inputs(NULL, C);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2409
  region->init_req(1, slow_ctrl);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2410
  // region inputs are now complete
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2411
  transform_later(region);
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2412
  _igvn.replace_node(_fallthroughproj, region);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2413
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 23528
diff changeset
  2414
  Node *memproj = transform_later(new ProjNode(call, TypeFunc::Memory) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2415
  mem_phi->init_req(1, memproj );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2416
  mem_phi->init_req(2, mem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2417
  transform_later(mem_phi);
2532
da0b1680593b 6711117: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
kvn
parents: 2154
diff changeset
  2418
  _igvn.replace_node(_memproj_fallthrough, mem_phi);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2419
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2420
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2421
//---------------------------eliminate_macro_nodes----------------------
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2422
// Eliminate scalar replaced allocations and associated locks.
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2423
void PhaseMacroExpand::eliminate_macro_nodes() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2424
  if (C->macro_count() == 0)
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2425
    return;
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2426
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2427
  // First, attempt to eliminate locks
9977
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2428
  int cnt = C->macro_count();
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2429
  for (int i=0; i < cnt; i++) {
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2430
    Node *n = C->macro_node(i);
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2431
    if (n->is_AbstractLock()) { // Lock and Unlock nodes
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2432
      // Before elimination mark all associated (same box and obj)
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2433
      // lock and unlock nodes.
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2434
      mark_eliminated_locking_nodes(n->as_AbstractLock());
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2435
    }
c23d1a8dcaa9 7050280: assert(u->as_Unlock()->is_eliminated()) failed: sanity
kvn
parents: 9446
diff changeset
  2436
  }
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2437
  bool progress = true;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2438
  while (progress) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2439
    progress = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2440
    for (int i = C->macro_count(); i > 0; i--) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2441
      Node * n = C->macro_node(i-1);
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2442
      bool success = false;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2443
      debug_only(int old_macro_count = C->macro_count(););
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2444
      if (n->is_AbstractLock()) {
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2445
        success = eliminate_locking_node(n->as_AbstractLock());
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2446
      }
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2447
      assert(success == (C->macro_count() < old_macro_count), "elimination reduces macro count");
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2448
      progress = progress || success;
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2449
    }
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2450
  }
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2451
  // Next, attempt to eliminate allocations
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2452
  _has_locks = false;
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2453
  progress = true;
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2454
  while (progress) {
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2455
    progress = false;
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2456
    for (int i = C->macro_count(); i > 0; i--) {
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2457
      Node * n = C->macro_node(i-1);
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2458
      bool success = false;
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2459
      debug_only(int old_macro_count = C->macro_count(););
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2460
      switch (n->class_id()) {
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2461
      case Node::Class_Allocate:
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2462
      case Node::Class_AllocateArray:
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2463
        success = eliminate_allocate_node(n->as_Allocate());
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2464
        break;
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2465
      case Node::Class_CallStaticJava:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2466
        success = eliminate_boxing_node(n->as_CallStaticJava());
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2467
        break;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2468
      case Node::Class_Lock:
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2469
      case Node::Class_Unlock:
1613
be097ec639a2 6775880: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
kvn
parents: 1555
diff changeset
  2470
        assert(!n->as_AbstractLock()->is_eliminated(), "sanity");
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2471
        _has_locks = true;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2472
        break;
26166
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2473
      case Node::Class_ArrayCopy:
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2474
        break;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2475
      default:
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2476
        assert(n->Opcode() == Op_LoopLimit ||
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2477
               n->Opcode() == Op_Opaque1   ||
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2478
               n->Opcode() == Op_Opaque2   ||
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2479
               n->Opcode() == Op_Opaque3, "unknown node type in macro list");
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2480
      }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2481
      assert(success == (C->macro_count() < old_macro_count), "elimination reduces macro count");
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2482
      progress = progress || success;
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2483
    }
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2484
  }
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2485
}
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2486
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2487
//------------------------------expand_macro_nodes----------------------
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2488
//  Returns true if a failure occurred.
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2489
bool PhaseMacroExpand::expand_macro_nodes() {
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2490
  // Last attempt to eliminate macro nodes.
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2491
  eliminate_macro_nodes();
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2492
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2493
  // Make sure expansion will not cause node limit to be exceeded.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2494
  // Worst case is a macro node gets expanded into about 50 nodes.
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2495
  // Allow 50% more for optimization.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
  if (C->check_node_count(C->macro_count() * 75, "out of nodes before macro expansion" ) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
    return true;
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2498
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2499
  // Eliminate Opaque and LoopLimit nodes. Do it after all loop optimizations.
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2500
  bool progress = true;
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2501
  while (progress) {
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2502
    progress = false;
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2503
    for (int i = C->macro_count(); i > 0; i--) {
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2504
      Node * n = C->macro_node(i-1);
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2505
      bool success = false;
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2506
      debug_only(int old_macro_count = C->macro_count(););
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2507
      if (n->Opcode() == Op_LoopLimit) {
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2508
        // Remove it from macro list and put on IGVN worklist to optimize.
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2509
        C->remove_macro_node(n);
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2510
        _igvn._worklist.push(n);
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2511
        success = true;
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2512
      } else if (n->Opcode() == Op_CallStaticJava) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2513
        // Remove it from macro list and put on IGVN worklist to optimize.
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2514
        C->remove_macro_node(n);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2515
        _igvn._worklist.push(n);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 15874
diff changeset
  2516
        success = true;
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2517
      } else if (n->Opcode() == Op_Opaque1 || n->Opcode() == Op_Opaque2) {
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2518
        _igvn.replace_node(n, n->in(1));
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2519
        success = true;
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2520
#if INCLUDE_RTM_OPT
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2521
      } else if ((n->Opcode() == Op_Opaque3) && ((Opaque3Node*)n)->rtm_opt()) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2522
        assert(C->profile_rtm(), "should be used only in rtm deoptimization code");
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2523
        assert((n->outcnt() == 1) && n->unique_out()->is_Cmp(), "");
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2524
        Node* cmp = n->unique_out();
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2525
#ifdef ASSERT
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2526
        // Validate graph.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2527
        assert((cmp->outcnt() == 1) && cmp->unique_out()->is_Bool(), "");
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2528
        BoolNode* bol = cmp->unique_out()->as_Bool();
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2529
        assert((bol->outcnt() == 1) && bol->unique_out()->is_If() &&
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2530
               (bol->_test._test == BoolTest::ne), "");
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2531
        IfNode* ifn = bol->unique_out()->as_If();
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2532
        assert((ifn->outcnt() == 2) &&
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2533
               ifn->proj_out(1)->is_uncommon_trap_proj(Deoptimization::Reason_rtm_state_change), "");
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2534
#endif
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2535
        Node* repl = n->in(1);
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2536
        if (!_has_locks) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2537
          // Remove RTM state check if there are no locks in the code.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2538
          // Replace input to compare the same value.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2539
          repl = (cmp->in(1) == n) ? cmp->in(2) : cmp->in(1);
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2540
        }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2541
        _igvn.replace_node(n, repl);
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2542
        success = true;
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22872
diff changeset
  2543
#endif
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2544
      }
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2545
      assert(success == (C->macro_count() < old_macro_count), "elimination reduces macro count");
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2546
      progress = progress || success;
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2547
    }
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2548
  }
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2549
26166
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2550
  // expand arraycopy "macro" nodes first
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2551
  // For ReduceBulkZeroing, we must first process all arraycopy nodes
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2552
  // before the allocate nodes are expanded.
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2553
  int macro_idx = C->macro_count() - 1;
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2554
  while (macro_idx >= 0) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2555
    Node * n = C->macro_node(macro_idx);
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2556
    assert(n->is_macro(), "only macro nodes expected here");
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2557
    if (_igvn.type(n) == Type::TOP || n->in(0)->is_top() ) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2558
      // node is unreachable, so don't try to expand it
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2559
      C->remove_macro_node(n);
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2560
    } else if (n->is_ArrayCopy()){
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2561
      int macro_count = C->macro_count();
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2562
      expand_arraycopy_node(n->as_ArrayCopy());
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2563
      assert(C->macro_count() < macro_count, "must have deleted a node from macro list");
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2564
    }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2565
    if (C->failing())  return true;
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2566
    macro_idx --;
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2567
  }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25935
diff changeset
  2568
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
  // expand "macro" nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
  // nodes are removed from the macro list as they are processed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
  while (C->macro_count() > 0) {
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2572
    int macro_count = C->macro_count();
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2573
    Node * n = C->macro_node(macro_count-1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
    assert(n->is_macro(), "only macro nodes expected here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
    if (_igvn.type(n) == Type::TOP || n->in(0)->is_top() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
      // node is unreachable, so don't try to expand it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
      C->remove_macro_node(n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2580
    switch (n->class_id()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
    case Node::Class_Allocate:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
      expand_allocate(n->as_Allocate());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
    case Node::Class_AllocateArray:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
      expand_allocate_array(n->as_AllocateArray());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
    case Node::Class_Lock:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2588
      expand_lock_node(n->as_Lock());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2590
    case Node::Class_Unlock:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
      expand_unlock_node(n->as_Unlock());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
      assert(false, "unknown node type in macro list");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
    }
246
b029af7e69d3 6259129: (Escape Analysis) scalar replacement for not escaping objects
kvn
parents: 239
diff changeset
  2596
    assert(C->macro_count() < macro_count, "must have deleted a node from macro list");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
    if (C->failing())  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
  }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 246
diff changeset
  2599
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 246
diff changeset
  2600
  _igvn.set_delay_transform(false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2601
  _igvn.optimize();
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 10566
diff changeset
  2602
  if (C->failing())  return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
}