author | eosterlund |
Fri, 18 May 2018 14:51:06 +0200 | |
changeset 50180 | ffa644980dff |
parent 49359 | 59f6547e151f |
child 50728 | 9375184cec98 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
49359
59f6547e151f
8199264: Remove universe.inline.hpp to simplify include dependencies
stefank
parents:
47765
diff
changeset
|
2 |
* Copyright (c) 1998, 2018, Oracle and/or its affiliates. All rights reserved. |
1 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4893
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4893
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
4893
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "compiler/compileLog.hpp" |
|
27 |
#include "interpreter/linkResolver.hpp" |
|
49359
59f6547e151f
8199264: Remove universe.inline.hpp to simplify include dependencies
stefank
parents:
47765
diff
changeset
|
28 |
#include "memory/universe.hpp" |
7397 | 29 |
#include "oops/objArrayKlass.hpp" |
30 |
#include "opto/addnode.hpp" |
|
23528 | 31 |
#include "opto/castnode.hpp" |
7397 | 32 |
#include "opto/memnode.hpp" |
33 |
#include "opto/parse.hpp" |
|
34 |
#include "opto/rootnode.hpp" |
|
35 |
#include "opto/runtime.hpp" |
|
36 |
#include "opto/subnode.hpp" |
|
37 |
#include "runtime/deoptimization.hpp" |
|
38 |
#include "runtime/handles.inline.hpp" |
|
1 | 39 |
|
40 |
//============================================================================= |
|
41 |
// Helper methods for _get* and _put* bytecodes |
|
42 |
//============================================================================= |
|
43 |
bool Parse::static_field_ok_in_clinit(ciField *field, ciMethod *method) { |
|
44 |
// Could be the field_holder's <clinit> method, or <clinit> for a subklass. |
|
45 |
// Better to check now than to Deoptimize as soon as we execute |
|
46 |
assert( field->is_static(), "Only check if field is static"); |
|
47 |
// is_being_initialized() is too generous. It allows access to statics |
|
48 |
// by threads that are not running the <clinit> before the <clinit> finishes. |
|
49 |
// return field->holder()->is_being_initialized(); |
|
50 |
||
51 |
// The following restriction is correct but conservative. |
|
52 |
// It is also desirable to allow compilation of methods called from <clinit> |
|
53 |
// but this generated code will need to be made safe for execution by |
|
54 |
// other threads, or the transition from interpreted to compiled code would |
|
55 |
// need to be guarded. |
|
56 |
ciInstanceKlass *field_holder = field->holder(); |
|
57 |
||
58 |
bool access_OK = false; |
|
59 |
if (method->holder()->is_subclass_of(field_holder)) { |
|
60 |
if (method->is_static()) { |
|
61 |
if (method->name() == ciSymbol::class_initializer_name()) { |
|
62 |
// OK to access static fields inside initializer |
|
63 |
access_OK = true; |
|
64 |
} |
|
65 |
} else { |
|
66 |
if (method->name() == ciSymbol::object_initializer_name()) { |
|
67 |
// It's also OK to access static fields inside a constructor, |
|
68 |
// because any thread calling the constructor must first have |
|
69 |
// synchronized on the class by executing a '_new' bytecode. |
|
70 |
access_OK = true; |
|
71 |
} |
|
72 |
} |
|
73 |
} |
|
74 |
||
75 |
return access_OK; |
|
76 |
||
77 |
} |
|
78 |
||
79 |
||
80 |
void Parse::do_field_access(bool is_get, bool is_field) { |
|
81 |
bool will_link; |
|
82 |
ciField* field = iter().get_field(will_link); |
|
83 |
assert(will_link, "getfield: typeflow responsibility"); |
|
84 |
||
85 |
ciInstanceKlass* field_holder = field->holder(); |
|
86 |
||
87 |
if (is_field == field->is_static()) { |
|
88 |
// Interpreter will throw java_lang_IncompatibleClassChangeError |
|
89 |
// Check this before allowing <clinit> methods to access static fields |
|
90 |
uncommon_trap(Deoptimization::Reason_unhandled, |
|
91 |
Deoptimization::Action_none); |
|
92 |
return; |
|
93 |
} |
|
94 |
||
95 |
if (!is_field && !field_holder->is_initialized()) { |
|
96 |
if (!static_field_ok_in_clinit(field, method())) { |
|
97 |
uncommon_trap(Deoptimization::Reason_uninitialized, |
|
98 |
Deoptimization::Action_reinterpret, |
|
99 |
NULL, "!static_field_ok_in_clinit"); |
|
100 |
return; |
|
101 |
} |
|
102 |
} |
|
103 |
||
10510
ab626d1bdf53
7085404: JSR 292: VolatileCallSites should have push notification too
twisti
parents:
10265
diff
changeset
|
104 |
// Deoptimize on putfield writes to call site target field. |
10265
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
105 |
if (!is_get && field->is_call_site_target()) { |
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
106 |
uncommon_trap(Deoptimization::Reason_unhandled, |
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
107 |
Deoptimization::Action_reinterpret, |
10510
ab626d1bdf53
7085404: JSR 292: VolatileCallSites should have push notification too
twisti
parents:
10265
diff
changeset
|
108 |
NULL, "put to call site target field"); |
10265
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
109 |
return; |
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
110 |
} |
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
111 |
|
39421
a9652c919db8
8157181: Compilers accept modification of final fields outside initializer methods
zmajo
parents:
38030
diff
changeset
|
112 |
assert(field->will_link(method(), bc()), "getfield: typeflow responsibility"); |
1 | 113 |
|
114 |
// Note: We do not check for an unloaded field type here any more. |
|
115 |
||
116 |
// Generate code for the object pointer. |
|
117 |
Node* obj; |
|
118 |
if (is_field) { |
|
119 |
int obj_depth = is_get ? 0 : field->type()->size(); |
|
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
120 |
obj = null_check(peek(obj_depth)); |
1 | 121 |
// Compile-time detect of null-exception? |
122 |
if (stopped()) return; |
|
123 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
124 |
#ifdef ASSERT |
1 | 125 |
const TypeInstPtr *tjp = TypeInstPtr::make(TypePtr::NotNull, iter().get_declared_field_holder()); |
126 |
assert(_gvn.type(obj)->higher_equal(tjp), "cast_up is no longer needed"); |
|
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
127 |
#endif |
1 | 128 |
|
129 |
if (is_get) { |
|
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
130 |
(void) pop(); // pop receiver before getting |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
131 |
do_get_xxx(obj, field, is_field); |
1 | 132 |
} else { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
133 |
do_put_xxx(obj, field, is_field); |
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
134 |
(void) pop(); // pop receiver after putting |
1 | 135 |
} |
136 |
} else { |
|
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
137 |
const TypeInstPtr* tip = TypeInstPtr::make(field_holder->java_mirror()); |
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
138 |
obj = _gvn.makecon(tip); |
1 | 139 |
if (is_get) { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
140 |
do_get_xxx(obj, field, is_field); |
1 | 141 |
} else { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
142 |
do_put_xxx(obj, field, is_field); |
1 | 143 |
} |
144 |
} |
|
145 |
} |
|
146 |
||
147 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
148 |
void Parse::do_get_xxx(Node* obj, ciField* field, bool is_field) { |
44996
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
149 |
BasicType bt = field->layout_type(); |
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
150 |
|
1 | 151 |
// Does this field have a constant value? If so, just push the value. |
44996
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
152 |
if (field->is_constant() && |
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
153 |
// Keep consistent with types found by ciTypeFlow: for an |
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
154 |
// unloaded field type, ciTypeFlow::StateVector::do_getstatic() |
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
155 |
// speculates the field is null. The code in the rest of this |
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
156 |
// method does the same. We must not bypass it and use a non |
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
157 |
// null constant here. |
072847273bae
8179070: nashorn+octane's box2d causes c2 to crash with "Bad graph detected in compute_lca_of_uses"
roland
parents:
39421
diff
changeset
|
158 |
(bt != T_OBJECT || field->type()->is_loaded())) { |
19770
7cb9f982ea81
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
18956
diff
changeset
|
159 |
// final or stable field |
38030
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
160 |
Node* con = make_constant_from_field(field, obj); |
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
161 |
if (con != NULL) { |
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
162 |
push_node(field->layout_type(), con); |
31857
adbf29d9ca43
8078629: VM should constant fold Unsafe.get*() loads from final fields
vlivanov
parents:
31035
diff
changeset
|
163 |
return; |
4567
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
164 |
} |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
165 |
} |
1 | 166 |
|
167 |
ciType* field_klass = field->type(); |
|
168 |
bool is_vol = field->is_volatile(); |
|
169 |
||
170 |
// Compute address and memory type. |
|
171 |
int offset = field->offset_in_bytes(); |
|
172 |
const TypePtr* adr_type = C->alias_type(field)->adr_type(); |
|
173 |
Node *adr = basic_plus_adr(obj, obj, offset); |
|
174 |
||
175 |
// Build the resultant type of the load |
|
176 |
const Type *type; |
|
177 |
||
178 |
bool must_assert_null = false; |
|
179 |
||
50180 | 180 |
DecoratorSet decorators = IN_HEAP; |
181 |
decorators |= is_vol ? MO_SEQ_CST : MO_UNORDERED; |
|
182 |
||
183 |
bool is_obj = bt == T_OBJECT || bt == T_ARRAY; |
|
184 |
||
185 |
if (is_obj) { |
|
1 | 186 |
if (!field->type()->is_loaded()) { |
187 |
type = TypeInstPtr::BOTTOM; |
|
188 |
must_assert_null = true; |
|
38030
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
189 |
} else if (field->is_static_constant()) { |
1 | 190 |
// This can happen if the constant oop is non-perm. |
191 |
ciObject* con = field->constant_value().as_object(); |
|
192 |
// Do not "join" in the previous type; it doesn't add value, |
|
193 |
// and may yield a vacuous result if the field is of interface type. |
|
38030
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
194 |
if (con->is_null_object()) { |
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
195 |
type = TypePtr::NULL_PTR; |
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
196 |
} else { |
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
197 |
type = TypeOopPtr::make_from_constant(con)->isa_oopptr(); |
93f24e7b3c43
8152590: C2: @Stable support doesn't always work w/ incremental inlining
vlivanov
parents:
34183
diff
changeset
|
198 |
} |
1 | 199 |
assert(type != NULL, "field singleton type must be consistent"); |
200 |
} else { |
|
201 |
type = TypeOopPtr::make_from_klass(field_klass->as_klass()); |
|
202 |
} |
|
203 |
} else { |
|
204 |
type = Type::get_const_basic_type(bt); |
|
205 |
} |
|
50180 | 206 |
|
207 |
Node* ld = access_load_at(obj, adr, adr_type, type, bt, decorators); |
|
1 | 208 |
|
209 |
// Adjust Java stack |
|
210 |
if (type2size[bt] == 1) |
|
211 |
push(ld); |
|
212 |
else |
|
213 |
push_pair(ld); |
|
214 |
||
215 |
if (must_assert_null) { |
|
216 |
// Do not take a trap here. It's possible that the program |
|
217 |
// will never load the field's class, and will happily see |
|
218 |
// null values in this field forever. Don't stumble into a |
|
219 |
// trap for such a program, or we might get a long series |
|
220 |
// of useless recompilations. (Or, we might load a class |
|
221 |
// which should not be loaded.) If we ever see a non-null |
|
222 |
// value, we will then trap and recompile. (The trap will |
|
223 |
// not need to mention the class index, since the class will |
|
224 |
// already have been loaded if we ever see a non-null value.) |
|
225 |
// uncommon_trap(iter().get_field_signature_index()); |
|
226 |
if (PrintOpto && (Verbose || WizardMode)) { |
|
227 |
method()->print_name(); tty->print_cr(" asserting nullness of field at bci: %d", bci()); |
|
228 |
} |
|
229 |
if (C->log() != NULL) { |
|
230 |
C->log()->elem("assert_null reason='field' klass='%d'", |
|
231 |
C->log()->identify(field->type())); |
|
232 |
} |
|
233 |
// If there is going to be a trap, put it at the next bytecode: |
|
234 |
set_bci(iter().next_bci()); |
|
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
235 |
null_assert(peek()); |
1 | 236 |
set_bci(iter().cur_bci()); // put it back |
237 |
} |
|
238 |
} |
|
239 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
240 |
void Parse::do_put_xxx(Node* obj, ciField* field, bool is_field) { |
1 | 241 |
bool is_vol = field->is_volatile(); |
242 |
||
243 |
// Compute address and memory type. |
|
244 |
int offset = field->offset_in_bytes(); |
|
245 |
const TypePtr* adr_type = C->alias_type(field)->adr_type(); |
|
246 |
Node* adr = basic_plus_adr(obj, obj, offset); |
|
247 |
BasicType bt = field->layout_type(); |
|
248 |
// Value to be stored |
|
249 |
Node* val = type2size[bt] == 1 ? pop() : pop_pair(); |
|
250 |
||
50180 | 251 |
DecoratorSet decorators = IN_HEAP; |
252 |
decorators |= is_vol ? MO_SEQ_CST : MO_UNORDERED; |
|
253 |
||
254 |
bool is_obj = bt == T_OBJECT || bt == T_ARRAY; |
|
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
19770
diff
changeset
|
255 |
|
1 | 256 |
// Store the value. |
50180 | 257 |
const Type* field_type; |
258 |
if (!field->type()->is_loaded()) { |
|
259 |
field_type = TypeInstPtr::BOTTOM; |
|
1 | 260 |
} else { |
50180 | 261 |
if (is_obj) { |
262 |
field_type = TypeOopPtr::make_from_klass(field->type()->as_klass()); |
|
263 |
} else { |
|
264 |
field_type = Type::BOTTOM; |
|
265 |
} |
|
1 | 266 |
} |
50180 | 267 |
access_store_at(control(), obj, adr, adr_type, val, field_type, bt, decorators); |
1 | 268 |
|
50180 | 269 |
if (is_field) { |
22868
7f6eb436873b
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
22845
diff
changeset
|
270 |
// Remember we wrote a volatile field. |
7f6eb436873b
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
22845
diff
changeset
|
271 |
// For not multiple copy atomic cpu (ppc64) a barrier should be issued |
7f6eb436873b
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
22845
diff
changeset
|
272 |
// in constructors which have such stores. See do_exits() in parse1.cpp. |
50180 | 273 |
if (is_vol) { |
22868
7f6eb436873b
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
22845
diff
changeset
|
274 |
set_wrote_volatile(true); |
7f6eb436873b
8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents:
22845
diff
changeset
|
275 |
} |
23190
e8bbf9cd711e
8031818: Experimental VM flag for enforcing safe object construction
shade
parents:
23189
diff
changeset
|
276 |
set_wrote_fields(true); |
e8bbf9cd711e
8031818: Experimental VM flag for enforcing safe object construction
shade
parents:
23189
diff
changeset
|
277 |
|
50180 | 278 |
// If the field is final, the rules of Java say we are in <init> or <clinit>. |
279 |
// Note the presence of writes to final non-static fields, so that we |
|
280 |
// can insert a memory barrier later on to keep the writes from floating |
|
281 |
// out of the constructor. |
|
282 |
// Any method can write a @Stable field; insert memory barriers after those also. |
|
23190
e8bbf9cd711e
8031818: Experimental VM flag for enforcing safe object construction
shade
parents:
23189
diff
changeset
|
283 |
if (field->is_final()) { |
50180 | 284 |
set_wrote_final(true); |
285 |
if (AllocateNode::Ideal_allocation(obj, &_gvn) != NULL) { |
|
286 |
// Preserve allocation ptr to create precedent edge to it in membar |
|
287 |
// generated on exit from constructor. |
|
288 |
// Can't bind stable with its allocation, only record allocation for final field. |
|
289 |
set_alloc_with_final(obj); |
|
290 |
} |
|
23190
e8bbf9cd711e
8031818: Experimental VM flag for enforcing safe object construction
shade
parents:
23189
diff
changeset
|
291 |
} |
e8bbf9cd711e
8031818: Experimental VM flag for enforcing safe object construction
shade
parents:
23189
diff
changeset
|
292 |
if (field->is_stable()) { |
50180 | 293 |
set_wrote_stable(true); |
17383 | 294 |
} |
1 | 295 |
} |
296 |
} |
|
297 |
||
298 |
//============================================================================= |
|
299 |
void Parse::do_anewarray() { |
|
300 |
bool will_link; |
|
301 |
ciKlass* klass = iter().get_klass(will_link); |
|
302 |
||
303 |
// Uncommon Trap when class that array contains is not loaded |
|
304 |
// we need the loaded class for the rest of graph; do not |
|
305 |
// initialize the container class (see Java spec)!!! |
|
306 |
assert(will_link, "anewarray: typeflow responsibility"); |
|
307 |
||
308 |
ciObjArrayKlass* array_klass = ciObjArrayKlass::make(klass); |
|
309 |
// Check that array_klass object is loaded |
|
310 |
if (!array_klass->is_loaded()) { |
|
311 |
// Generate uncommon_trap for unloaded array_class |
|
312 |
uncommon_trap(Deoptimization::Reason_unloaded, |
|
313 |
Deoptimization::Action_reinterpret, |
|
314 |
array_klass); |
|
315 |
return; |
|
316 |
} |
|
317 |
||
318 |
kill_dead_locals(); |
|
319 |
||
320 |
const TypeKlassPtr* array_klass_type = TypeKlassPtr::make(array_klass); |
|
321 |
Node* count_val = pop(); |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
322 |
Node* obj = new_array(makecon(array_klass_type), count_val, 1); |
1 | 323 |
push(obj); |
324 |
} |
|
325 |
||
326 |
||
327 |
void Parse::do_newarray(BasicType elem_type) { |
|
328 |
kill_dead_locals(); |
|
329 |
||
330 |
Node* count_val = pop(); |
|
331 |
const TypeKlassPtr* array_klass = TypeKlassPtr::make(ciTypeArrayKlass::make(elem_type)); |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
332 |
Node* obj = new_array(makecon(array_klass), count_val, 1); |
1 | 333 |
// Push resultant oop onto stack |
334 |
push(obj); |
|
335 |
} |
|
336 |
||
337 |
// Expand simple expressions like new int[3][5] and new Object[2][nonConLen]. |
|
338 |
// Also handle the degenerate 1-dimensional case of anewarray. |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
339 |
Node* Parse::expand_multianewarray(ciArrayKlass* array_klass, Node* *lengths, int ndimensions, int nargs) { |
1 | 340 |
Node* length = lengths[0]; |
341 |
assert(length != NULL, ""); |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
342 |
Node* array = new_array(makecon(TypeKlassPtr::make(array_klass)), length, nargs); |
1 | 343 |
if (ndimensions > 1) { |
344 |
jint length_con = find_int_con(length, -1); |
|
345 |
guarantee(length_con >= 0, "non-constant multianewarray"); |
|
346 |
ciArrayKlass* array_klass_1 = array_klass->as_obj_array_klass()->element_klass()->as_array_klass(); |
|
347 |
const TypePtr* adr_type = TypeAryPtr::OOPS; |
|
3180
c589129153a4
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
3178
diff
changeset
|
348 |
const TypeOopPtr* elemtype = _gvn.type(array)->is_aryptr()->elem()->make_oopptr(); |
1 | 349 |
const intptr_t header = arrayOopDesc::base_offset_in_bytes(T_OBJECT); |
350 |
for (jint i = 0; i < length_con; i++) { |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
351 |
Node* elem = expand_multianewarray(array_klass_1, &lengths[1], ndimensions-1, nargs); |
360
21d113ecbf6a
6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents:
353
diff
changeset
|
352 |
intptr_t offset = header + ((intptr_t)i << LogBytesPerHeapOop); |
1 | 353 |
Node* eaddr = basic_plus_adr(array, offset); |
50180 | 354 |
access_store_at(control(), array, eaddr, adr_type, elem, elemtype, T_OBJECT, IN_HEAP | IN_HEAP_ARRAY); |
1 | 355 |
} |
356 |
} |
|
357 |
return array; |
|
358 |
} |
|
359 |
||
360 |
void Parse::do_multianewarray() { |
|
361 |
int ndimensions = iter().get_dimensions(); |
|
362 |
||
363 |
// the m-dimensional array |
|
364 |
bool will_link; |
|
365 |
ciArrayKlass* array_klass = iter().get_klass(will_link)->as_array_klass(); |
|
366 |
assert(will_link, "multianewarray: typeflow responsibility"); |
|
367 |
||
368 |
// Note: Array classes are always initialized; no is_initialized check. |
|
369 |
||
370 |
kill_dead_locals(); |
|
371 |
||
372 |
// get the lengths from the stack (first dimension is on top) |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
373 |
Node** length = NEW_RESOURCE_ARRAY(Node*, ndimensions + 1); |
1 | 374 |
length[ndimensions] = NULL; // terminating null for make_runtime_call |
375 |
int j; |
|
376 |
for (j = ndimensions-1; j >= 0 ; j--) length[j] = pop(); |
|
377 |
||
378 |
// The original expression was of this form: new T[length0][length1]... |
|
379 |
// It is often the case that the lengths are small (except the last). |
|
380 |
// If that happens, use the fast 1-d creator a constant number of times. |
|
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
381 |
const int expand_limit = MIN2((int)MultiArrayExpandLimit, 100); |
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
382 |
int expand_count = 1; // count of allocations in the expansion |
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
383 |
int expand_fanout = 1; // running total fanout |
1 | 384 |
for (j = 0; j < ndimensions-1; j++) { |
47765
b7c7428eaab9
8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents:
47216
diff
changeset
|
385 |
int dim_con = find_int_con(length[j], -1); |
1 | 386 |
expand_fanout *= dim_con; |
387 |
expand_count += expand_fanout; // count the level-J sub-arrays |
|
353 | 388 |
if (dim_con <= 0 |
1 | 389 |
|| dim_con > expand_limit |
390 |
|| expand_count > expand_limit) { |
|
391 |
expand_count = 0; |
|
392 |
break; |
|
393 |
} |
|
394 |
} |
|
395 |
||
396 |
// Can use multianewarray instead of [a]newarray if only one dimension, |
|
397 |
// or if all non-final dimensions are small constants. |
|
4893
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
398 |
if (ndimensions == 1 || (1 <= expand_count && expand_count <= expand_limit)) { |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
399 |
Node* obj = NULL; |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
400 |
// Set the original stack and the reexecute bit for the interpreter |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
401 |
// to reexecute the multianewarray bytecode if deoptimization happens. |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
402 |
// Do it unconditionally even for one dimension multianewarray. |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
403 |
// Note: the reexecute bit will be set in GraphKit::add_safepoint_edges() |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
404 |
// when AllocateArray node for newarray is created. |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
405 |
{ PreserveReexecuteState preexecs(this); |
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
406 |
inc_sp(ndimensions); |
4893
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
407 |
// Pass 0 as nargs since uncommon trap code does not need to restore stack. |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
408 |
obj = expand_multianewarray(array_klass, &length[0], ndimensions, 0); |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
409 |
} //original reexecute and sp are set back here |
1 | 410 |
push(obj); |
411 |
return; |
|
412 |
} |
|
413 |
||
414 |
address fun = NULL; |
|
415 |
switch (ndimensions) { |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
416 |
case 1: ShouldNotReachHere(); break; |
1 | 417 |
case 2: fun = OptoRuntime::multianewarray2_Java(); break; |
418 |
case 3: fun = OptoRuntime::multianewarray3_Java(); break; |
|
419 |
case 4: fun = OptoRuntime::multianewarray4_Java(); break; |
|
420 |
case 5: fun = OptoRuntime::multianewarray5_Java(); break; |
|
421 |
}; |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
422 |
Node* c = NULL; |
1 | 423 |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
424 |
if (fun != NULL) { |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
425 |
c = make_runtime_call(RC_NO_LEAF | RC_NO_IO, |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
426 |
OptoRuntime::multianewarray_Type(ndimensions), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
427 |
fun, NULL, TypeRawPtr::BOTTOM, |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
428 |
makecon(TypeKlassPtr::make(array_klass)), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
429 |
length[0], length[1], length[2], |
15480
a9e84da84519
8006807: C2 crash due to out of bounds array access in Parse::do_multianewarray
drchase
parents:
14835
diff
changeset
|
430 |
(ndimensions > 2) ? length[3] : NULL, |
a9e84da84519
8006807: C2 crash due to out of bounds array access in Parse::do_multianewarray
drchase
parents:
14835
diff
changeset
|
431 |
(ndimensions > 3) ? length[4] : NULL); |
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
432 |
} else { |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
433 |
// Create a java array for dimension sizes |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
434 |
Node* dims = NULL; |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
435 |
{ PreserveReexecuteState preexecs(this); |
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
436 |
inc_sp(ndimensions); |
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
437 |
Node* dims_array_klass = makecon(TypeKlassPtr::make(ciArrayKlass::make(ciType::make(T_INT)))); |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
438 |
dims = new_array(dims_array_klass, intcon(ndimensions), 0); |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
439 |
|
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
440 |
// Fill-in it with values |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
441 |
for (j = 0; j < ndimensions; j++) { |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
442 |
Node *dims_elem = array_element_address(dims, intcon(j), T_INT); |
22845
d8812d0ff387
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering
goetz
parents:
19770
diff
changeset
|
443 |
store_to_memory(control(), dims_elem, length[j], T_INT, TypeAryPtr::INTS, MemNode::unordered); |
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
444 |
} |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
445 |
} |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
446 |
|
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
447 |
c = make_runtime_call(RC_NO_LEAF | RC_NO_IO, |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
448 |
OptoRuntime::multianewarrayN_Type(), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
449 |
OptoRuntime::multianewarrayN_Java(), NULL, TypeRawPtr::BOTTOM, |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
450 |
makecon(TypeKlassPtr::make(array_klass)), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
451 |
dims); |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
452 |
} |
14835
70896cb93c35
8004741: Missing compiled exception handle table entry for multidimensional array allocation
kvn
parents:
14621
diff
changeset
|
453 |
make_slow_call_ex(c, env()->Throwable_klass(), false); |
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
454 |
|
24923
9631f7d691dc
8034812: remove IDX_INIT macro hack in Node class
thartmann
parents:
23528
diff
changeset
|
455 |
Node* res = _gvn.transform(new ProjNode(c, TypeFunc::Parms)); |
1 | 456 |
|
457 |
const Type* type = TypeOopPtr::make_from_klass_raw(array_klass); |
|
458 |
||
459 |
// Improve the type: We know it's not null, exact, and of a given length. |
|
460 |
type = type->is_ptr()->cast_to_ptr_type(TypePtr::NotNull); |
|
461 |
type = type->is_aryptr()->cast_to_exactness(true); |
|
462 |
||
463 |
const TypeInt* ltype = _gvn.find_int_type(length[0]); |
|
464 |
if (ltype != NULL) |
|
465 |
type = type->is_aryptr()->cast_to_size(ltype); |
|
466 |
||
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
467 |
// We cannot sharpen the nested sub-arrays, since the top level is mutable. |
1 | 468 |
|
24923
9631f7d691dc
8034812: remove IDX_INIT macro hack in Node class
thartmann
parents:
23528
diff
changeset
|
469 |
Node* cast = _gvn.transform( new CheckCastPPNode(control(), res, type) ); |
1 | 470 |
push(cast); |
471 |
||
472 |
// Possible improvements: |
|
473 |
// - Make a fast path for small multi-arrays. (W/ implicit init. loops.) |
|
474 |
// - Issue CastII against length[*] values, to TypeInt::POS. |
|
475 |
} |