annotate src/share/vm/opto/memnode.cpp @ 452:00b023ae2d78

6722113: CMS: Incorrect overflow handling during precleaning of Reference lists Summary: When we encounter marking stack overflow during precleaning of Reference lists, we were using the overflow list mechanism, which can cause problems on account of mutating the mark word of the header because of conflicts with mutator accesses and updates of that field. Instead we should use the usual mechanism for overflow handling in concurrent phases, namely dirtying of the card on which the overflowed object lies. Since precleaning effectively does a form of discovered list processing, albeit with discovery enabled, we needed to adjust some code to be correct in the face of interleaved processing and discovery. Reviewed-by: apetrusenko, jcoomes
author ysr
date Thu, 20 Nov 2008 12:27:41 -0800
parents a1980da045cc
children 82a980778b92 041fe019d769
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
196
d1605aabd0a1 6719955: Update copyright year
xdono
parents: 193
diff changeset
2 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
a61af66fc99e Initial load
duke
parents:
diff changeset
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
a61af66fc99e Initial load
duke
parents:
diff changeset
20 * CA 95054 USA or visit www.sun.com if you need additional information or
a61af66fc99e Initial load
duke
parents:
diff changeset
21 * have any questions.
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
a61af66fc99e Initial load
duke
parents:
diff changeset
25 // Portions of code courtesy of Clifford Click
a61af66fc99e Initial load
duke
parents:
diff changeset
26
a61af66fc99e Initial load
duke
parents:
diff changeset
27 // Optimization - Graph Style
a61af66fc99e Initial load
duke
parents:
diff changeset
28
a61af66fc99e Initial load
duke
parents:
diff changeset
29 #include "incls/_precompiled.incl"
a61af66fc99e Initial load
duke
parents:
diff changeset
30 #include "incls/_memnode.cpp.incl"
a61af66fc99e Initial load
duke
parents:
diff changeset
31
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
32 static Node *step_through_mergemem(PhaseGVN *phase, MergeMemNode *mmem, const TypePtr *tp, const TypePtr *adr_check, outputStream *st);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
33
0
a61af66fc99e Initial load
duke
parents:
diff changeset
34 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
35 uint MemNode::size_of() const { return sizeof(*this); }
a61af66fc99e Initial load
duke
parents:
diff changeset
36
a61af66fc99e Initial load
duke
parents:
diff changeset
37 const TypePtr *MemNode::adr_type() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
38 Node* adr = in(Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
39 const TypePtr* cross_check = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
40 DEBUG_ONLY(cross_check = _adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
41 return calculate_adr_type(adr->bottom_type(), cross_check);
a61af66fc99e Initial load
duke
parents:
diff changeset
42 }
a61af66fc99e Initial load
duke
parents:
diff changeset
43
a61af66fc99e Initial load
duke
parents:
diff changeset
44 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
45 void MemNode::dump_spec(outputStream *st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
46 if (in(Address) == NULL) return; // node is dead
a61af66fc99e Initial load
duke
parents:
diff changeset
47 #ifndef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
48 // fake the missing field
a61af66fc99e Initial load
duke
parents:
diff changeset
49 const TypePtr* _adr_type = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
50 if (in(Address) != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
51 _adr_type = in(Address)->bottom_type()->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
52 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
53 dump_adr_type(this, _adr_type, st);
a61af66fc99e Initial load
duke
parents:
diff changeset
54
a61af66fc99e Initial load
duke
parents:
diff changeset
55 Compile* C = Compile::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
56 if( C->alias_type(_adr_type)->is_volatile() )
a61af66fc99e Initial load
duke
parents:
diff changeset
57 st->print(" Volatile!");
a61af66fc99e Initial load
duke
parents:
diff changeset
58 }
a61af66fc99e Initial load
duke
parents:
diff changeset
59
a61af66fc99e Initial load
duke
parents:
diff changeset
60 void MemNode::dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st) {
a61af66fc99e Initial load
duke
parents:
diff changeset
61 st->print(" @");
a61af66fc99e Initial load
duke
parents:
diff changeset
62 if (adr_type == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
63 st->print("NULL");
a61af66fc99e Initial load
duke
parents:
diff changeset
64 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
65 adr_type->dump_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
66 Compile* C = Compile::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
67 Compile::AliasType* atp = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
68 if (C->have_alias_type(adr_type)) atp = C->alias_type(adr_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
69 if (atp == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
70 st->print(", idx=?\?;");
a61af66fc99e Initial load
duke
parents:
diff changeset
71 else if (atp->index() == Compile::AliasIdxBot)
a61af66fc99e Initial load
duke
parents:
diff changeset
72 st->print(", idx=Bot;");
a61af66fc99e Initial load
duke
parents:
diff changeset
73 else if (atp->index() == Compile::AliasIdxTop)
a61af66fc99e Initial load
duke
parents:
diff changeset
74 st->print(", idx=Top;");
a61af66fc99e Initial load
duke
parents:
diff changeset
75 else if (atp->index() == Compile::AliasIdxRaw)
a61af66fc99e Initial load
duke
parents:
diff changeset
76 st->print(", idx=Raw;");
a61af66fc99e Initial load
duke
parents:
diff changeset
77 else {
a61af66fc99e Initial load
duke
parents:
diff changeset
78 ciField* field = atp->field();
a61af66fc99e Initial load
duke
parents:
diff changeset
79 if (field) {
a61af66fc99e Initial load
duke
parents:
diff changeset
80 st->print(", name=");
a61af66fc99e Initial load
duke
parents:
diff changeset
81 field->print_name_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
82 }
a61af66fc99e Initial load
duke
parents:
diff changeset
83 st->print(", idx=%d;", atp->index());
a61af66fc99e Initial load
duke
parents:
diff changeset
84 }
a61af66fc99e Initial load
duke
parents:
diff changeset
85 }
a61af66fc99e Initial load
duke
parents:
diff changeset
86 }
a61af66fc99e Initial load
duke
parents:
diff changeset
87
a61af66fc99e Initial load
duke
parents:
diff changeset
88 extern void print_alias_types();
a61af66fc99e Initial load
duke
parents:
diff changeset
89
a61af66fc99e Initial load
duke
parents:
diff changeset
90 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
91
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
92 Node *MemNode::optimize_simple_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
93 const TypeOopPtr *tinst = t_adr->isa_oopptr();
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
94 if (tinst == NULL || !tinst->is_known_instance_field())
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
95 return mchain; // don't try to optimize non-instance types
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
96 uint instance_id = tinst->instance_id();
253
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
97 Node *start_mem = phase->C->start()->proj_out(TypeFunc::Memory);
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
98 Node *prev = NULL;
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
99 Node *result = mchain;
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
100 while (prev != result) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
101 prev = result;
253
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
102 if (result == start_mem)
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
103 break; // hit one of our sentinals
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
104 // skip over a call which does not affect this memory slice
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
105 if (result->is_Proj() && result->as_Proj()->_con == TypeFunc::Memory) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
106 Node *proj_in = result->in(0);
253
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
107 if (proj_in->is_Allocate() && proj_in->_idx == instance_id) {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
108 break; // hit one of our sentinals
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
109 } else if (proj_in->is_Call()) {
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
110 CallNode *call = proj_in->as_Call();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
111 if (!call->may_modify(t_adr, phase)) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
112 result = call->in(TypeFunc::Memory);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
113 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
114 } else if (proj_in->is_Initialize()) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
115 AllocateNode* alloc = proj_in->as_Initialize()->allocation();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
116 // Stop if this is the initialization for the object instance which
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
117 // which contains this memory slice, otherwise skip over it.
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
118 if (alloc != NULL && alloc->_idx != instance_id) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
119 result = proj_in->in(TypeFunc::Memory);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
120 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
121 } else if (proj_in->is_MemBar()) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
122 result = proj_in->in(TypeFunc::Memory);
253
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
123 } else {
b0fe4deeb9fb 6726999: nsk/stress/jck12a/jck12a010 assert(n != null,"Bad immediate dominator info.")
kvn
parents: 247
diff changeset
124 assert(false, "unexpected projection");
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
125 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
126 } else if (result->is_MergeMem()) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
127 result = step_through_mergemem(phase, result->as_MergeMem(), t_adr, NULL, tty);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
128 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
129 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
130 return result;
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
131 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
132
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
133 Node *MemNode::optimize_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
134 const TypeOopPtr *t_oop = t_adr->isa_oopptr();
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
135 bool is_instance = (t_oop != NULL) && t_oop->is_known_instance_field();
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
136 PhaseIterGVN *igvn = phase->is_IterGVN();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
137 Node *result = mchain;
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
138 result = optimize_simple_memory_chain(result, t_adr, phase);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
139 if (is_instance && igvn != NULL && result->is_Phi()) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
140 PhiNode *mphi = result->as_Phi();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
141 assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
142 const TypePtr *t = mphi->adr_type();
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
143 if (t == TypePtr::BOTTOM || t == TypeRawPtr::BOTTOM ||
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
144 t->isa_oopptr() && !t->is_oopptr()->is_known_instance() &&
247
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 235
diff changeset
145 t->is_oopptr()->cast_to_exactness(true)
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 235
diff changeset
146 ->is_oopptr()->cast_to_ptr_type(t_oop->ptr())
02a35ad4adf8 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 235
diff changeset
147 ->is_oopptr()->cast_to_instance_id(t_oop->instance_id()) == t_oop) {
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
148 // clone the Phi with our address type
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
149 result = mphi->split_out_instance(t_adr, igvn);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
150 } else {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
151 assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr), "correct memory chain");
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
152 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
153 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
154 return result;
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
155 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
156
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
157 static Node *step_through_mergemem(PhaseGVN *phase, MergeMemNode *mmem, const TypePtr *tp, const TypePtr *adr_check, outputStream *st) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
158 uint alias_idx = phase->C->get_alias_index(tp);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
159 Node *mem = mmem;
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
160 #ifdef ASSERT
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
161 {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
162 // Check that current type is consistent with the alias index used during graph construction
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
163 assert(alias_idx >= Compile::AliasIdxRaw, "must not be a bad alias_idx");
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
164 bool consistent = adr_check == NULL || adr_check->empty() ||
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
165 phase->C->must_alias(adr_check, alias_idx );
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
166 // Sometimes dead array references collapse to a[-1], a[-2], or a[-3]
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
167 if( !consistent && adr_check != NULL && !adr_check->empty() &&
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
168 tp->isa_aryptr() && tp->offset() == Type::OffsetBot &&
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
169 adr_check->isa_aryptr() && adr_check->offset() != Type::OffsetBot &&
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
170 ( adr_check->offset() == arrayOopDesc::length_offset_in_bytes() ||
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
171 adr_check->offset() == oopDesc::klass_offset_in_bytes() ||
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
172 adr_check->offset() == oopDesc::mark_offset_in_bytes() ) ) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
173 // don't assert if it is dead code.
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
174 consistent = true;
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
175 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
176 if( !consistent ) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
177 st->print("alias_idx==%d, adr_check==", alias_idx);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
178 if( adr_check == NULL ) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
179 st->print("NULL");
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
180 } else {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
181 adr_check->dump();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
182 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
183 st->cr();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
184 print_alias_types();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
185 assert(consistent, "adr_check must match alias idx");
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
186 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
187 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
188 #endif
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
189 // TypeInstPtr::NOTNULL+any is an OOP with unknown offset - generally
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
190 // means an array I have not precisely typed yet. Do not do any
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
191 // alias stuff with it any time soon.
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
192 const TypeOopPtr *tinst = tp->isa_oopptr();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
193 if( tp->base() != Type::AnyPtr &&
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
194 !(tinst &&
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
195 tinst->klass()->is_java_lang_Object() &&
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
196 tinst->offset() == Type::OffsetBot) ) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
197 // compress paths and change unreachable cycles to TOP
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
198 // If not, we can update the input infinitely along a MergeMem cycle
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
199 // Equivalent code in PhiNode::Ideal
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
200 Node* m = phase->transform(mmem);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
201 // If tranformed to a MergeMem, get the desired slice
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
202 // Otherwise the returned node represents memory for every slice
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
203 mem = (m->is_MergeMem())? m->as_MergeMem()->memory_at(alias_idx) : m;
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
204 // Update input if it is progress over what we have now
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
205 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
206 return mem;
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
207 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
208
0
a61af66fc99e Initial load
duke
parents:
diff changeset
209 //--------------------------Ideal_common---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
210 // Look for degenerate control and memory inputs. Bypass MergeMem inputs.
a61af66fc99e Initial load
duke
parents:
diff changeset
211 // Unhook non-raw memories from complete (macro-expanded) initializations.
a61af66fc99e Initial load
duke
parents:
diff changeset
212 Node *MemNode::Ideal_common(PhaseGVN *phase, bool can_reshape) {
a61af66fc99e Initial load
duke
parents:
diff changeset
213 // If our control input is a dead region, kill all below the region
a61af66fc99e Initial load
duke
parents:
diff changeset
214 Node *ctl = in(MemNode::Control);
a61af66fc99e Initial load
duke
parents:
diff changeset
215 if (ctl && remove_dead_region(phase, can_reshape))
a61af66fc99e Initial load
duke
parents:
diff changeset
216 return this;
305
ab075d07f1ba 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 293
diff changeset
217 ctl = in(MemNode::Control);
ab075d07f1ba 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 293
diff changeset
218 // Don't bother trying to transform a dead node
ab075d07f1ba 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 293
diff changeset
219 if( ctl && ctl->is_top() ) return NodeSentinel;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
220
a61af66fc99e Initial load
duke
parents:
diff changeset
221 // Ignore if memory is dead, or self-loop
a61af66fc99e Initial load
duke
parents:
diff changeset
222 Node *mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
223 if( phase->type( mem ) == Type::TOP ) return NodeSentinel; // caller will return NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
224 assert( mem != this, "dead loop in MemNode::Ideal" );
a61af66fc99e Initial load
duke
parents:
diff changeset
225
a61af66fc99e Initial load
duke
parents:
diff changeset
226 Node *address = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
227 const Type *t_adr = phase->type( address );
a61af66fc99e Initial load
duke
parents:
diff changeset
228 if( t_adr == Type::TOP ) return NodeSentinel; // caller will return NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
229
420
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
230 PhaseIterGVN *igvn = phase->is_IterGVN();
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
231 if( can_reshape && igvn != NULL && igvn->_worklist.member(address) ) {
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
232 // The address's base and type may change when the address is processed.
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
233 // Delay this mem node transformation until the address is processed.
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
234 phase->is_IterGVN()->_worklist.push(this);
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
235 return NodeSentinel; // caller will return NULL
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
236 }
a1980da045cc 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 366
diff changeset
237
0
a61af66fc99e Initial load
duke
parents:
diff changeset
238 // Avoid independent memory operations
a61af66fc99e Initial load
duke
parents:
diff changeset
239 Node* old_mem = mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
240
36
f34d9da7acb2 6667618: disable LoadL->ConvL2I ==> LoadI optimization
kvn
parents: 29
diff changeset
241 // The code which unhooks non-raw memories from complete (macro-expanded)
f34d9da7acb2 6667618: disable LoadL->ConvL2I ==> LoadI optimization
kvn
parents: 29
diff changeset
242 // initializations was removed. After macro-expansion all stores catched
f34d9da7acb2 6667618: disable LoadL->ConvL2I ==> LoadI optimization
kvn
parents: 29
diff changeset
243 // by Initialize node became raw stores and there is no information
f34d9da7acb2 6667618: disable LoadL->ConvL2I ==> LoadI optimization
kvn
parents: 29
diff changeset
244 // which memory slices they modify. So it is unsafe to move any memory
f34d9da7acb2 6667618: disable LoadL->ConvL2I ==> LoadI optimization
kvn
parents: 29
diff changeset
245 // operation above these stores. Also in most cases hooked non-raw memories
f34d9da7acb2 6667618: disable LoadL->ConvL2I ==> LoadI optimization
kvn
parents: 29
diff changeset
246 // were already unhooked by using information from detect_ptr_independence()
f34d9da7acb2 6667618: disable LoadL->ConvL2I ==> LoadI optimization
kvn
parents: 29
diff changeset
247 // and find_previous_store().
0
a61af66fc99e Initial load
duke
parents:
diff changeset
248
a61af66fc99e Initial load
duke
parents:
diff changeset
249 if (mem->is_MergeMem()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
250 MergeMemNode* mmem = mem->as_MergeMem();
a61af66fc99e Initial load
duke
parents:
diff changeset
251 const TypePtr *tp = t_adr->is_ptr();
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
252
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
253 mem = step_through_mergemem(phase, mmem, tp, adr_type(), tty);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
254 }
a61af66fc99e Initial load
duke
parents:
diff changeset
255
a61af66fc99e Initial load
duke
parents:
diff changeset
256 if (mem != old_mem) {
a61af66fc99e Initial load
duke
parents:
diff changeset
257 set_req(MemNode::Memory, mem);
305
ab075d07f1ba 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 293
diff changeset
258 if (phase->type( mem ) == Type::TOP) return NodeSentinel;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
259 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
260 }
a61af66fc99e Initial load
duke
parents:
diff changeset
261
a61af66fc99e Initial load
duke
parents:
diff changeset
262 // let the subclass continue analyzing...
a61af66fc99e Initial load
duke
parents:
diff changeset
263 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
264 }
a61af66fc99e Initial load
duke
parents:
diff changeset
265
a61af66fc99e Initial load
duke
parents:
diff changeset
266 // Helper function for proving some simple control dominations.
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
267 // Attempt to prove that all control inputs of 'dom' dominate 'sub'.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
268 // Already assumes that 'dom' is available at 'sub', and that 'sub'
a61af66fc99e Initial load
duke
parents:
diff changeset
269 // is not a constant (dominated by the method's StartNode).
a61af66fc99e Initial load
duke
parents:
diff changeset
270 // Used by MemNode::find_previous_store to prove that the
a61af66fc99e Initial load
duke
parents:
diff changeset
271 // control input of a memory operation predates (dominates)
a61af66fc99e Initial load
duke
parents:
diff changeset
272 // an allocation it wants to look past.
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
273 bool MemNode::all_controls_dominate(Node* dom, Node* sub) {
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
274 if (dom == NULL || dom->is_top() || sub == NULL || sub->is_top())
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
275 return false; // Conservative answer for dead code
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
276
193
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
277 // Check 'dom'. Skip Proj and CatchProj nodes.
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
278 dom = dom->find_exact_control(dom);
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
279 if (dom == NULL || dom->is_top())
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
280 return false; // Conservative answer for dead code
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
281
193
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
282 if (dom == sub) {
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
283 // For the case when, for example, 'sub' is Initialize and the original
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
284 // 'dom' is Proj node of the 'sub'.
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
285 return false;
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
286 }
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
287
155
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 128
diff changeset
288 if (dom->is_Con() || dom->is_Start() || dom->is_Root() || dom == sub)
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
289 return true;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
290
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
291 // 'dom' dominates 'sub' if its control edge and control edges
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
292 // of all its inputs dominate or equal to sub's control edge.
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
293
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
294 // Currently 'sub' is either Allocate, Initialize or Start nodes.
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
295 // Or Region for the check in LoadNode::Ideal();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
296 // 'sub' should have sub->in(0) != NULL.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
297 assert(sub->is_Allocate() || sub->is_Initialize() || sub->is_Start() ||
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
298 sub->is_Region(), "expecting only these nodes");
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
299
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
300 // Get control edge of 'sub'.
193
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
301 Node* orig_sub = sub;
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
302 sub = sub->find_exact_control(sub->in(0));
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
303 if (sub == NULL || sub->is_top())
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
304 return false; // Conservative answer for dead code
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
305
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
306 assert(sub->is_CFG(), "expecting control");
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
307
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
308 if (sub == dom)
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
309 return true;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
310
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
311 if (sub->is_Start() || sub->is_Root())
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
312 return false;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
313
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
314 {
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
315 // Check all control edges of 'dom'.
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
316
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
317 ResourceMark rm;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
318 Arena* arena = Thread::current()->resource_area();
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
319 Node_List nlist(arena);
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
320 Unique_Node_List dom_list(arena);
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
321
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
322 dom_list.push(dom);
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
323 bool only_dominating_controls = false;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
324
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
325 for (uint next = 0; next < dom_list.size(); next++) {
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
326 Node* n = dom_list.at(next);
193
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
327 if (n == orig_sub)
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
328 return false; // One of dom's inputs dominated by sub.
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
329 if (!n->is_CFG() && n->pinned()) {
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
330 // Check only own control edge for pinned non-control nodes.
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
331 n = n->find_exact_control(n->in(0));
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
332 if (n == NULL || n->is_top())
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
333 return false; // Conservative answer for dead code
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
334 assert(n->is_CFG(), "expecting control");
193
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
335 dom_list.push(n);
44a553b2809d 6714406: Node::dominates() does not always check for TOP
kvn
parents: 169
diff changeset
336 } else if (n->is_Con() || n->is_Start() || n->is_Root()) {
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
337 only_dominating_controls = true;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
338 } else if (n->is_CFG()) {
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
339 if (n->dominates(sub, nlist))
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
340 only_dominating_controls = true;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
341 else
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
342 return false;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
343 } else {
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
344 // First, own control edge.
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
345 Node* m = n->find_exact_control(n->in(0));
155
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 128
diff changeset
346 if (m != NULL) {
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 128
diff changeset
347 if (m->is_top())
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 128
diff changeset
348 return false; // Conservative answer for dead code
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 128
diff changeset
349 dom_list.push(m);
723be81c1212 6701887: JDK7 server VM in endless loop in Node::dominates
kvn
parents: 128
diff changeset
350 }
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
351 // Now, the rest of edges.
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
352 uint cnt = n->req();
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
353 for (uint i = 1; i < cnt; i++) {
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
354 m = n->find_exact_control(n->in(i));
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
355 if (m == NULL || m->is_top())
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
356 continue;
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
357 dom_list.push(m);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
358 }
a61af66fc99e Initial load
duke
parents:
diff changeset
359 }
a61af66fc99e Initial load
duke
parents:
diff changeset
360 }
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
361 return only_dominating_controls;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
362 }
a61af66fc99e Initial load
duke
parents:
diff changeset
363 }
a61af66fc99e Initial load
duke
parents:
diff changeset
364
a61af66fc99e Initial load
duke
parents:
diff changeset
365 //---------------------detect_ptr_independence---------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
366 // Used by MemNode::find_previous_store to prove that two base
a61af66fc99e Initial load
duke
parents:
diff changeset
367 // pointers are never equal.
a61af66fc99e Initial load
duke
parents:
diff changeset
368 // The pointers are accompanied by their associated allocations,
a61af66fc99e Initial load
duke
parents:
diff changeset
369 // if any, which have been previously discovered by the caller.
a61af66fc99e Initial load
duke
parents:
diff changeset
370 bool MemNode::detect_ptr_independence(Node* p1, AllocateNode* a1,
a61af66fc99e Initial load
duke
parents:
diff changeset
371 Node* p2, AllocateNode* a2,
a61af66fc99e Initial load
duke
parents:
diff changeset
372 PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
373 // Attempt to prove that these two pointers cannot be aliased.
a61af66fc99e Initial load
duke
parents:
diff changeset
374 // They may both manifestly be allocations, and they should differ.
a61af66fc99e Initial load
duke
parents:
diff changeset
375 // Or, if they are not both allocations, they can be distinct constants.
a61af66fc99e Initial load
duke
parents:
diff changeset
376 // Otherwise, one is an allocation and the other a pre-existing value.
a61af66fc99e Initial load
duke
parents:
diff changeset
377 if (a1 == NULL && a2 == NULL) { // neither an allocation
a61af66fc99e Initial load
duke
parents:
diff changeset
378 return (p1 != p2) && p1->is_Con() && p2->is_Con();
a61af66fc99e Initial load
duke
parents:
diff changeset
379 } else if (a1 != NULL && a2 != NULL) { // both allocations
a61af66fc99e Initial load
duke
parents:
diff changeset
380 return (a1 != a2);
a61af66fc99e Initial load
duke
parents:
diff changeset
381 } else if (a1 != NULL) { // one allocation a1
a61af66fc99e Initial load
duke
parents:
diff changeset
382 // (Note: p2->is_Con implies p2->in(0)->is_Root, which dominates.)
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
383 return all_controls_dominate(p2, a1);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
384 } else { //(a2 != NULL) // one allocation a2
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
385 return all_controls_dominate(p1, a2);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
386 }
a61af66fc99e Initial load
duke
parents:
diff changeset
387 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
388 }
a61af66fc99e Initial load
duke
parents:
diff changeset
389
a61af66fc99e Initial load
duke
parents:
diff changeset
390
a61af66fc99e Initial load
duke
parents:
diff changeset
391 // The logic for reordering loads and stores uses four steps:
a61af66fc99e Initial load
duke
parents:
diff changeset
392 // (a) Walk carefully past stores and initializations which we
a61af66fc99e Initial load
duke
parents:
diff changeset
393 // can prove are independent of this load.
a61af66fc99e Initial load
duke
parents:
diff changeset
394 // (b) Observe that the next memory state makes an exact match
a61af66fc99e Initial load
duke
parents:
diff changeset
395 // with self (load or store), and locate the relevant store.
a61af66fc99e Initial load
duke
parents:
diff changeset
396 // (c) Ensure that, if we were to wire self directly to the store,
a61af66fc99e Initial load
duke
parents:
diff changeset
397 // the optimizer would fold it up somehow.
a61af66fc99e Initial load
duke
parents:
diff changeset
398 // (d) Do the rewiring, and return, depending on some other part of
a61af66fc99e Initial load
duke
parents:
diff changeset
399 // the optimizer to fold up the load.
a61af66fc99e Initial load
duke
parents:
diff changeset
400 // This routine handles steps (a) and (b). Steps (c) and (d) are
a61af66fc99e Initial load
duke
parents:
diff changeset
401 // specific to loads and stores, so they are handled by the callers.
a61af66fc99e Initial load
duke
parents:
diff changeset
402 // (Currently, only LoadNode::Ideal has steps (c), (d). More later.)
a61af66fc99e Initial load
duke
parents:
diff changeset
403 //
a61af66fc99e Initial load
duke
parents:
diff changeset
404 Node* MemNode::find_previous_store(PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
405 Node* ctrl = in(MemNode::Control);
a61af66fc99e Initial load
duke
parents:
diff changeset
406 Node* adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
407 intptr_t offset = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
408 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
409 AllocateNode* alloc = AllocateNode::Ideal_allocation(base, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
410
a61af66fc99e Initial load
duke
parents:
diff changeset
411 if (offset == Type::OffsetBot)
a61af66fc99e Initial load
duke
parents:
diff changeset
412 return NULL; // cannot unalias unless there are precise offsets
a61af66fc99e Initial load
duke
parents:
diff changeset
413
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
414 const TypeOopPtr *addr_t = adr->bottom_type()->isa_oopptr();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
415
0
a61af66fc99e Initial load
duke
parents:
diff changeset
416 intptr_t size_in_bytes = memory_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
417
a61af66fc99e Initial load
duke
parents:
diff changeset
418 Node* mem = in(MemNode::Memory); // start searching here...
a61af66fc99e Initial load
duke
parents:
diff changeset
419
a61af66fc99e Initial load
duke
parents:
diff changeset
420 int cnt = 50; // Cycle limiter
a61af66fc99e Initial load
duke
parents:
diff changeset
421 for (;;) { // While we can dance past unrelated stores...
a61af66fc99e Initial load
duke
parents:
diff changeset
422 if (--cnt < 0) break; // Caught in cycle or a complicated dance?
a61af66fc99e Initial load
duke
parents:
diff changeset
423
a61af66fc99e Initial load
duke
parents:
diff changeset
424 if (mem->is_Store()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
425 Node* st_adr = mem->in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
426 intptr_t st_offset = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
427 Node* st_base = AddPNode::Ideal_base_and_offset(st_adr, phase, st_offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
428 if (st_base == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
429 break; // inscrutable pointer
a61af66fc99e Initial load
duke
parents:
diff changeset
430 if (st_offset != offset && st_offset != Type::OffsetBot) {
a61af66fc99e Initial load
duke
parents:
diff changeset
431 const int MAX_STORE = BytesPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
432 if (st_offset >= offset + size_in_bytes ||
a61af66fc99e Initial load
duke
parents:
diff changeset
433 st_offset <= offset - MAX_STORE ||
a61af66fc99e Initial load
duke
parents:
diff changeset
434 st_offset <= offset - mem->as_Store()->memory_size()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
435 // Success: The offsets are provably independent.
a61af66fc99e Initial load
duke
parents:
diff changeset
436 // (You may ask, why not just test st_offset != offset and be done?
a61af66fc99e Initial load
duke
parents:
diff changeset
437 // The answer is that stores of different sizes can co-exist
a61af66fc99e Initial load
duke
parents:
diff changeset
438 // in the same sequence of RawMem effects. We sometimes initialize
a61af66fc99e Initial load
duke
parents:
diff changeset
439 // a whole 'tile' of array elements with a single jint or jlong.)
a61af66fc99e Initial load
duke
parents:
diff changeset
440 mem = mem->in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
441 continue; // (a) advance through independent store memory
a61af66fc99e Initial load
duke
parents:
diff changeset
442 }
a61af66fc99e Initial load
duke
parents:
diff changeset
443 }
a61af66fc99e Initial load
duke
parents:
diff changeset
444 if (st_base != base &&
a61af66fc99e Initial load
duke
parents:
diff changeset
445 detect_ptr_independence(base, alloc,
a61af66fc99e Initial load
duke
parents:
diff changeset
446 st_base,
a61af66fc99e Initial load
duke
parents:
diff changeset
447 AllocateNode::Ideal_allocation(st_base, phase),
a61af66fc99e Initial load
duke
parents:
diff changeset
448 phase)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
449 // Success: The bases are provably independent.
a61af66fc99e Initial load
duke
parents:
diff changeset
450 mem = mem->in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
451 continue; // (a) advance through independent store memory
a61af66fc99e Initial load
duke
parents:
diff changeset
452 }
a61af66fc99e Initial load
duke
parents:
diff changeset
453
a61af66fc99e Initial load
duke
parents:
diff changeset
454 // (b) At this point, if the bases or offsets do not agree, we lose,
a61af66fc99e Initial load
duke
parents:
diff changeset
455 // since we have not managed to prove 'this' and 'mem' independent.
a61af66fc99e Initial load
duke
parents:
diff changeset
456 if (st_base == base && st_offset == offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
457 return mem; // let caller handle steps (c), (d)
a61af66fc99e Initial load
duke
parents:
diff changeset
458 }
a61af66fc99e Initial load
duke
parents:
diff changeset
459
a61af66fc99e Initial load
duke
parents:
diff changeset
460 } else if (mem->is_Proj() && mem->in(0)->is_Initialize()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
461 InitializeNode* st_init = mem->in(0)->as_Initialize();
a61af66fc99e Initial load
duke
parents:
diff changeset
462 AllocateNode* st_alloc = st_init->allocation();
a61af66fc99e Initial load
duke
parents:
diff changeset
463 if (st_alloc == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
464 break; // something degenerated
a61af66fc99e Initial load
duke
parents:
diff changeset
465 bool known_identical = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
466 bool known_independent = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
467 if (alloc == st_alloc)
a61af66fc99e Initial load
duke
parents:
diff changeset
468 known_identical = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
469 else if (alloc != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
470 known_independent = true;
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
471 else if (all_controls_dominate(this, st_alloc))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
472 known_independent = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
473
a61af66fc99e Initial load
duke
parents:
diff changeset
474 if (known_independent) {
a61af66fc99e Initial load
duke
parents:
diff changeset
475 // The bases are provably independent: Either they are
a61af66fc99e Initial load
duke
parents:
diff changeset
476 // manifestly distinct allocations, or else the control
a61af66fc99e Initial load
duke
parents:
diff changeset
477 // of this load dominates the store's allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
478 int alias_idx = phase->C->get_alias_index(adr_type());
a61af66fc99e Initial load
duke
parents:
diff changeset
479 if (alias_idx == Compile::AliasIdxRaw) {
a61af66fc99e Initial load
duke
parents:
diff changeset
480 mem = st_alloc->in(TypeFunc::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
481 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
482 mem = st_init->memory(alias_idx);
a61af66fc99e Initial load
duke
parents:
diff changeset
483 }
a61af66fc99e Initial load
duke
parents:
diff changeset
484 continue; // (a) advance through independent store memory
a61af66fc99e Initial load
duke
parents:
diff changeset
485 }
a61af66fc99e Initial load
duke
parents:
diff changeset
486
a61af66fc99e Initial load
duke
parents:
diff changeset
487 // (b) at this point, if we are not looking at a store initializing
a61af66fc99e Initial load
duke
parents:
diff changeset
488 // the same allocation we are loading from, we lose.
a61af66fc99e Initial load
duke
parents:
diff changeset
489 if (known_identical) {
a61af66fc99e Initial load
duke
parents:
diff changeset
490 // From caller, can_see_stored_value will consult find_captured_store.
a61af66fc99e Initial load
duke
parents:
diff changeset
491 return mem; // let caller handle steps (c), (d)
a61af66fc99e Initial load
duke
parents:
diff changeset
492 }
a61af66fc99e Initial load
duke
parents:
diff changeset
493
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
494 } else if (addr_t != NULL && addr_t->is_known_instance_field()) {
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
495 // Can't use optimize_simple_memory_chain() since it needs PhaseGVN.
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
496 if (mem->is_Proj() && mem->in(0)->is_Call()) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
497 CallNode *call = mem->in(0)->as_Call();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
498 if (!call->may_modify(addr_t, phase)) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
499 mem = call->in(TypeFunc::Memory);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
500 continue; // (a) advance through independent call memory
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
501 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
502 } else if (mem->is_Proj() && mem->in(0)->is_MemBar()) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
503 mem = mem->in(0)->in(TypeFunc::Memory);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
504 continue; // (a) advance through independent MemBar memory
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
505 } else if (mem->is_MergeMem()) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
506 int alias_idx = phase->C->get_alias_index(adr_type());
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
507 mem = mem->as_MergeMem()->memory_at(alias_idx);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
508 continue; // (a) advance through independent MergeMem memory
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
509 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
510 }
a61af66fc99e Initial load
duke
parents:
diff changeset
511
a61af66fc99e Initial load
duke
parents:
diff changeset
512 // Unless there is an explicit 'continue', we must bail out here,
a61af66fc99e Initial load
duke
parents:
diff changeset
513 // because 'mem' is an inscrutable memory state (e.g., a call).
a61af66fc99e Initial load
duke
parents:
diff changeset
514 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
515 }
a61af66fc99e Initial load
duke
parents:
diff changeset
516
a61af66fc99e Initial load
duke
parents:
diff changeset
517 return NULL; // bail out
a61af66fc99e Initial load
duke
parents:
diff changeset
518 }
a61af66fc99e Initial load
duke
parents:
diff changeset
519
a61af66fc99e Initial load
duke
parents:
diff changeset
520 //----------------------calculate_adr_type-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
521 // Helper function. Notices when the given type of address hits top or bottom.
a61af66fc99e Initial load
duke
parents:
diff changeset
522 // Also, asserts a cross-check of the type against the expected address type.
a61af66fc99e Initial load
duke
parents:
diff changeset
523 const TypePtr* MemNode::calculate_adr_type(const Type* t, const TypePtr* cross_check) {
a61af66fc99e Initial load
duke
parents:
diff changeset
524 if (t == Type::TOP) return NULL; // does not touch memory any more?
a61af66fc99e Initial load
duke
parents:
diff changeset
525 #ifdef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
526 cross_check = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
527 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
528 if (!VerifyAliases || is_error_reported() || Node::in_dump()) cross_check = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
529 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
530 const TypePtr* tp = t->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
531 if (tp == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
532 assert(cross_check == NULL || cross_check == TypePtr::BOTTOM, "expected memory type must be wide");
a61af66fc99e Initial load
duke
parents:
diff changeset
533 return TypePtr::BOTTOM; // touches lots of memory
a61af66fc99e Initial load
duke
parents:
diff changeset
534 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
535 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
536 // %%%% [phh] We don't check the alias index if cross_check is
a61af66fc99e Initial load
duke
parents:
diff changeset
537 // TypeRawPtr::BOTTOM. Needs to be investigated.
a61af66fc99e Initial load
duke
parents:
diff changeset
538 if (cross_check != NULL &&
a61af66fc99e Initial load
duke
parents:
diff changeset
539 cross_check != TypePtr::BOTTOM &&
a61af66fc99e Initial load
duke
parents:
diff changeset
540 cross_check != TypeRawPtr::BOTTOM) {
a61af66fc99e Initial load
duke
parents:
diff changeset
541 // Recheck the alias index, to see if it has changed (due to a bug).
a61af66fc99e Initial load
duke
parents:
diff changeset
542 Compile* C = Compile::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
543 assert(C->get_alias_index(cross_check) == C->get_alias_index(tp),
a61af66fc99e Initial load
duke
parents:
diff changeset
544 "must stay in the original alias category");
a61af66fc99e Initial load
duke
parents:
diff changeset
545 // The type of the address must be contained in the adr_type,
a61af66fc99e Initial load
duke
parents:
diff changeset
546 // disregarding "null"-ness.
a61af66fc99e Initial load
duke
parents:
diff changeset
547 // (We make an exception for TypeRawPtr::BOTTOM, which is a bit bucket.)
a61af66fc99e Initial load
duke
parents:
diff changeset
548 const TypePtr* tp_notnull = tp->join(TypePtr::NOTNULL)->is_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
549 assert(cross_check->meet(tp_notnull) == cross_check,
a61af66fc99e Initial load
duke
parents:
diff changeset
550 "real address must not escape from expected memory type");
a61af66fc99e Initial load
duke
parents:
diff changeset
551 }
a61af66fc99e Initial load
duke
parents:
diff changeset
552 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
553 return tp;
a61af66fc99e Initial load
duke
parents:
diff changeset
554 }
a61af66fc99e Initial load
duke
parents:
diff changeset
555 }
a61af66fc99e Initial load
duke
parents:
diff changeset
556
a61af66fc99e Initial load
duke
parents:
diff changeset
557 //------------------------adr_phi_is_loop_invariant----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
558 // A helper function for Ideal_DU_postCCP to check if a Phi in a counted
a61af66fc99e Initial load
duke
parents:
diff changeset
559 // loop is loop invariant. Make a quick traversal of Phi and associated
a61af66fc99e Initial load
duke
parents:
diff changeset
560 // CastPP nodes, looking to see if they are a closed group within the loop.
a61af66fc99e Initial load
duke
parents:
diff changeset
561 bool MemNode::adr_phi_is_loop_invariant(Node* adr_phi, Node* cast) {
a61af66fc99e Initial load
duke
parents:
diff changeset
562 // The idea is that the phi-nest must boil down to only CastPP nodes
a61af66fc99e Initial load
duke
parents:
diff changeset
563 // with the same data. This implies that any path into the loop already
a61af66fc99e Initial load
duke
parents:
diff changeset
564 // includes such a CastPP, and so the original cast, whatever its input,
a61af66fc99e Initial load
duke
parents:
diff changeset
565 // must be covered by an equivalent cast, with an earlier control input.
a61af66fc99e Initial load
duke
parents:
diff changeset
566 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
567
a61af66fc99e Initial load
duke
parents:
diff changeset
568 // The loop entry input of the phi should be the unique dominating
a61af66fc99e Initial load
duke
parents:
diff changeset
569 // node for every Phi/CastPP in the loop.
a61af66fc99e Initial load
duke
parents:
diff changeset
570 Unique_Node_List closure;
a61af66fc99e Initial load
duke
parents:
diff changeset
571 closure.push(adr_phi->in(LoopNode::EntryControl));
a61af66fc99e Initial load
duke
parents:
diff changeset
572
a61af66fc99e Initial load
duke
parents:
diff changeset
573 // Add the phi node and the cast to the worklist.
a61af66fc99e Initial load
duke
parents:
diff changeset
574 Unique_Node_List worklist;
a61af66fc99e Initial load
duke
parents:
diff changeset
575 worklist.push(adr_phi);
a61af66fc99e Initial load
duke
parents:
diff changeset
576 if( cast != NULL ){
a61af66fc99e Initial load
duke
parents:
diff changeset
577 if( !cast->is_ConstraintCast() ) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
578 worklist.push(cast);
a61af66fc99e Initial load
duke
parents:
diff changeset
579 }
a61af66fc99e Initial load
duke
parents:
diff changeset
580
a61af66fc99e Initial load
duke
parents:
diff changeset
581 // Begin recursive walk of phi nodes.
a61af66fc99e Initial load
duke
parents:
diff changeset
582 while( worklist.size() ){
a61af66fc99e Initial load
duke
parents:
diff changeset
583 // Take a node off the worklist
a61af66fc99e Initial load
duke
parents:
diff changeset
584 Node *n = worklist.pop();
a61af66fc99e Initial load
duke
parents:
diff changeset
585 if( !closure.member(n) ){
a61af66fc99e Initial load
duke
parents:
diff changeset
586 // Add it to the closure.
a61af66fc99e Initial load
duke
parents:
diff changeset
587 closure.push(n);
a61af66fc99e Initial load
duke
parents:
diff changeset
588 // Make a sanity check to ensure we don't waste too much time here.
a61af66fc99e Initial load
duke
parents:
diff changeset
589 if( closure.size() > 20) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
590 // This node is OK if:
a61af66fc99e Initial load
duke
parents:
diff changeset
591 // - it is a cast of an identical value
a61af66fc99e Initial load
duke
parents:
diff changeset
592 // - or it is a phi node (then we add its inputs to the worklist)
a61af66fc99e Initial load
duke
parents:
diff changeset
593 // Otherwise, the node is not OK, and we presume the cast is not invariant
a61af66fc99e Initial load
duke
parents:
diff changeset
594 if( n->is_ConstraintCast() ){
a61af66fc99e Initial load
duke
parents:
diff changeset
595 worklist.push(n->in(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
596 } else if( n->is_Phi() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
597 for( uint i = 1; i < n->req(); i++ ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
598 worklist.push(n->in(i));
a61af66fc99e Initial load
duke
parents:
diff changeset
599 }
a61af66fc99e Initial load
duke
parents:
diff changeset
600 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
601 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
602 }
a61af66fc99e Initial load
duke
parents:
diff changeset
603 }
a61af66fc99e Initial load
duke
parents:
diff changeset
604 }
a61af66fc99e Initial load
duke
parents:
diff changeset
605
a61af66fc99e Initial load
duke
parents:
diff changeset
606 // Quit when the worklist is empty, and we've found no offending nodes.
a61af66fc99e Initial load
duke
parents:
diff changeset
607 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
608 }
a61af66fc99e Initial load
duke
parents:
diff changeset
609
a61af66fc99e Initial load
duke
parents:
diff changeset
610 //------------------------------Ideal_DU_postCCP-------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
611 // Find any cast-away of null-ness and keep its control. Null cast-aways are
a61af66fc99e Initial load
duke
parents:
diff changeset
612 // going away in this pass and we need to make this memory op depend on the
a61af66fc99e Initial load
duke
parents:
diff changeset
613 // gating null check.
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
614 Node *MemNode::Ideal_DU_postCCP( PhaseCCP *ccp ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
615 return Ideal_common_DU_postCCP(ccp, this, in(MemNode::Address));
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
616 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
617
a61af66fc99e Initial load
duke
parents:
diff changeset
618 // I tried to leave the CastPP's in. This makes the graph more accurate in
a61af66fc99e Initial load
duke
parents:
diff changeset
619 // some sense; we get to keep around the knowledge that an oop is not-null
a61af66fc99e Initial load
duke
parents:
diff changeset
620 // after some test. Alas, the CastPP's interfere with GVN (some values are
a61af66fc99e Initial load
duke
parents:
diff changeset
621 // the regular oop, some are the CastPP of the oop, all merge at Phi's which
a61af66fc99e Initial load
duke
parents:
diff changeset
622 // cannot collapse, etc). This cost us 10% on SpecJVM, even when I removed
a61af66fc99e Initial load
duke
parents:
diff changeset
623 // some of the more trivial cases in the optimizer. Removing more useless
a61af66fc99e Initial load
duke
parents:
diff changeset
624 // Phi's started allowing Loads to illegally float above null checks. I gave
a61af66fc99e Initial load
duke
parents:
diff changeset
625 // up on this approach. CNC 10/20/2000
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
626 // This static method may be called not from MemNode (EncodePNode calls it).
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
627 // Only the control edge of the node 'n' might be updated.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
628 Node *MemNode::Ideal_common_DU_postCCP( PhaseCCP *ccp, Node* n, Node* adr ) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
629 Node *skipped_cast = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
630 // Need a null check? Regular static accesses do not because they are
a61af66fc99e Initial load
duke
parents:
diff changeset
631 // from constant addresses. Array ops are gated by the range check (which
a61af66fc99e Initial load
duke
parents:
diff changeset
632 // always includes a NULL check). Just check field ops.
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
633 if( n->in(MemNode::Control) == NULL ) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
634 // Scan upwards for the highest location we can place this memory op.
a61af66fc99e Initial load
duke
parents:
diff changeset
635 while( true ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
636 switch( adr->Opcode() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
637
a61af66fc99e Initial load
duke
parents:
diff changeset
638 case Op_AddP: // No change to NULL-ness, so peek thru AddP's
a61af66fc99e Initial load
duke
parents:
diff changeset
639 adr = adr->in(AddPNode::Base);
a61af66fc99e Initial load
duke
parents:
diff changeset
640 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
641
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
642 case Op_DecodeN: // No change to NULL-ness, so peek thru
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
643 adr = adr->in(1);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
644 continue;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
645
0
a61af66fc99e Initial load
duke
parents:
diff changeset
646 case Op_CastPP:
a61af66fc99e Initial load
duke
parents:
diff changeset
647 // If the CastPP is useless, just peek on through it.
a61af66fc99e Initial load
duke
parents:
diff changeset
648 if( ccp->type(adr) == ccp->type(adr->in(1)) ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
649 // Remember the cast that we've peeked though. If we peek
a61af66fc99e Initial load
duke
parents:
diff changeset
650 // through more than one, then we end up remembering the highest
a61af66fc99e Initial load
duke
parents:
diff changeset
651 // one, that is, if in a loop, the one closest to the top.
a61af66fc99e Initial load
duke
parents:
diff changeset
652 skipped_cast = adr;
a61af66fc99e Initial load
duke
parents:
diff changeset
653 adr = adr->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
654 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
655 }
a61af66fc99e Initial load
duke
parents:
diff changeset
656 // CastPP is going away in this pass! We need this memory op to be
a61af66fc99e Initial load
duke
parents:
diff changeset
657 // control-dependent on the test that is guarding the CastPP.
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
658 ccp->hash_delete(n);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
659 n->set_req(MemNode::Control, adr->in(0));
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
660 ccp->hash_insert(n);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
661 return n;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
662
a61af66fc99e Initial load
duke
parents:
diff changeset
663 case Op_Phi:
a61af66fc99e Initial load
duke
parents:
diff changeset
664 // Attempt to float above a Phi to some dominating point.
a61af66fc99e Initial load
duke
parents:
diff changeset
665 if (adr->in(0) != NULL && adr->in(0)->is_CountedLoop()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
666 // If we've already peeked through a Cast (which could have set the
a61af66fc99e Initial load
duke
parents:
diff changeset
667 // control), we can't float above a Phi, because the skipped Cast
a61af66fc99e Initial load
duke
parents:
diff changeset
668 // may not be loop invariant.
a61af66fc99e Initial load
duke
parents:
diff changeset
669 if (adr_phi_is_loop_invariant(adr, skipped_cast)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
670 adr = adr->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
671 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
672 }
a61af66fc99e Initial load
duke
parents:
diff changeset
673 }
a61af66fc99e Initial load
duke
parents:
diff changeset
674
a61af66fc99e Initial load
duke
parents:
diff changeset
675 // Intentional fallthrough!
a61af66fc99e Initial load
duke
parents:
diff changeset
676
a61af66fc99e Initial load
duke
parents:
diff changeset
677 // No obvious dominating point. The mem op is pinned below the Phi
a61af66fc99e Initial load
duke
parents:
diff changeset
678 // by the Phi itself. If the Phi goes away (no true value is merged)
a61af66fc99e Initial load
duke
parents:
diff changeset
679 // then the mem op can float, but not indefinitely. It must be pinned
a61af66fc99e Initial load
duke
parents:
diff changeset
680 // behind the controls leading to the Phi.
a61af66fc99e Initial load
duke
parents:
diff changeset
681 case Op_CheckCastPP:
a61af66fc99e Initial load
duke
parents:
diff changeset
682 // These usually stick around to change address type, however a
a61af66fc99e Initial load
duke
parents:
diff changeset
683 // useless one can be elided and we still need to pick up a control edge
a61af66fc99e Initial load
duke
parents:
diff changeset
684 if (adr->in(0) == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
685 // This CheckCastPP node has NO control and is likely useless. But we
a61af66fc99e Initial load
duke
parents:
diff changeset
686 // need check further up the ancestor chain for a control input to keep
a61af66fc99e Initial load
duke
parents:
diff changeset
687 // the node in place. 4959717.
a61af66fc99e Initial load
duke
parents:
diff changeset
688 skipped_cast = adr;
a61af66fc99e Initial load
duke
parents:
diff changeset
689 adr = adr->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
690 continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
691 }
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
692 ccp->hash_delete(n);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
693 n->set_req(MemNode::Control, adr->in(0));
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
694 ccp->hash_insert(n);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
695 return n;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
696
a61af66fc99e Initial load
duke
parents:
diff changeset
697 // List of "safe" opcodes; those that implicitly block the memory
a61af66fc99e Initial load
duke
parents:
diff changeset
698 // op below any null check.
a61af66fc99e Initial load
duke
parents:
diff changeset
699 case Op_CastX2P: // no null checks on native pointers
a61af66fc99e Initial load
duke
parents:
diff changeset
700 case Op_Parm: // 'this' pointer is not null
a61af66fc99e Initial load
duke
parents:
diff changeset
701 case Op_LoadP: // Loading from within a klass
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
702 case Op_LoadN: // Loading from within a klass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
703 case Op_LoadKlass: // Loading from within a klass
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
704 case Op_LoadNKlass: // Loading from within a klass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
705 case Op_ConP: // Loading from a klass
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
706 case Op_ConN: // Loading from a klass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
707 case Op_CreateEx: // Sucking up the guts of an exception oop
a61af66fc99e Initial load
duke
parents:
diff changeset
708 case Op_Con: // Reading from TLS
a61af66fc99e Initial load
duke
parents:
diff changeset
709 case Op_CMoveP: // CMoveP is pinned
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
710 case Op_CMoveN: // CMoveN is pinned
0
a61af66fc99e Initial load
duke
parents:
diff changeset
711 break; // No progress
a61af66fc99e Initial load
duke
parents:
diff changeset
712
a61af66fc99e Initial load
duke
parents:
diff changeset
713 case Op_Proj: // Direct call to an allocation routine
a61af66fc99e Initial load
duke
parents:
diff changeset
714 case Op_SCMemProj: // Memory state from store conditional ops
a61af66fc99e Initial load
duke
parents:
diff changeset
715 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
716 {
a61af66fc99e Initial load
duke
parents:
diff changeset
717 assert(adr->as_Proj()->_con == TypeFunc::Parms, "must be return value");
a61af66fc99e Initial load
duke
parents:
diff changeset
718 const Node* call = adr->in(0);
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
719 if (call->is_CallJava()) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
720 const CallJavaNode* call_java = call->as_CallJava();
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
721 const TypeTuple *r = call_java->tf()->range();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
722 assert(r->cnt() > TypeFunc::Parms, "must return value");
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
723 const Type* ret_type = r->field_at(TypeFunc::Parms);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
724 assert(ret_type && ret_type->isa_ptr(), "must return pointer");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
725 // We further presume that this is one of
a61af66fc99e Initial load
duke
parents:
diff changeset
726 // new_instance_Java, new_array_Java, or
a61af66fc99e Initial load
duke
parents:
diff changeset
727 // the like, but do not assert for this.
a61af66fc99e Initial load
duke
parents:
diff changeset
728 } else if (call->is_Allocate()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
729 // similar case to new_instance_Java, etc.
a61af66fc99e Initial load
duke
parents:
diff changeset
730 } else if (!call->is_CallLeaf()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
731 // Projections from fetch_oop (OSR) are allowed as well.
a61af66fc99e Initial load
duke
parents:
diff changeset
732 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
733 }
a61af66fc99e Initial load
duke
parents:
diff changeset
734 }
a61af66fc99e Initial load
duke
parents:
diff changeset
735 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
736 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
737 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
738 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
739 }
a61af66fc99e Initial load
duke
parents:
diff changeset
740 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
741 }
a61af66fc99e Initial load
duke
parents:
diff changeset
742 }
a61af66fc99e Initial load
duke
parents:
diff changeset
743
a61af66fc99e Initial load
duke
parents:
diff changeset
744 return NULL; // No progress
a61af66fc99e Initial load
duke
parents:
diff changeset
745 }
a61af66fc99e Initial load
duke
parents:
diff changeset
746
a61af66fc99e Initial load
duke
parents:
diff changeset
747
a61af66fc99e Initial load
duke
parents:
diff changeset
748 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
749 uint LoadNode::size_of() const { return sizeof(*this); }
a61af66fc99e Initial load
duke
parents:
diff changeset
750 uint LoadNode::cmp( const Node &n ) const
a61af66fc99e Initial load
duke
parents:
diff changeset
751 { return !Type::cmp( _type, ((LoadNode&)n)._type ); }
a61af66fc99e Initial load
duke
parents:
diff changeset
752 const Type *LoadNode::bottom_type() const { return _type; }
a61af66fc99e Initial load
duke
parents:
diff changeset
753 uint LoadNode::ideal_reg() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
754 return Matcher::base2reg[_type->base()];
a61af66fc99e Initial load
duke
parents:
diff changeset
755 }
a61af66fc99e Initial load
duke
parents:
diff changeset
756
a61af66fc99e Initial load
duke
parents:
diff changeset
757 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
758 void LoadNode::dump_spec(outputStream *st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
759 MemNode::dump_spec(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
760 if( !Verbose && !WizardMode ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
761 // standard dump does this in Verbose and WizardMode
a61af66fc99e Initial load
duke
parents:
diff changeset
762 st->print(" #"); _type->dump_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
763 }
a61af66fc99e Initial load
duke
parents:
diff changeset
764 }
a61af66fc99e Initial load
duke
parents:
diff changeset
765 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
766
a61af66fc99e Initial load
duke
parents:
diff changeset
767
a61af66fc99e Initial load
duke
parents:
diff changeset
768 //----------------------------LoadNode::make-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
769 // Polymorphic factory method:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
770 Node *LoadNode::make( PhaseGVN& gvn, Node *ctl, Node *mem, Node *adr, const TypePtr* adr_type, const Type *rt, BasicType bt ) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
771 Compile* C = gvn.C;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
772
0
a61af66fc99e Initial load
duke
parents:
diff changeset
773 // sanity check the alias category against the created node type
a61af66fc99e Initial load
duke
parents:
diff changeset
774 assert(!(adr_type->isa_oopptr() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
775 adr_type->offset() == oopDesc::klass_offset_in_bytes()),
a61af66fc99e Initial load
duke
parents:
diff changeset
776 "use LoadKlassNode instead");
a61af66fc99e Initial load
duke
parents:
diff changeset
777 assert(!(adr_type->isa_aryptr() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
778 adr_type->offset() == arrayOopDesc::length_offset_in_bytes()),
a61af66fc99e Initial load
duke
parents:
diff changeset
779 "use LoadRangeNode instead");
a61af66fc99e Initial load
duke
parents:
diff changeset
780 switch (bt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
781 case T_BOOLEAN:
a61af66fc99e Initial load
duke
parents:
diff changeset
782 case T_BYTE: return new (C, 3) LoadBNode(ctl, mem, adr, adr_type, rt->is_int() );
a61af66fc99e Initial load
duke
parents:
diff changeset
783 case T_INT: return new (C, 3) LoadINode(ctl, mem, adr, adr_type, rt->is_int() );
a61af66fc99e Initial load
duke
parents:
diff changeset
784 case T_CHAR: return new (C, 3) LoadCNode(ctl, mem, adr, adr_type, rt->is_int() );
a61af66fc99e Initial load
duke
parents:
diff changeset
785 case T_SHORT: return new (C, 3) LoadSNode(ctl, mem, adr, adr_type, rt->is_int() );
a61af66fc99e Initial load
duke
parents:
diff changeset
786 case T_LONG: return new (C, 3) LoadLNode(ctl, mem, adr, adr_type, rt->is_long() );
a61af66fc99e Initial load
duke
parents:
diff changeset
787 case T_FLOAT: return new (C, 3) LoadFNode(ctl, mem, adr, adr_type, rt );
a61af66fc99e Initial load
duke
parents:
diff changeset
788 case T_DOUBLE: return new (C, 3) LoadDNode(ctl, mem, adr, adr_type, rt );
a61af66fc99e Initial load
duke
parents:
diff changeset
789 case T_ADDRESS: return new (C, 3) LoadPNode(ctl, mem, adr, adr_type, rt->is_ptr() );
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
790 case T_OBJECT:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
791 #ifdef _LP64
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
792 if (adr->bottom_type()->is_ptr_to_narrowoop()) {
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
793 Node* load = gvn.transform(new (C, 3) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop()));
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
794 return new (C, 2) DecodeNNode(load, load->bottom_type()->make_ptr());
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
795 } else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
796 #endif
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
797 {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
798 assert(!adr->bottom_type()->is_ptr_to_narrowoop(), "should have got back a narrow oop");
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
799 return new (C, 3) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr());
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
800 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
801 }
a61af66fc99e Initial load
duke
parents:
diff changeset
802 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
803 return (LoadNode*)NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
804 }
a61af66fc99e Initial load
duke
parents:
diff changeset
805
a61af66fc99e Initial load
duke
parents:
diff changeset
806 LoadLNode* LoadLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
807 bool require_atomic = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
808 return new (C, 3) LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), require_atomic);
a61af66fc99e Initial load
duke
parents:
diff changeset
809 }
a61af66fc99e Initial load
duke
parents:
diff changeset
810
a61af66fc99e Initial load
duke
parents:
diff changeset
811
a61af66fc99e Initial load
duke
parents:
diff changeset
812
a61af66fc99e Initial load
duke
parents:
diff changeset
813
a61af66fc99e Initial load
duke
parents:
diff changeset
814 //------------------------------hash-------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
815 uint LoadNode::hash() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
816 // unroll addition of interesting fields
a61af66fc99e Initial load
duke
parents:
diff changeset
817 return (uintptr_t)in(Control) + (uintptr_t)in(Memory) + (uintptr_t)in(Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
818 }
a61af66fc99e Initial load
duke
parents:
diff changeset
819
a61af66fc99e Initial load
duke
parents:
diff changeset
820 //---------------------------can_see_stored_value------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
821 // This routine exists to make sure this set of tests is done the same
a61af66fc99e Initial load
duke
parents:
diff changeset
822 // everywhere. We need to make a coordinated change: first LoadNode::Ideal
a61af66fc99e Initial load
duke
parents:
diff changeset
823 // will change the graph shape in a way which makes memory alive twice at the
a61af66fc99e Initial load
duke
parents:
diff changeset
824 // same time (uses the Oracle model of aliasing), then some
a61af66fc99e Initial load
duke
parents:
diff changeset
825 // LoadXNode::Identity will fold things back to the equivalence-class model
a61af66fc99e Initial load
duke
parents:
diff changeset
826 // of aliasing.
a61af66fc99e Initial load
duke
parents:
diff changeset
827 Node* MemNode::can_see_stored_value(Node* st, PhaseTransform* phase) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
828 Node* ld_adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
829
17
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
830 const TypeInstPtr* tp = phase->type(ld_adr)->isa_instptr();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
831 Compile::AliasType* atp = tp != NULL ? phase->C->alias_type(tp) : NULL;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
832 if (EliminateAutoBox && atp != NULL && atp->index() >= Compile::AliasIdxRaw &&
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
833 atp->field() != NULL && !atp->field()->is_volatile()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
834 uint alias_idx = atp->index();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
835 bool final = atp->field()->is_final();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
836 Node* result = NULL;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
837 Node* current = st;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
838 // Skip through chains of MemBarNodes checking the MergeMems for
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
839 // new states for the slice of this load. Stop once any other
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
840 // kind of node is encountered. Loads from final memory can skip
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
841 // through any kind of MemBar but normal loads shouldn't skip
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
842 // through MemBarAcquire since the could allow them to move out of
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
843 // a synchronized region.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
844 while (current->is_Proj()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
845 int opc = current->in(0)->Opcode();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
846 if ((final && opc == Op_MemBarAcquire) ||
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
847 opc == Op_MemBarRelease || opc == Op_MemBarCPUOrder) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
848 Node* mem = current->in(0)->in(TypeFunc::Memory);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
849 if (mem->is_MergeMem()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
850 MergeMemNode* merge = mem->as_MergeMem();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
851 Node* new_st = merge->memory_at(alias_idx);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
852 if (new_st == merge->base_memory()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
853 // Keep searching
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
854 current = merge->base_memory();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
855 continue;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
856 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
857 // Save the new memory state for the slice and fall through
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
858 // to exit.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
859 result = new_st;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
860 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
861 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
862 break;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
863 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
864 if (result != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
865 st = result;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
866 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
867 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
868
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
869
0
a61af66fc99e Initial load
duke
parents:
diff changeset
870 // Loop around twice in the case Load -> Initialize -> Store.
a61af66fc99e Initial load
duke
parents:
diff changeset
871 // (See PhaseIterGVN::add_users_to_worklist, which knows about this case.)
a61af66fc99e Initial load
duke
parents:
diff changeset
872 for (int trip = 0; trip <= 1; trip++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
873
a61af66fc99e Initial load
duke
parents:
diff changeset
874 if (st->is_Store()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
875 Node* st_adr = st->in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
876 if (!phase->eqv(st_adr, ld_adr)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
877 // Try harder before giving up... Match raw and non-raw pointers.
a61af66fc99e Initial load
duke
parents:
diff changeset
878 intptr_t st_off = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
879 AllocateNode* alloc = AllocateNode::Ideal_allocation(st_adr, phase, st_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
880 if (alloc == NULL) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
881 intptr_t ld_off = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
882 AllocateNode* allo2 = AllocateNode::Ideal_allocation(ld_adr, phase, ld_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
883 if (alloc != allo2) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
884 if (ld_off != st_off) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
885 // At this point we have proven something like this setup:
a61af66fc99e Initial load
duke
parents:
diff changeset
886 // A = Allocate(...)
a61af66fc99e Initial load
duke
parents:
diff changeset
887 // L = LoadQ(, AddP(CastPP(, A.Parm),, #Off))
a61af66fc99e Initial load
duke
parents:
diff changeset
888 // S = StoreQ(, AddP(, A.Parm , #Off), V)
a61af66fc99e Initial load
duke
parents:
diff changeset
889 // (Actually, we haven't yet proven the Q's are the same.)
a61af66fc99e Initial load
duke
parents:
diff changeset
890 // In other words, we are loading from a casted version of
a61af66fc99e Initial load
duke
parents:
diff changeset
891 // the same pointer-and-offset that we stored to.
a61af66fc99e Initial load
duke
parents:
diff changeset
892 // Thus, we are able to replace L by V.
a61af66fc99e Initial load
duke
parents:
diff changeset
893 }
a61af66fc99e Initial load
duke
parents:
diff changeset
894 // Now prove that we have a LoadQ matched to a StoreQ, for some Q.
a61af66fc99e Initial load
duke
parents:
diff changeset
895 if (store_Opcode() != st->Opcode())
a61af66fc99e Initial load
duke
parents:
diff changeset
896 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
897 return st->in(MemNode::ValueIn);
a61af66fc99e Initial load
duke
parents:
diff changeset
898 }
a61af66fc99e Initial load
duke
parents:
diff changeset
899
a61af66fc99e Initial load
duke
parents:
diff changeset
900 intptr_t offset = 0; // scratch
a61af66fc99e Initial load
duke
parents:
diff changeset
901
a61af66fc99e Initial load
duke
parents:
diff changeset
902 // A load from a freshly-created object always returns zero.
a61af66fc99e Initial load
duke
parents:
diff changeset
903 // (This can happen after LoadNode::Ideal resets the load's memory input
a61af66fc99e Initial load
duke
parents:
diff changeset
904 // to find_captured_store, which returned InitializeNode::zero_memory.)
a61af66fc99e Initial load
duke
parents:
diff changeset
905 if (st->is_Proj() && st->in(0)->is_Allocate() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
906 st->in(0) == AllocateNode::Ideal_allocation(ld_adr, phase, offset) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
907 offset >= st->in(0)->as_Allocate()->minimum_header_size()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
908 // return a zero value for the load's basic type
a61af66fc99e Initial load
duke
parents:
diff changeset
909 // (This is one of the few places where a generic PhaseTransform
a61af66fc99e Initial load
duke
parents:
diff changeset
910 // can create new nodes. Think of it as lazily manifesting
a61af66fc99e Initial load
duke
parents:
diff changeset
911 // virtually pre-existing constants.)
a61af66fc99e Initial load
duke
parents:
diff changeset
912 return phase->zerocon(memory_type());
a61af66fc99e Initial load
duke
parents:
diff changeset
913 }
a61af66fc99e Initial load
duke
parents:
diff changeset
914
a61af66fc99e Initial load
duke
parents:
diff changeset
915 // A load from an initialization barrier can match a captured store.
a61af66fc99e Initial load
duke
parents:
diff changeset
916 if (st->is_Proj() && st->in(0)->is_Initialize()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
917 InitializeNode* init = st->in(0)->as_Initialize();
a61af66fc99e Initial load
duke
parents:
diff changeset
918 AllocateNode* alloc = init->allocation();
a61af66fc99e Initial load
duke
parents:
diff changeset
919 if (alloc != NULL &&
a61af66fc99e Initial load
duke
parents:
diff changeset
920 alloc == AllocateNode::Ideal_allocation(ld_adr, phase, offset)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
921 // examine a captured store value
a61af66fc99e Initial load
duke
parents:
diff changeset
922 st = init->find_captured_store(offset, memory_size(), phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
923 if (st != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
924 continue; // take one more trip around
a61af66fc99e Initial load
duke
parents:
diff changeset
925 }
a61af66fc99e Initial load
duke
parents:
diff changeset
926 }
a61af66fc99e Initial load
duke
parents:
diff changeset
927
a61af66fc99e Initial load
duke
parents:
diff changeset
928 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
929 }
a61af66fc99e Initial load
duke
parents:
diff changeset
930
a61af66fc99e Initial load
duke
parents:
diff changeset
931 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
932 }
a61af66fc99e Initial load
duke
parents:
diff changeset
933
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
934 //----------------------is_instance_field_load_with_local_phi------------------
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
935 bool LoadNode::is_instance_field_load_with_local_phi(Node* ctrl) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
936 if( in(MemNode::Memory)->is_Phi() && in(MemNode::Memory)->in(0) == ctrl &&
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
937 in(MemNode::Address)->is_AddP() ) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
938 const TypeOopPtr* t_oop = in(MemNode::Address)->bottom_type()->isa_oopptr();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
939 // Only instances.
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
940 if( t_oop != NULL && t_oop->is_known_instance_field() &&
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
941 t_oop->offset() != Type::OffsetBot &&
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
942 t_oop->offset() != Type::OffsetTop) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
943 return true;
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
944 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
945 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
946 return false;
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
947 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
948
0
a61af66fc99e Initial load
duke
parents:
diff changeset
949 //------------------------------Identity---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
950 // Loads are identity if previous store is to same address
a61af66fc99e Initial load
duke
parents:
diff changeset
951 Node *LoadNode::Identity( PhaseTransform *phase ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
952 // If the previous store-maker is the right kind of Store, and the store is
a61af66fc99e Initial load
duke
parents:
diff changeset
953 // to the same address, then we are equal to the value stored.
a61af66fc99e Initial load
duke
parents:
diff changeset
954 Node* mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
955 Node* value = can_see_stored_value(mem, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
956 if( value ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
957 // byte, short & char stores truncate naturally.
a61af66fc99e Initial load
duke
parents:
diff changeset
958 // A load has to load the truncated value which requires
a61af66fc99e Initial load
duke
parents:
diff changeset
959 // some sort of masking operation and that requires an
a61af66fc99e Initial load
duke
parents:
diff changeset
960 // Ideal call instead of an Identity call.
a61af66fc99e Initial load
duke
parents:
diff changeset
961 if (memory_size() < BytesPerInt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
962 // If the input to the store does not fit with the load's result type,
a61af66fc99e Initial load
duke
parents:
diff changeset
963 // it must be truncated via an Ideal call.
a61af66fc99e Initial load
duke
parents:
diff changeset
964 if (!phase->type(value)->higher_equal(phase->type(this)))
a61af66fc99e Initial load
duke
parents:
diff changeset
965 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
966 }
a61af66fc99e Initial load
duke
parents:
diff changeset
967 // (This works even when value is a Con, but LoadNode::Value
a61af66fc99e Initial load
duke
parents:
diff changeset
968 // usually runs first, producing the singleton type of the Con.)
a61af66fc99e Initial load
duke
parents:
diff changeset
969 return value;
a61af66fc99e Initial load
duke
parents:
diff changeset
970 }
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
971
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
972 // Search for an existing data phi which was generated before for the same
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
973 // instance's field to avoid infinite genertion of phis in a loop.
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
974 Node *region = mem->in(0);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
975 if (is_instance_field_load_with_local_phi(region)) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
976 const TypePtr *addr_t = in(MemNode::Address)->bottom_type()->isa_ptr();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
977 int this_index = phase->C->get_alias_index(addr_t);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
978 int this_offset = addr_t->offset();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
979 int this_id = addr_t->is_oopptr()->instance_id();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
980 const Type* this_type = bottom_type();
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
981 for (DUIterator_Fast imax, i = region->fast_outs(imax); i < imax; i++) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
982 Node* phi = region->fast_out(i);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
983 if (phi->is_Phi() && phi != mem &&
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
984 phi->as_Phi()->is_same_inst_field(this_type, this_id, this_index, this_offset)) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
985 return phi;
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
986 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
987 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
988 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
989
0
a61af66fc99e Initial load
duke
parents:
diff changeset
990 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
991 }
a61af66fc99e Initial load
duke
parents:
diff changeset
992
17
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
993
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
994 // Returns true if the AliasType refers to the field that holds the
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
995 // cached box array. Currently only handles the IntegerCache case.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
996 static bool is_autobox_cache(Compile::AliasType* atp) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
997 if (atp != NULL && atp->field() != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
998 ciField* field = atp->field();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
999 ciSymbol* klass = field->holder()->name();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1000 if (field->name() == ciSymbol::cache_field_name() &&
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1001 field->holder()->uses_default_loader() &&
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1002 klass == ciSymbol::java_lang_Integer_IntegerCache()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1003 return true;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1004 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1005 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1006 return false;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1007 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1008
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1009 // Fetch the base value in the autobox array
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1010 static bool fetch_autobox_base(Compile::AliasType* atp, int& cache_offset) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1011 if (atp != NULL && atp->field() != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1012 ciField* field = atp->field();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1013 ciSymbol* klass = field->holder()->name();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1014 if (field->name() == ciSymbol::cache_field_name() &&
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1015 field->holder()->uses_default_loader() &&
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1016 klass == ciSymbol::java_lang_Integer_IntegerCache()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1017 assert(field->is_constant(), "what?");
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1018 ciObjArray* array = field->constant_value().as_object()->as_obj_array();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1019 // Fetch the box object at the base of the array and get its value
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1020 ciInstance* box = array->obj_at(0)->as_instance();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1021 ciInstanceKlass* ik = box->klass()->as_instance_klass();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1022 if (ik->nof_nonstatic_fields() == 1) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1023 // This should be true nonstatic_field_at requires calling
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1024 // nof_nonstatic_fields so check it anyway
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1025 ciConstant c = box->field_value(ik->nonstatic_field_at(0));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1026 cache_offset = c.as_int();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1027 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1028 return true;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1029 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1030 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1031 return false;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1032 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1033
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1034 // Returns true if the AliasType refers to the value field of an
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1035 // autobox object. Currently only handles Integer.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1036 static bool is_autobox_object(Compile::AliasType* atp) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1037 if (atp != NULL && atp->field() != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1038 ciField* field = atp->field();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1039 ciSymbol* klass = field->holder()->name();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1040 if (field->name() == ciSymbol::value_name() &&
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1041 field->holder()->uses_default_loader() &&
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1042 klass == ciSymbol::java_lang_Integer()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1043 return true;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1044 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1045 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1046 return false;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1047 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1048
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1049
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1050 // We're loading from an object which has autobox behaviour.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1051 // If this object is result of a valueOf call we'll have a phi
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1052 // merging a newly allocated object and a load from the cache.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1053 // We want to replace this load with the original incoming
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1054 // argument to the valueOf call.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1055 Node* LoadNode::eliminate_autobox(PhaseGVN* phase) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1056 Node* base = in(Address)->in(AddPNode::Base);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1057 if (base->is_Phi() && base->req() == 3) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1058 AllocateNode* allocation = NULL;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1059 int allocation_index = -1;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1060 int load_index = -1;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1061 for (uint i = 1; i < base->req(); i++) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1062 allocation = AllocateNode::Ideal_allocation(base->in(i), phase);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1063 if (allocation != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1064 allocation_index = i;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1065 load_index = 3 - allocation_index;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1066 break;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1067 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1068 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1069 LoadNode* load = NULL;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1070 if (allocation != NULL && base->in(load_index)->is_Load()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1071 load = base->in(load_index)->as_Load();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1072 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1073 if (load != NULL && in(Memory)->is_Phi() && in(Memory)->in(0) == base->in(0)) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1074 // Push the loads from the phi that comes from valueOf up
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1075 // through it to allow elimination of the loads and the recovery
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1076 // of the original value.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1077 Node* mem_phi = in(Memory);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1078 Node* offset = in(Address)->in(AddPNode::Offset);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1079
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1080 Node* in1 = clone();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1081 Node* in1_addr = in1->in(Address)->clone();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1082 in1_addr->set_req(AddPNode::Base, base->in(allocation_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1083 in1_addr->set_req(AddPNode::Address, base->in(allocation_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1084 in1_addr->set_req(AddPNode::Offset, offset);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1085 in1->set_req(0, base->in(allocation_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1086 in1->set_req(Address, in1_addr);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1087 in1->set_req(Memory, mem_phi->in(allocation_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1088
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1089 Node* in2 = clone();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1090 Node* in2_addr = in2->in(Address)->clone();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1091 in2_addr->set_req(AddPNode::Base, base->in(load_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1092 in2_addr->set_req(AddPNode::Address, base->in(load_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1093 in2_addr->set_req(AddPNode::Offset, offset);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1094 in2->set_req(0, base->in(load_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1095 in2->set_req(Address, in2_addr);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1096 in2->set_req(Memory, mem_phi->in(load_index));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1097
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1098 in1_addr = phase->transform(in1_addr);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1099 in1 = phase->transform(in1);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1100 in2_addr = phase->transform(in2_addr);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1101 in2 = phase->transform(in2);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1102
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1103 PhiNode* result = PhiNode::make_blank(base->in(0), this);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1104 result->set_req(allocation_index, in1);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1105 result->set_req(load_index, in2);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1106 return result;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1107 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1108 } else if (base->is_Load()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1109 // Eliminate the load of Integer.value for integers from the cache
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1110 // array by deriving the value from the index into the array.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1111 // Capture the offset of the load and then reverse the computation.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1112 Node* load_base = base->in(Address)->in(AddPNode::Base);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1113 if (load_base != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1114 Compile::AliasType* atp = phase->C->alias_type(load_base->adr_type());
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1115 intptr_t cache_offset;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1116 int shift = -1;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1117 Node* cache = NULL;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1118 if (is_autobox_cache(atp)) {
29
d5fc211aea19 6633953: type2aelembytes{T_ADDRESS} should be 8 bytes in 64 bit VM
kvn
parents: 17
diff changeset
1119 shift = exact_log2(type2aelembytes(T_OBJECT));
17
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1120 cache = AddPNode::Ideal_base_and_offset(load_base->in(Address), phase, cache_offset);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1121 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1122 if (cache != NULL && base->in(Address)->is_AddP()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1123 Node* elements[4];
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1124 int count = base->in(Address)->as_AddP()->unpack_offsets(elements, ARRAY_SIZE(elements));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1125 int cache_low;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1126 if (count > 0 && fetch_autobox_base(atp, cache_low)) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1127 int offset = arrayOopDesc::base_offset_in_bytes(memory_type()) - (cache_low << shift);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1128 // Add up all the offsets making of the address of the load
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1129 Node* result = elements[0];
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1130 for (int i = 1; i < count; i++) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1131 result = phase->transform(new (phase->C, 3) AddXNode(result, elements[i]));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1132 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1133 // Remove the constant offset from the address and then
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1134 // remove the scaling of the offset to recover the original index.
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1135 result = phase->transform(new (phase->C, 3) AddXNode(result, phase->MakeConX(-offset)));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1136 if (result->Opcode() == Op_LShiftX && result->in(2) == phase->intcon(shift)) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1137 // Peel the shift off directly but wrap it in a dummy node
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1138 // since Ideal can't return existing nodes
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1139 result = new (phase->C, 3) RShiftXNode(result->in(1), phase->intcon(0));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1140 } else {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1141 result = new (phase->C, 3) RShiftXNode(result, phase->intcon(shift));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1142 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1143 #ifdef _LP64
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1144 result = new (phase->C, 2) ConvL2INode(phase->transform(result));
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1145 #endif
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1146 return result;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1147 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1148 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1149 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1150 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1151 return NULL;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1152 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1153
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1154 //------------------------------split_through_phi------------------------------
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1155 // Split instance field load through Phi.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1156 Node *LoadNode::split_through_phi(PhaseGVN *phase) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1157 Node* mem = in(MemNode::Memory);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1158 Node* address = in(MemNode::Address);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1159 const TypePtr *addr_t = phase->type(address)->isa_ptr();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1160 const TypeOopPtr *t_oop = addr_t->isa_oopptr();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1161
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1162 assert(mem->is_Phi() && (t_oop != NULL) &&
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
1163 t_oop->is_known_instance_field(), "invalide conditions");
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1164
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1165 Node *region = mem->in(0);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1166 if (region == NULL) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1167 return NULL; // Wait stable graph
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1168 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1169 uint cnt = mem->req();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1170 for( uint i = 1; i < cnt; i++ ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1171 Node *in = mem->in(i);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1172 if( in == NULL ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1173 return NULL; // Wait stable graph
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1174 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1175 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1176 // Check for loop invariant.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1177 if (cnt == 3) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1178 for( uint i = 1; i < cnt; i++ ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1179 Node *in = mem->in(i);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1180 Node* m = MemNode::optimize_memory_chain(in, addr_t, phase);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1181 if (m == mem) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1182 set_req(MemNode::Memory, mem->in(cnt - i)); // Skip this phi.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1183 return this;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1184 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1185 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1186 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1187 // Split through Phi (see original code in loopopts.cpp).
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1188 assert(phase->C->have_alias_type(addr_t), "instance should have alias type");
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1189
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1190 // Do nothing here if Identity will find a value
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1191 // (to avoid infinite chain of value phis generation).
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1192 if ( !phase->eqv(this, this->Identity(phase)) )
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1193 return NULL;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1194
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1195 // Skip the split if the region dominates some control edge of the address.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1196 if (cnt == 3 && !MemNode::all_controls_dominate(address, region))
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1197 return NULL;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1198
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1199 const Type* this_type = this->bottom_type();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1200 int this_index = phase->C->get_alias_index(addr_t);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1201 int this_offset = addr_t->offset();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1202 int this_iid = addr_t->is_oopptr()->instance_id();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1203 int wins = 0;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1204 PhaseIterGVN *igvn = phase->is_IterGVN();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1205 Node *phi = new (igvn->C, region->req()) PhiNode(region, this_type, NULL, this_iid, this_index, this_offset);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1206 for( uint i = 1; i < region->req(); i++ ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1207 Node *x;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1208 Node* the_clone = NULL;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1209 if( region->in(i) == phase->C->top() ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1210 x = phase->C->top(); // Dead path? Use a dead data op
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1211 } else {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1212 x = this->clone(); // Else clone up the data op
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1213 the_clone = x; // Remember for possible deletion.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1214 // Alter data node to use pre-phi inputs
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1215 if( this->in(0) == region ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1216 x->set_req( 0, region->in(i) );
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1217 } else {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1218 x->set_req( 0, NULL );
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1219 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1220 for( uint j = 1; j < this->req(); j++ ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1221 Node *in = this->in(j);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1222 if( in->is_Phi() && in->in(0) == region )
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1223 x->set_req( j, in->in(i) ); // Use pre-Phi input for the clone
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1224 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1225 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1226 // Check for a 'win' on some paths
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1227 const Type *t = x->Value(igvn);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1228
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1229 bool singleton = t->singleton();
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1230
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1231 // See comments in PhaseIdealLoop::split_thru_phi().
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1232 if( singleton && t == Type::TOP ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1233 singleton &= region->is_Loop() && (i != LoopNode::EntryControl);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1234 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1235
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1236 if( singleton ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1237 wins++;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1238 x = igvn->makecon(t);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1239 } else {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1240 // We now call Identity to try to simplify the cloned node.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1241 // Note that some Identity methods call phase->type(this).
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1242 // Make sure that the type array is big enough for
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1243 // our new node, even though we may throw the node away.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1244 // (This tweaking with igvn only works because x is a new node.)
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1245 igvn->set_type(x, t);
293
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 253
diff changeset
1246 // If x is a TypeNode, capture any more-precise type permanently into Node
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 253
diff changeset
1247 // othewise it will be not updated during igvn->transform since
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 253
diff changeset
1248 // igvn->type(x) is set to x->Value() already.
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 253
diff changeset
1249 x->raise_bottom_type(t);
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1250 Node *y = x->Identity(igvn);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1251 if( y != x ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1252 wins++;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1253 x = y;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1254 } else {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1255 y = igvn->hash_find(x);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1256 if( y ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1257 wins++;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1258 x = y;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1259 } else {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1260 // Else x is a new node we are keeping
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1261 // We do not need register_new_node_with_optimizer
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1262 // because set_type has already been called.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1263 igvn->_worklist.push(x);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1264 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1265 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1266 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1267 if (x != the_clone && the_clone != NULL)
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1268 igvn->remove_dead_node(the_clone);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1269 phi->set_req(i, x);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1270 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1271 if( wins > 0 ) {
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1272 // Record Phi
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1273 igvn->register_new_node_with_optimizer(phi);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1274 return phi;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1275 }
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1276 igvn->remove_dead_node(phi);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1277 return NULL;
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1278 }
17
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1279
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1280 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1281 // If the load is from Field memory and the pointer is non-null, we can
a61af66fc99e Initial load
duke
parents:
diff changeset
1282 // zero out the control input.
a61af66fc99e Initial load
duke
parents:
diff changeset
1283 // If the offset is constant and the base is an object allocation,
a61af66fc99e Initial load
duke
parents:
diff changeset
1284 // try to hook me up to the exact initializing store.
a61af66fc99e Initial load
duke
parents:
diff changeset
1285 Node *LoadNode::Ideal(PhaseGVN *phase, bool can_reshape) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1286 Node* p = MemNode::Ideal_common(phase, can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
1287 if (p) return (p == NodeSentinel) ? NULL : p;
a61af66fc99e Initial load
duke
parents:
diff changeset
1288
a61af66fc99e Initial load
duke
parents:
diff changeset
1289 Node* ctrl = in(MemNode::Control);
a61af66fc99e Initial load
duke
parents:
diff changeset
1290 Node* address = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
1291
a61af66fc99e Initial load
duke
parents:
diff changeset
1292 // Skip up past a SafePoint control. Cannot do this for Stores because
a61af66fc99e Initial load
duke
parents:
diff changeset
1293 // pointer stores & cardmarks must stay on the same side of a SafePoint.
a61af66fc99e Initial load
duke
parents:
diff changeset
1294 if( ctrl != NULL && ctrl->Opcode() == Op_SafePoint &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1295 phase->C->get_alias_index(phase->type(address)->is_ptr()) != Compile::AliasIdxRaw ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1296 ctrl = ctrl->in(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1297 set_req(MemNode::Control,ctrl);
a61af66fc99e Initial load
duke
parents:
diff changeset
1298 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1299
a61af66fc99e Initial load
duke
parents:
diff changeset
1300 // Check for useless control edge in some common special cases
a61af66fc99e Initial load
duke
parents:
diff changeset
1301 if (in(MemNode::Control) != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1302 intptr_t ignore = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1303 Node* base = AddPNode::Ideal_base_and_offset(address, phase, ignore);
a61af66fc99e Initial load
duke
parents:
diff changeset
1304 if (base != NULL
a61af66fc99e Initial load
duke
parents:
diff changeset
1305 && phase->type(base)->higher_equal(TypePtr::NOTNULL)
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
1306 && all_controls_dominate(base, phase->C->start())) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1307 // A method-invariant, non-null address (constant or 'this' argument).
a61af66fc99e Initial load
duke
parents:
diff changeset
1308 set_req(MemNode::Control, NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
1309 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1310 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1311
17
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1312 if (EliminateAutoBox && can_reshape && in(Address)->is_AddP()) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1313 Node* base = in(Address)->in(AddPNode::Base);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1314 if (base != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1315 Compile::AliasType* atp = phase->C->alias_type(adr_type());
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1316 if (is_autobox_object(atp)) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1317 Node* result = eliminate_autobox(phase);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1318 if (result != NULL) return result;
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1319 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1320 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1321 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1322
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1323 Node* mem = in(MemNode::Memory);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1324 const TypePtr *addr_t = phase->type(address)->isa_ptr();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1325
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1326 if (addr_t != NULL) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1327 // try to optimize our memory input
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1328 Node* opt_mem = MemNode::optimize_memory_chain(mem, addr_t, phase);
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1329 if (opt_mem != mem) {
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1330 set_req(MemNode::Memory, opt_mem);
305
ab075d07f1ba 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 293
diff changeset
1331 if (phase->type( opt_mem ) == Type::TOP) return NULL;
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1332 return this;
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1333 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1334 const TypeOopPtr *t_oop = addr_t->isa_oopptr();
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1335 if (can_reshape && opt_mem->is_Phi() &&
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
1336 (t_oop != NULL) && t_oop->is_known_instance_field()) {
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1337 // Split instance field load through Phi.
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1338 Node* result = split_through_phi(phase);
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1339 if (result != NULL) return result;
74
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1340 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1341 }
2a9af0b9cb1c 6674600: (Escape Analysis) Optimize memory graph for instance's fields
kvn
parents: 68
diff changeset
1342
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1343 // Check for prior store with a different base or offset; make Load
a61af66fc99e Initial load
duke
parents:
diff changeset
1344 // independent. Skip through any number of them. Bail out if the stores
a61af66fc99e Initial load
duke
parents:
diff changeset
1345 // are in an endless dead cycle and report no progress. This is a key
a61af66fc99e Initial load
duke
parents:
diff changeset
1346 // transform for Reflection. However, if after skipping through the Stores
a61af66fc99e Initial load
duke
parents:
diff changeset
1347 // we can't then fold up against a prior store do NOT do the transform as
a61af66fc99e Initial load
duke
parents:
diff changeset
1348 // this amounts to using the 'Oracle' model of aliasing. It leaves the same
a61af66fc99e Initial load
duke
parents:
diff changeset
1349 // array memory alive twice: once for the hoisted Load and again after the
a61af66fc99e Initial load
duke
parents:
diff changeset
1350 // bypassed Store. This situation only works if EVERYBODY who does
a61af66fc99e Initial load
duke
parents:
diff changeset
1351 // anti-dependence work knows how to bypass. I.e. we need all
a61af66fc99e Initial load
duke
parents:
diff changeset
1352 // anti-dependence checks to ask the same Oracle. Right now, that Oracle is
a61af66fc99e Initial load
duke
parents:
diff changeset
1353 // the alias index stuff. So instead, peek through Stores and IFF we can
a61af66fc99e Initial load
duke
parents:
diff changeset
1354 // fold up, do so.
a61af66fc99e Initial load
duke
parents:
diff changeset
1355 Node* prev_mem = find_previous_store(phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1356 // Steps (a), (b): Walk past independent stores to find an exact match.
a61af66fc99e Initial load
duke
parents:
diff changeset
1357 if (prev_mem != NULL && prev_mem != in(MemNode::Memory)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1358 // (c) See if we can fold up on the spot, but don't fold up here.
a61af66fc99e Initial load
duke
parents:
diff changeset
1359 // Fold-up might require truncation (for LoadB/LoadS/LoadC) or
a61af66fc99e Initial load
duke
parents:
diff changeset
1360 // just return a prior value, which is done by Identity calls.
a61af66fc99e Initial load
duke
parents:
diff changeset
1361 if (can_see_stored_value(prev_mem, phase)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1362 // Make ready for step (d):
a61af66fc99e Initial load
duke
parents:
diff changeset
1363 set_req(MemNode::Memory, prev_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
1364 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
1365 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1366 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1367
a61af66fc99e Initial load
duke
parents:
diff changeset
1368 return NULL; // No further progress
a61af66fc99e Initial load
duke
parents:
diff changeset
1369 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1370
a61af66fc99e Initial load
duke
parents:
diff changeset
1371 // Helper to recognize certain Klass fields which are invariant across
a61af66fc99e Initial load
duke
parents:
diff changeset
1372 // some group of array types (e.g., int[] or all T[] where T < Object).
a61af66fc99e Initial load
duke
parents:
diff changeset
1373 const Type*
a61af66fc99e Initial load
duke
parents:
diff changeset
1374 LoadNode::load_array_final_field(const TypeKlassPtr *tkls,
a61af66fc99e Initial load
duke
parents:
diff changeset
1375 ciKlass* klass) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
1376 if (tkls->offset() == Klass::modifier_flags_offset_in_bytes() + (int)sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1377 // The field is Klass::_modifier_flags. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1378 // (Folds up the 2nd indirection in aClassConstant.getModifiers().)
a61af66fc99e Initial load
duke
parents:
diff changeset
1379 assert(this->Opcode() == Op_LoadI, "must load an int from _modifier_flags");
a61af66fc99e Initial load
duke
parents:
diff changeset
1380 return TypeInt::make(klass->modifier_flags());
a61af66fc99e Initial load
duke
parents:
diff changeset
1381 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1382 if (tkls->offset() == Klass::access_flags_offset_in_bytes() + (int)sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1383 // The field is Klass::_access_flags. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1384 // (Folds up the 2nd indirection in Reflection.getClassAccessFlags(aClassConstant).)
a61af66fc99e Initial load
duke
parents:
diff changeset
1385 assert(this->Opcode() == Op_LoadI, "must load an int from _access_flags");
a61af66fc99e Initial load
duke
parents:
diff changeset
1386 return TypeInt::make(klass->access_flags());
a61af66fc99e Initial load
duke
parents:
diff changeset
1387 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1388 if (tkls->offset() == Klass::layout_helper_offset_in_bytes() + (int)sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1389 // The field is Klass::_layout_helper. Return its constant value if known.
a61af66fc99e Initial load
duke
parents:
diff changeset
1390 assert(this->Opcode() == Op_LoadI, "must load an int from _layout_helper");
a61af66fc99e Initial load
duke
parents:
diff changeset
1391 return TypeInt::make(klass->layout_helper());
a61af66fc99e Initial load
duke
parents:
diff changeset
1392 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1393
a61af66fc99e Initial load
duke
parents:
diff changeset
1394 // No match.
a61af66fc99e Initial load
duke
parents:
diff changeset
1395 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1396 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1397
a61af66fc99e Initial load
duke
parents:
diff changeset
1398 //------------------------------Value-----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1399 const Type *LoadNode::Value( PhaseTransform *phase ) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
1400 // Either input is TOP ==> the result is TOP
a61af66fc99e Initial load
duke
parents:
diff changeset
1401 Node* mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
1402 const Type *t1 = phase->type(mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
1403 if (t1 == Type::TOP) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1404 Node* adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
1405 const TypePtr* tp = phase->type(adr)->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1406 if (tp == NULL || tp->empty()) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1407 int off = tp->offset();
a61af66fc99e Initial load
duke
parents:
diff changeset
1408 assert(off != Type::OffsetTop, "case covered by TypePtr::empty");
a61af66fc99e Initial load
duke
parents:
diff changeset
1409
a61af66fc99e Initial load
duke
parents:
diff changeset
1410 // Try to guess loaded type from pointer type
a61af66fc99e Initial load
duke
parents:
diff changeset
1411 if (tp->base() == Type::AryPtr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1412 const Type *t = tp->is_aryptr()->elem();
a61af66fc99e Initial load
duke
parents:
diff changeset
1413 // Don't do this for integer types. There is only potential profit if
a61af66fc99e Initial load
duke
parents:
diff changeset
1414 // the element type t is lower than _type; that is, for int types, if _type is
a61af66fc99e Initial load
duke
parents:
diff changeset
1415 // more restrictive than t. This only happens here if one is short and the other
a61af66fc99e Initial load
duke
parents:
diff changeset
1416 // char (both 16 bits), and in those cases we've made an intentional decision
a61af66fc99e Initial load
duke
parents:
diff changeset
1417 // to use one kind of load over the other. See AndINode::Ideal and 4965907.
a61af66fc99e Initial load
duke
parents:
diff changeset
1418 // Also, do not try to narrow the type for a LoadKlass, regardless of offset.
a61af66fc99e Initial load
duke
parents:
diff changeset
1419 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1420 // Yes, it is possible to encounter an expression like (LoadKlass p1:(AddP x x 8))
a61af66fc99e Initial load
duke
parents:
diff changeset
1421 // where the _gvn.type of the AddP is wider than 8. This occurs when an earlier
a61af66fc99e Initial load
duke
parents:
diff changeset
1422 // copy p0 of (AddP x x 8) has been proven equal to p1, and the p0 has been
a61af66fc99e Initial load
duke
parents:
diff changeset
1423 // subsumed by p1. If p1 is on the worklist but has not yet been re-transformed,
a61af66fc99e Initial load
duke
parents:
diff changeset
1424 // it is possible that p1 will have a type like Foo*[int+]:NotNull*+any.
a61af66fc99e Initial load
duke
parents:
diff changeset
1425 // In fact, that could have been the original type of p1, and p1 could have
a61af66fc99e Initial load
duke
parents:
diff changeset
1426 // had an original form like p1:(AddP x x (LShiftL quux 3)), where the
a61af66fc99e Initial load
duke
parents:
diff changeset
1427 // expression (LShiftL quux 3) independently optimized to the constant 8.
a61af66fc99e Initial load
duke
parents:
diff changeset
1428 if ((t->isa_int() == NULL) && (t->isa_long() == NULL)
293
c3e045194476 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 253
diff changeset
1429 && Opcode() != Op_LoadKlass && Opcode() != Op_LoadNKlass) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1430 // t might actually be lower than _type, if _type is a unique
a61af66fc99e Initial load
duke
parents:
diff changeset
1431 // concrete subclass of abstract class t.
a61af66fc99e Initial load
duke
parents:
diff changeset
1432 // Make sure the reference is not into the header, by comparing
a61af66fc99e Initial load
duke
parents:
diff changeset
1433 // the offset against the offset of the start of the array's data.
a61af66fc99e Initial load
duke
parents:
diff changeset
1434 // Different array types begin at slightly different offsets (12 vs. 16).
a61af66fc99e Initial load
duke
parents:
diff changeset
1435 // We choose T_BYTE as an example base type that is least restrictive
a61af66fc99e Initial load
duke
parents:
diff changeset
1436 // as to alignment, which will therefore produce the smallest
a61af66fc99e Initial load
duke
parents:
diff changeset
1437 // possible base offset.
a61af66fc99e Initial load
duke
parents:
diff changeset
1438 const int min_base_off = arrayOopDesc::base_offset_in_bytes(T_BYTE);
a61af66fc99e Initial load
duke
parents:
diff changeset
1439 if ((uint)off >= (uint)min_base_off) { // is the offset beyond the header?
a61af66fc99e Initial load
duke
parents:
diff changeset
1440 const Type* jt = t->join(_type);
a61af66fc99e Initial load
duke
parents:
diff changeset
1441 // In any case, do not allow the join, per se, to empty out the type.
a61af66fc99e Initial load
duke
parents:
diff changeset
1442 if (jt->empty() && !t->empty()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1443 // This can happen if a interface-typed array narrows to a class type.
a61af66fc99e Initial load
duke
parents:
diff changeset
1444 jt = _type;
a61af66fc99e Initial load
duke
parents:
diff changeset
1445 }
17
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1446
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1447 if (EliminateAutoBox) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1448 // The pointers in the autobox arrays are always non-null
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1449 Node* base = in(Address)->in(AddPNode::Base);
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1450 if (base != NULL) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1451 Compile::AliasType* atp = phase->C->alias_type(base->adr_type());
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1452 if (is_autobox_cache(atp)) {
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1453 return jt->join(TypePtr::NOTNULL)->is_ptr();
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1454 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1455 }
ff5961f4c095 6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents: 0
diff changeset
1456 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1457 return jt;
a61af66fc99e Initial load
duke
parents:
diff changeset
1458 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1459 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1460 } else if (tp->base() == Type::InstPtr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1461 assert( off != Type::OffsetBot ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1462 // arrays can be cast to Objects
a61af66fc99e Initial load
duke
parents:
diff changeset
1463 tp->is_oopptr()->klass()->is_java_lang_Object() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1464 // unsafe field access may not have a constant offset
a61af66fc99e Initial load
duke
parents:
diff changeset
1465 phase->C->has_unsafe_access(),
a61af66fc99e Initial load
duke
parents:
diff changeset
1466 "Field accesses must be precise" );
a61af66fc99e Initial load
duke
parents:
diff changeset
1467 // For oop loads, we expect the _type to be precise
a61af66fc99e Initial load
duke
parents:
diff changeset
1468 } else if (tp->base() == Type::KlassPtr) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1469 assert( off != Type::OffsetBot ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1470 // arrays can be cast to Objects
a61af66fc99e Initial load
duke
parents:
diff changeset
1471 tp->is_klassptr()->klass()->is_java_lang_Object() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1472 // also allow array-loading from the primary supertype
a61af66fc99e Initial load
duke
parents:
diff changeset
1473 // array during subtype checks
a61af66fc99e Initial load
duke
parents:
diff changeset
1474 Opcode() == Op_LoadKlass,
a61af66fc99e Initial load
duke
parents:
diff changeset
1475 "Field accesses must be precise" );
a61af66fc99e Initial load
duke
parents:
diff changeset
1476 // For klass/static loads, we expect the _type to be precise
a61af66fc99e Initial load
duke
parents:
diff changeset
1477 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1478
a61af66fc99e Initial load
duke
parents:
diff changeset
1479 const TypeKlassPtr *tkls = tp->isa_klassptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1480 if (tkls != NULL && !StressReflectiveCode) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1481 ciKlass* klass = tkls->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1482 if (klass->is_loaded() && tkls->klass_is_exact()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1483 // We are loading a field from a Klass metaobject whose identity
a61af66fc99e Initial load
duke
parents:
diff changeset
1484 // is known at compile time (the type is "exact" or "precise").
a61af66fc99e Initial load
duke
parents:
diff changeset
1485 // Check for fields we know are maintained as constants by the VM.
a61af66fc99e Initial load
duke
parents:
diff changeset
1486 if (tkls->offset() == Klass::super_check_offset_offset_in_bytes() + (int)sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1487 // The field is Klass::_super_check_offset. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1488 // (Folds up type checking code.)
a61af66fc99e Initial load
duke
parents:
diff changeset
1489 assert(Opcode() == Op_LoadI, "must load an int from _super_check_offset");
a61af66fc99e Initial load
duke
parents:
diff changeset
1490 return TypeInt::make(klass->super_check_offset());
a61af66fc99e Initial load
duke
parents:
diff changeset
1491 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1492 // Compute index into primary_supers array
a61af66fc99e Initial load
duke
parents:
diff changeset
1493 juint depth = (tkls->offset() - (Klass::primary_supers_offset_in_bytes() + (int)sizeof(oopDesc))) / sizeof(klassOop);
a61af66fc99e Initial load
duke
parents:
diff changeset
1494 // Check for overflowing; use unsigned compare to handle the negative case.
a61af66fc99e Initial load
duke
parents:
diff changeset
1495 if( depth < ciKlass::primary_super_limit() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1496 // The field is an element of Klass::_primary_supers. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1497 // (Folds up type checking code.)
a61af66fc99e Initial load
duke
parents:
diff changeset
1498 assert(Opcode() == Op_LoadKlass, "must load a klass from _primary_supers");
a61af66fc99e Initial load
duke
parents:
diff changeset
1499 ciKlass *ss = klass->super_of_depth(depth);
a61af66fc99e Initial load
duke
parents:
diff changeset
1500 return ss ? TypeKlassPtr::make(ss) : TypePtr::NULL_PTR;
a61af66fc99e Initial load
duke
parents:
diff changeset
1501 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1502 const Type* aift = load_array_final_field(tkls, klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
1503 if (aift != NULL) return aift;
a61af66fc99e Initial load
duke
parents:
diff changeset
1504 if (tkls->offset() == in_bytes(arrayKlass::component_mirror_offset()) + (int)sizeof(oopDesc)
a61af66fc99e Initial load
duke
parents:
diff changeset
1505 && klass->is_array_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1506 // The field is arrayKlass::_component_mirror. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1507 // (Folds up aClassConstant.getComponentType, common in Arrays.copyOf.)
a61af66fc99e Initial load
duke
parents:
diff changeset
1508 assert(Opcode() == Op_LoadP, "must load an oop from _component_mirror");
a61af66fc99e Initial load
duke
parents:
diff changeset
1509 return TypeInstPtr::make(klass->as_array_klass()->component_mirror());
a61af66fc99e Initial load
duke
parents:
diff changeset
1510 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1511 if (tkls->offset() == Klass::java_mirror_offset_in_bytes() + (int)sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1512 // The field is Klass::_java_mirror. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1513 // (Folds up the 2nd indirection in anObjConstant.getClass().)
a61af66fc99e Initial load
duke
parents:
diff changeset
1514 assert(Opcode() == Op_LoadP, "must load an oop from _java_mirror");
a61af66fc99e Initial load
duke
parents:
diff changeset
1515 return TypeInstPtr::make(klass->java_mirror());
a61af66fc99e Initial load
duke
parents:
diff changeset
1516 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1517 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1518
a61af66fc99e Initial load
duke
parents:
diff changeset
1519 // We can still check if we are loading from the primary_supers array at a
a61af66fc99e Initial load
duke
parents:
diff changeset
1520 // shallow enough depth. Even though the klass is not exact, entries less
a61af66fc99e Initial load
duke
parents:
diff changeset
1521 // than or equal to its super depth are correct.
a61af66fc99e Initial load
duke
parents:
diff changeset
1522 if (klass->is_loaded() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1523 ciType *inner = klass->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1524 while( inner->is_obj_array_klass() )
a61af66fc99e Initial load
duke
parents:
diff changeset
1525 inner = inner->as_obj_array_klass()->base_element_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
1526 if( inner->is_instance_klass() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1527 !inner->as_instance_klass()->flags().is_interface() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1528 // Compute index into primary_supers array
a61af66fc99e Initial load
duke
parents:
diff changeset
1529 juint depth = (tkls->offset() - (Klass::primary_supers_offset_in_bytes() + (int)sizeof(oopDesc))) / sizeof(klassOop);
a61af66fc99e Initial load
duke
parents:
diff changeset
1530 // Check for overflowing; use unsigned compare to handle the negative case.
a61af66fc99e Initial load
duke
parents:
diff changeset
1531 if( depth < ciKlass::primary_super_limit() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1532 depth <= klass->super_depth() ) { // allow self-depth checks to handle self-check case
a61af66fc99e Initial load
duke
parents:
diff changeset
1533 // The field is an element of Klass::_primary_supers. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1534 // (Folds up type checking code.)
a61af66fc99e Initial load
duke
parents:
diff changeset
1535 assert(Opcode() == Op_LoadKlass, "must load a klass from _primary_supers");
a61af66fc99e Initial load
duke
parents:
diff changeset
1536 ciKlass *ss = klass->super_of_depth(depth);
a61af66fc99e Initial load
duke
parents:
diff changeset
1537 return ss ? TypeKlassPtr::make(ss) : TypePtr::NULL_PTR;
a61af66fc99e Initial load
duke
parents:
diff changeset
1538 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1539 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1540 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1541
a61af66fc99e Initial load
duke
parents:
diff changeset
1542 // If the type is enough to determine that the thing is not an array,
a61af66fc99e Initial load
duke
parents:
diff changeset
1543 // we can give the layout_helper a positive interval type.
a61af66fc99e Initial load
duke
parents:
diff changeset
1544 // This will help short-circuit some reflective code.
a61af66fc99e Initial load
duke
parents:
diff changeset
1545 if (tkls->offset() == Klass::layout_helper_offset_in_bytes() + (int)sizeof(oopDesc)
a61af66fc99e Initial load
duke
parents:
diff changeset
1546 && !klass->is_array_klass() // not directly typed as an array
a61af66fc99e Initial load
duke
parents:
diff changeset
1547 && !klass->is_interface() // specifically not Serializable & Cloneable
a61af66fc99e Initial load
duke
parents:
diff changeset
1548 && !klass->is_java_lang_Object() // not the supertype of all T[]
a61af66fc99e Initial load
duke
parents:
diff changeset
1549 ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1550 // Note: When interfaces are reliable, we can narrow the interface
a61af66fc99e Initial load
duke
parents:
diff changeset
1551 // test to (klass != Serializable && klass != Cloneable).
a61af66fc99e Initial load
duke
parents:
diff changeset
1552 assert(Opcode() == Op_LoadI, "must load an int from _layout_helper");
a61af66fc99e Initial load
duke
parents:
diff changeset
1553 jint min_size = Klass::instance_layout_helper(oopDesc::header_size(), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
1554 // The key property of this type is that it folds up tests
a61af66fc99e Initial load
duke
parents:
diff changeset
1555 // for array-ness, since it proves that the layout_helper is positive.
a61af66fc99e Initial load
duke
parents:
diff changeset
1556 // Thus, a generic value like the basic object layout helper works fine.
a61af66fc99e Initial load
duke
parents:
diff changeset
1557 return TypeInt::make(min_size, max_jint, Type::WidenMin);
a61af66fc99e Initial load
duke
parents:
diff changeset
1558 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1559 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1560
a61af66fc99e Initial load
duke
parents:
diff changeset
1561 // If we are loading from a freshly-allocated object, produce a zero,
a61af66fc99e Initial load
duke
parents:
diff changeset
1562 // if the load is provably beyond the header of the object.
a61af66fc99e Initial load
duke
parents:
diff changeset
1563 // (Also allow a variable load from a fresh array to produce zero.)
a61af66fc99e Initial load
duke
parents:
diff changeset
1564 if (ReduceFieldZeroing) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1565 Node* value = can_see_stored_value(mem,phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1566 if (value != NULL && value->is_Con())
a61af66fc99e Initial load
duke
parents:
diff changeset
1567 return value->bottom_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
1568 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1569
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1570 const TypeOopPtr *tinst = tp->isa_oopptr();
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
1571 if (tinst != NULL && tinst->is_known_instance_field()) {
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1572 // If we have an instance type and our memory input is the
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1573 // programs's initial memory state, there is no matching store,
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1574 // so just return a zero of the appropriate type
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1575 Node *mem = in(MemNode::Memory);
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1576 if (mem->is_Parm() && mem->in(0)->is_Start()) {
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1577 assert(mem->as_Parm()->_con == TypeFunc::Memory, "must be memory Parm");
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1578 return Type::get_zero_type(_type->basic_type());
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1579 }
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
1580 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1581 return _type;
a61af66fc99e Initial load
duke
parents:
diff changeset
1582 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1583
a61af66fc99e Initial load
duke
parents:
diff changeset
1584 //------------------------------match_edge-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1585 // Do we Match on this edge index or not? Match only the address.
a61af66fc99e Initial load
duke
parents:
diff changeset
1586 uint LoadNode::match_edge(uint idx) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
1587 return idx == MemNode::Address;
a61af66fc99e Initial load
duke
parents:
diff changeset
1588 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1589
a61af66fc99e Initial load
duke
parents:
diff changeset
1590 //--------------------------LoadBNode::Ideal--------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1591 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1592 // If the previous store is to the same address as this load,
a61af66fc99e Initial load
duke
parents:
diff changeset
1593 // and the value stored was larger than a byte, replace this load
a61af66fc99e Initial load
duke
parents:
diff changeset
1594 // with the value stored truncated to a byte. If no truncation is
a61af66fc99e Initial load
duke
parents:
diff changeset
1595 // needed, the replacement is done in LoadNode::Identity().
a61af66fc99e Initial load
duke
parents:
diff changeset
1596 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1597 Node *LoadBNode::Ideal(PhaseGVN *phase, bool can_reshape) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1598 Node* mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
1599 Node* value = can_see_stored_value(mem,phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1600 if( value && !phase->type(value)->higher_equal( _type ) ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1601 Node *result = phase->transform( new (phase->C, 3) LShiftINode(value, phase->intcon(24)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1602 return new (phase->C, 3) RShiftINode(result, phase->intcon(24));
a61af66fc99e Initial load
duke
parents:
diff changeset
1603 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1604 // Identity call will handle the case where truncation is not needed.
a61af66fc99e Initial load
duke
parents:
diff changeset
1605 return LoadNode::Ideal(phase, can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
1606 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1607
a61af66fc99e Initial load
duke
parents:
diff changeset
1608 //--------------------------LoadCNode::Ideal--------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1609 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1610 // If the previous store is to the same address as this load,
a61af66fc99e Initial load
duke
parents:
diff changeset
1611 // and the value stored was larger than a char, replace this load
a61af66fc99e Initial load
duke
parents:
diff changeset
1612 // with the value stored truncated to a char. If no truncation is
a61af66fc99e Initial load
duke
parents:
diff changeset
1613 // needed, the replacement is done in LoadNode::Identity().
a61af66fc99e Initial load
duke
parents:
diff changeset
1614 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1615 Node *LoadCNode::Ideal(PhaseGVN *phase, bool can_reshape) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1616 Node* mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
1617 Node* value = can_see_stored_value(mem,phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1618 if( value && !phase->type(value)->higher_equal( _type ) )
a61af66fc99e Initial load
duke
parents:
diff changeset
1619 return new (phase->C, 3) AndINode(value,phase->intcon(0xFFFF));
a61af66fc99e Initial load
duke
parents:
diff changeset
1620 // Identity call will handle the case where truncation is not needed.
a61af66fc99e Initial load
duke
parents:
diff changeset
1621 return LoadNode::Ideal(phase, can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
1622 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1623
a61af66fc99e Initial load
duke
parents:
diff changeset
1624 //--------------------------LoadSNode::Ideal--------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1625 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1626 // If the previous store is to the same address as this load,
a61af66fc99e Initial load
duke
parents:
diff changeset
1627 // and the value stored was larger than a short, replace this load
a61af66fc99e Initial load
duke
parents:
diff changeset
1628 // with the value stored truncated to a short. If no truncation is
a61af66fc99e Initial load
duke
parents:
diff changeset
1629 // needed, the replacement is done in LoadNode::Identity().
a61af66fc99e Initial load
duke
parents:
diff changeset
1630 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1631 Node *LoadSNode::Ideal(PhaseGVN *phase, bool can_reshape) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1632 Node* mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
1633 Node* value = can_see_stored_value(mem,phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1634 if( value && !phase->type(value)->higher_equal( _type ) ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1635 Node *result = phase->transform( new (phase->C, 3) LShiftINode(value, phase->intcon(16)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1636 return new (phase->C, 3) RShiftINode(result, phase->intcon(16));
a61af66fc99e Initial load
duke
parents:
diff changeset
1637 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1638 // Identity call will handle the case where truncation is not needed.
a61af66fc99e Initial load
duke
parents:
diff changeset
1639 return LoadNode::Ideal(phase, can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
1640 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1641
a61af66fc99e Initial load
duke
parents:
diff changeset
1642 //=============================================================================
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1643 //----------------------------LoadKlassNode::make------------------------------
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1644 // Polymorphic factory method:
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1645 Node *LoadKlassNode::make( PhaseGVN& gvn, Node *mem, Node *adr, const TypePtr* at, const TypeKlassPtr *tk ) {
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1646 Compile* C = gvn.C;
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1647 Node *ctl = NULL;
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1648 // sanity check the alias category against the created node type
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1649 const TypeOopPtr *adr_type = adr->bottom_type()->isa_oopptr();
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1650 assert(adr_type != NULL, "expecting TypeOopPtr");
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1651 #ifdef _LP64
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1652 if (adr_type->is_ptr_to_narrowoop()) {
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1653 Node* load_klass = gvn.transform(new (C, 3) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowoop()));
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1654 return new (C, 2) DecodeNNode(load_klass, load_klass->bottom_type()->make_ptr());
168
7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents: 164
diff changeset
1655 }
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1656 #endif
168
7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents: 164
diff changeset
1657 assert(!adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop");
7793bd37a336 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents: 164
diff changeset
1658 return new (C, 3) LoadKlassNode(ctl, mem, adr, at, tk);
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1659 }
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1660
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1661 //------------------------------Value------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1662 const Type *LoadKlassNode::Value( PhaseTransform *phase ) const {
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1663 return klass_value_common(phase);
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1664 }
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1665
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1666 const Type *LoadNode::klass_value_common( PhaseTransform *phase ) const {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1667 // Either input is TOP ==> the result is TOP
a61af66fc99e Initial load
duke
parents:
diff changeset
1668 const Type *t1 = phase->type( in(MemNode::Memory) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1669 if (t1 == Type::TOP) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1670 Node *adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
1671 const Type *t2 = phase->type( adr );
a61af66fc99e Initial load
duke
parents:
diff changeset
1672 if (t2 == Type::TOP) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1673 const TypePtr *tp = t2->is_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1674 if (TypePtr::above_centerline(tp->ptr()) ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1675 tp->ptr() == TypePtr::Null) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1676
a61af66fc99e Initial load
duke
parents:
diff changeset
1677 // Return a more precise klass, if possible
a61af66fc99e Initial load
duke
parents:
diff changeset
1678 const TypeInstPtr *tinst = tp->isa_instptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1679 if (tinst != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1680 ciInstanceKlass* ik = tinst->klass()->as_instance_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1681 int offset = tinst->offset();
a61af66fc99e Initial load
duke
parents:
diff changeset
1682 if (ik == phase->C->env()->Class_klass()
a61af66fc99e Initial load
duke
parents:
diff changeset
1683 && (offset == java_lang_Class::klass_offset_in_bytes() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1684 offset == java_lang_Class::array_klass_offset_in_bytes())) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1685 // We are loading a special hidden field from a Class mirror object,
a61af66fc99e Initial load
duke
parents:
diff changeset
1686 // the field which points to the VM's Klass metaobject.
a61af66fc99e Initial load
duke
parents:
diff changeset
1687 ciType* t = tinst->java_mirror_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
1688 // java_mirror_type returns non-null for compile-time Class constants.
a61af66fc99e Initial load
duke
parents:
diff changeset
1689 if (t != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1690 // constant oop => constant klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1691 if (offset == java_lang_Class::array_klass_offset_in_bytes()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1692 return TypeKlassPtr::make(ciArrayKlass::make(t));
a61af66fc99e Initial load
duke
parents:
diff changeset
1693 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1694 if (!t->is_klass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1695 // a primitive Class (e.g., int.class) has NULL for a klass field
a61af66fc99e Initial load
duke
parents:
diff changeset
1696 return TypePtr::NULL_PTR;
a61af66fc99e Initial load
duke
parents:
diff changeset
1697 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1698 // (Folds up the 1st indirection in aClassConstant.getModifiers().)
a61af66fc99e Initial load
duke
parents:
diff changeset
1699 return TypeKlassPtr::make(t->as_klass());
a61af66fc99e Initial load
duke
parents:
diff changeset
1700 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1701 // non-constant mirror, so we can't tell what's going on
a61af66fc99e Initial load
duke
parents:
diff changeset
1702 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1703 if( !ik->is_loaded() )
a61af66fc99e Initial load
duke
parents:
diff changeset
1704 return _type; // Bail out if not loaded
a61af66fc99e Initial load
duke
parents:
diff changeset
1705 if (offset == oopDesc::klass_offset_in_bytes()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1706 if (tinst->klass_is_exact()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1707 return TypeKlassPtr::make(ik);
a61af66fc99e Initial load
duke
parents:
diff changeset
1708 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1709 // See if we can become precise: no subklasses and no interface
a61af66fc99e Initial load
duke
parents:
diff changeset
1710 // (Note: We need to support verified interfaces.)
a61af66fc99e Initial load
duke
parents:
diff changeset
1711 if (!ik->is_interface() && !ik->has_subklass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1712 //assert(!UseExactTypes, "this code should be useless with exact types");
a61af66fc99e Initial load
duke
parents:
diff changeset
1713 // Add a dependence; if any subclass added we need to recompile
a61af66fc99e Initial load
duke
parents:
diff changeset
1714 if (!ik->is_final()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1715 // %%% should use stronger assert_unique_concrete_subtype instead
a61af66fc99e Initial load
duke
parents:
diff changeset
1716 phase->C->dependencies()->assert_leaf_type(ik);
a61af66fc99e Initial load
duke
parents:
diff changeset
1717 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1718 // Return precise klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1719 return TypeKlassPtr::make(ik);
a61af66fc99e Initial load
duke
parents:
diff changeset
1720 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1721
a61af66fc99e Initial load
duke
parents:
diff changeset
1722 // Return root of possible klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1723 return TypeKlassPtr::make(TypePtr::NotNull, ik, 0/*offset*/);
a61af66fc99e Initial load
duke
parents:
diff changeset
1724 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1725 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1726
a61af66fc99e Initial load
duke
parents:
diff changeset
1727 // Check for loading klass from an array
a61af66fc99e Initial load
duke
parents:
diff changeset
1728 const TypeAryPtr *tary = tp->isa_aryptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1729 if( tary != NULL ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1730 ciKlass *tary_klass = tary->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1731 if (tary_klass != NULL // can be NULL when at BOTTOM or TOP
a61af66fc99e Initial load
duke
parents:
diff changeset
1732 && tary->offset() == oopDesc::klass_offset_in_bytes()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1733 if (tary->klass_is_exact()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1734 return TypeKlassPtr::make(tary_klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
1735 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1736 ciArrayKlass *ak = tary->klass()->as_array_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1737 // If the klass is an object array, we defer the question to the
a61af66fc99e Initial load
duke
parents:
diff changeset
1738 // array component klass.
a61af66fc99e Initial load
duke
parents:
diff changeset
1739 if( ak->is_obj_array_klass() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1740 assert( ak->is_loaded(), "" );
a61af66fc99e Initial load
duke
parents:
diff changeset
1741 ciKlass *base_k = ak->as_obj_array_klass()->base_element_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1742 if( base_k->is_loaded() && base_k->is_instance_klass() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1743 ciInstanceKlass* ik = base_k->as_instance_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1744 // See if we can become precise: no subklasses and no interface
a61af66fc99e Initial load
duke
parents:
diff changeset
1745 if (!ik->is_interface() && !ik->has_subklass()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1746 //assert(!UseExactTypes, "this code should be useless with exact types");
a61af66fc99e Initial load
duke
parents:
diff changeset
1747 // Add a dependence; if any subclass added we need to recompile
a61af66fc99e Initial load
duke
parents:
diff changeset
1748 if (!ik->is_final()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1749 phase->C->dependencies()->assert_leaf_type(ik);
a61af66fc99e Initial load
duke
parents:
diff changeset
1750 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1751 // Return precise array klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1752 return TypeKlassPtr::make(ak);
a61af66fc99e Initial load
duke
parents:
diff changeset
1753 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1754 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1755 return TypeKlassPtr::make(TypePtr::NotNull, ak, 0/*offset*/);
a61af66fc99e Initial load
duke
parents:
diff changeset
1756 } else { // Found a type-array?
a61af66fc99e Initial load
duke
parents:
diff changeset
1757 //assert(!UseExactTypes, "this code should be useless with exact types");
a61af66fc99e Initial load
duke
parents:
diff changeset
1758 assert( ak->is_type_array_klass(), "" );
a61af66fc99e Initial load
duke
parents:
diff changeset
1759 return TypeKlassPtr::make(ak); // These are always precise
a61af66fc99e Initial load
duke
parents:
diff changeset
1760 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1761 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1762 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1763
a61af66fc99e Initial load
duke
parents:
diff changeset
1764 // Check for loading klass from an array klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1765 const TypeKlassPtr *tkls = tp->isa_klassptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1766 if (tkls != NULL && !StressReflectiveCode) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1767 ciKlass* klass = tkls->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1768 if( !klass->is_loaded() )
a61af66fc99e Initial load
duke
parents:
diff changeset
1769 return _type; // Bail out if not loaded
a61af66fc99e Initial load
duke
parents:
diff changeset
1770 if( klass->is_obj_array_klass() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1771 (uint)tkls->offset() == objArrayKlass::element_klass_offset_in_bytes() + sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1772 ciKlass* elem = klass->as_obj_array_klass()->element_klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
1773 // // Always returning precise element type is incorrect,
a61af66fc99e Initial load
duke
parents:
diff changeset
1774 // // e.g., element type could be object and array may contain strings
a61af66fc99e Initial load
duke
parents:
diff changeset
1775 // return TypeKlassPtr::make(TypePtr::Constant, elem, 0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1776
a61af66fc99e Initial load
duke
parents:
diff changeset
1777 // The array's TypeKlassPtr was declared 'precise' or 'not precise'
a61af66fc99e Initial load
duke
parents:
diff changeset
1778 // according to the element type's subclassing.
a61af66fc99e Initial load
duke
parents:
diff changeset
1779 return TypeKlassPtr::make(tkls->ptr(), elem, 0/*offset*/);
a61af66fc99e Initial load
duke
parents:
diff changeset
1780 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1781 if( klass->is_instance_klass() && tkls->klass_is_exact() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1782 (uint)tkls->offset() == Klass::super_offset_in_bytes() + sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1783 ciKlass* sup = klass->as_instance_klass()->super();
a61af66fc99e Initial load
duke
parents:
diff changeset
1784 // The field is Klass::_super. Return its (constant) value.
a61af66fc99e Initial load
duke
parents:
diff changeset
1785 // (Folds up the 2nd indirection in aClassConstant.getSuperClass().)
a61af66fc99e Initial load
duke
parents:
diff changeset
1786 return sup ? TypeKlassPtr::make(sup) : TypePtr::NULL_PTR;
a61af66fc99e Initial load
duke
parents:
diff changeset
1787 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1788 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1789
a61af66fc99e Initial load
duke
parents:
diff changeset
1790 // Bailout case
a61af66fc99e Initial load
duke
parents:
diff changeset
1791 return LoadNode::Value(phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1792 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1793
a61af66fc99e Initial load
duke
parents:
diff changeset
1794 //------------------------------Identity---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1795 // To clean up reflective code, simplify k.java_mirror.as_klass to plain k.
a61af66fc99e Initial load
duke
parents:
diff changeset
1796 // Also feed through the klass in Allocate(...klass...)._klass.
a61af66fc99e Initial load
duke
parents:
diff changeset
1797 Node* LoadKlassNode::Identity( PhaseTransform *phase ) {
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1798 return klass_identity_common(phase);
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1799 }
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1800
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1801 Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1802 Node* x = LoadNode::Identity(phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1803 if (x != this) return x;
a61af66fc99e Initial load
duke
parents:
diff changeset
1804
a61af66fc99e Initial load
duke
parents:
diff changeset
1805 // Take apart the address into an oop and and offset.
a61af66fc99e Initial load
duke
parents:
diff changeset
1806 // Return 'this' if we cannot.
a61af66fc99e Initial load
duke
parents:
diff changeset
1807 Node* adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
1808 intptr_t offset = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1809 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1810 if (base == NULL) return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
1811 const TypeOopPtr* toop = phase->type(adr)->isa_oopptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1812 if (toop == NULL) return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
1813
a61af66fc99e Initial load
duke
parents:
diff changeset
1814 // We can fetch the klass directly through an AllocateNode.
a61af66fc99e Initial load
duke
parents:
diff changeset
1815 // This works even if the klass is not constant (clone or newArray).
a61af66fc99e Initial load
duke
parents:
diff changeset
1816 if (offset == oopDesc::klass_offset_in_bytes()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1817 Node* allocated_klass = AllocateNode::Ideal_klass(base, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1818 if (allocated_klass != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1819 return allocated_klass;
a61af66fc99e Initial load
duke
parents:
diff changeset
1820 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1821 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1822
a61af66fc99e Initial load
duke
parents:
diff changeset
1823 // Simplify k.java_mirror.as_klass to plain k, where k is a klassOop.
a61af66fc99e Initial load
duke
parents:
diff changeset
1824 // Simplify ak.component_mirror.array_klass to plain ak, ak an arrayKlass.
a61af66fc99e Initial load
duke
parents:
diff changeset
1825 // See inline_native_Class_query for occurrences of these patterns.
a61af66fc99e Initial load
duke
parents:
diff changeset
1826 // Java Example: x.getClass().isAssignableFrom(y)
a61af66fc99e Initial load
duke
parents:
diff changeset
1827 // Java Example: Array.newInstance(x.getClass().getComponentType(), n)
a61af66fc99e Initial load
duke
parents:
diff changeset
1828 //
a61af66fc99e Initial load
duke
parents:
diff changeset
1829 // This improves reflective code, often making the Class
a61af66fc99e Initial load
duke
parents:
diff changeset
1830 // mirror go completely dead. (Current exception: Class
a61af66fc99e Initial load
duke
parents:
diff changeset
1831 // mirrors may appear in debug info, but we could clean them out by
a61af66fc99e Initial load
duke
parents:
diff changeset
1832 // introducing a new debug info operator for klassOop.java_mirror).
a61af66fc99e Initial load
duke
parents:
diff changeset
1833 if (toop->isa_instptr() && toop->klass() == phase->C->env()->Class_klass()
a61af66fc99e Initial load
duke
parents:
diff changeset
1834 && (offset == java_lang_Class::klass_offset_in_bytes() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1835 offset == java_lang_Class::array_klass_offset_in_bytes())) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1836 // We are loading a special hidden field from a Class mirror,
a61af66fc99e Initial load
duke
parents:
diff changeset
1837 // the field which points to its Klass or arrayKlass metaobject.
a61af66fc99e Initial load
duke
parents:
diff changeset
1838 if (base->is_Load()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1839 Node* adr2 = base->in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
1840 const TypeKlassPtr* tkls = phase->type(adr2)->isa_klassptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1841 if (tkls != NULL && !tkls->empty()
a61af66fc99e Initial load
duke
parents:
diff changeset
1842 && (tkls->klass()->is_instance_klass() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
1843 tkls->klass()->is_array_klass())
a61af66fc99e Initial load
duke
parents:
diff changeset
1844 && adr2->is_AddP()
a61af66fc99e Initial load
duke
parents:
diff changeset
1845 ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1846 int mirror_field = Klass::java_mirror_offset_in_bytes();
a61af66fc99e Initial load
duke
parents:
diff changeset
1847 if (offset == java_lang_Class::array_klass_offset_in_bytes()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1848 mirror_field = in_bytes(arrayKlass::component_mirror_offset());
a61af66fc99e Initial load
duke
parents:
diff changeset
1849 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1850 if (tkls->offset() == mirror_field + (int)sizeof(oopDesc)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1851 return adr2->in(AddPNode::Base);
a61af66fc99e Initial load
duke
parents:
diff changeset
1852 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1853 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1854 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1855 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1856
a61af66fc99e Initial load
duke
parents:
diff changeset
1857 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
1858 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1859
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1860
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1861 //------------------------------Value------------------------------------------
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1862 const Type *LoadNKlassNode::Value( PhaseTransform *phase ) const {
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1863 const Type *t = klass_value_common(phase);
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1864 if (t == Type::TOP)
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1865 return t;
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1866
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1867 return t->make_narrowoop();
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1868 }
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1869
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1870 //------------------------------Identity---------------------------------------
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1871 // To clean up reflective code, simplify k.java_mirror.as_klass to narrow k.
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1872 // Also feed through the klass in Allocate(...klass...)._klass.
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1873 Node* LoadNKlassNode::Identity( PhaseTransform *phase ) {
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1874 Node *x = klass_identity_common(phase);
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1875
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1876 const Type *t = phase->type( x );
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1877 if( t == Type::TOP ) return x;
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1878 if( t->isa_narrowoop()) return x;
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1879
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1880 return phase->transform(new (phase->C, 2) EncodePNode(x, t->make_narrowoop()));
164
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1881 }
c436414a719e 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 163
diff changeset
1882
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1883 //------------------------------Value-----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1884 const Type *LoadRangeNode::Value( PhaseTransform *phase ) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
1885 // Either input is TOP ==> the result is TOP
a61af66fc99e Initial load
duke
parents:
diff changeset
1886 const Type *t1 = phase->type( in(MemNode::Memory) );
a61af66fc99e Initial load
duke
parents:
diff changeset
1887 if( t1 == Type::TOP ) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1888 Node *adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
1889 const Type *t2 = phase->type( adr );
a61af66fc99e Initial load
duke
parents:
diff changeset
1890 if( t2 == Type::TOP ) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1891 const TypePtr *tp = t2->is_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1892 if (TypePtr::above_centerline(tp->ptr())) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
1893 const TypeAryPtr *tap = tp->isa_aryptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1894 if( !tap ) return _type;
a61af66fc99e Initial load
duke
parents:
diff changeset
1895 return tap->size();
a61af66fc99e Initial load
duke
parents:
diff changeset
1896 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1897
366
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1898 //-------------------------------Ideal---------------------------------------
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1899 // Feed through the length in AllocateArray(...length...)._length.
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1900 Node *LoadRangeNode::Ideal(PhaseGVN *phase, bool can_reshape) {
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1901 Node* p = MemNode::Ideal_common(phase, can_reshape);
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1902 if (p) return (p == NodeSentinel) ? NULL : p;
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1903
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1904 // Take apart the address into an oop and and offset.
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1905 // Return 'this' if we cannot.
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1906 Node* adr = in(MemNode::Address);
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1907 intptr_t offset = 0;
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1908 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1909 if (base == NULL) return NULL;
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1910 const TypeAryPtr* tary = phase->type(adr)->isa_aryptr();
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1911 if (tary == NULL) return NULL;
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1912
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1913 // We can fetch the length directly through an AllocateArrayNode.
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1914 // This works even if the length is not constant (clone or newArray).
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1915 if (offset == arrayOopDesc::length_offset_in_bytes()) {
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1916 AllocateArrayNode* alloc = AllocateArrayNode::Ideal_array_allocation(base, phase);
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1917 if (alloc != NULL) {
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1918 Node* allocated_length = alloc->Ideal_length();
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1919 Node* len = alloc->make_ideal_length(tary, phase);
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1920 if (allocated_length != len) {
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1921 // New CastII improves on this.
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1922 return len;
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1923 }
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1924 }
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1925 }
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1926
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1927 return NULL;
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1928 }
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1929
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1930 //------------------------------Identity---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1931 // Feed through the length in AllocateArray(...length...)._length.
a61af66fc99e Initial load
duke
parents:
diff changeset
1932 Node* LoadRangeNode::Identity( PhaseTransform *phase ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1933 Node* x = LoadINode::Identity(phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
1934 if (x != this) return x;
a61af66fc99e Initial load
duke
parents:
diff changeset
1935
a61af66fc99e Initial load
duke
parents:
diff changeset
1936 // Take apart the address into an oop and and offset.
a61af66fc99e Initial load
duke
parents:
diff changeset
1937 // Return 'this' if we cannot.
a61af66fc99e Initial load
duke
parents:
diff changeset
1938 Node* adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
1939 intptr_t offset = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
1940 Node* base = AddPNode::Ideal_base_and_offset(adr, phase, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
1941 if (base == NULL) return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
1942 const TypeAryPtr* tary = phase->type(adr)->isa_aryptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
1943 if (tary == NULL) return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
1944
a61af66fc99e Initial load
duke
parents:
diff changeset
1945 // We can fetch the length directly through an AllocateArrayNode.
a61af66fc99e Initial load
duke
parents:
diff changeset
1946 // This works even if the length is not constant (clone or newArray).
a61af66fc99e Initial load
duke
parents:
diff changeset
1947 if (offset == arrayOopDesc::length_offset_in_bytes()) {
366
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1948 AllocateArrayNode* alloc = AllocateArrayNode::Ideal_array_allocation(base, phase);
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1949 if (alloc != NULL) {
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1950 Node* allocated_length = alloc->Ideal_length();
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1951 // Do not allow make_ideal_length to allocate a CastII node.
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1952 Node* len = alloc->make_ideal_length(tary, phase, false);
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1953 if (allocated_length == len) {
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1954 // Return allocated_length only if it would not be improved by a CastII.
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1955 return allocated_length;
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1956 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1957 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1958 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1959
a61af66fc99e Initial load
duke
parents:
diff changeset
1960 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
1961
a61af66fc99e Initial load
duke
parents:
diff changeset
1962 }
366
8261ee795323 6711100: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
rasbold
parents: 305
diff changeset
1963
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1964 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
1965 //---------------------------StoreNode::make-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
1966 // Polymorphic factory method:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1967 StoreNode* StoreNode::make( PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, BasicType bt ) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1968 Compile* C = gvn.C;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1969
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1970 switch (bt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1971 case T_BOOLEAN:
a61af66fc99e Initial load
duke
parents:
diff changeset
1972 case T_BYTE: return new (C, 4) StoreBNode(ctl, mem, adr, adr_type, val);
a61af66fc99e Initial load
duke
parents:
diff changeset
1973 case T_INT: return new (C, 4) StoreINode(ctl, mem, adr, adr_type, val);
a61af66fc99e Initial load
duke
parents:
diff changeset
1974 case T_CHAR:
a61af66fc99e Initial load
duke
parents:
diff changeset
1975 case T_SHORT: return new (C, 4) StoreCNode(ctl, mem, adr, adr_type, val);
a61af66fc99e Initial load
duke
parents:
diff changeset
1976 case T_LONG: return new (C, 4) StoreLNode(ctl, mem, adr, adr_type, val);
a61af66fc99e Initial load
duke
parents:
diff changeset
1977 case T_FLOAT: return new (C, 4) StoreFNode(ctl, mem, adr, adr_type, val);
a61af66fc99e Initial load
duke
parents:
diff changeset
1978 case T_DOUBLE: return new (C, 4) StoreDNode(ctl, mem, adr, adr_type, val);
a61af66fc99e Initial load
duke
parents:
diff changeset
1979 case T_ADDRESS:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1980 case T_OBJECT:
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1981 #ifdef _LP64
163
885ed790ecf0 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 155
diff changeset
1982 if (adr->bottom_type()->is_ptr_to_narrowoop() ||
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1983 (UseCompressedOops && val->bottom_type()->isa_klassptr() &&
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1984 adr->bottom_type()->isa_rawptr())) {
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1985 val = gvn.transform(new (C, 2) EncodePNode(val, val->bottom_type()->make_narrowoop()));
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1986 return new (C, 4) StoreNNode(ctl, mem, adr, adr_type, val);
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1987 } else
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
1988 #endif
221
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1989 {
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1990 return new (C, 4) StorePNode(ctl, mem, adr, adr_type, val);
1e026f8da827 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 193
diff changeset
1991 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1992 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1993 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
1994 return (StoreNode*)NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1995 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1996
a61af66fc99e Initial load
duke
parents:
diff changeset
1997 StoreLNode* StoreLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1998 bool require_atomic = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1999 return new (C, 4) StoreLNode(ctl, mem, adr, adr_type, val, require_atomic);
a61af66fc99e Initial load
duke
parents:
diff changeset
2000 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2001
a61af66fc99e Initial load
duke
parents:
diff changeset
2002
a61af66fc99e Initial load
duke
parents:
diff changeset
2003 //--------------------------bottom_type----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2004 const Type *StoreNode::bottom_type() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2005 return Type::MEMORY;
a61af66fc99e Initial load
duke
parents:
diff changeset
2006 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2007
a61af66fc99e Initial load
duke
parents:
diff changeset
2008 //------------------------------hash-------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2009 uint StoreNode::hash() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2010 // unroll addition of interesting fields
a61af66fc99e Initial load
duke
parents:
diff changeset
2011 //return (uintptr_t)in(Control) + (uintptr_t)in(Memory) + (uintptr_t)in(Address) + (uintptr_t)in(ValueIn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2012
a61af66fc99e Initial load
duke
parents:
diff changeset
2013 // Since they are not commoned, do not hash them:
a61af66fc99e Initial load
duke
parents:
diff changeset
2014 return NO_HASH;
a61af66fc99e Initial load
duke
parents:
diff changeset
2015 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2016
a61af66fc99e Initial load
duke
parents:
diff changeset
2017 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2018 // Change back-to-back Store(, p, x) -> Store(m, p, y) to Store(m, p, x).
a61af66fc99e Initial load
duke
parents:
diff changeset
2019 // When a store immediately follows a relevant allocation/initialization,
a61af66fc99e Initial load
duke
parents:
diff changeset
2020 // try to capture it into the initialization, or hoist it above.
a61af66fc99e Initial load
duke
parents:
diff changeset
2021 Node *StoreNode::Ideal(PhaseGVN *phase, bool can_reshape) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2022 Node* p = MemNode::Ideal_common(phase, can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
2023 if (p) return (p == NodeSentinel) ? NULL : p;
a61af66fc99e Initial load
duke
parents:
diff changeset
2024
a61af66fc99e Initial load
duke
parents:
diff changeset
2025 Node* mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
2026 Node* address = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
2027
a61af66fc99e Initial load
duke
parents:
diff changeset
2028 // Back-to-back stores to same address? Fold em up.
a61af66fc99e Initial load
duke
parents:
diff changeset
2029 // Generally unsafe if I have intervening uses...
a61af66fc99e Initial load
duke
parents:
diff changeset
2030 if (mem->is_Store() && phase->eqv_uncast(mem->in(MemNode::Address), address)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2031 // Looking at a dead closed cycle of memory?
a61af66fc99e Initial load
duke
parents:
diff changeset
2032 assert(mem != mem->in(MemNode::Memory), "dead loop in StoreNode::Ideal");
a61af66fc99e Initial load
duke
parents:
diff changeset
2033
a61af66fc99e Initial load
duke
parents:
diff changeset
2034 assert(Opcode() == mem->Opcode() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
2035 phase->C->get_alias_index(adr_type()) == Compile::AliasIdxRaw,
a61af66fc99e Initial load
duke
parents:
diff changeset
2036 "no mismatched stores, except on raw memory");
a61af66fc99e Initial load
duke
parents:
diff changeset
2037
a61af66fc99e Initial load
duke
parents:
diff changeset
2038 if (mem->outcnt() == 1 && // check for intervening uses
a61af66fc99e Initial load
duke
parents:
diff changeset
2039 mem->as_Store()->memory_size() <= this->memory_size()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2040 // If anybody other than 'this' uses 'mem', we cannot fold 'mem' away.
a61af66fc99e Initial load
duke
parents:
diff changeset
2041 // For example, 'mem' might be the final state at a conditional return.
a61af66fc99e Initial load
duke
parents:
diff changeset
2042 // Or, 'mem' might be used by some node which is live at the same time
a61af66fc99e Initial load
duke
parents:
diff changeset
2043 // 'this' is live, which might be unschedulable. So, require exactly
a61af66fc99e Initial load
duke
parents:
diff changeset
2044 // ONE user, the 'this' store, until such time as we clone 'mem' for
a61af66fc99e Initial load
duke
parents:
diff changeset
2045 // each of 'mem's uses (thus making the exactly-1-user-rule hold true).
a61af66fc99e Initial load
duke
parents:
diff changeset
2046 if (can_reshape) { // (%%% is this an anachronism?)
a61af66fc99e Initial load
duke
parents:
diff changeset
2047 set_req_X(MemNode::Memory, mem->in(MemNode::Memory),
a61af66fc99e Initial load
duke
parents:
diff changeset
2048 phase->is_IterGVN());
a61af66fc99e Initial load
duke
parents:
diff changeset
2049 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2050 // It's OK to do this in the parser, since DU info is always accurate,
a61af66fc99e Initial load
duke
parents:
diff changeset
2051 // and the parser always refers to nodes via SafePointNode maps.
a61af66fc99e Initial load
duke
parents:
diff changeset
2052 set_req(MemNode::Memory, mem->in(MemNode::Memory));
a61af66fc99e Initial load
duke
parents:
diff changeset
2053 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2054 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
2055 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2056 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2057
a61af66fc99e Initial load
duke
parents:
diff changeset
2058 // Capture an unaliased, unconditional, simple store into an initializer.
a61af66fc99e Initial load
duke
parents:
diff changeset
2059 // Or, if it is independent of the allocation, hoist it above the allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
2060 if (ReduceFieldZeroing && /*can_reshape &&*/
a61af66fc99e Initial load
duke
parents:
diff changeset
2061 mem->is_Proj() && mem->in(0)->is_Initialize()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2062 InitializeNode* init = mem->in(0)->as_Initialize();
a61af66fc99e Initial load
duke
parents:
diff changeset
2063 intptr_t offset = init->can_capture_store(this, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2064 if (offset > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2065 Node* moved = init->capture_store(this, offset, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2066 // If the InitializeNode captured me, it made a raw copy of me,
a61af66fc99e Initial load
duke
parents:
diff changeset
2067 // and I need to disappear.
a61af66fc99e Initial load
duke
parents:
diff changeset
2068 if (moved != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2069 // %%% hack to ensure that Ideal returns a new node:
a61af66fc99e Initial load
duke
parents:
diff changeset
2070 mem = MergeMemNode::make(phase->C, mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
2071 return mem; // fold me away
a61af66fc99e Initial load
duke
parents:
diff changeset
2072 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2073 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2074 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2075
a61af66fc99e Initial load
duke
parents:
diff changeset
2076 return NULL; // No further progress
a61af66fc99e Initial load
duke
parents:
diff changeset
2077 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2078
a61af66fc99e Initial load
duke
parents:
diff changeset
2079 //------------------------------Value-----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2080 const Type *StoreNode::Value( PhaseTransform *phase ) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2081 // Either input is TOP ==> the result is TOP
a61af66fc99e Initial load
duke
parents:
diff changeset
2082 const Type *t1 = phase->type( in(MemNode::Memory) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2083 if( t1 == Type::TOP ) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
2084 const Type *t2 = phase->type( in(MemNode::Address) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2085 if( t2 == Type::TOP ) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
2086 const Type *t3 = phase->type( in(MemNode::ValueIn) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2087 if( t3 == Type::TOP ) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
2088 return Type::MEMORY;
a61af66fc99e Initial load
duke
parents:
diff changeset
2089 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2090
a61af66fc99e Initial load
duke
parents:
diff changeset
2091 //------------------------------Identity---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2092 // Remove redundant stores:
a61af66fc99e Initial load
duke
parents:
diff changeset
2093 // Store(m, p, Load(m, p)) changes to m.
a61af66fc99e Initial load
duke
parents:
diff changeset
2094 // Store(, p, x) -> Store(m, p, x) changes to Store(m, p, x).
a61af66fc99e Initial load
duke
parents:
diff changeset
2095 Node *StoreNode::Identity( PhaseTransform *phase ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2096 Node* mem = in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
2097 Node* adr = in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
2098 Node* val = in(MemNode::ValueIn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2099
a61af66fc99e Initial load
duke
parents:
diff changeset
2100 // Load then Store? Then the Store is useless
a61af66fc99e Initial load
duke
parents:
diff changeset
2101 if (val->is_Load() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2102 phase->eqv_uncast( val->in(MemNode::Address), adr ) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2103 phase->eqv_uncast( val->in(MemNode::Memory ), mem ) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2104 val->as_Load()->store_Opcode() == Opcode()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2105 return mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
2106 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2107
a61af66fc99e Initial load
duke
parents:
diff changeset
2108 // Two stores in a row of the same value?
a61af66fc99e Initial load
duke
parents:
diff changeset
2109 if (mem->is_Store() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2110 phase->eqv_uncast( mem->in(MemNode::Address), adr ) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2111 phase->eqv_uncast( mem->in(MemNode::ValueIn), val ) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2112 mem->Opcode() == Opcode()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2113 return mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
2114 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2115
a61af66fc99e Initial load
duke
parents:
diff changeset
2116 // Store of zero anywhere into a freshly-allocated object?
a61af66fc99e Initial load
duke
parents:
diff changeset
2117 // Then the store is useless.
a61af66fc99e Initial load
duke
parents:
diff changeset
2118 // (It must already have been captured by the InitializeNode.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2119 if (ReduceFieldZeroing && phase->type(val)->is_zero_type()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2120 // a newly allocated object is already all-zeroes everywhere
a61af66fc99e Initial load
duke
parents:
diff changeset
2121 if (mem->is_Proj() && mem->in(0)->is_Allocate()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2122 return mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
2123 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2124
a61af66fc99e Initial load
duke
parents:
diff changeset
2125 // the store may also apply to zero-bits in an earlier object
a61af66fc99e Initial load
duke
parents:
diff changeset
2126 Node* prev_mem = find_previous_store(phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2127 // Steps (a), (b): Walk past independent stores to find an exact match.
a61af66fc99e Initial load
duke
parents:
diff changeset
2128 if (prev_mem != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2129 Node* prev_val = can_see_stored_value(prev_mem, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2130 if (prev_val != NULL && phase->eqv(prev_val, val)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2131 // prev_val and val might differ by a cast; it would be good
a61af66fc99e Initial load
duke
parents:
diff changeset
2132 // to keep the more informative of the two.
a61af66fc99e Initial load
duke
parents:
diff changeset
2133 return mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
2134 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2135 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2136 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2137
a61af66fc99e Initial load
duke
parents:
diff changeset
2138 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
2139 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2140
a61af66fc99e Initial load
duke
parents:
diff changeset
2141 //------------------------------match_edge-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2142 // Do we Match on this edge index or not? Match only memory & value
a61af66fc99e Initial load
duke
parents:
diff changeset
2143 uint StoreNode::match_edge(uint idx) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2144 return idx == MemNode::Address || idx == MemNode::ValueIn;
a61af66fc99e Initial load
duke
parents:
diff changeset
2145 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2146
a61af66fc99e Initial load
duke
parents:
diff changeset
2147 //------------------------------cmp--------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2148 // Do not common stores up together. They generally have to be split
a61af66fc99e Initial load
duke
parents:
diff changeset
2149 // back up anyways, so do not bother.
a61af66fc99e Initial load
duke
parents:
diff changeset
2150 uint StoreNode::cmp( const Node &n ) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2151 return (&n == this); // Always fail except on self
a61af66fc99e Initial load
duke
parents:
diff changeset
2152 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2153
a61af66fc99e Initial load
duke
parents:
diff changeset
2154 //------------------------------Ideal_masked_input-----------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2155 // Check for a useless mask before a partial-word store
a61af66fc99e Initial load
duke
parents:
diff changeset
2156 // (StoreB ... (AndI valIn conIa) )
a61af66fc99e Initial load
duke
parents:
diff changeset
2157 // If (conIa & mask == mask) this simplifies to
a61af66fc99e Initial load
duke
parents:
diff changeset
2158 // (StoreB ... (valIn) )
a61af66fc99e Initial load
duke
parents:
diff changeset
2159 Node *StoreNode::Ideal_masked_input(PhaseGVN *phase, uint mask) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2160 Node *val = in(MemNode::ValueIn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2161 if( val->Opcode() == Op_AndI ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2162 const TypeInt *t = phase->type( val->in(2) )->isa_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
2163 if( t && t->is_con() && (t->get_con() & mask) == mask ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2164 set_req(MemNode::ValueIn, val->in(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
2165 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
2166 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2167 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2168 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2169 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2170
a61af66fc99e Initial load
duke
parents:
diff changeset
2171
a61af66fc99e Initial load
duke
parents:
diff changeset
2172 //------------------------------Ideal_sign_extended_input----------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2173 // Check for useless sign-extension before a partial-word store
a61af66fc99e Initial load
duke
parents:
diff changeset
2174 // (StoreB ... (RShiftI _ (LShiftI _ valIn conIL ) conIR) )
a61af66fc99e Initial load
duke
parents:
diff changeset
2175 // If (conIL == conIR && conIR <= num_bits) this simplifies to
a61af66fc99e Initial load
duke
parents:
diff changeset
2176 // (StoreB ... (valIn) )
a61af66fc99e Initial load
duke
parents:
diff changeset
2177 Node *StoreNode::Ideal_sign_extended_input(PhaseGVN *phase, int num_bits) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2178 Node *val = in(MemNode::ValueIn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2179 if( val->Opcode() == Op_RShiftI ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2180 const TypeInt *t = phase->type( val->in(2) )->isa_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
2181 if( t && t->is_con() && (t->get_con() <= num_bits) ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2182 Node *shl = val->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2183 if( shl->Opcode() == Op_LShiftI ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2184 const TypeInt *t2 = phase->type( shl->in(2) )->isa_int();
a61af66fc99e Initial load
duke
parents:
diff changeset
2185 if( t2 && t2->is_con() && (t2->get_con() == t->get_con()) ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2186 set_req(MemNode::ValueIn, shl->in(1));
a61af66fc99e Initial load
duke
parents:
diff changeset
2187 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
2188 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2189 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2190 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2191 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2192 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2193 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2194
a61af66fc99e Initial load
duke
parents:
diff changeset
2195 //------------------------------value_never_loaded-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2196 // Determine whether there are any possible loads of the value stored.
a61af66fc99e Initial load
duke
parents:
diff changeset
2197 // For simplicity, we actually check if there are any loads from the
a61af66fc99e Initial load
duke
parents:
diff changeset
2198 // address stored to, not just for loads of the value stored by this node.
a61af66fc99e Initial load
duke
parents:
diff changeset
2199 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2200 bool StoreNode::value_never_loaded( PhaseTransform *phase) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2201 Node *adr = in(Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
2202 const TypeOopPtr *adr_oop = phase->type(adr)->isa_oopptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2203 if (adr_oop == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
2204 return false;
223
1dd146f17531 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 221
diff changeset
2205 if (!adr_oop->is_known_instance_field())
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2206 return false; // if not a distinct instance, there may be aliases of the address
a61af66fc99e Initial load
duke
parents:
diff changeset
2207 for (DUIterator_Fast imax, i = adr->fast_outs(imax); i < imax; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2208 Node *use = adr->fast_out(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2209 int opc = use->Opcode();
a61af66fc99e Initial load
duke
parents:
diff changeset
2210 if (use->is_Load() || use->is_LoadStore()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2211 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2212 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2213 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2214 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2215 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2216
a61af66fc99e Initial load
duke
parents:
diff changeset
2217 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2218 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2219 // If the store is from an AND mask that leaves the low bits untouched, then
a61af66fc99e Initial load
duke
parents:
diff changeset
2220 // we can skip the AND operation. If the store is from a sign-extension
a61af66fc99e Initial load
duke
parents:
diff changeset
2221 // (a left shift, then right shift) we can skip both.
a61af66fc99e Initial load
duke
parents:
diff changeset
2222 Node *StoreBNode::Ideal(PhaseGVN *phase, bool can_reshape){
a61af66fc99e Initial load
duke
parents:
diff changeset
2223 Node *progress = StoreNode::Ideal_masked_input(phase, 0xFF);
a61af66fc99e Initial load
duke
parents:
diff changeset
2224 if( progress != NULL ) return progress;
a61af66fc99e Initial load
duke
parents:
diff changeset
2225
a61af66fc99e Initial load
duke
parents:
diff changeset
2226 progress = StoreNode::Ideal_sign_extended_input(phase, 24);
a61af66fc99e Initial load
duke
parents:
diff changeset
2227 if( progress != NULL ) return progress;
a61af66fc99e Initial load
duke
parents:
diff changeset
2228
a61af66fc99e Initial load
duke
parents:
diff changeset
2229 // Finally check the default case
a61af66fc99e Initial load
duke
parents:
diff changeset
2230 return StoreNode::Ideal(phase, can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
2231 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2232
a61af66fc99e Initial load
duke
parents:
diff changeset
2233 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2234 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2235 // If the store is from an AND mask that leaves the low bits untouched, then
a61af66fc99e Initial load
duke
parents:
diff changeset
2236 // we can skip the AND operation
a61af66fc99e Initial load
duke
parents:
diff changeset
2237 Node *StoreCNode::Ideal(PhaseGVN *phase, bool can_reshape){
a61af66fc99e Initial load
duke
parents:
diff changeset
2238 Node *progress = StoreNode::Ideal_masked_input(phase, 0xFFFF);
a61af66fc99e Initial load
duke
parents:
diff changeset
2239 if( progress != NULL ) return progress;
a61af66fc99e Initial load
duke
parents:
diff changeset
2240
a61af66fc99e Initial load
duke
parents:
diff changeset
2241 progress = StoreNode::Ideal_sign_extended_input(phase, 16);
a61af66fc99e Initial load
duke
parents:
diff changeset
2242 if( progress != NULL ) return progress;
a61af66fc99e Initial load
duke
parents:
diff changeset
2243
a61af66fc99e Initial load
duke
parents:
diff changeset
2244 // Finally check the default case
a61af66fc99e Initial load
duke
parents:
diff changeset
2245 return StoreNode::Ideal(phase, can_reshape);
a61af66fc99e Initial load
duke
parents:
diff changeset
2246 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2247
a61af66fc99e Initial load
duke
parents:
diff changeset
2248 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2249 //------------------------------Identity---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2250 Node *StoreCMNode::Identity( PhaseTransform *phase ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2251 // No need to card mark when storing a null ptr
a61af66fc99e Initial load
duke
parents:
diff changeset
2252 Node* my_store = in(MemNode::OopStore);
a61af66fc99e Initial load
duke
parents:
diff changeset
2253 if (my_store->is_Store()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2254 const Type *t1 = phase->type( my_store->in(MemNode::ValueIn) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2255 if( t1 == TypePtr::NULL_PTR ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2256 return in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
2257 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2258 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2259 return this;
a61af66fc99e Initial load
duke
parents:
diff changeset
2260 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2261
a61af66fc99e Initial load
duke
parents:
diff changeset
2262 //------------------------------Value-----------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2263 const Type *StoreCMNode::Value( PhaseTransform *phase ) const {
43
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2264 // Either input is TOP ==> the result is TOP
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2265 const Type *t = phase->type( in(MemNode::Memory) );
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2266 if( t == Type::TOP ) return Type::TOP;
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2267 t = phase->type( in(MemNode::Address) );
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2268 if( t == Type::TOP ) return Type::TOP;
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2269 t = phase->type( in(MemNode::ValueIn) );
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2270 if( t == Type::TOP ) return Type::TOP;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2271 // If extra input is TOP ==> the result is TOP
43
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2272 t = phase->type( in(MemNode::OopStore) );
d821d920b465 6623167: C2 crashed in StoreCMNode::Value
kvn
parents: 36
diff changeset
2273 if( t == Type::TOP ) return Type::TOP;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2274
a61af66fc99e Initial load
duke
parents:
diff changeset
2275 return StoreNode::Value( phase );
a61af66fc99e Initial load
duke
parents:
diff changeset
2276 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2277
a61af66fc99e Initial load
duke
parents:
diff changeset
2278
a61af66fc99e Initial load
duke
parents:
diff changeset
2279 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2280 //----------------------------------SCMemProjNode------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2281 const Type * SCMemProjNode::Value( PhaseTransform *phase ) const
a61af66fc99e Initial load
duke
parents:
diff changeset
2282 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2283 return bottom_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
2284 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2285
a61af66fc99e Initial load
duke
parents:
diff changeset
2286 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2287 LoadStoreNode::LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex ) : Node(5) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2288 init_req(MemNode::Control, c );
a61af66fc99e Initial load
duke
parents:
diff changeset
2289 init_req(MemNode::Memory , mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
2290 init_req(MemNode::Address, adr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2291 init_req(MemNode::ValueIn, val);
a61af66fc99e Initial load
duke
parents:
diff changeset
2292 init_req( ExpectedIn, ex );
a61af66fc99e Initial load
duke
parents:
diff changeset
2293 init_class_id(Class_LoadStore);
a61af66fc99e Initial load
duke
parents:
diff changeset
2294
a61af66fc99e Initial load
duke
parents:
diff changeset
2295 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2296
a61af66fc99e Initial load
duke
parents:
diff changeset
2297 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2298 //-------------------------------adr_type--------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2299 // Do we Match on this edge index or not? Do not match memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2300 const TypePtr* ClearArrayNode::adr_type() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2301 Node *adr = in(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
2302 return MemNode::calculate_adr_type(adr->bottom_type());
a61af66fc99e Initial load
duke
parents:
diff changeset
2303 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2304
a61af66fc99e Initial load
duke
parents:
diff changeset
2305 //------------------------------match_edge-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2306 // Do we Match on this edge index or not? Do not match memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2307 uint ClearArrayNode::match_edge(uint idx) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2308 return idx > 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2309 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2310
a61af66fc99e Initial load
duke
parents:
diff changeset
2311 //------------------------------Identity---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2312 // Clearing a zero length array does nothing
a61af66fc99e Initial load
duke
parents:
diff changeset
2313 Node *ClearArrayNode::Identity( PhaseTransform *phase ) {
68
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2314 return phase->type(in(2))->higher_equal(TypeX::ZERO) ? in(1) : this;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2315 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2316
a61af66fc99e Initial load
duke
parents:
diff changeset
2317 //------------------------------Idealize---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2318 // Clearing a short array is faster with stores
a61af66fc99e Initial load
duke
parents:
diff changeset
2319 Node *ClearArrayNode::Ideal(PhaseGVN *phase, bool can_reshape){
a61af66fc99e Initial load
duke
parents:
diff changeset
2320 const int unit = BytesPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
2321 const TypeX* t = phase->type(in(2))->isa_intptr_t();
a61af66fc99e Initial load
duke
parents:
diff changeset
2322 if (!t) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2323 if (!t->is_con()) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2324 intptr_t raw_count = t->get_con();
a61af66fc99e Initial load
duke
parents:
diff changeset
2325 intptr_t size = raw_count;
a61af66fc99e Initial load
duke
parents:
diff changeset
2326 if (!Matcher::init_array_count_is_in_bytes) size *= unit;
a61af66fc99e Initial load
duke
parents:
diff changeset
2327 // Clearing nothing uses the Identity call.
a61af66fc99e Initial load
duke
parents:
diff changeset
2328 // Negative clears are possible on dead ClearArrays
a61af66fc99e Initial load
duke
parents:
diff changeset
2329 // (see jck test stmt114.stmt11402.val).
a61af66fc99e Initial load
duke
parents:
diff changeset
2330 if (size <= 0 || size % unit != 0) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2331 intptr_t count = size / unit;
a61af66fc99e Initial load
duke
parents:
diff changeset
2332 // Length too long; use fast hardware clear
a61af66fc99e Initial load
duke
parents:
diff changeset
2333 if (size > Matcher::init_array_short_size) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2334 Node *mem = in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2335 if( phase->type(mem)==Type::TOP ) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2336 Node *adr = in(3);
a61af66fc99e Initial load
duke
parents:
diff changeset
2337 const Type* at = phase->type(adr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2338 if( at==Type::TOP ) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2339 const TypePtr* atp = at->isa_ptr();
a61af66fc99e Initial load
duke
parents:
diff changeset
2340 // adjust atp to be the correct array element address type
a61af66fc99e Initial load
duke
parents:
diff changeset
2341 if (atp == NULL) atp = TypePtr::BOTTOM;
a61af66fc99e Initial load
duke
parents:
diff changeset
2342 else atp = atp->add_offset(Type::OffsetBot);
a61af66fc99e Initial load
duke
parents:
diff changeset
2343 // Get base for derived pointer purposes
a61af66fc99e Initial load
duke
parents:
diff changeset
2344 if( adr->Opcode() != Op_AddP ) Unimplemented();
a61af66fc99e Initial load
duke
parents:
diff changeset
2345 Node *base = adr->in(1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2346
a61af66fc99e Initial load
duke
parents:
diff changeset
2347 Node *zero = phase->makecon(TypeLong::ZERO);
a61af66fc99e Initial load
duke
parents:
diff changeset
2348 Node *off = phase->MakeConX(BytesPerLong);
a61af66fc99e Initial load
duke
parents:
diff changeset
2349 mem = new (phase->C, 4) StoreLNode(in(0),mem,adr,atp,zero);
a61af66fc99e Initial load
duke
parents:
diff changeset
2350 count--;
a61af66fc99e Initial load
duke
parents:
diff changeset
2351 while( count-- ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2352 mem = phase->transform(mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
2353 adr = phase->transform(new (phase->C, 4) AddPNode(base,adr,off));
a61af66fc99e Initial load
duke
parents:
diff changeset
2354 mem = new (phase->C, 4) StoreLNode(in(0),mem,adr,atp,zero);
a61af66fc99e Initial load
duke
parents:
diff changeset
2355 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2356 return mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
2357 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2358
a61af66fc99e Initial load
duke
parents:
diff changeset
2359 //----------------------------clear_memory-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2360 // Generate code to initialize object storage to zero.
a61af66fc99e Initial load
duke
parents:
diff changeset
2361 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
2362 intptr_t start_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
2363 Node* end_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
2364 PhaseGVN* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2365 Compile* C = phase->C;
a61af66fc99e Initial load
duke
parents:
diff changeset
2366 intptr_t offset = start_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
2367
a61af66fc99e Initial load
duke
parents:
diff changeset
2368 int unit = BytesPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
2369 if ((offset % unit) != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2370 Node* adr = new (C, 4) AddPNode(dest, dest, phase->MakeConX(offset));
a61af66fc99e Initial load
duke
parents:
diff changeset
2371 adr = phase->transform(adr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2372 const TypePtr* atp = TypeRawPtr::BOTTOM;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
2373 mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2374 mem = phase->transform(mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
2375 offset += BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
2376 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2377 assert((offset % unit) == 0, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
2378
a61af66fc99e Initial load
duke
parents:
diff changeset
2379 // Initialize the remaining stuff, if any, with a ClearArray.
a61af66fc99e Initial load
duke
parents:
diff changeset
2380 return clear_memory(ctl, mem, dest, phase->MakeConX(offset), end_offset, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2381 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2382
a61af66fc99e Initial load
duke
parents:
diff changeset
2383 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
2384 Node* start_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
2385 Node* end_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
2386 PhaseGVN* phase) {
68
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2387 if (start_offset == end_offset) {
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2388 // nothing to do
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2389 return mem;
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2390 }
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2391
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2392 Compile* C = phase->C;
a61af66fc99e Initial load
duke
parents:
diff changeset
2393 int unit = BytesPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
2394 Node* zbase = start_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
2395 Node* zend = end_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
2396
a61af66fc99e Initial load
duke
parents:
diff changeset
2397 // Scale to the unit required by the CPU:
a61af66fc99e Initial load
duke
parents:
diff changeset
2398 if (!Matcher::init_array_count_is_in_bytes) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2399 Node* shift = phase->intcon(exact_log2(unit));
a61af66fc99e Initial load
duke
parents:
diff changeset
2400 zbase = phase->transform( new(C,3) URShiftXNode(zbase, shift) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2401 zend = phase->transform( new(C,3) URShiftXNode(zend, shift) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2402 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2403
a61af66fc99e Initial load
duke
parents:
diff changeset
2404 Node* zsize = phase->transform( new(C,3) SubXNode(zend, zbase) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2405 Node* zinit = phase->zerocon((unit == BytesPerLong) ? T_LONG : T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
2406
a61af66fc99e Initial load
duke
parents:
diff changeset
2407 // Bulk clear double-words
a61af66fc99e Initial load
duke
parents:
diff changeset
2408 Node* adr = phase->transform( new(C,4) AddPNode(dest, dest, start_offset) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2409 mem = new (C, 4) ClearArrayNode(ctl, mem, zsize, adr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2410 return phase->transform(mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
2411 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2412
a61af66fc99e Initial load
duke
parents:
diff changeset
2413 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
2414 intptr_t start_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
2415 intptr_t end_offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
2416 PhaseGVN* phase) {
68
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2417 if (start_offset == end_offset) {
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2418 // nothing to do
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2419 return mem;
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2420 }
daf38130e60d 6676841: ClearArrayNode::Identity is incorrect for 64-bit
never
parents: 64
diff changeset
2421
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2422 Compile* C = phase->C;
a61af66fc99e Initial load
duke
parents:
diff changeset
2423 assert((end_offset % BytesPerInt) == 0, "odd end offset");
a61af66fc99e Initial load
duke
parents:
diff changeset
2424 intptr_t done_offset = end_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
2425 if ((done_offset % BytesPerLong) != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2426 done_offset -= BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
2427 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2428 if (done_offset > start_offset) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2429 mem = clear_memory(ctl, mem, dest,
a61af66fc99e Initial load
duke
parents:
diff changeset
2430 start_offset, phase->MakeConX(done_offset), phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2431 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2432 if (done_offset < end_offset) { // emit the final 32-bit store
a61af66fc99e Initial load
duke
parents:
diff changeset
2433 Node* adr = new (C, 4) AddPNode(dest, dest, phase->MakeConX(done_offset));
a61af66fc99e Initial load
duke
parents:
diff changeset
2434 adr = phase->transform(adr);
a61af66fc99e Initial load
duke
parents:
diff changeset
2435 const TypePtr* atp = TypeRawPtr::BOTTOM;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
2436 mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2437 mem = phase->transform(mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
2438 done_offset += BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
2439 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2440 assert(done_offset == end_offset, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
2441 return mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
2442 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2443
a61af66fc99e Initial load
duke
parents:
diff changeset
2444 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2445 // Do we match on this edge? No memory edges
a61af66fc99e Initial load
duke
parents:
diff changeset
2446 uint StrCompNode::match_edge(uint idx) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2447 return idx == 5 || idx == 6;
a61af66fc99e Initial load
duke
parents:
diff changeset
2448 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2449
a61af66fc99e Initial load
duke
parents:
diff changeset
2450 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2451 // Return a node which is more "ideal" than the current node. Strip out
a61af66fc99e Initial load
duke
parents:
diff changeset
2452 // control copies
a61af66fc99e Initial load
duke
parents:
diff changeset
2453 Node *StrCompNode::Ideal(PhaseGVN *phase, bool can_reshape){
a61af66fc99e Initial load
duke
parents:
diff changeset
2454 return remove_dead_region(phase, can_reshape) ? this : NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2455 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2456
169
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
2457 //------------------------------Ideal------------------------------------------
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
2458 // Return a node which is more "ideal" than the current node. Strip out
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
2459 // control copies
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
2460 Node *AryEqNode::Ideal(PhaseGVN *phase, bool can_reshape){
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
2461 return remove_dead_region(phase, can_reshape) ? this : NULL;
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
2462 }
9148c65abefc 6695049: (coll) Create an x86 intrinsic for Arrays.equals
rasbold
parents: 168
diff changeset
2463
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2464
a61af66fc99e Initial load
duke
parents:
diff changeset
2465 //=============================================================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2466 MemBarNode::MemBarNode(Compile* C, int alias_idx, Node* precedent)
a61af66fc99e Initial load
duke
parents:
diff changeset
2467 : MultiNode(TypeFunc::Parms + (precedent == NULL? 0: 1)),
a61af66fc99e Initial load
duke
parents:
diff changeset
2468 _adr_type(C->get_adr_type(alias_idx))
a61af66fc99e Initial load
duke
parents:
diff changeset
2469 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2470 init_class_id(Class_MemBar);
a61af66fc99e Initial load
duke
parents:
diff changeset
2471 Node* top = C->top();
a61af66fc99e Initial load
duke
parents:
diff changeset
2472 init_req(TypeFunc::I_O,top);
a61af66fc99e Initial load
duke
parents:
diff changeset
2473 init_req(TypeFunc::FramePtr,top);
a61af66fc99e Initial load
duke
parents:
diff changeset
2474 init_req(TypeFunc::ReturnAdr,top);
a61af66fc99e Initial load
duke
parents:
diff changeset
2475 if (precedent != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
2476 init_req(TypeFunc::Parms, precedent);
a61af66fc99e Initial load
duke
parents:
diff changeset
2477 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2478
a61af66fc99e Initial load
duke
parents:
diff changeset
2479 //------------------------------cmp--------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2480 uint MemBarNode::hash() const { return NO_HASH; }
a61af66fc99e Initial load
duke
parents:
diff changeset
2481 uint MemBarNode::cmp( const Node &n ) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2482 return (&n == this); // Always fail except on self
a61af66fc99e Initial load
duke
parents:
diff changeset
2483 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2484
a61af66fc99e Initial load
duke
parents:
diff changeset
2485 //------------------------------make-------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2486 MemBarNode* MemBarNode::make(Compile* C, int opcode, int atp, Node* pn) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2487 int len = Precedent + (pn == NULL? 0: 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
2488 switch (opcode) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2489 case Op_MemBarAcquire: return new(C, len) MemBarAcquireNode(C, atp, pn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2490 case Op_MemBarRelease: return new(C, len) MemBarReleaseNode(C, atp, pn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2491 case Op_MemBarVolatile: return new(C, len) MemBarVolatileNode(C, atp, pn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2492 case Op_MemBarCPUOrder: return new(C, len) MemBarCPUOrderNode(C, atp, pn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2493 case Op_Initialize: return new(C, len) InitializeNode(C, atp, pn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2494 default: ShouldNotReachHere(); return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2495 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2496 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2497
a61af66fc99e Initial load
duke
parents:
diff changeset
2498 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2499 // Return a node which is more "ideal" than the current node. Strip out
a61af66fc99e Initial load
duke
parents:
diff changeset
2500 // control copies
a61af66fc99e Initial load
duke
parents:
diff changeset
2501 Node *MemBarNode::Ideal(PhaseGVN *phase, bool can_reshape) {
305
ab075d07f1ba 6736417: Fastdebug C2 crashes in StoreBNode::Ideal
kvn
parents: 293
diff changeset
2502 return remove_dead_region(phase, can_reshape) ? this : NULL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2503 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2504
a61af66fc99e Initial load
duke
parents:
diff changeset
2505 //------------------------------Value------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2506 const Type *MemBarNode::Value( PhaseTransform *phase ) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2507 if( !in(0) ) return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
2508 if( phase->type(in(0)) == Type::TOP )
a61af66fc99e Initial load
duke
parents:
diff changeset
2509 return Type::TOP;
a61af66fc99e Initial load
duke
parents:
diff changeset
2510 return TypeTuple::MEMBAR;
a61af66fc99e Initial load
duke
parents:
diff changeset
2511 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2512
a61af66fc99e Initial load
duke
parents:
diff changeset
2513 //------------------------------match------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2514 // Construct projections for memory.
a61af66fc99e Initial load
duke
parents:
diff changeset
2515 Node *MemBarNode::match( const ProjNode *proj, const Matcher *m ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2516 switch (proj->_con) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2517 case TypeFunc::Control:
a61af66fc99e Initial load
duke
parents:
diff changeset
2518 case TypeFunc::Memory:
a61af66fc99e Initial load
duke
parents:
diff changeset
2519 return new (m->C, 1) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
a61af66fc99e Initial load
duke
parents:
diff changeset
2520 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2521 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
2522 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2523 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2524
a61af66fc99e Initial load
duke
parents:
diff changeset
2525 //===========================InitializeNode====================================
a61af66fc99e Initial load
duke
parents:
diff changeset
2526 // SUMMARY:
a61af66fc99e Initial load
duke
parents:
diff changeset
2527 // This node acts as a memory barrier on raw memory, after some raw stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
2528 // The 'cooked' oop value feeds from the Initialize, not the Allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
2529 // The Initialize can 'capture' suitably constrained stores as raw inits.
a61af66fc99e Initial load
duke
parents:
diff changeset
2530 // It can coalesce related raw stores into larger units (called 'tiles').
a61af66fc99e Initial load
duke
parents:
diff changeset
2531 // It can avoid zeroing new storage for memory units which have raw inits.
a61af66fc99e Initial load
duke
parents:
diff changeset
2532 // At macro-expansion, it is marked 'complete', and does not optimize further.
a61af66fc99e Initial load
duke
parents:
diff changeset
2533 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2534 // EXAMPLE:
a61af66fc99e Initial load
duke
parents:
diff changeset
2535 // The object 'new short[2]' occupies 16 bytes in a 32-bit machine.
a61af66fc99e Initial load
duke
parents:
diff changeset
2536 // ctl = incoming control; mem* = incoming memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2537 // (Note: A star * on a memory edge denotes I/O and other standard edges.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2538 // First allocate uninitialized memory and fill in the header:
a61af66fc99e Initial load
duke
parents:
diff changeset
2539 // alloc = (Allocate ctl mem* 16 #short[].klass ...)
a61af66fc99e Initial load
duke
parents:
diff changeset
2540 // ctl := alloc.Control; mem* := alloc.Memory*
a61af66fc99e Initial load
duke
parents:
diff changeset
2541 // rawmem = alloc.Memory; rawoop = alloc.RawAddress
a61af66fc99e Initial load
duke
parents:
diff changeset
2542 // Then initialize to zero the non-header parts of the raw memory block:
a61af66fc99e Initial load
duke
parents:
diff changeset
2543 // init = (Initialize alloc.Control alloc.Memory* alloc.RawAddress)
a61af66fc99e Initial load
duke
parents:
diff changeset
2544 // ctl := init.Control; mem.SLICE(#short[*]) := init.Memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2545 // After the initialize node executes, the object is ready for service:
a61af66fc99e Initial load
duke
parents:
diff changeset
2546 // oop := (CheckCastPP init.Control alloc.RawAddress #short[])
a61af66fc99e Initial load
duke
parents:
diff changeset
2547 // Suppose its body is immediately initialized as {1,2}:
a61af66fc99e Initial load
duke
parents:
diff changeset
2548 // store1 = (StoreC init.Control init.Memory (+ oop 12) 1)
a61af66fc99e Initial load
duke
parents:
diff changeset
2549 // store2 = (StoreC init.Control store1 (+ oop 14) 2)
a61af66fc99e Initial load
duke
parents:
diff changeset
2550 // mem.SLICE(#short[*]) := store2
a61af66fc99e Initial load
duke
parents:
diff changeset
2551 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2552 // DETAILS:
a61af66fc99e Initial load
duke
parents:
diff changeset
2553 // An InitializeNode collects and isolates object initialization after
a61af66fc99e Initial load
duke
parents:
diff changeset
2554 // an AllocateNode and before the next possible safepoint. As a
a61af66fc99e Initial load
duke
parents:
diff changeset
2555 // memory barrier (MemBarNode), it keeps critical stores from drifting
a61af66fc99e Initial load
duke
parents:
diff changeset
2556 // down past any safepoint or any publication of the allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
2557 // Before this barrier, a newly-allocated object may have uninitialized bits.
a61af66fc99e Initial load
duke
parents:
diff changeset
2558 // After this barrier, it may be treated as a real oop, and GC is allowed.
a61af66fc99e Initial load
duke
parents:
diff changeset
2559 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2560 // The semantics of the InitializeNode include an implicit zeroing of
a61af66fc99e Initial load
duke
parents:
diff changeset
2561 // the new object from object header to the end of the object.
a61af66fc99e Initial load
duke
parents:
diff changeset
2562 // (The object header and end are determined by the AllocateNode.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2563 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2564 // Certain stores may be added as direct inputs to the InitializeNode.
a61af66fc99e Initial load
duke
parents:
diff changeset
2565 // These stores must update raw memory, and they must be to addresses
a61af66fc99e Initial load
duke
parents:
diff changeset
2566 // derived from the raw address produced by AllocateNode, and with
a61af66fc99e Initial load
duke
parents:
diff changeset
2567 // a constant offset. They must be ordered by increasing offset.
a61af66fc99e Initial load
duke
parents:
diff changeset
2568 // The first one is at in(RawStores), the last at in(req()-1).
a61af66fc99e Initial load
duke
parents:
diff changeset
2569 // Unlike most memory operations, they are not linked in a chain,
a61af66fc99e Initial load
duke
parents:
diff changeset
2570 // but are displayed in parallel as users of the rawmem output of
a61af66fc99e Initial load
duke
parents:
diff changeset
2571 // the allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
2572 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2573 // (See comments in InitializeNode::capture_store, which continue
a61af66fc99e Initial load
duke
parents:
diff changeset
2574 // the example given above.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2575 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2576 // When the associated Allocate is macro-expanded, the InitializeNode
a61af66fc99e Initial load
duke
parents:
diff changeset
2577 // may be rewritten to optimize collected stores. A ClearArrayNode
a61af66fc99e Initial load
duke
parents:
diff changeset
2578 // may also be created at that point to represent any required zeroing.
a61af66fc99e Initial load
duke
parents:
diff changeset
2579 // The InitializeNode is then marked 'complete', prohibiting further
a61af66fc99e Initial load
duke
parents:
diff changeset
2580 // capturing of nearby memory operations.
a61af66fc99e Initial load
duke
parents:
diff changeset
2581 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2582 // During macro-expansion, all captured initializations which store
a61af66fc99e Initial load
duke
parents:
diff changeset
2583 // constant values of 32 bits or smaller are coalesced (if advantagous)
a61af66fc99e Initial load
duke
parents:
diff changeset
2584 // into larger 'tiles' 32 or 64 bits. This allows an object to be
a61af66fc99e Initial load
duke
parents:
diff changeset
2585 // initialized in fewer memory operations. Memory words which are
a61af66fc99e Initial load
duke
parents:
diff changeset
2586 // covered by neither tiles nor non-constant stores are pre-zeroed
a61af66fc99e Initial load
duke
parents:
diff changeset
2587 // by explicit stores of zero. (The code shape happens to do all
a61af66fc99e Initial load
duke
parents:
diff changeset
2588 // zeroing first, then all other stores, with both sequences occurring
a61af66fc99e Initial load
duke
parents:
diff changeset
2589 // in order of ascending offsets.)
a61af66fc99e Initial load
duke
parents:
diff changeset
2590 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2591 // Alternatively, code may be inserted between an AllocateNode and its
a61af66fc99e Initial load
duke
parents:
diff changeset
2592 // InitializeNode, to perform arbitrary initialization of the new object.
a61af66fc99e Initial load
duke
parents:
diff changeset
2593 // E.g., the object copying intrinsics insert complex data transfers here.
a61af66fc99e Initial load
duke
parents:
diff changeset
2594 // The initialization must then be marked as 'complete' disable the
a61af66fc99e Initial load
duke
parents:
diff changeset
2595 // built-in zeroing semantics and the collection of initializing stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
2596 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2597 // While an InitializeNode is incomplete, reads from the memory state
a61af66fc99e Initial load
duke
parents:
diff changeset
2598 // produced by it are optimizable if they match the control edge and
a61af66fc99e Initial load
duke
parents:
diff changeset
2599 // new oop address associated with the allocation/initialization.
a61af66fc99e Initial load
duke
parents:
diff changeset
2600 // They return a stored value (if the offset matches) or else zero.
a61af66fc99e Initial load
duke
parents:
diff changeset
2601 // A write to the memory state, if it matches control and address,
a61af66fc99e Initial load
duke
parents:
diff changeset
2602 // and if it is to a constant offset, may be 'captured' by the
a61af66fc99e Initial load
duke
parents:
diff changeset
2603 // InitializeNode. It is cloned as a raw memory operation and rewired
a61af66fc99e Initial load
duke
parents:
diff changeset
2604 // inside the initialization, to the raw oop produced by the allocation.
a61af66fc99e Initial load
duke
parents:
diff changeset
2605 // Operations on addresses which are provably distinct (e.g., to
a61af66fc99e Initial load
duke
parents:
diff changeset
2606 // other AllocateNodes) are allowed to bypass the initialization.
a61af66fc99e Initial load
duke
parents:
diff changeset
2607 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2608 // The effect of all this is to consolidate object initialization
a61af66fc99e Initial load
duke
parents:
diff changeset
2609 // (both arrays and non-arrays, both piecewise and bulk) into a
a61af66fc99e Initial load
duke
parents:
diff changeset
2610 // single location, where it can be optimized as a unit.
a61af66fc99e Initial load
duke
parents:
diff changeset
2611 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2612 // Only stores with an offset less than TrackedInitializationLimit words
a61af66fc99e Initial load
duke
parents:
diff changeset
2613 // will be considered for capture by an InitializeNode. This puts a
a61af66fc99e Initial load
duke
parents:
diff changeset
2614 // reasonable limit on the complexity of optimized initializations.
a61af66fc99e Initial load
duke
parents:
diff changeset
2615
a61af66fc99e Initial load
duke
parents:
diff changeset
2616 //---------------------------InitializeNode------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
2617 InitializeNode::InitializeNode(Compile* C, int adr_type, Node* rawoop)
a61af66fc99e Initial load
duke
parents:
diff changeset
2618 : _is_complete(false),
a61af66fc99e Initial load
duke
parents:
diff changeset
2619 MemBarNode(C, adr_type, rawoop)
a61af66fc99e Initial load
duke
parents:
diff changeset
2620 {
a61af66fc99e Initial load
duke
parents:
diff changeset
2621 init_class_id(Class_Initialize);
a61af66fc99e Initial load
duke
parents:
diff changeset
2622
a61af66fc99e Initial load
duke
parents:
diff changeset
2623 assert(adr_type == Compile::AliasIdxRaw, "only valid atp");
a61af66fc99e Initial load
duke
parents:
diff changeset
2624 assert(in(RawAddress) == rawoop, "proper init");
a61af66fc99e Initial load
duke
parents:
diff changeset
2625 // Note: allocation() can be NULL, for secondary initialization barriers
a61af66fc99e Initial load
duke
parents:
diff changeset
2626 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2627
a61af66fc99e Initial load
duke
parents:
diff changeset
2628 // Since this node is not matched, it will be processed by the
a61af66fc99e Initial load
duke
parents:
diff changeset
2629 // register allocator. Declare that there are no constraints
a61af66fc99e Initial load
duke
parents:
diff changeset
2630 // on the allocation of the RawAddress edge.
a61af66fc99e Initial load
duke
parents:
diff changeset
2631 const RegMask &InitializeNode::in_RegMask(uint idx) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
2632 // This edge should be set to top, by the set_complete. But be conservative.
a61af66fc99e Initial load
duke
parents:
diff changeset
2633 if (idx == InitializeNode::RawAddress)
a61af66fc99e Initial load
duke
parents:
diff changeset
2634 return *(Compile::current()->matcher()->idealreg2spillmask[in(idx)->ideal_reg()]);
a61af66fc99e Initial load
duke
parents:
diff changeset
2635 return RegMask::Empty;
a61af66fc99e Initial load
duke
parents:
diff changeset
2636 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2637
a61af66fc99e Initial load
duke
parents:
diff changeset
2638 Node* InitializeNode::memory(uint alias_idx) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2639 Node* mem = in(Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
2640 if (mem->is_MergeMem()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2641 return mem->as_MergeMem()->memory_at(alias_idx);
a61af66fc99e Initial load
duke
parents:
diff changeset
2642 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2643 // incoming raw memory is not split
a61af66fc99e Initial load
duke
parents:
diff changeset
2644 return mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
2645 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2646 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2647
a61af66fc99e Initial load
duke
parents:
diff changeset
2648 bool InitializeNode::is_non_zero() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2649 if (is_complete()) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2650 remove_extra_zeroes();
a61af66fc99e Initial load
duke
parents:
diff changeset
2651 return (req() > RawStores);
a61af66fc99e Initial load
duke
parents:
diff changeset
2652 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2653
a61af66fc99e Initial load
duke
parents:
diff changeset
2654 void InitializeNode::set_complete(PhaseGVN* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2655 assert(!is_complete(), "caller responsibility");
a61af66fc99e Initial load
duke
parents:
diff changeset
2656 _is_complete = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2657
a61af66fc99e Initial load
duke
parents:
diff changeset
2658 // After this node is complete, it contains a bunch of
a61af66fc99e Initial load
duke
parents:
diff changeset
2659 // raw-memory initializations. There is no need for
a61af66fc99e Initial load
duke
parents:
diff changeset
2660 // it to have anything to do with non-raw memory effects.
a61af66fc99e Initial load
duke
parents:
diff changeset
2661 // Therefore, tell all non-raw users to re-optimize themselves,
a61af66fc99e Initial load
duke
parents:
diff changeset
2662 // after skipping the memory effects of this initialization.
a61af66fc99e Initial load
duke
parents:
diff changeset
2663 PhaseIterGVN* igvn = phase->is_IterGVN();
a61af66fc99e Initial load
duke
parents:
diff changeset
2664 if (igvn) igvn->add_users_to_worklist(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
2665 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2666
a61af66fc99e Initial load
duke
parents:
diff changeset
2667 // convenience function
a61af66fc99e Initial load
duke
parents:
diff changeset
2668 // return false if the init contains any stores already
a61af66fc99e Initial load
duke
parents:
diff changeset
2669 bool AllocateNode::maybe_set_complete(PhaseGVN* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2670 InitializeNode* init = initialization();
a61af66fc99e Initial load
duke
parents:
diff changeset
2671 if (init == NULL || init->is_complete()) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2672 init->remove_extra_zeroes();
a61af66fc99e Initial load
duke
parents:
diff changeset
2673 // for now, if this allocation has already collected any inits, bail:
a61af66fc99e Initial load
duke
parents:
diff changeset
2674 if (init->is_non_zero()) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2675 init->set_complete(phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2676 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2677 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2678
a61af66fc99e Initial load
duke
parents:
diff changeset
2679 void InitializeNode::remove_extra_zeroes() {
a61af66fc99e Initial load
duke
parents:
diff changeset
2680 if (req() == RawStores) return;
a61af66fc99e Initial load
duke
parents:
diff changeset
2681 Node* zmem = zero_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
2682 uint fill = RawStores;
a61af66fc99e Initial load
duke
parents:
diff changeset
2683 for (uint i = fill; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2684 Node* n = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2685 if (n->is_top() || n == zmem) continue; // skip
a61af66fc99e Initial load
duke
parents:
diff changeset
2686 if (fill < i) set_req(fill, n); // compact
a61af66fc99e Initial load
duke
parents:
diff changeset
2687 ++fill;
a61af66fc99e Initial load
duke
parents:
diff changeset
2688 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2689 // delete any empty spaces created:
a61af66fc99e Initial load
duke
parents:
diff changeset
2690 while (fill < req()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2691 del_req(fill);
a61af66fc99e Initial load
duke
parents:
diff changeset
2692 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2693 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2694
a61af66fc99e Initial load
duke
parents:
diff changeset
2695 // Helper for remembering which stores go with which offsets.
a61af66fc99e Initial load
duke
parents:
diff changeset
2696 intptr_t InitializeNode::get_store_offset(Node* st, PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2697 if (!st->is_Store()) return -1; // can happen to dead code via subsume_node
a61af66fc99e Initial load
duke
parents:
diff changeset
2698 intptr_t offset = -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
2699 Node* base = AddPNode::Ideal_base_and_offset(st->in(MemNode::Address),
a61af66fc99e Initial load
duke
parents:
diff changeset
2700 phase, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2701 if (base == NULL) return -1; // something is dead,
a61af66fc99e Initial load
duke
parents:
diff changeset
2702 if (offset < 0) return -1; // dead, dead
a61af66fc99e Initial load
duke
parents:
diff changeset
2703 return offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
2704 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2705
a61af66fc99e Initial load
duke
parents:
diff changeset
2706 // Helper for proving that an initialization expression is
a61af66fc99e Initial load
duke
parents:
diff changeset
2707 // "simple enough" to be folded into an object initialization.
a61af66fc99e Initial load
duke
parents:
diff changeset
2708 // Attempts to prove that a store's initial value 'n' can be captured
a61af66fc99e Initial load
duke
parents:
diff changeset
2709 // within the initialization without creating a vicious cycle, such as:
a61af66fc99e Initial load
duke
parents:
diff changeset
2710 // { Foo p = new Foo(); p.next = p; }
a61af66fc99e Initial load
duke
parents:
diff changeset
2711 // True for constants and parameters and small combinations thereof.
a61af66fc99e Initial load
duke
parents:
diff changeset
2712 bool InitializeNode::detect_init_independence(Node* n,
a61af66fc99e Initial load
duke
parents:
diff changeset
2713 bool st_is_pinned,
a61af66fc99e Initial load
duke
parents:
diff changeset
2714 int& count) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2715 if (n == NULL) return true; // (can this really happen?)
a61af66fc99e Initial load
duke
parents:
diff changeset
2716 if (n->is_Proj()) n = n->in(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
2717 if (n == this) return false; // found a cycle
a61af66fc99e Initial load
duke
parents:
diff changeset
2718 if (n->is_Con()) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2719 if (n->is_Start()) return true; // params, etc., are OK
a61af66fc99e Initial load
duke
parents:
diff changeset
2720 if (n->is_Root()) return true; // even better
a61af66fc99e Initial load
duke
parents:
diff changeset
2721
a61af66fc99e Initial load
duke
parents:
diff changeset
2722 Node* ctl = n->in(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
2723 if (ctl != NULL && !ctl->is_top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2724 if (ctl->is_Proj()) ctl = ctl->in(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
2725 if (ctl == this) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2726
a61af66fc99e Initial load
duke
parents:
diff changeset
2727 // If we already know that the enclosing memory op is pinned right after
a61af66fc99e Initial load
duke
parents:
diff changeset
2728 // the init, then any control flow that the store has picked up
a61af66fc99e Initial load
duke
parents:
diff changeset
2729 // must have preceded the init, or else be equal to the init.
a61af66fc99e Initial load
duke
parents:
diff changeset
2730 // Even after loop optimizations (which might change control edges)
a61af66fc99e Initial load
duke
parents:
diff changeset
2731 // a store is never pinned *before* the availability of its inputs.
119
d1a5218d7eaf 6686791: Side effect in NumberFormat tests with -server -Xcomp
kvn
parents: 113
diff changeset
2732 if (!MemNode::all_controls_dominate(n, this))
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2733 return false; // failed to prove a good control
a61af66fc99e Initial load
duke
parents:
diff changeset
2734
a61af66fc99e Initial load
duke
parents:
diff changeset
2735 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2736
a61af66fc99e Initial load
duke
parents:
diff changeset
2737 // Check data edges for possible dependencies on 'this'.
a61af66fc99e Initial load
duke
parents:
diff changeset
2738 if ((count += 1) > 20) return false; // complexity limit
a61af66fc99e Initial load
duke
parents:
diff changeset
2739 for (uint i = 1; i < n->req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2740 Node* m = n->in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2741 if (m == NULL || m == n || m->is_top()) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
2742 uint first_i = n->find_edge(m);
a61af66fc99e Initial load
duke
parents:
diff changeset
2743 if (i != first_i) continue; // process duplicate edge just once
a61af66fc99e Initial load
duke
parents:
diff changeset
2744 if (!detect_init_independence(m, st_is_pinned, count)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2745 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
2746 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2747 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2748
a61af66fc99e Initial load
duke
parents:
diff changeset
2749 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
2750 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2751
a61af66fc99e Initial load
duke
parents:
diff changeset
2752 // Here are all the checks a Store must pass before it can be moved into
a61af66fc99e Initial load
duke
parents:
diff changeset
2753 // an initialization. Returns zero if a check fails.
a61af66fc99e Initial load
duke
parents:
diff changeset
2754 // On success, returns the (constant) offset to which the store applies,
a61af66fc99e Initial load
duke
parents:
diff changeset
2755 // within the initialized memory.
a61af66fc99e Initial load
duke
parents:
diff changeset
2756 intptr_t InitializeNode::can_capture_store(StoreNode* st, PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2757 const int FAIL = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2758 if (st->req() != MemNode::ValueIn + 1)
a61af66fc99e Initial load
duke
parents:
diff changeset
2759 return FAIL; // an inscrutable StoreNode (card mark?)
a61af66fc99e Initial load
duke
parents:
diff changeset
2760 Node* ctl = st->in(MemNode::Control);
a61af66fc99e Initial load
duke
parents:
diff changeset
2761 if (!(ctl != NULL && ctl->is_Proj() && ctl->in(0) == this))
a61af66fc99e Initial load
duke
parents:
diff changeset
2762 return FAIL; // must be unconditional after the initialization
a61af66fc99e Initial load
duke
parents:
diff changeset
2763 Node* mem = st->in(MemNode::Memory);
a61af66fc99e Initial load
duke
parents:
diff changeset
2764 if (!(mem->is_Proj() && mem->in(0) == this))
a61af66fc99e Initial load
duke
parents:
diff changeset
2765 return FAIL; // must not be preceded by other stores
a61af66fc99e Initial load
duke
parents:
diff changeset
2766 Node* adr = st->in(MemNode::Address);
a61af66fc99e Initial load
duke
parents:
diff changeset
2767 intptr_t offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
2768 AllocateNode* alloc = AllocateNode::Ideal_allocation(adr, phase, offset);
a61af66fc99e Initial load
duke
parents:
diff changeset
2769 if (alloc == NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
2770 return FAIL; // inscrutable address
a61af66fc99e Initial load
duke
parents:
diff changeset
2771 if (alloc != allocation())
a61af66fc99e Initial load
duke
parents:
diff changeset
2772 return FAIL; // wrong allocation! (store needs to float up)
a61af66fc99e Initial load
duke
parents:
diff changeset
2773 Node* val = st->in(MemNode::ValueIn);
a61af66fc99e Initial load
duke
parents:
diff changeset
2774 int complexity_count = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2775 if (!detect_init_independence(val, true, complexity_count))
a61af66fc99e Initial load
duke
parents:
diff changeset
2776 return FAIL; // stored value must be 'simple enough'
a61af66fc99e Initial load
duke
parents:
diff changeset
2777
a61af66fc99e Initial load
duke
parents:
diff changeset
2778 return offset; // success
a61af66fc99e Initial load
duke
parents:
diff changeset
2779 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2780
a61af66fc99e Initial load
duke
parents:
diff changeset
2781 // Find the captured store in(i) which corresponds to the range
a61af66fc99e Initial load
duke
parents:
diff changeset
2782 // [start..start+size) in the initialized object.
a61af66fc99e Initial load
duke
parents:
diff changeset
2783 // If there is one, return its index i. If there isn't, return the
a61af66fc99e Initial load
duke
parents:
diff changeset
2784 // negative of the index where it should be inserted.
a61af66fc99e Initial load
duke
parents:
diff changeset
2785 // Return 0 if the queried range overlaps an initialization boundary
a61af66fc99e Initial load
duke
parents:
diff changeset
2786 // or if dead code is encountered.
a61af66fc99e Initial load
duke
parents:
diff changeset
2787 // If size_in_bytes is zero, do not bother with overlap checks.
a61af66fc99e Initial load
duke
parents:
diff changeset
2788 int InitializeNode::captured_store_insertion_point(intptr_t start,
a61af66fc99e Initial load
duke
parents:
diff changeset
2789 int size_in_bytes,
a61af66fc99e Initial load
duke
parents:
diff changeset
2790 PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2791 const int FAIL = 0, MAX_STORE = BytesPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
2792
a61af66fc99e Initial load
duke
parents:
diff changeset
2793 if (is_complete())
a61af66fc99e Initial load
duke
parents:
diff changeset
2794 return FAIL; // arraycopy got here first; punt
a61af66fc99e Initial load
duke
parents:
diff changeset
2795
a61af66fc99e Initial load
duke
parents:
diff changeset
2796 assert(allocation() != NULL, "must be present");
a61af66fc99e Initial load
duke
parents:
diff changeset
2797
a61af66fc99e Initial load
duke
parents:
diff changeset
2798 // no negatives, no header fields:
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
2799 if (start < (intptr_t) allocation()->minimum_header_size()) return FAIL;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2800
a61af66fc99e Initial load
duke
parents:
diff changeset
2801 // after a certain size, we bail out on tracking all the stores:
a61af66fc99e Initial load
duke
parents:
diff changeset
2802 intptr_t ti_limit = (TrackedInitializationLimit * HeapWordSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
2803 if (start >= ti_limit) return FAIL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2804
a61af66fc99e Initial load
duke
parents:
diff changeset
2805 for (uint i = InitializeNode::RawStores, limit = req(); ; ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2806 if (i >= limit) return -(int)i; // not found; here is where to put it
a61af66fc99e Initial load
duke
parents:
diff changeset
2807
a61af66fc99e Initial load
duke
parents:
diff changeset
2808 Node* st = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
2809 intptr_t st_off = get_store_offset(st, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2810 if (st_off < 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2811 if (st != zero_memory()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2812 return FAIL; // bail out if there is dead garbage
a61af66fc99e Initial load
duke
parents:
diff changeset
2813 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2814 } else if (st_off > start) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2815 // ...we are done, since stores are ordered
a61af66fc99e Initial load
duke
parents:
diff changeset
2816 if (st_off < start + size_in_bytes) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2817 return FAIL; // the next store overlaps
a61af66fc99e Initial load
duke
parents:
diff changeset
2818 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2819 return -(int)i; // not found; here is where to put it
a61af66fc99e Initial load
duke
parents:
diff changeset
2820 } else if (st_off < start) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2821 if (size_in_bytes != 0 &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2822 start < st_off + MAX_STORE &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2823 start < st_off + st->as_Store()->memory_size()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2824 return FAIL; // the previous store overlaps
a61af66fc99e Initial load
duke
parents:
diff changeset
2825 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2826 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2827 if (size_in_bytes != 0 &&
a61af66fc99e Initial load
duke
parents:
diff changeset
2828 st->as_Store()->memory_size() != size_in_bytes) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2829 return FAIL; // mismatched store size
a61af66fc99e Initial load
duke
parents:
diff changeset
2830 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2831 return i;
a61af66fc99e Initial load
duke
parents:
diff changeset
2832 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2833
a61af66fc99e Initial load
duke
parents:
diff changeset
2834 ++i;
a61af66fc99e Initial load
duke
parents:
diff changeset
2835 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2836 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2837
a61af66fc99e Initial load
duke
parents:
diff changeset
2838 // Look for a captured store which initializes at the offset 'start'
a61af66fc99e Initial load
duke
parents:
diff changeset
2839 // with the given size. If there is no such store, and no other
a61af66fc99e Initial load
duke
parents:
diff changeset
2840 // initialization interferes, then return zero_memory (the memory
a61af66fc99e Initial load
duke
parents:
diff changeset
2841 // projection of the AllocateNode).
a61af66fc99e Initial load
duke
parents:
diff changeset
2842 Node* InitializeNode::find_captured_store(intptr_t start, int size_in_bytes,
a61af66fc99e Initial load
duke
parents:
diff changeset
2843 PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2844 assert(stores_are_sane(phase), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
2845 int i = captured_store_insertion_point(start, size_in_bytes, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2846 if (i == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2847 return NULL; // something is dead
a61af66fc99e Initial load
duke
parents:
diff changeset
2848 } else if (i < 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2849 return zero_memory(); // just primordial zero bits here
a61af66fc99e Initial load
duke
parents:
diff changeset
2850 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2851 Node* st = in(i); // here is the store at this position
a61af66fc99e Initial load
duke
parents:
diff changeset
2852 assert(get_store_offset(st->as_Store(), phase) == start, "sanity");
a61af66fc99e Initial load
duke
parents:
diff changeset
2853 return st;
a61af66fc99e Initial load
duke
parents:
diff changeset
2854 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2855 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2856
a61af66fc99e Initial load
duke
parents:
diff changeset
2857 // Create, as a raw pointer, an address within my new object at 'offset'.
a61af66fc99e Initial load
duke
parents:
diff changeset
2858 Node* InitializeNode::make_raw_address(intptr_t offset,
a61af66fc99e Initial load
duke
parents:
diff changeset
2859 PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2860 Node* addr = in(RawAddress);
a61af66fc99e Initial load
duke
parents:
diff changeset
2861 if (offset != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2862 Compile* C = phase->C;
a61af66fc99e Initial load
duke
parents:
diff changeset
2863 addr = phase->transform( new (C, 4) AddPNode(C->top(), addr,
a61af66fc99e Initial load
duke
parents:
diff changeset
2864 phase->MakeConX(offset)) );
a61af66fc99e Initial load
duke
parents:
diff changeset
2865 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2866 return addr;
a61af66fc99e Initial load
duke
parents:
diff changeset
2867 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2868
a61af66fc99e Initial load
duke
parents:
diff changeset
2869 // Clone the given store, converting it into a raw store
a61af66fc99e Initial load
duke
parents:
diff changeset
2870 // initializing a field or element of my new object.
a61af66fc99e Initial load
duke
parents:
diff changeset
2871 // Caller is responsible for retiring the original store,
a61af66fc99e Initial load
duke
parents:
diff changeset
2872 // with subsume_node or the like.
a61af66fc99e Initial load
duke
parents:
diff changeset
2873 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2874 // From the example above InitializeNode::InitializeNode,
a61af66fc99e Initial load
duke
parents:
diff changeset
2875 // here are the old stores to be captured:
a61af66fc99e Initial load
duke
parents:
diff changeset
2876 // store1 = (StoreC init.Control init.Memory (+ oop 12) 1)
a61af66fc99e Initial load
duke
parents:
diff changeset
2877 // store2 = (StoreC init.Control store1 (+ oop 14) 2)
a61af66fc99e Initial load
duke
parents:
diff changeset
2878 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2879 // Here is the changed code; note the extra edges on init:
a61af66fc99e Initial load
duke
parents:
diff changeset
2880 // alloc = (Allocate ...)
a61af66fc99e Initial load
duke
parents:
diff changeset
2881 // rawoop = alloc.RawAddress
a61af66fc99e Initial load
duke
parents:
diff changeset
2882 // rawstore1 = (StoreC alloc.Control alloc.Memory (+ rawoop 12) 1)
a61af66fc99e Initial load
duke
parents:
diff changeset
2883 // rawstore2 = (StoreC alloc.Control alloc.Memory (+ rawoop 14) 2)
a61af66fc99e Initial load
duke
parents:
diff changeset
2884 // init = (Initialize alloc.Control alloc.Memory rawoop
a61af66fc99e Initial load
duke
parents:
diff changeset
2885 // rawstore1 rawstore2)
a61af66fc99e Initial load
duke
parents:
diff changeset
2886 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2887 Node* InitializeNode::capture_store(StoreNode* st, intptr_t start,
a61af66fc99e Initial load
duke
parents:
diff changeset
2888 PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2889 assert(stores_are_sane(phase), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
2890
a61af66fc99e Initial load
duke
parents:
diff changeset
2891 if (start < 0) return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
2892 assert(can_capture_store(st, phase) == start, "sanity");
a61af66fc99e Initial load
duke
parents:
diff changeset
2893
a61af66fc99e Initial load
duke
parents:
diff changeset
2894 Compile* C = phase->C;
a61af66fc99e Initial load
duke
parents:
diff changeset
2895 int size_in_bytes = st->memory_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
2896 int i = captured_store_insertion_point(start, size_in_bytes, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
2897 if (i == 0) return NULL; // bail out
a61af66fc99e Initial load
duke
parents:
diff changeset
2898 Node* prev_mem = NULL; // raw memory for the captured store
a61af66fc99e Initial load
duke
parents:
diff changeset
2899 if (i > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2900 prev_mem = in(i); // there is a pre-existing store under this one
a61af66fc99e Initial load
duke
parents:
diff changeset
2901 set_req(i, C->top()); // temporarily disconnect it
a61af66fc99e Initial load
duke
parents:
diff changeset
2902 // See StoreNode::Ideal 'st->outcnt() == 1' for the reason to disconnect.
a61af66fc99e Initial load
duke
parents:
diff changeset
2903 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
2904 i = -i; // no pre-existing store
a61af66fc99e Initial load
duke
parents:
diff changeset
2905 prev_mem = zero_memory(); // a slice of the newly allocated object
a61af66fc99e Initial load
duke
parents:
diff changeset
2906 if (i > InitializeNode::RawStores && in(i-1) == prev_mem)
a61af66fc99e Initial load
duke
parents:
diff changeset
2907 set_req(--i, C->top()); // reuse this edge; it has been folded away
a61af66fc99e Initial load
duke
parents:
diff changeset
2908 else
a61af66fc99e Initial load
duke
parents:
diff changeset
2909 ins_req(i, C->top()); // build a new edge
a61af66fc99e Initial load
duke
parents:
diff changeset
2910 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2911 Node* new_st = st->clone();
a61af66fc99e Initial load
duke
parents:
diff changeset
2912 new_st->set_req(MemNode::Control, in(Control));
a61af66fc99e Initial load
duke
parents:
diff changeset
2913 new_st->set_req(MemNode::Memory, prev_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
2914 new_st->set_req(MemNode::Address, make_raw_address(start, phase));
a61af66fc99e Initial load
duke
parents:
diff changeset
2915 new_st = phase->transform(new_st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2916
a61af66fc99e Initial load
duke
parents:
diff changeset
2917 // At this point, new_st might have swallowed a pre-existing store
a61af66fc99e Initial load
duke
parents:
diff changeset
2918 // at the same offset, or perhaps new_st might have disappeared,
a61af66fc99e Initial load
duke
parents:
diff changeset
2919 // if it redundantly stored the same value (or zero to fresh memory).
a61af66fc99e Initial load
duke
parents:
diff changeset
2920
a61af66fc99e Initial load
duke
parents:
diff changeset
2921 // In any case, wire it in:
a61af66fc99e Initial load
duke
parents:
diff changeset
2922 set_req(i, new_st);
a61af66fc99e Initial load
duke
parents:
diff changeset
2923
a61af66fc99e Initial load
duke
parents:
diff changeset
2924 // The caller may now kill the old guy.
a61af66fc99e Initial load
duke
parents:
diff changeset
2925 DEBUG_ONLY(Node* check_st = find_captured_store(start, size_in_bytes, phase));
a61af66fc99e Initial load
duke
parents:
diff changeset
2926 assert(check_st == new_st || check_st == NULL, "must be findable");
a61af66fc99e Initial load
duke
parents:
diff changeset
2927 assert(!is_complete(), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
2928 return new_st;
a61af66fc99e Initial load
duke
parents:
diff changeset
2929 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2930
a61af66fc99e Initial load
duke
parents:
diff changeset
2931 static bool store_constant(jlong* tiles, int num_tiles,
a61af66fc99e Initial load
duke
parents:
diff changeset
2932 intptr_t st_off, int st_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
2933 jlong con) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2934 if ((st_off & (st_size-1)) != 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
2935 return false; // strange store offset (assume size==2**N)
a61af66fc99e Initial load
duke
parents:
diff changeset
2936 address addr = (address)tiles + st_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
2937 assert(st_off >= 0 && addr+st_size <= (address)&tiles[num_tiles], "oob");
a61af66fc99e Initial load
duke
parents:
diff changeset
2938 switch (st_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2939 case sizeof(jbyte): *(jbyte*) addr = (jbyte) con; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2940 case sizeof(jchar): *(jchar*) addr = (jchar) con; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2941 case sizeof(jint): *(jint*) addr = (jint) con; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2942 case sizeof(jlong): *(jlong*) addr = (jlong) con; break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2943 default: return false; // strange store size (detect size!=2**N here)
a61af66fc99e Initial load
duke
parents:
diff changeset
2944 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2945 return true; // return success to caller
a61af66fc99e Initial load
duke
parents:
diff changeset
2946 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2947
a61af66fc99e Initial load
duke
parents:
diff changeset
2948 // Coalesce subword constants into int constants and possibly
a61af66fc99e Initial load
duke
parents:
diff changeset
2949 // into long constants. The goal, if the CPU permits,
a61af66fc99e Initial load
duke
parents:
diff changeset
2950 // is to initialize the object with a small number of 64-bit tiles.
a61af66fc99e Initial load
duke
parents:
diff changeset
2951 // Also, convert floating-point constants to bit patterns.
a61af66fc99e Initial load
duke
parents:
diff changeset
2952 // Non-constants are not relevant to this pass.
a61af66fc99e Initial load
duke
parents:
diff changeset
2953 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2954 // In terms of the running example on InitializeNode::InitializeNode
a61af66fc99e Initial load
duke
parents:
diff changeset
2955 // and InitializeNode::capture_store, here is the transformation
a61af66fc99e Initial load
duke
parents:
diff changeset
2956 // of rawstore1 and rawstore2 into rawstore12:
a61af66fc99e Initial load
duke
parents:
diff changeset
2957 // alloc = (Allocate ...)
a61af66fc99e Initial load
duke
parents:
diff changeset
2958 // rawoop = alloc.RawAddress
a61af66fc99e Initial load
duke
parents:
diff changeset
2959 // tile12 = 0x00010002
a61af66fc99e Initial load
duke
parents:
diff changeset
2960 // rawstore12 = (StoreI alloc.Control alloc.Memory (+ rawoop 12) tile12)
a61af66fc99e Initial load
duke
parents:
diff changeset
2961 // init = (Initialize alloc.Control alloc.Memory rawoop rawstore12)
a61af66fc99e Initial load
duke
parents:
diff changeset
2962 //
a61af66fc99e Initial load
duke
parents:
diff changeset
2963 void
a61af66fc99e Initial load
duke
parents:
diff changeset
2964 InitializeNode::coalesce_subword_stores(intptr_t header_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
2965 Node* size_in_bytes,
a61af66fc99e Initial load
duke
parents:
diff changeset
2966 PhaseGVN* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
2967 Compile* C = phase->C;
a61af66fc99e Initial load
duke
parents:
diff changeset
2968
a61af66fc99e Initial load
duke
parents:
diff changeset
2969 assert(stores_are_sane(phase), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
2970 // Note: After this pass, they are not completely sane,
a61af66fc99e Initial load
duke
parents:
diff changeset
2971 // since there may be some overlaps.
a61af66fc99e Initial load
duke
parents:
diff changeset
2972
a61af66fc99e Initial load
duke
parents:
diff changeset
2973 int old_subword = 0, old_long = 0, new_int = 0, new_long = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
2974
a61af66fc99e Initial load
duke
parents:
diff changeset
2975 intptr_t ti_limit = (TrackedInitializationLimit * HeapWordSize);
a61af66fc99e Initial load
duke
parents:
diff changeset
2976 intptr_t size_limit = phase->find_intptr_t_con(size_in_bytes, ti_limit);
a61af66fc99e Initial load
duke
parents:
diff changeset
2977 size_limit = MIN2(size_limit, ti_limit);
a61af66fc99e Initial load
duke
parents:
diff changeset
2978 size_limit = align_size_up(size_limit, BytesPerLong);
a61af66fc99e Initial load
duke
parents:
diff changeset
2979 int num_tiles = size_limit / BytesPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
2980
a61af66fc99e Initial load
duke
parents:
diff changeset
2981 // allocate space for the tile map:
a61af66fc99e Initial load
duke
parents:
diff changeset
2982 const int small_len = DEBUG_ONLY(true ? 3 :) 30; // keep stack frames small
a61af66fc99e Initial load
duke
parents:
diff changeset
2983 jlong tiles_buf[small_len];
a61af66fc99e Initial load
duke
parents:
diff changeset
2984 Node* nodes_buf[small_len];
a61af66fc99e Initial load
duke
parents:
diff changeset
2985 jlong inits_buf[small_len];
a61af66fc99e Initial load
duke
parents:
diff changeset
2986 jlong* tiles = ((num_tiles <= small_len) ? &tiles_buf[0]
a61af66fc99e Initial load
duke
parents:
diff changeset
2987 : NEW_RESOURCE_ARRAY(jlong, num_tiles));
a61af66fc99e Initial load
duke
parents:
diff changeset
2988 Node** nodes = ((num_tiles <= small_len) ? &nodes_buf[0]
a61af66fc99e Initial load
duke
parents:
diff changeset
2989 : NEW_RESOURCE_ARRAY(Node*, num_tiles));
a61af66fc99e Initial load
duke
parents:
diff changeset
2990 jlong* inits = ((num_tiles <= small_len) ? &inits_buf[0]
a61af66fc99e Initial load
duke
parents:
diff changeset
2991 : NEW_RESOURCE_ARRAY(jlong, num_tiles));
a61af66fc99e Initial load
duke
parents:
diff changeset
2992 // tiles: exact bitwise model of all primitive constants
a61af66fc99e Initial load
duke
parents:
diff changeset
2993 // nodes: last constant-storing node subsumed into the tiles model
a61af66fc99e Initial load
duke
parents:
diff changeset
2994 // inits: which bytes (in each tile) are touched by any initializations
a61af66fc99e Initial load
duke
parents:
diff changeset
2995
a61af66fc99e Initial load
duke
parents:
diff changeset
2996 //// Pass A: Fill in the tile model with any relevant stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
2997
a61af66fc99e Initial load
duke
parents:
diff changeset
2998 Copy::zero_to_bytes(tiles, sizeof(tiles[0]) * num_tiles);
a61af66fc99e Initial load
duke
parents:
diff changeset
2999 Copy::zero_to_bytes(nodes, sizeof(nodes[0]) * num_tiles);
a61af66fc99e Initial load
duke
parents:
diff changeset
3000 Copy::zero_to_bytes(inits, sizeof(inits[0]) * num_tiles);
a61af66fc99e Initial load
duke
parents:
diff changeset
3001 Node* zmem = zero_memory(); // initially zero memory state
a61af66fc99e Initial load
duke
parents:
diff changeset
3002 for (uint i = InitializeNode::RawStores, limit = req(); i < limit; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3003 Node* st = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3004 intptr_t st_off = get_store_offset(st, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3005
a61af66fc99e Initial load
duke
parents:
diff changeset
3006 // Figure out the store's offset and constant value:
a61af66fc99e Initial load
duke
parents:
diff changeset
3007 if (st_off < header_size) continue; //skip (ignore header)
a61af66fc99e Initial load
duke
parents:
diff changeset
3008 if (st->in(MemNode::Memory) != zmem) continue; //skip (odd store chain)
a61af66fc99e Initial load
duke
parents:
diff changeset
3009 int st_size = st->as_Store()->memory_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
3010 if (st_off + st_size > size_limit) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3011
a61af66fc99e Initial load
duke
parents:
diff changeset
3012 // Record which bytes are touched, whether by constant or not.
a61af66fc99e Initial load
duke
parents:
diff changeset
3013 if (!store_constant(inits, num_tiles, st_off, st_size, (jlong) -1))
a61af66fc99e Initial load
duke
parents:
diff changeset
3014 continue; // skip (strange store size)
a61af66fc99e Initial load
duke
parents:
diff changeset
3015
a61af66fc99e Initial load
duke
parents:
diff changeset
3016 const Type* val = phase->type(st->in(MemNode::ValueIn));
a61af66fc99e Initial load
duke
parents:
diff changeset
3017 if (!val->singleton()) continue; //skip (non-con store)
a61af66fc99e Initial load
duke
parents:
diff changeset
3018 BasicType type = val->basic_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
3019
a61af66fc99e Initial load
duke
parents:
diff changeset
3020 jlong con = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3021 switch (type) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3022 case T_INT: con = val->is_int()->get_con(); break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3023 case T_LONG: con = val->is_long()->get_con(); break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3024 case T_FLOAT: con = jint_cast(val->getf()); break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3025 case T_DOUBLE: con = jlong_cast(val->getd()); break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3026 default: continue; //skip (odd store type)
a61af66fc99e Initial load
duke
parents:
diff changeset
3027 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3028
a61af66fc99e Initial load
duke
parents:
diff changeset
3029 if (type == T_LONG && Matcher::isSimpleConstant64(con) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
3030 st->Opcode() == Op_StoreL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3031 continue; // This StoreL is already optimal.
a61af66fc99e Initial load
duke
parents:
diff changeset
3032 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3033
a61af66fc99e Initial load
duke
parents:
diff changeset
3034 // Store down the constant.
a61af66fc99e Initial load
duke
parents:
diff changeset
3035 store_constant(tiles, num_tiles, st_off, st_size, con);
a61af66fc99e Initial load
duke
parents:
diff changeset
3036
a61af66fc99e Initial load
duke
parents:
diff changeset
3037 intptr_t j = st_off >> LogBytesPerLong;
a61af66fc99e Initial load
duke
parents:
diff changeset
3038
a61af66fc99e Initial load
duke
parents:
diff changeset
3039 if (type == T_INT && st_size == BytesPerInt
a61af66fc99e Initial load
duke
parents:
diff changeset
3040 && (st_off & BytesPerInt) == BytesPerInt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3041 jlong lcon = tiles[j];
a61af66fc99e Initial load
duke
parents:
diff changeset
3042 if (!Matcher::isSimpleConstant64(lcon) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
3043 st->Opcode() == Op_StoreI) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3044 // This StoreI is already optimal by itself.
a61af66fc99e Initial load
duke
parents:
diff changeset
3045 jint* intcon = (jint*) &tiles[j];
a61af66fc99e Initial load
duke
parents:
diff changeset
3046 intcon[1] = 0; // undo the store_constant()
a61af66fc99e Initial load
duke
parents:
diff changeset
3047
a61af66fc99e Initial load
duke
parents:
diff changeset
3048 // If the previous store is also optimal by itself, back up and
a61af66fc99e Initial load
duke
parents:
diff changeset
3049 // undo the action of the previous loop iteration... if we can.
a61af66fc99e Initial load
duke
parents:
diff changeset
3050 // But if we can't, just let the previous half take care of itself.
a61af66fc99e Initial load
duke
parents:
diff changeset
3051 st = nodes[j];
a61af66fc99e Initial load
duke
parents:
diff changeset
3052 st_off -= BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
3053 con = intcon[0];
a61af66fc99e Initial load
duke
parents:
diff changeset
3054 if (con != 0 && st != NULL && st->Opcode() == Op_StoreI) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3055 assert(st_off >= header_size, "still ignoring header");
a61af66fc99e Initial load
duke
parents:
diff changeset
3056 assert(get_store_offset(st, phase) == st_off, "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
3057 assert(in(i-1) == zmem, "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
3058 DEBUG_ONLY(const Type* tcon = phase->type(st->in(MemNode::ValueIn)));
a61af66fc99e Initial load
duke
parents:
diff changeset
3059 assert(con == tcon->is_int()->get_con(), "must be");
a61af66fc99e Initial load
duke
parents:
diff changeset
3060 // Undo the effects of the previous loop trip, which swallowed st:
a61af66fc99e Initial load
duke
parents:
diff changeset
3061 intcon[0] = 0; // undo store_constant()
a61af66fc99e Initial load
duke
parents:
diff changeset
3062 set_req(i-1, st); // undo set_req(i, zmem)
a61af66fc99e Initial load
duke
parents:
diff changeset
3063 nodes[j] = NULL; // undo nodes[j] = st
a61af66fc99e Initial load
duke
parents:
diff changeset
3064 --old_subword; // undo ++old_subword
a61af66fc99e Initial load
duke
parents:
diff changeset
3065 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3066 continue; // This StoreI is already optimal.
a61af66fc99e Initial load
duke
parents:
diff changeset
3067 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3068 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3069
a61af66fc99e Initial load
duke
parents:
diff changeset
3070 // This store is not needed.
a61af66fc99e Initial load
duke
parents:
diff changeset
3071 set_req(i, zmem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3072 nodes[j] = st; // record for the moment
a61af66fc99e Initial load
duke
parents:
diff changeset
3073 if (st_size < BytesPerLong) // something has changed
a61af66fc99e Initial load
duke
parents:
diff changeset
3074 ++old_subword; // includes int/float, but who's counting...
a61af66fc99e Initial load
duke
parents:
diff changeset
3075 else ++old_long;
a61af66fc99e Initial load
duke
parents:
diff changeset
3076 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3077
a61af66fc99e Initial load
duke
parents:
diff changeset
3078 if ((old_subword + old_long) == 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
3079 return; // nothing more to do
a61af66fc99e Initial load
duke
parents:
diff changeset
3080
a61af66fc99e Initial load
duke
parents:
diff changeset
3081 //// Pass B: Convert any non-zero tiles into optimal constant stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
3082 // Be sure to insert them before overlapping non-constant stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
3083 // (E.g., byte[] x = { 1,2,y,4 } => x[int 0] = 0x01020004, x[2]=y.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3084 for (int j = 0; j < num_tiles; j++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3085 jlong con = tiles[j];
a61af66fc99e Initial load
duke
parents:
diff changeset
3086 jlong init = inits[j];
a61af66fc99e Initial load
duke
parents:
diff changeset
3087 if (con == 0) continue;
a61af66fc99e Initial load
duke
parents:
diff changeset
3088 jint con0, con1; // split the constant, address-wise
a61af66fc99e Initial load
duke
parents:
diff changeset
3089 jint init0, init1; // split the init map, address-wise
a61af66fc99e Initial load
duke
parents:
diff changeset
3090 { union { jlong con; jint intcon[2]; } u;
a61af66fc99e Initial load
duke
parents:
diff changeset
3091 u.con = con;
a61af66fc99e Initial load
duke
parents:
diff changeset
3092 con0 = u.intcon[0];
a61af66fc99e Initial load
duke
parents:
diff changeset
3093 con1 = u.intcon[1];
a61af66fc99e Initial load
duke
parents:
diff changeset
3094 u.con = init;
a61af66fc99e Initial load
duke
parents:
diff changeset
3095 init0 = u.intcon[0];
a61af66fc99e Initial load
duke
parents:
diff changeset
3096 init1 = u.intcon[1];
a61af66fc99e Initial load
duke
parents:
diff changeset
3097 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3098
a61af66fc99e Initial load
duke
parents:
diff changeset
3099 Node* old = nodes[j];
a61af66fc99e Initial load
duke
parents:
diff changeset
3100 assert(old != NULL, "need the prior store");
a61af66fc99e Initial load
duke
parents:
diff changeset
3101 intptr_t offset = (j * BytesPerLong);
a61af66fc99e Initial load
duke
parents:
diff changeset
3102
a61af66fc99e Initial load
duke
parents:
diff changeset
3103 bool split = !Matcher::isSimpleConstant64(con);
a61af66fc99e Initial load
duke
parents:
diff changeset
3104
a61af66fc99e Initial load
duke
parents:
diff changeset
3105 if (offset < header_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3106 assert(offset + BytesPerInt >= header_size, "second int counts");
a61af66fc99e Initial load
duke
parents:
diff changeset
3107 assert(*(jint*)&tiles[j] == 0, "junk in header");
a61af66fc99e Initial load
duke
parents:
diff changeset
3108 split = true; // only the second word counts
a61af66fc99e Initial load
duke
parents:
diff changeset
3109 // Example: int a[] = { 42 ... }
a61af66fc99e Initial load
duke
parents:
diff changeset
3110 } else if (con0 == 0 && init0 == -1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3111 split = true; // first word is covered by full inits
a61af66fc99e Initial load
duke
parents:
diff changeset
3112 // Example: int a[] = { ... foo(), 42 ... }
a61af66fc99e Initial load
duke
parents:
diff changeset
3113 } else if (con1 == 0 && init1 == -1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3114 split = true; // second word is covered by full inits
a61af66fc99e Initial load
duke
parents:
diff changeset
3115 // Example: int a[] = { ... 42, foo() ... }
a61af66fc99e Initial load
duke
parents:
diff changeset
3116 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3117
a61af66fc99e Initial load
duke
parents:
diff changeset
3118 // Here's a case where init0 is neither 0 nor -1:
a61af66fc99e Initial load
duke
parents:
diff changeset
3119 // byte a[] = { ... 0,0,foo(),0, 0,0,0,42 ... }
a61af66fc99e Initial load
duke
parents:
diff changeset
3120 // Assuming big-endian memory, init0, init1 are 0x0000FF00, 0x000000FF.
a61af66fc99e Initial load
duke
parents:
diff changeset
3121 // In this case the tile is not split; it is (jlong)42.
a61af66fc99e Initial load
duke
parents:
diff changeset
3122 // The big tile is stored down, and then the foo() value is inserted.
a61af66fc99e Initial load
duke
parents:
diff changeset
3123 // (If there were foo(),foo() instead of foo(),0, init0 would be -1.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3124
a61af66fc99e Initial load
duke
parents:
diff changeset
3125 Node* ctl = old->in(MemNode::Control);
a61af66fc99e Initial load
duke
parents:
diff changeset
3126 Node* adr = make_raw_address(offset, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3127 const TypePtr* atp = TypeRawPtr::BOTTOM;
a61af66fc99e Initial load
duke
parents:
diff changeset
3128
a61af66fc99e Initial load
duke
parents:
diff changeset
3129 // One or two coalesced stores to plop down.
a61af66fc99e Initial load
duke
parents:
diff changeset
3130 Node* st[2];
a61af66fc99e Initial load
duke
parents:
diff changeset
3131 intptr_t off[2];
a61af66fc99e Initial load
duke
parents:
diff changeset
3132 int nst = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3133 if (!split) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3134 ++new_long;
a61af66fc99e Initial load
duke
parents:
diff changeset
3135 off[nst] = offset;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3136 st[nst++] = StoreNode::make(*phase, ctl, zmem, adr, atp,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3137 phase->longcon(con), T_LONG);
a61af66fc99e Initial load
duke
parents:
diff changeset
3138 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3139 // Omit either if it is a zero.
a61af66fc99e Initial load
duke
parents:
diff changeset
3140 if (con0 != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3141 ++new_int;
a61af66fc99e Initial load
duke
parents:
diff changeset
3142 off[nst] = offset;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3143 st[nst++] = StoreNode::make(*phase, ctl, zmem, adr, atp,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3144 phase->intcon(con0), T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3145 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3146 if (con1 != 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3147 ++new_int;
a61af66fc99e Initial load
duke
parents:
diff changeset
3148 offset += BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
3149 adr = make_raw_address(offset, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3150 off[nst] = offset;
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3151 st[nst++] = StoreNode::make(*phase, ctl, zmem, adr, atp,
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3152 phase->intcon(con1), T_INT);
a61af66fc99e Initial load
duke
parents:
diff changeset
3153 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3154 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3155
a61af66fc99e Initial load
duke
parents:
diff changeset
3156 // Insert second store first, then the first before the second.
a61af66fc99e Initial load
duke
parents:
diff changeset
3157 // Insert each one just before any overlapping non-constant stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
3158 while (nst > 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3159 Node* st1 = st[--nst];
a61af66fc99e Initial load
duke
parents:
diff changeset
3160 C->copy_node_notes_to(st1, old);
a61af66fc99e Initial load
duke
parents:
diff changeset
3161 st1 = phase->transform(st1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3162 offset = off[nst];
a61af66fc99e Initial load
duke
parents:
diff changeset
3163 assert(offset >= header_size, "do not smash header");
a61af66fc99e Initial load
duke
parents:
diff changeset
3164 int ins_idx = captured_store_insertion_point(offset, /*size:*/0, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3165 guarantee(ins_idx != 0, "must re-insert constant store");
a61af66fc99e Initial load
duke
parents:
diff changeset
3166 if (ins_idx < 0) ins_idx = -ins_idx; // never overlap
a61af66fc99e Initial load
duke
parents:
diff changeset
3167 if (ins_idx > InitializeNode::RawStores && in(ins_idx-1) == zmem)
a61af66fc99e Initial load
duke
parents:
diff changeset
3168 set_req(--ins_idx, st1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3169 else
a61af66fc99e Initial load
duke
parents:
diff changeset
3170 ins_req(ins_idx, st1);
a61af66fc99e Initial load
duke
parents:
diff changeset
3171 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3172 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3173
a61af66fc99e Initial load
duke
parents:
diff changeset
3174 if (PrintCompilation && WizardMode)
a61af66fc99e Initial load
duke
parents:
diff changeset
3175 tty->print_cr("Changed %d/%d subword/long constants into %d/%d int/long",
a61af66fc99e Initial load
duke
parents:
diff changeset
3176 old_subword, old_long, new_int, new_long);
a61af66fc99e Initial load
duke
parents:
diff changeset
3177 if (C->log() != NULL)
a61af66fc99e Initial load
duke
parents:
diff changeset
3178 C->log()->elem("comment that='%d/%d subword/long to %d/%d int/long'",
a61af66fc99e Initial load
duke
parents:
diff changeset
3179 old_subword, old_long, new_int, new_long);
a61af66fc99e Initial load
duke
parents:
diff changeset
3180
a61af66fc99e Initial load
duke
parents:
diff changeset
3181 // Clean up any remaining occurrences of zmem:
a61af66fc99e Initial load
duke
parents:
diff changeset
3182 remove_extra_zeroes();
a61af66fc99e Initial load
duke
parents:
diff changeset
3183 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3184
a61af66fc99e Initial load
duke
parents:
diff changeset
3185 // Explore forward from in(start) to find the first fully initialized
a61af66fc99e Initial load
duke
parents:
diff changeset
3186 // word, and return its offset. Skip groups of subword stores which
a61af66fc99e Initial load
duke
parents:
diff changeset
3187 // together initialize full words. If in(start) is itself part of a
a61af66fc99e Initial load
duke
parents:
diff changeset
3188 // fully initialized word, return the offset of in(start). If there
a61af66fc99e Initial load
duke
parents:
diff changeset
3189 // are no following full-word stores, or if something is fishy, return
a61af66fc99e Initial load
duke
parents:
diff changeset
3190 // a negative value.
a61af66fc99e Initial load
duke
parents:
diff changeset
3191 intptr_t InitializeNode::find_next_fullword_store(uint start, PhaseGVN* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3192 int int_map = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3193 intptr_t int_map_off = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3194 const int FULL_MAP = right_n_bits(BytesPerInt); // the int_map we hope for
a61af66fc99e Initial load
duke
parents:
diff changeset
3195
a61af66fc99e Initial load
duke
parents:
diff changeset
3196 for (uint i = start, limit = req(); i < limit; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3197 Node* st = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3198
a61af66fc99e Initial load
duke
parents:
diff changeset
3199 intptr_t st_off = get_store_offset(st, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3200 if (st_off < 0) break; // return conservative answer
a61af66fc99e Initial load
duke
parents:
diff changeset
3201
a61af66fc99e Initial load
duke
parents:
diff changeset
3202 int st_size = st->as_Store()->memory_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
3203 if (st_size >= BytesPerInt && (st_off % BytesPerInt) == 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3204 return st_off; // we found a complete word init
a61af66fc99e Initial load
duke
parents:
diff changeset
3205 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3206
a61af66fc99e Initial load
duke
parents:
diff changeset
3207 // update the map:
a61af66fc99e Initial load
duke
parents:
diff changeset
3208
a61af66fc99e Initial load
duke
parents:
diff changeset
3209 intptr_t this_int_off = align_size_down(st_off, BytesPerInt);
a61af66fc99e Initial load
duke
parents:
diff changeset
3210 if (this_int_off != int_map_off) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3211 // reset the map:
a61af66fc99e Initial load
duke
parents:
diff changeset
3212 int_map = 0;
a61af66fc99e Initial load
duke
parents:
diff changeset
3213 int_map_off = this_int_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
3214 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3215
a61af66fc99e Initial load
duke
parents:
diff changeset
3216 int subword_off = st_off - this_int_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
3217 int_map |= right_n_bits(st_size) << subword_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
3218 if ((int_map & FULL_MAP) == FULL_MAP) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3219 return this_int_off; // we found a complete word init
a61af66fc99e Initial load
duke
parents:
diff changeset
3220 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3221
a61af66fc99e Initial load
duke
parents:
diff changeset
3222 // Did this store hit or cross the word boundary?
a61af66fc99e Initial load
duke
parents:
diff changeset
3223 intptr_t next_int_off = align_size_down(st_off + st_size, BytesPerInt);
a61af66fc99e Initial load
duke
parents:
diff changeset
3224 if (next_int_off == this_int_off + BytesPerInt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3225 // We passed the current int, without fully initializing it.
a61af66fc99e Initial load
duke
parents:
diff changeset
3226 int_map_off = next_int_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
3227 int_map >>= BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
3228 } else if (next_int_off > this_int_off + BytesPerInt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3229 // We passed the current and next int.
a61af66fc99e Initial load
duke
parents:
diff changeset
3230 return this_int_off + BytesPerInt;
a61af66fc99e Initial load
duke
parents:
diff changeset
3231 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3232 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3233
a61af66fc99e Initial load
duke
parents:
diff changeset
3234 return -1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3235 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3236
a61af66fc99e Initial load
duke
parents:
diff changeset
3237
a61af66fc99e Initial load
duke
parents:
diff changeset
3238 // Called when the associated AllocateNode is expanded into CFG.
a61af66fc99e Initial load
duke
parents:
diff changeset
3239 // At this point, we may perform additional optimizations.
a61af66fc99e Initial load
duke
parents:
diff changeset
3240 // Linearize the stores by ascending offset, to make memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3241 // activity as coherent as possible.
a61af66fc99e Initial load
duke
parents:
diff changeset
3242 Node* InitializeNode::complete_stores(Node* rawctl, Node* rawmem, Node* rawptr,
a61af66fc99e Initial load
duke
parents:
diff changeset
3243 intptr_t header_size,
a61af66fc99e Initial load
duke
parents:
diff changeset
3244 Node* size_in_bytes,
a61af66fc99e Initial load
duke
parents:
diff changeset
3245 PhaseGVN* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3246 assert(!is_complete(), "not already complete");
a61af66fc99e Initial load
duke
parents:
diff changeset
3247 assert(stores_are_sane(phase), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3248 assert(allocation() != NULL, "must be present");
a61af66fc99e Initial load
duke
parents:
diff changeset
3249
a61af66fc99e Initial load
duke
parents:
diff changeset
3250 remove_extra_zeroes();
a61af66fc99e Initial load
duke
parents:
diff changeset
3251
a61af66fc99e Initial load
duke
parents:
diff changeset
3252 if (ReduceFieldZeroing || ReduceBulkZeroing)
a61af66fc99e Initial load
duke
parents:
diff changeset
3253 // reduce instruction count for common initialization patterns
a61af66fc99e Initial load
duke
parents:
diff changeset
3254 coalesce_subword_stores(header_size, size_in_bytes, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3255
a61af66fc99e Initial load
duke
parents:
diff changeset
3256 Node* zmem = zero_memory(); // initially zero memory state
a61af66fc99e Initial load
duke
parents:
diff changeset
3257 Node* inits = zmem; // accumulating a linearized chain of inits
a61af66fc99e Initial load
duke
parents:
diff changeset
3258 #ifdef ASSERT
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3259 intptr_t first_offset = allocation()->minimum_header_size();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3260 intptr_t last_init_off = first_offset; // previous init offset
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3261 intptr_t last_init_end = first_offset; // previous init offset+size
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3262 intptr_t last_tile_end = first_offset; // previous tile offset+size
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3263 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3264 intptr_t zeroes_done = header_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
3265
a61af66fc99e Initial load
duke
parents:
diff changeset
3266 bool do_zeroing = true; // we might give up if inits are very sparse
a61af66fc99e Initial load
duke
parents:
diff changeset
3267 int big_init_gaps = 0; // how many large gaps have we seen?
a61af66fc99e Initial load
duke
parents:
diff changeset
3268
a61af66fc99e Initial load
duke
parents:
diff changeset
3269 if (ZeroTLAB) do_zeroing = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3270 if (!ReduceFieldZeroing && !ReduceBulkZeroing) do_zeroing = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3271
a61af66fc99e Initial load
duke
parents:
diff changeset
3272 for (uint i = InitializeNode::RawStores, limit = req(); i < limit; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3273 Node* st = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3274 intptr_t st_off = get_store_offset(st, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3275 if (st_off < 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
3276 break; // unknown junk in the inits
a61af66fc99e Initial load
duke
parents:
diff changeset
3277 if (st->in(MemNode::Memory) != zmem)
a61af66fc99e Initial load
duke
parents:
diff changeset
3278 break; // complicated store chains somehow in list
a61af66fc99e Initial load
duke
parents:
diff changeset
3279
a61af66fc99e Initial load
duke
parents:
diff changeset
3280 int st_size = st->as_Store()->memory_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
3281 intptr_t next_init_off = st_off + st_size;
a61af66fc99e Initial load
duke
parents:
diff changeset
3282
a61af66fc99e Initial load
duke
parents:
diff changeset
3283 if (do_zeroing && zeroes_done < next_init_off) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3284 // See if this store needs a zero before it or under it.
a61af66fc99e Initial load
duke
parents:
diff changeset
3285 intptr_t zeroes_needed = st_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
3286
a61af66fc99e Initial load
duke
parents:
diff changeset
3287 if (st_size < BytesPerInt) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3288 // Look for subword stores which only partially initialize words.
a61af66fc99e Initial load
duke
parents:
diff changeset
3289 // If we find some, we must lay down some word-level zeroes first,
a61af66fc99e Initial load
duke
parents:
diff changeset
3290 // underneath the subword stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
3291 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3292 // Examples:
a61af66fc99e Initial load
duke
parents:
diff changeset
3293 // byte[] a = { p,q,r,s } => a[0]=p,a[1]=q,a[2]=r,a[3]=s
a61af66fc99e Initial load
duke
parents:
diff changeset
3294 // byte[] a = { x,y,0,0 } => a[0..3] = 0, a[0]=x,a[1]=y
a61af66fc99e Initial load
duke
parents:
diff changeset
3295 // byte[] a = { 0,0,z,0 } => a[0..3] = 0, a[2]=z
a61af66fc99e Initial load
duke
parents:
diff changeset
3296 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3297 // Note: coalesce_subword_stores may have already done this,
a61af66fc99e Initial load
duke
parents:
diff changeset
3298 // if it was prompted by constant non-zero subword initializers.
a61af66fc99e Initial load
duke
parents:
diff changeset
3299 // But this case can still arise with non-constant stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
3300
a61af66fc99e Initial load
duke
parents:
diff changeset
3301 intptr_t next_full_store = find_next_fullword_store(i, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3302
a61af66fc99e Initial load
duke
parents:
diff changeset
3303 // In the examples above:
a61af66fc99e Initial load
duke
parents:
diff changeset
3304 // in(i) p q r s x y z
a61af66fc99e Initial load
duke
parents:
diff changeset
3305 // st_off 12 13 14 15 12 13 14
a61af66fc99e Initial load
duke
parents:
diff changeset
3306 // st_size 1 1 1 1 1 1 1
a61af66fc99e Initial load
duke
parents:
diff changeset
3307 // next_full_s. 12 16 16 16 16 16 16
a61af66fc99e Initial load
duke
parents:
diff changeset
3308 // z's_done 12 16 16 16 12 16 12
a61af66fc99e Initial load
duke
parents:
diff changeset
3309 // z's_needed 12 16 16 16 16 16 16
a61af66fc99e Initial load
duke
parents:
diff changeset
3310 // zsize 0 0 0 0 4 0 4
a61af66fc99e Initial load
duke
parents:
diff changeset
3311 if (next_full_store < 0) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3312 // Conservative tack: Zero to end of current word.
a61af66fc99e Initial load
duke
parents:
diff changeset
3313 zeroes_needed = align_size_up(zeroes_needed, BytesPerInt);
a61af66fc99e Initial load
duke
parents:
diff changeset
3314 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3315 // Zero to beginning of next fully initialized word.
a61af66fc99e Initial load
duke
parents:
diff changeset
3316 // Or, don't zero at all, if we are already in that word.
a61af66fc99e Initial load
duke
parents:
diff changeset
3317 assert(next_full_store >= zeroes_needed, "must go forward");
a61af66fc99e Initial load
duke
parents:
diff changeset
3318 assert((next_full_store & (BytesPerInt-1)) == 0, "even boundary");
a61af66fc99e Initial load
duke
parents:
diff changeset
3319 zeroes_needed = next_full_store;
a61af66fc99e Initial load
duke
parents:
diff changeset
3320 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3321 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3322
a61af66fc99e Initial load
duke
parents:
diff changeset
3323 if (zeroes_needed > zeroes_done) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3324 intptr_t zsize = zeroes_needed - zeroes_done;
a61af66fc99e Initial load
duke
parents:
diff changeset
3325 // Do some incremental zeroing on rawmem, in parallel with inits.
a61af66fc99e Initial load
duke
parents:
diff changeset
3326 zeroes_done = align_size_down(zeroes_done, BytesPerInt);
a61af66fc99e Initial load
duke
parents:
diff changeset
3327 rawmem = ClearArrayNode::clear_memory(rawctl, rawmem, rawptr,
a61af66fc99e Initial load
duke
parents:
diff changeset
3328 zeroes_done, zeroes_needed,
a61af66fc99e Initial load
duke
parents:
diff changeset
3329 phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3330 zeroes_done = zeroes_needed;
a61af66fc99e Initial load
duke
parents:
diff changeset
3331 if (zsize > Matcher::init_array_short_size && ++big_init_gaps > 2)
a61af66fc99e Initial load
duke
parents:
diff changeset
3332 do_zeroing = false; // leave the hole, next time
a61af66fc99e Initial load
duke
parents:
diff changeset
3333 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3334 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3335
a61af66fc99e Initial load
duke
parents:
diff changeset
3336 // Collect the store and move on:
a61af66fc99e Initial load
duke
parents:
diff changeset
3337 st->set_req(MemNode::Memory, inits);
a61af66fc99e Initial load
duke
parents:
diff changeset
3338 inits = st; // put it on the linearized chain
a61af66fc99e Initial load
duke
parents:
diff changeset
3339 set_req(i, zmem); // unhook from previous position
a61af66fc99e Initial load
duke
parents:
diff changeset
3340
a61af66fc99e Initial load
duke
parents:
diff changeset
3341 if (zeroes_done == st_off)
a61af66fc99e Initial load
duke
parents:
diff changeset
3342 zeroes_done = next_init_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
3343
a61af66fc99e Initial load
duke
parents:
diff changeset
3344 assert(!do_zeroing || zeroes_done >= next_init_off, "don't miss any");
a61af66fc99e Initial load
duke
parents:
diff changeset
3345
a61af66fc99e Initial load
duke
parents:
diff changeset
3346 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3347 // Various order invariants. Weaker than stores_are_sane because
a61af66fc99e Initial load
duke
parents:
diff changeset
3348 // a large constant tile can be filled in by smaller non-constant stores.
a61af66fc99e Initial load
duke
parents:
diff changeset
3349 assert(st_off >= last_init_off, "inits do not reverse");
a61af66fc99e Initial load
duke
parents:
diff changeset
3350 last_init_off = st_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
3351 const Type* val = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3352 if (st_size >= BytesPerInt &&
a61af66fc99e Initial load
duke
parents:
diff changeset
3353 (val = phase->type(st->in(MemNode::ValueIn)))->singleton() &&
a61af66fc99e Initial load
duke
parents:
diff changeset
3354 (int)val->basic_type() < (int)T_OBJECT) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3355 assert(st_off >= last_tile_end, "tiles do not overlap");
a61af66fc99e Initial load
duke
parents:
diff changeset
3356 assert(st_off >= last_init_end, "tiles do not overwrite inits");
a61af66fc99e Initial load
duke
parents:
diff changeset
3357 last_tile_end = MAX2(last_tile_end, next_init_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
3358 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3359 intptr_t st_tile_end = align_size_up(next_init_off, BytesPerLong);
a61af66fc99e Initial load
duke
parents:
diff changeset
3360 assert(st_tile_end >= last_tile_end, "inits stay with tiles");
a61af66fc99e Initial load
duke
parents:
diff changeset
3361 assert(st_off >= last_init_end, "inits do not overlap");
a61af66fc99e Initial load
duke
parents:
diff changeset
3362 last_init_end = next_init_off; // it's a non-tile
a61af66fc99e Initial load
duke
parents:
diff changeset
3363 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3364 #endif //ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3365 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3366
a61af66fc99e Initial load
duke
parents:
diff changeset
3367 remove_extra_zeroes(); // clear out all the zmems left over
a61af66fc99e Initial load
duke
parents:
diff changeset
3368 add_req(inits);
a61af66fc99e Initial load
duke
parents:
diff changeset
3369
a61af66fc99e Initial load
duke
parents:
diff changeset
3370 if (!ZeroTLAB) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3371 // If anything remains to be zeroed, zero it all now.
a61af66fc99e Initial load
duke
parents:
diff changeset
3372 zeroes_done = align_size_down(zeroes_done, BytesPerInt);
a61af66fc99e Initial load
duke
parents:
diff changeset
3373 // if it is the last unused 4 bytes of an instance, forget about it
a61af66fc99e Initial load
duke
parents:
diff changeset
3374 intptr_t size_limit = phase->find_intptr_t_con(size_in_bytes, max_jint);
a61af66fc99e Initial load
duke
parents:
diff changeset
3375 if (zeroes_done + BytesPerLong >= size_limit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3376 assert(allocation() != NULL, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3377 Node* klass_node = allocation()->in(AllocateNode::KlassNode);
a61af66fc99e Initial load
duke
parents:
diff changeset
3378 ciKlass* k = phase->type(klass_node)->is_klassptr()->klass();
a61af66fc99e Initial load
duke
parents:
diff changeset
3379 if (zeroes_done == k->layout_helper())
a61af66fc99e Initial load
duke
parents:
diff changeset
3380 zeroes_done = size_limit;
a61af66fc99e Initial load
duke
parents:
diff changeset
3381 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3382 if (zeroes_done < size_limit) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3383 rawmem = ClearArrayNode::clear_memory(rawctl, rawmem, rawptr,
a61af66fc99e Initial load
duke
parents:
diff changeset
3384 zeroes_done, size_in_bytes, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3385 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3386 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3387
a61af66fc99e Initial load
duke
parents:
diff changeset
3388 set_complete(phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3389 return rawmem;
a61af66fc99e Initial load
duke
parents:
diff changeset
3390 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3391
a61af66fc99e Initial load
duke
parents:
diff changeset
3392
a61af66fc99e Initial load
duke
parents:
diff changeset
3393 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3394 bool InitializeNode::stores_are_sane(PhaseTransform* phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3395 if (is_complete())
a61af66fc99e Initial load
duke
parents:
diff changeset
3396 return true; // stores could be anything at this point
113
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3397 assert(allocation() != NULL, "must be present");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 82
diff changeset
3398 intptr_t last_off = allocation()->minimum_header_size();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3399 for (uint i = InitializeNode::RawStores; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3400 Node* st = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3401 intptr_t st_off = get_store_offset(st, phase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3402 if (st_off < 0) continue; // ignore dead garbage
a61af66fc99e Initial load
duke
parents:
diff changeset
3403 if (last_off > st_off) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3404 tty->print_cr("*** bad store offset at %d: %d > %d", i, last_off, st_off);
a61af66fc99e Initial load
duke
parents:
diff changeset
3405 this->dump(2);
a61af66fc99e Initial load
duke
parents:
diff changeset
3406 assert(false, "ascending store offsets");
a61af66fc99e Initial load
duke
parents:
diff changeset
3407 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3408 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3409 last_off = st_off + st->as_Store()->memory_size();
a61af66fc99e Initial load
duke
parents:
diff changeset
3410 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3411 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3412 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3413 #endif //ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3414
a61af66fc99e Initial load
duke
parents:
diff changeset
3415
a61af66fc99e Initial load
duke
parents:
diff changeset
3416
a61af66fc99e Initial load
duke
parents:
diff changeset
3417
a61af66fc99e Initial load
duke
parents:
diff changeset
3418 //============================MergeMemNode=====================================
a61af66fc99e Initial load
duke
parents:
diff changeset
3419 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3420 // SEMANTICS OF MEMORY MERGES: A MergeMem is a memory state assembled from several
a61af66fc99e Initial load
duke
parents:
diff changeset
3421 // contributing store or call operations. Each contributor provides the memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3422 // state for a particular "alias type" (see Compile::alias_type). For example,
a61af66fc99e Initial load
duke
parents:
diff changeset
3423 // if a MergeMem has an input X for alias category #6, then any memory reference
a61af66fc99e Initial load
duke
parents:
diff changeset
3424 // to alias category #6 may use X as its memory state input, as an exact equivalent
a61af66fc99e Initial load
duke
parents:
diff changeset
3425 // to using the MergeMem as a whole.
a61af66fc99e Initial load
duke
parents:
diff changeset
3426 // Load<6>( MergeMem(<6>: X, ...), p ) <==> Load<6>(X,p)
a61af66fc99e Initial load
duke
parents:
diff changeset
3427 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3428 // (Here, the <N> notation gives the index of the relevant adr_type.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3429 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3430 // In one special case (and more cases in the future), alias categories overlap.
a61af66fc99e Initial load
duke
parents:
diff changeset
3431 // The special alias category "Bot" (Compile::AliasIdxBot) includes all memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3432 // states. Therefore, if a MergeMem has only one contributing input W for Bot,
a61af66fc99e Initial load
duke
parents:
diff changeset
3433 // it is exactly equivalent to that state W:
a61af66fc99e Initial load
duke
parents:
diff changeset
3434 // MergeMem(<Bot>: W) <==> W
a61af66fc99e Initial load
duke
parents:
diff changeset
3435 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3436 // Usually, the merge has more than one input. In that case, where inputs
a61af66fc99e Initial load
duke
parents:
diff changeset
3437 // overlap (i.e., one is Bot), the narrower alias type determines the memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3438 // state for that type, and the wider alias type (Bot) fills in everywhere else:
a61af66fc99e Initial load
duke
parents:
diff changeset
3439 // Load<5>( MergeMem(<Bot>: W, <6>: X), p ) <==> Load<5>(W,p)
a61af66fc99e Initial load
duke
parents:
diff changeset
3440 // Load<6>( MergeMem(<Bot>: W, <6>: X), p ) <==> Load<6>(X,p)
a61af66fc99e Initial load
duke
parents:
diff changeset
3441 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3442 // A merge can take a "wide" memory state as one of its narrow inputs.
a61af66fc99e Initial load
duke
parents:
diff changeset
3443 // This simply means that the merge observes out only the relevant parts of
a61af66fc99e Initial load
duke
parents:
diff changeset
3444 // the wide input. That is, wide memory states arriving at narrow merge inputs
a61af66fc99e Initial load
duke
parents:
diff changeset
3445 // are implicitly "filtered" or "sliced" as necessary. (This is rare.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3446 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3447 // These rules imply that MergeMem nodes may cascade (via their <Bot> links),
a61af66fc99e Initial load
duke
parents:
diff changeset
3448 // and that memory slices "leak through":
a61af66fc99e Initial load
duke
parents:
diff changeset
3449 // MergeMem(<Bot>: MergeMem(<Bot>: W, <7>: Y)) <==> MergeMem(<Bot>: W, <7>: Y)
a61af66fc99e Initial load
duke
parents:
diff changeset
3450 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3451 // But, in such a cascade, repeated memory slices can "block the leak":
a61af66fc99e Initial load
duke
parents:
diff changeset
3452 // MergeMem(<Bot>: MergeMem(<Bot>: W, <7>: Y), <7>: Y') <==> MergeMem(<Bot>: W, <7>: Y')
a61af66fc99e Initial load
duke
parents:
diff changeset
3453 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3454 // In the last example, Y is not part of the combined memory state of the
a61af66fc99e Initial load
duke
parents:
diff changeset
3455 // outermost MergeMem. The system must, of course, prevent unschedulable
a61af66fc99e Initial load
duke
parents:
diff changeset
3456 // memory states from arising, so you can be sure that the state Y is somehow
a61af66fc99e Initial load
duke
parents:
diff changeset
3457 // a precursor to state Y'.
a61af66fc99e Initial load
duke
parents:
diff changeset
3458 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3459 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3460 // REPRESENTATION OF MEMORY MERGES: The indexes used to address the Node::in array
a61af66fc99e Initial load
duke
parents:
diff changeset
3461 // of each MergeMemNode array are exactly the numerical alias indexes, including
a61af66fc99e Initial load
duke
parents:
diff changeset
3462 // but not limited to AliasIdxTop, AliasIdxBot, and AliasIdxRaw. The functions
a61af66fc99e Initial load
duke
parents:
diff changeset
3463 // Compile::alias_type (and kin) produce and manage these indexes.
a61af66fc99e Initial load
duke
parents:
diff changeset
3464 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3465 // By convention, the value of in(AliasIdxTop) (i.e., in(1)) is always the top node.
a61af66fc99e Initial load
duke
parents:
diff changeset
3466 // (Note that this provides quick access to the top node inside MergeMem methods,
a61af66fc99e Initial load
duke
parents:
diff changeset
3467 // without the need to reach out via TLS to Compile::current.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3468 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3469 // As a consequence of what was just described, a MergeMem that represents a full
a61af66fc99e Initial load
duke
parents:
diff changeset
3470 // memory state has an edge in(AliasIdxBot) which is a "wide" memory state,
a61af66fc99e Initial load
duke
parents:
diff changeset
3471 // containing all alias categories.
a61af66fc99e Initial load
duke
parents:
diff changeset
3472 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3473 // MergeMem nodes never (?) have control inputs, so in(0) is NULL.
a61af66fc99e Initial load
duke
parents:
diff changeset
3474 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3475 // All other edges in(N) (including in(AliasIdxRaw), which is in(3)) are either
a61af66fc99e Initial load
duke
parents:
diff changeset
3476 // a memory state for the alias type <N>, or else the top node, meaning that
a61af66fc99e Initial load
duke
parents:
diff changeset
3477 // there is no particular input for that alias type. Note that the length of
a61af66fc99e Initial load
duke
parents:
diff changeset
3478 // a MergeMem is variable, and may be extended at any time to accommodate new
a61af66fc99e Initial load
duke
parents:
diff changeset
3479 // memory states at larger alias indexes. When merges grow, they are of course
a61af66fc99e Initial load
duke
parents:
diff changeset
3480 // filled with "top" in the unused in() positions.
a61af66fc99e Initial load
duke
parents:
diff changeset
3481 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3482 // This use of top is named "empty_memory()", or "empty_mem" (no-memory) as a variable.
a61af66fc99e Initial load
duke
parents:
diff changeset
3483 // (Top was chosen because it works smoothly with passes like GCM.)
a61af66fc99e Initial load
duke
parents:
diff changeset
3484 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3485 // For convenience, we hardwire the alias index for TypeRawPtr::BOTTOM. (It is
a61af66fc99e Initial load
duke
parents:
diff changeset
3486 // the type of random VM bits like TLS references.) Since it is always the
a61af66fc99e Initial load
duke
parents:
diff changeset
3487 // first non-Bot memory slice, some low-level loops use it to initialize an
a61af66fc99e Initial load
duke
parents:
diff changeset
3488 // index variable: for (i = AliasIdxRaw; i < req(); i++).
a61af66fc99e Initial load
duke
parents:
diff changeset
3489 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3490 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3491 // ACCESSORS: There is a special accessor MergeMemNode::base_memory which returns
a61af66fc99e Initial load
duke
parents:
diff changeset
3492 // the distinguished "wide" state. The accessor MergeMemNode::memory_at(N) returns
a61af66fc99e Initial load
duke
parents:
diff changeset
3493 // the memory state for alias type <N>, or (if there is no particular slice at <N>,
a61af66fc99e Initial load
duke
parents:
diff changeset
3494 // it returns the base memory. To prevent bugs, memory_at does not accept <Top>
a61af66fc99e Initial load
duke
parents:
diff changeset
3495 // or <Bot> indexes. The iterator MergeMemStream provides robust iteration over
a61af66fc99e Initial load
duke
parents:
diff changeset
3496 // MergeMem nodes or pairs of such nodes, ensuring that the non-top edges are visited.
a61af66fc99e Initial load
duke
parents:
diff changeset
3497 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3498 // %%%% We may get rid of base_memory as a separate accessor at some point; it isn't
a61af66fc99e Initial load
duke
parents:
diff changeset
3499 // really that different from the other memory inputs. An abbreviation called
a61af66fc99e Initial load
duke
parents:
diff changeset
3500 // "bot_memory()" for "memory_at(AliasIdxBot)" would keep code tidy.
a61af66fc99e Initial load
duke
parents:
diff changeset
3501 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3502 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3503 // PARTIAL MEMORY STATES: During optimization, MergeMem nodes may arise that represent
a61af66fc99e Initial load
duke
parents:
diff changeset
3504 // partial memory states. When a Phi splits through a MergeMem, the copy of the Phi
a61af66fc99e Initial load
duke
parents:
diff changeset
3505 // that "emerges though" the base memory will be marked as excluding the alias types
a61af66fc99e Initial load
duke
parents:
diff changeset
3506 // of the other (narrow-memory) copies which "emerged through" the narrow edges:
a61af66fc99e Initial load
duke
parents:
diff changeset
3507 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3508 // Phi<Bot>(U, MergeMem(<Bot>: W, <8>: Y))
a61af66fc99e Initial load
duke
parents:
diff changeset
3509 // ==Ideal=> MergeMem(<Bot>: Phi<Bot-8>(U, W), Phi<8>(U, Y))
a61af66fc99e Initial load
duke
parents:
diff changeset
3510 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3511 // This strange "subtraction" effect is necessary to ensure IGVN convergence.
a61af66fc99e Initial load
duke
parents:
diff changeset
3512 // (It is currently unimplemented.) As you can see, the resulting merge is
a61af66fc99e Initial load
duke
parents:
diff changeset
3513 // actually a disjoint union of memory states, rather than an overlay.
a61af66fc99e Initial load
duke
parents:
diff changeset
3514 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3515
a61af66fc99e Initial load
duke
parents:
diff changeset
3516 //------------------------------MergeMemNode-----------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3517 Node* MergeMemNode::make_empty_memory() {
a61af66fc99e Initial load
duke
parents:
diff changeset
3518 Node* empty_memory = (Node*) Compile::current()->top();
a61af66fc99e Initial load
duke
parents:
diff changeset
3519 assert(empty_memory->is_top(), "correct sentinel identity");
a61af66fc99e Initial load
duke
parents:
diff changeset
3520 return empty_memory;
a61af66fc99e Initial load
duke
parents:
diff changeset
3521 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3522
a61af66fc99e Initial load
duke
parents:
diff changeset
3523 MergeMemNode::MergeMemNode(Node *new_base) : Node(1+Compile::AliasIdxRaw) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3524 init_class_id(Class_MergeMem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3525 // all inputs are nullified in Node::Node(int)
a61af66fc99e Initial load
duke
parents:
diff changeset
3526 // set_input(0, NULL); // no control input
a61af66fc99e Initial load
duke
parents:
diff changeset
3527
a61af66fc99e Initial load
duke
parents:
diff changeset
3528 // Initialize the edges uniformly to top, for starters.
a61af66fc99e Initial load
duke
parents:
diff changeset
3529 Node* empty_mem = make_empty_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3530 for (uint i = Compile::AliasIdxTop; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3531 init_req(i,empty_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3532 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3533 assert(empty_memory() == empty_mem, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3534
a61af66fc99e Initial load
duke
parents:
diff changeset
3535 if( new_base != NULL && new_base->is_MergeMem() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3536 MergeMemNode* mdef = new_base->as_MergeMem();
a61af66fc99e Initial load
duke
parents:
diff changeset
3537 assert(mdef->empty_memory() == empty_mem, "consistent sentinels");
a61af66fc99e Initial load
duke
parents:
diff changeset
3538 for (MergeMemStream mms(this, mdef); mms.next_non_empty2(); ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3539 mms.set_memory(mms.memory2());
a61af66fc99e Initial load
duke
parents:
diff changeset
3540 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3541 assert(base_memory() == mdef->base_memory(), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3542 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3543 set_base_memory(new_base);
a61af66fc99e Initial load
duke
parents:
diff changeset
3544 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3545 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3546
a61af66fc99e Initial load
duke
parents:
diff changeset
3547 // Make a new, untransformed MergeMem with the same base as 'mem'.
a61af66fc99e Initial load
duke
parents:
diff changeset
3548 // If mem is itself a MergeMem, populate the result with the same edges.
a61af66fc99e Initial load
duke
parents:
diff changeset
3549 MergeMemNode* MergeMemNode::make(Compile* C, Node* mem) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3550 return new(C, 1+Compile::AliasIdxRaw) MergeMemNode(mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3551 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3552
a61af66fc99e Initial load
duke
parents:
diff changeset
3553 //------------------------------cmp--------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3554 uint MergeMemNode::hash() const { return NO_HASH; }
a61af66fc99e Initial load
duke
parents:
diff changeset
3555 uint MergeMemNode::cmp( const Node &n ) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
3556 return (&n == this); // Always fail except on self
a61af66fc99e Initial load
duke
parents:
diff changeset
3557 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3558
a61af66fc99e Initial load
duke
parents:
diff changeset
3559 //------------------------------Identity---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3560 Node* MergeMemNode::Identity(PhaseTransform *phase) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3561 // Identity if this merge point does not record any interesting memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3562 // disambiguations.
a61af66fc99e Initial load
duke
parents:
diff changeset
3563 Node* base_mem = base_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3564 Node* empty_mem = empty_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3565 if (base_mem != empty_mem) { // Memory path is not dead?
a61af66fc99e Initial load
duke
parents:
diff changeset
3566 for (uint i = Compile::AliasIdxRaw; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3567 Node* mem = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3568 if (mem != empty_mem && mem != base_mem) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3569 return this; // Many memory splits; no change
a61af66fc99e Initial load
duke
parents:
diff changeset
3570 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3571 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3572 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3573 return base_mem; // No memory splits; ID on the one true input
a61af66fc99e Initial load
duke
parents:
diff changeset
3574 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3575
a61af66fc99e Initial load
duke
parents:
diff changeset
3576 //------------------------------Ideal------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3577 // This method is invoked recursively on chains of MergeMem nodes
a61af66fc99e Initial load
duke
parents:
diff changeset
3578 Node *MergeMemNode::Ideal(PhaseGVN *phase, bool can_reshape) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3579 // Remove chain'd MergeMems
a61af66fc99e Initial load
duke
parents:
diff changeset
3580 //
a61af66fc99e Initial load
duke
parents:
diff changeset
3581 // This is delicate, because the each "in(i)" (i >= Raw) is interpreted
a61af66fc99e Initial load
duke
parents:
diff changeset
3582 // relative to the "in(Bot)". Since we are patching both at the same time,
a61af66fc99e Initial load
duke
parents:
diff changeset
3583 // we have to be careful to read each "in(i)" relative to the old "in(Bot)",
a61af66fc99e Initial load
duke
parents:
diff changeset
3584 // but rewrite each "in(i)" relative to the new "in(Bot)".
a61af66fc99e Initial load
duke
parents:
diff changeset
3585 Node *progress = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3586
a61af66fc99e Initial load
duke
parents:
diff changeset
3587
a61af66fc99e Initial load
duke
parents:
diff changeset
3588 Node* old_base = base_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3589 Node* empty_mem = empty_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3590 if (old_base == empty_mem)
a61af66fc99e Initial load
duke
parents:
diff changeset
3591 return NULL; // Dead memory path.
a61af66fc99e Initial load
duke
parents:
diff changeset
3592
a61af66fc99e Initial load
duke
parents:
diff changeset
3593 MergeMemNode* old_mbase;
a61af66fc99e Initial load
duke
parents:
diff changeset
3594 if (old_base != NULL && old_base->is_MergeMem())
a61af66fc99e Initial load
duke
parents:
diff changeset
3595 old_mbase = old_base->as_MergeMem();
a61af66fc99e Initial load
duke
parents:
diff changeset
3596 else
a61af66fc99e Initial load
duke
parents:
diff changeset
3597 old_mbase = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3598 Node* new_base = old_base;
a61af66fc99e Initial load
duke
parents:
diff changeset
3599
a61af66fc99e Initial load
duke
parents:
diff changeset
3600 // simplify stacked MergeMems in base memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3601 if (old_mbase) new_base = old_mbase->base_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3602
a61af66fc99e Initial load
duke
parents:
diff changeset
3603 // the base memory might contribute new slices beyond my req()
a61af66fc99e Initial load
duke
parents:
diff changeset
3604 if (old_mbase) grow_to_match(old_mbase);
a61af66fc99e Initial load
duke
parents:
diff changeset
3605
a61af66fc99e Initial load
duke
parents:
diff changeset
3606 // Look carefully at the base node if it is a phi.
a61af66fc99e Initial load
duke
parents:
diff changeset
3607 PhiNode* phi_base;
a61af66fc99e Initial load
duke
parents:
diff changeset
3608 if (new_base != NULL && new_base->is_Phi())
a61af66fc99e Initial load
duke
parents:
diff changeset
3609 phi_base = new_base->as_Phi();
a61af66fc99e Initial load
duke
parents:
diff changeset
3610 else
a61af66fc99e Initial load
duke
parents:
diff changeset
3611 phi_base = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3612
a61af66fc99e Initial load
duke
parents:
diff changeset
3613 Node* phi_reg = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3614 uint phi_len = (uint)-1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3615 if (phi_base != NULL && !phi_base->is_copy()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3616 // do not examine phi if degraded to a copy
a61af66fc99e Initial load
duke
parents:
diff changeset
3617 phi_reg = phi_base->region();
a61af66fc99e Initial load
duke
parents:
diff changeset
3618 phi_len = phi_base->req();
a61af66fc99e Initial load
duke
parents:
diff changeset
3619 // see if the phi is unfinished
a61af66fc99e Initial load
duke
parents:
diff changeset
3620 for (uint i = 1; i < phi_len; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3621 if (phi_base->in(i) == NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3622 // incomplete phi; do not look at it yet!
a61af66fc99e Initial load
duke
parents:
diff changeset
3623 phi_reg = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3624 phi_len = (uint)-1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3625 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3626 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3627 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3628 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3629
a61af66fc99e Initial load
duke
parents:
diff changeset
3630 // Note: We do not call verify_sparse on entry, because inputs
a61af66fc99e Initial load
duke
parents:
diff changeset
3631 // can normalize to the base_memory via subsume_node or similar
a61af66fc99e Initial load
duke
parents:
diff changeset
3632 // mechanisms. This method repairs that damage.
a61af66fc99e Initial load
duke
parents:
diff changeset
3633
a61af66fc99e Initial load
duke
parents:
diff changeset
3634 assert(!old_mbase || old_mbase->is_empty_memory(empty_mem), "consistent sentinels");
a61af66fc99e Initial load
duke
parents:
diff changeset
3635
a61af66fc99e Initial load
duke
parents:
diff changeset
3636 // Look at each slice.
a61af66fc99e Initial load
duke
parents:
diff changeset
3637 for (uint i = Compile::AliasIdxRaw; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3638 Node* old_in = in(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3639 // calculate the old memory value
a61af66fc99e Initial load
duke
parents:
diff changeset
3640 Node* old_mem = old_in;
a61af66fc99e Initial load
duke
parents:
diff changeset
3641 if (old_mem == empty_mem) old_mem = old_base;
a61af66fc99e Initial load
duke
parents:
diff changeset
3642 assert(old_mem == memory_at(i), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3643
a61af66fc99e Initial load
duke
parents:
diff changeset
3644 // maybe update (reslice) the old memory value
a61af66fc99e Initial load
duke
parents:
diff changeset
3645
a61af66fc99e Initial load
duke
parents:
diff changeset
3646 // simplify stacked MergeMems
a61af66fc99e Initial load
duke
parents:
diff changeset
3647 Node* new_mem = old_mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
3648 MergeMemNode* old_mmem;
a61af66fc99e Initial load
duke
parents:
diff changeset
3649 if (old_mem != NULL && old_mem->is_MergeMem())
a61af66fc99e Initial load
duke
parents:
diff changeset
3650 old_mmem = old_mem->as_MergeMem();
a61af66fc99e Initial load
duke
parents:
diff changeset
3651 else
a61af66fc99e Initial load
duke
parents:
diff changeset
3652 old_mmem = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3653 if (old_mmem == this) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3654 // This can happen if loops break up and safepoints disappear.
a61af66fc99e Initial load
duke
parents:
diff changeset
3655 // A merge of BotPtr (default) with a RawPtr memory derived from a
a61af66fc99e Initial load
duke
parents:
diff changeset
3656 // safepoint can be rewritten to a merge of the same BotPtr with
a61af66fc99e Initial load
duke
parents:
diff changeset
3657 // the BotPtr phi coming into the loop. If that phi disappears
a61af66fc99e Initial load
duke
parents:
diff changeset
3658 // also, we can end up with a self-loop of the mergemem.
a61af66fc99e Initial load
duke
parents:
diff changeset
3659 // In general, if loops degenerate and memory effects disappear,
a61af66fc99e Initial load
duke
parents:
diff changeset
3660 // a mergemem can be left looking at itself. This simply means
a61af66fc99e Initial load
duke
parents:
diff changeset
3661 // that the mergemem's default should be used, since there is
a61af66fc99e Initial load
duke
parents:
diff changeset
3662 // no longer any apparent effect on this slice.
a61af66fc99e Initial load
duke
parents:
diff changeset
3663 // Note: If a memory slice is a MergeMem cycle, it is unreachable
a61af66fc99e Initial load
duke
parents:
diff changeset
3664 // from start. Update the input to TOP.
a61af66fc99e Initial load
duke
parents:
diff changeset
3665 new_mem = (new_base == this || new_base == empty_mem)? empty_mem : new_base;
a61af66fc99e Initial load
duke
parents:
diff changeset
3666 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3667 else if (old_mmem != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3668 new_mem = old_mmem->memory_at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3669 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3670 // else preceeding memory was not a MergeMem
a61af66fc99e Initial load
duke
parents:
diff changeset
3671
a61af66fc99e Initial load
duke
parents:
diff changeset
3672 // replace equivalent phis (unfortunately, they do not GVN together)
a61af66fc99e Initial load
duke
parents:
diff changeset
3673 if (new_mem != NULL && new_mem != new_base &&
a61af66fc99e Initial load
duke
parents:
diff changeset
3674 new_mem->req() == phi_len && new_mem->in(0) == phi_reg) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3675 if (new_mem->is_Phi()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3676 PhiNode* phi_mem = new_mem->as_Phi();
a61af66fc99e Initial load
duke
parents:
diff changeset
3677 for (uint i = 1; i < phi_len; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3678 if (phi_base->in(i) != phi_mem->in(i)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3679 phi_mem = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
3680 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3681 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3682 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3683 if (phi_mem != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3684 // equivalent phi nodes; revert to the def
a61af66fc99e Initial load
duke
parents:
diff changeset
3685 new_mem = new_base;
a61af66fc99e Initial load
duke
parents:
diff changeset
3686 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3687 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3688 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3689
a61af66fc99e Initial load
duke
parents:
diff changeset
3690 // maybe store down a new value
a61af66fc99e Initial load
duke
parents:
diff changeset
3691 Node* new_in = new_mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
3692 if (new_in == new_base) new_in = empty_mem;
a61af66fc99e Initial load
duke
parents:
diff changeset
3693
a61af66fc99e Initial load
duke
parents:
diff changeset
3694 if (new_in != old_in) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3695 // Warning: Do not combine this "if" with the previous "if"
a61af66fc99e Initial load
duke
parents:
diff changeset
3696 // A memory slice might have be be rewritten even if it is semantically
a61af66fc99e Initial load
duke
parents:
diff changeset
3697 // unchanged, if the base_memory value has changed.
a61af66fc99e Initial load
duke
parents:
diff changeset
3698 set_req(i, new_in);
a61af66fc99e Initial load
duke
parents:
diff changeset
3699 progress = this; // Report progress
a61af66fc99e Initial load
duke
parents:
diff changeset
3700 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3701 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3702
a61af66fc99e Initial load
duke
parents:
diff changeset
3703 if (new_base != old_base) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3704 set_req(Compile::AliasIdxBot, new_base);
a61af66fc99e Initial load
duke
parents:
diff changeset
3705 // Don't use set_base_memory(new_base), because we need to update du.
a61af66fc99e Initial load
duke
parents:
diff changeset
3706 assert(base_memory() == new_base, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3707 progress = this;
a61af66fc99e Initial load
duke
parents:
diff changeset
3708 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3709
a61af66fc99e Initial load
duke
parents:
diff changeset
3710 if( base_memory() == this ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3711 // a self cycle indicates this memory path is dead
a61af66fc99e Initial load
duke
parents:
diff changeset
3712 set_req(Compile::AliasIdxBot, empty_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3713 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3714
a61af66fc99e Initial load
duke
parents:
diff changeset
3715 // Resolve external cycles by calling Ideal on a MergeMem base_memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3716 // Recursion must occur after the self cycle check above
a61af66fc99e Initial load
duke
parents:
diff changeset
3717 if( base_memory()->is_MergeMem() ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3718 MergeMemNode *new_mbase = base_memory()->as_MergeMem();
a61af66fc99e Initial load
duke
parents:
diff changeset
3719 Node *m = phase->transform(new_mbase); // Rollup any cycles
a61af66fc99e Initial load
duke
parents:
diff changeset
3720 if( m != NULL && (m->is_top() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
3721 m->is_MergeMem() && m->as_MergeMem()->base_memory() == empty_mem) ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3722 // propagate rollup of dead cycle to self
a61af66fc99e Initial load
duke
parents:
diff changeset
3723 set_req(Compile::AliasIdxBot, empty_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3724 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3725 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3726
a61af66fc99e Initial load
duke
parents:
diff changeset
3727 if( base_memory() == empty_mem ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3728 progress = this;
a61af66fc99e Initial load
duke
parents:
diff changeset
3729 // Cut inputs during Parse phase only.
a61af66fc99e Initial load
duke
parents:
diff changeset
3730 // During Optimize phase a dead MergeMem node will be subsumed by Top.
a61af66fc99e Initial load
duke
parents:
diff changeset
3731 if( !can_reshape ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3732 for (uint i = Compile::AliasIdxRaw; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3733 if( in(i) != empty_mem ) { set_req(i, empty_mem); }
a61af66fc99e Initial load
duke
parents:
diff changeset
3734 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3735 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3736 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3737
a61af66fc99e Initial load
duke
parents:
diff changeset
3738 if( !progress && base_memory()->is_Phi() && can_reshape ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3739 // Check if PhiNode::Ideal's "Split phis through memory merges"
a61af66fc99e Initial load
duke
parents:
diff changeset
3740 // transform should be attempted. Look for this->phi->this cycle.
a61af66fc99e Initial load
duke
parents:
diff changeset
3741 uint merge_width = req();
a61af66fc99e Initial load
duke
parents:
diff changeset
3742 if (merge_width > Compile::AliasIdxRaw) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3743 PhiNode* phi = base_memory()->as_Phi();
a61af66fc99e Initial load
duke
parents:
diff changeset
3744 for( uint i = 1; i < phi->req(); ++i ) {// For all paths in
a61af66fc99e Initial load
duke
parents:
diff changeset
3745 if (phi->in(i) == this) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3746 phase->is_IterGVN()->_worklist.push(phi);
a61af66fc99e Initial load
duke
parents:
diff changeset
3747 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3748 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3749 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3750 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3751 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3752
64
b8f5ba577b02 6673473: (Escape Analysis) Add the instance's field information to PhiNode
kvn
parents: 43
diff changeset
3753 assert(progress || verify_sparse(), "please, no dups of base");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3754 return progress;
a61af66fc99e Initial load
duke
parents:
diff changeset
3755 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3756
a61af66fc99e Initial load
duke
parents:
diff changeset
3757 //-------------------------set_base_memory-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3758 void MergeMemNode::set_base_memory(Node *new_base) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3759 Node* empty_mem = empty_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3760 set_req(Compile::AliasIdxBot, new_base);
a61af66fc99e Initial load
duke
parents:
diff changeset
3761 assert(memory_at(req()) == new_base, "must set default memory");
a61af66fc99e Initial load
duke
parents:
diff changeset
3762 // Clear out other occurrences of new_base:
a61af66fc99e Initial load
duke
parents:
diff changeset
3763 if (new_base != empty_mem) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3764 for (uint i = Compile::AliasIdxRaw; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3765 if (in(i) == new_base) set_req(i, empty_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3766 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3767 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3768 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3769
a61af66fc99e Initial load
duke
parents:
diff changeset
3770 //------------------------------out_RegMask------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3771 const RegMask &MergeMemNode::out_RegMask() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
3772 return RegMask::Empty;
a61af66fc99e Initial load
duke
parents:
diff changeset
3773 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3774
a61af66fc99e Initial load
duke
parents:
diff changeset
3775 //------------------------------dump_spec--------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3776 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3777 void MergeMemNode::dump_spec(outputStream *st) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
3778 st->print(" {");
a61af66fc99e Initial load
duke
parents:
diff changeset
3779 Node* base_mem = base_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3780 for( uint i = Compile::AliasIdxRaw; i < req(); i++ ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3781 Node* mem = memory_at(i);
a61af66fc99e Initial load
duke
parents:
diff changeset
3782 if (mem == base_mem) { st->print(" -"); continue; }
a61af66fc99e Initial load
duke
parents:
diff changeset
3783 st->print( " N%d:", mem->_idx );
a61af66fc99e Initial load
duke
parents:
diff changeset
3784 Compile::current()->get_adr_type(i)->dump_on(st);
a61af66fc99e Initial load
duke
parents:
diff changeset
3785 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3786 st->print(" }");
a61af66fc99e Initial load
duke
parents:
diff changeset
3787 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3788 #endif // !PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3789
a61af66fc99e Initial load
duke
parents:
diff changeset
3790
a61af66fc99e Initial load
duke
parents:
diff changeset
3791 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3792 static bool might_be_same(Node* a, Node* b) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3793 if (a == b) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3794 if (!(a->is_Phi() || b->is_Phi())) return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3795 // phis shift around during optimization
a61af66fc99e Initial load
duke
parents:
diff changeset
3796 return true; // pretty stupid...
a61af66fc99e Initial load
duke
parents:
diff changeset
3797 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3798
a61af66fc99e Initial load
duke
parents:
diff changeset
3799 // verify a narrow slice (either incoming or outgoing)
a61af66fc99e Initial load
duke
parents:
diff changeset
3800 static void verify_memory_slice(const MergeMemNode* m, int alias_idx, Node* n) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3801 if (!VerifyAliases) return; // don't bother to verify unless requested
a61af66fc99e Initial load
duke
parents:
diff changeset
3802 if (is_error_reported()) return; // muzzle asserts when debugging an error
a61af66fc99e Initial load
duke
parents:
diff changeset
3803 if (Node::in_dump()) return; // muzzle asserts when printing
a61af66fc99e Initial load
duke
parents:
diff changeset
3804 assert(alias_idx >= Compile::AliasIdxRaw, "must not disturb base_memory or sentinel");
a61af66fc99e Initial load
duke
parents:
diff changeset
3805 assert(n != NULL, "");
a61af66fc99e Initial load
duke
parents:
diff changeset
3806 // Elide intervening MergeMem's
a61af66fc99e Initial load
duke
parents:
diff changeset
3807 while (n->is_MergeMem()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3808 n = n->as_MergeMem()->memory_at(alias_idx);
a61af66fc99e Initial load
duke
parents:
diff changeset
3809 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3810 Compile* C = Compile::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
3811 const TypePtr* n_adr_type = n->adr_type();
a61af66fc99e Initial load
duke
parents:
diff changeset
3812 if (n == m->empty_memory()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3813 // Implicit copy of base_memory()
a61af66fc99e Initial load
duke
parents:
diff changeset
3814 } else if (n_adr_type != TypePtr::BOTTOM) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3815 assert(n_adr_type != NULL, "new memory must have a well-defined adr_type");
a61af66fc99e Initial load
duke
parents:
diff changeset
3816 assert(C->must_alias(n_adr_type, alias_idx), "new memory must match selected slice");
a61af66fc99e Initial load
duke
parents:
diff changeset
3817 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3818 // A few places like make_runtime_call "know" that VM calls are narrow,
a61af66fc99e Initial load
duke
parents:
diff changeset
3819 // and can be used to update only the VM bits stored as TypeRawPtr::BOTTOM.
a61af66fc99e Initial load
duke
parents:
diff changeset
3820 bool expected_wide_mem = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3821 if (n == m->base_memory()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3822 expected_wide_mem = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3823 } else if (alias_idx == Compile::AliasIdxRaw ||
a61af66fc99e Initial load
duke
parents:
diff changeset
3824 n == m->memory_at(Compile::AliasIdxRaw)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3825 expected_wide_mem = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3826 } else if (!C->alias_type(alias_idx)->is_rewritable()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3827 // memory can "leak through" calls on channels that
a61af66fc99e Initial load
duke
parents:
diff changeset
3828 // are write-once. Allow this also.
a61af66fc99e Initial load
duke
parents:
diff changeset
3829 expected_wide_mem = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3830 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3831 assert(expected_wide_mem, "expected narrow slice replacement");
a61af66fc99e Initial load
duke
parents:
diff changeset
3832 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3833 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3834 #else // !ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3835 #define verify_memory_slice(m,i,n) (0) // PRODUCT version is no-op
a61af66fc99e Initial load
duke
parents:
diff changeset
3836 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3837
a61af66fc99e Initial load
duke
parents:
diff changeset
3838
a61af66fc99e Initial load
duke
parents:
diff changeset
3839 //-----------------------------memory_at---------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3840 Node* MergeMemNode::memory_at(uint alias_idx) const {
a61af66fc99e Initial load
duke
parents:
diff changeset
3841 assert(alias_idx >= Compile::AliasIdxRaw ||
a61af66fc99e Initial load
duke
parents:
diff changeset
3842 alias_idx == Compile::AliasIdxBot && Compile::current()->AliasLevel() == 0,
a61af66fc99e Initial load
duke
parents:
diff changeset
3843 "must avoid base_memory and AliasIdxTop");
a61af66fc99e Initial load
duke
parents:
diff changeset
3844
a61af66fc99e Initial load
duke
parents:
diff changeset
3845 // Otherwise, it is a narrow slice.
a61af66fc99e Initial load
duke
parents:
diff changeset
3846 Node* n = alias_idx < req() ? in(alias_idx) : empty_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3847 Compile *C = Compile::current();
a61af66fc99e Initial load
duke
parents:
diff changeset
3848 if (is_empty_memory(n)) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3849 // the array is sparse; empty slots are the "top" node
a61af66fc99e Initial load
duke
parents:
diff changeset
3850 n = base_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3851 assert(Node::in_dump()
a61af66fc99e Initial load
duke
parents:
diff changeset
3852 || n == NULL || n->bottom_type() == Type::TOP
a61af66fc99e Initial load
duke
parents:
diff changeset
3853 || n->adr_type() == TypePtr::BOTTOM
a61af66fc99e Initial load
duke
parents:
diff changeset
3854 || n->adr_type() == TypeRawPtr::BOTTOM
a61af66fc99e Initial load
duke
parents:
diff changeset
3855 || Compile::current()->AliasLevel() == 0,
a61af66fc99e Initial load
duke
parents:
diff changeset
3856 "must be a wide memory");
a61af66fc99e Initial load
duke
parents:
diff changeset
3857 // AliasLevel == 0 if we are organizing the memory states manually.
a61af66fc99e Initial load
duke
parents:
diff changeset
3858 // See verify_memory_slice for comments on TypeRawPtr::BOTTOM.
a61af66fc99e Initial load
duke
parents:
diff changeset
3859 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3860 // make sure the stored slice is sane
a61af66fc99e Initial load
duke
parents:
diff changeset
3861 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3862 if (is_error_reported() || Node::in_dump()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3863 } else if (might_be_same(n, base_memory())) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3864 // Give it a pass: It is a mostly harmless repetition of the base.
a61af66fc99e Initial load
duke
parents:
diff changeset
3865 // This can arise normally from node subsumption during optimization.
a61af66fc99e Initial load
duke
parents:
diff changeset
3866 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
3867 verify_memory_slice(this, alias_idx, n);
a61af66fc99e Initial load
duke
parents:
diff changeset
3868 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3869 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3870 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3871 return n;
a61af66fc99e Initial load
duke
parents:
diff changeset
3872 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3873
a61af66fc99e Initial load
duke
parents:
diff changeset
3874 //---------------------------set_memory_at-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3875 void MergeMemNode::set_memory_at(uint alias_idx, Node *n) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3876 verify_memory_slice(this, alias_idx, n);
a61af66fc99e Initial load
duke
parents:
diff changeset
3877 Node* empty_mem = empty_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3878 if (n == base_memory()) n = empty_mem; // collapse default
a61af66fc99e Initial load
duke
parents:
diff changeset
3879 uint need_req = alias_idx+1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3880 if (req() < need_req) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3881 if (n == empty_mem) return; // already the default, so do not grow me
a61af66fc99e Initial load
duke
parents:
diff changeset
3882 // grow the sparse array
a61af66fc99e Initial load
duke
parents:
diff changeset
3883 do {
a61af66fc99e Initial load
duke
parents:
diff changeset
3884 add_req(empty_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3885 } while (req() < need_req);
a61af66fc99e Initial load
duke
parents:
diff changeset
3886 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3887 set_req( alias_idx, n );
a61af66fc99e Initial load
duke
parents:
diff changeset
3888 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3889
a61af66fc99e Initial load
duke
parents:
diff changeset
3890
a61af66fc99e Initial load
duke
parents:
diff changeset
3891
a61af66fc99e Initial load
duke
parents:
diff changeset
3892 //--------------------------iteration_setup------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3893 void MergeMemNode::iteration_setup(const MergeMemNode* other) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3894 if (other != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3895 grow_to_match(other);
a61af66fc99e Initial load
duke
parents:
diff changeset
3896 // invariant: the finite support of mm2 is within mm->req()
a61af66fc99e Initial load
duke
parents:
diff changeset
3897 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
3898 for (uint i = req(); i < other->req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3899 assert(other->is_empty_memory(other->in(i)), "slice left uncovered");
a61af66fc99e Initial load
duke
parents:
diff changeset
3900 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3901 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
3902 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3903 // Replace spurious copies of base_memory by top.
a61af66fc99e Initial load
duke
parents:
diff changeset
3904 Node* base_mem = base_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3905 if (base_mem != NULL && !base_mem->is_top()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3906 for (uint i = Compile::AliasIdxBot+1, imax = req(); i < imax; i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3907 if (in(i) == base_mem)
a61af66fc99e Initial load
duke
parents:
diff changeset
3908 set_req(i, empty_memory());
a61af66fc99e Initial load
duke
parents:
diff changeset
3909 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3910 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3911 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3912
a61af66fc99e Initial load
duke
parents:
diff changeset
3913 //---------------------------grow_to_match-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3914 void MergeMemNode::grow_to_match(const MergeMemNode* other) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3915 Node* empty_mem = empty_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3916 assert(other->is_empty_memory(empty_mem), "consistent sentinels");
a61af66fc99e Initial load
duke
parents:
diff changeset
3917 // look for the finite support of the other memory
a61af66fc99e Initial load
duke
parents:
diff changeset
3918 for (uint i = other->req(); --i >= req(); ) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3919 if (other->in(i) != empty_mem) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3920 uint new_len = i+1;
a61af66fc99e Initial load
duke
parents:
diff changeset
3921 while (req() < new_len) add_req(empty_mem);
a61af66fc99e Initial load
duke
parents:
diff changeset
3922 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3923 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3924 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3925 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3926
a61af66fc99e Initial load
duke
parents:
diff changeset
3927 //---------------------------verify_sparse-------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
3928 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
3929 bool MergeMemNode::verify_sparse() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
3930 assert(is_empty_memory(make_empty_memory()), "sane sentinel");
a61af66fc99e Initial load
duke
parents:
diff changeset
3931 Node* base_mem = base_memory();
a61af66fc99e Initial load
duke
parents:
diff changeset
3932 // The following can happen in degenerate cases, since empty==top.
a61af66fc99e Initial load
duke
parents:
diff changeset
3933 if (is_empty_memory(base_mem)) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3934 for (uint i = Compile::AliasIdxRaw; i < req(); i++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3935 assert(in(i) != NULL, "sane slice");
a61af66fc99e Initial load
duke
parents:
diff changeset
3936 if (in(i) == base_mem) return false; // should have been the sentinel value!
a61af66fc99e Initial load
duke
parents:
diff changeset
3937 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3938 return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3939 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3940
a61af66fc99e Initial load
duke
parents:
diff changeset
3941 bool MergeMemStream::match_memory(Node* mem, const MergeMemNode* mm, int idx) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3942 Node* n;
a61af66fc99e Initial load
duke
parents:
diff changeset
3943 n = mm->in(idx);
a61af66fc99e Initial load
duke
parents:
diff changeset
3944 if (mem == n) return true; // might be empty_memory()
a61af66fc99e Initial load
duke
parents:
diff changeset
3945 n = (idx == Compile::AliasIdxBot)? mm->base_memory(): mm->memory_at(idx);
a61af66fc99e Initial load
duke
parents:
diff changeset
3946 if (mem == n) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3947 while (n->is_Phi() && (n = n->as_Phi()->is_copy()) != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
3948 if (mem == n) return true;
a61af66fc99e Initial load
duke
parents:
diff changeset
3949 if (n == NULL) break;
a61af66fc99e Initial load
duke
parents:
diff changeset
3950 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3951 return false;
a61af66fc99e Initial load
duke
parents:
diff changeset
3952 }
a61af66fc99e Initial load
duke
parents:
diff changeset
3953 #endif // !PRODUCT