author | adlertz |
Wed, 07 Aug 2013 17:56:19 +0200 | |
changeset 19279 | 4be3c2e6663c |
parent 18956 | f8fc5dd18a1d |
child 19770 | 7cb9f982ea81 |
permissions | -rw-r--r-- |
1 | 1 |
/* |
15480
a9e84da84519
8006807: C2 crash due to out of bounds array access in Parse::do_multianewarray
drchase
parents:
14835
diff
changeset
|
2 |
* Copyright (c) 1998, 2013, 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" |
|
28 |
#include "memory/universe.inline.hpp" |
|
29 |
#include "oops/objArrayKlass.hpp" |
|
30 |
#include "opto/addnode.hpp" |
|
31 |
#include "opto/memnode.hpp" |
|
32 |
#include "opto/parse.hpp" |
|
33 |
#include "opto/rootnode.hpp" |
|
34 |
#include "opto/runtime.hpp" |
|
35 |
#include "opto/subnode.hpp" |
|
36 |
#include "runtime/deoptimization.hpp" |
|
37 |
#include "runtime/handles.inline.hpp" |
|
1 | 38 |
|
39 |
//============================================================================= |
|
40 |
// Helper methods for _get* and _put* bytecodes |
|
41 |
//============================================================================= |
|
42 |
bool Parse::static_field_ok_in_clinit(ciField *field, ciMethod *method) { |
|
43 |
// Could be the field_holder's <clinit> method, or <clinit> for a subklass. |
|
44 |
// Better to check now than to Deoptimize as soon as we execute |
|
45 |
assert( field->is_static(), "Only check if field is static"); |
|
46 |
// is_being_initialized() is too generous. It allows access to statics |
|
47 |
// by threads that are not running the <clinit> before the <clinit> finishes. |
|
48 |
// return field->holder()->is_being_initialized(); |
|
49 |
||
50 |
// The following restriction is correct but conservative. |
|
51 |
// It is also desirable to allow compilation of methods called from <clinit> |
|
52 |
// but this generated code will need to be made safe for execution by |
|
53 |
// other threads, or the transition from interpreted to compiled code would |
|
54 |
// need to be guarded. |
|
55 |
ciInstanceKlass *field_holder = field->holder(); |
|
56 |
||
57 |
bool access_OK = false; |
|
58 |
if (method->holder()->is_subclass_of(field_holder)) { |
|
59 |
if (method->is_static()) { |
|
60 |
if (method->name() == ciSymbol::class_initializer_name()) { |
|
61 |
// OK to access static fields inside initializer |
|
62 |
access_OK = true; |
|
63 |
} |
|
64 |
} else { |
|
65 |
if (method->name() == ciSymbol::object_initializer_name()) { |
|
66 |
// It's also OK to access static fields inside a constructor, |
|
67 |
// because any thread calling the constructor must first have |
|
68 |
// synchronized on the class by executing a '_new' bytecode. |
|
69 |
access_OK = true; |
|
70 |
} |
|
71 |
} |
|
72 |
} |
|
73 |
||
74 |
return access_OK; |
|
75 |
||
76 |
} |
|
77 |
||
78 |
||
79 |
void Parse::do_field_access(bool is_get, bool is_field) { |
|
80 |
bool will_link; |
|
81 |
ciField* field = iter().get_field(will_link); |
|
82 |
assert(will_link, "getfield: typeflow responsibility"); |
|
83 |
||
84 |
ciInstanceKlass* field_holder = field->holder(); |
|
85 |
||
86 |
if (is_field == field->is_static()) { |
|
87 |
// Interpreter will throw java_lang_IncompatibleClassChangeError |
|
88 |
// Check this before allowing <clinit> methods to access static fields |
|
89 |
uncommon_trap(Deoptimization::Reason_unhandled, |
|
90 |
Deoptimization::Action_none); |
|
91 |
return; |
|
92 |
} |
|
93 |
||
94 |
if (!is_field && !field_holder->is_initialized()) { |
|
95 |
if (!static_field_ok_in_clinit(field, method())) { |
|
96 |
uncommon_trap(Deoptimization::Reason_uninitialized, |
|
97 |
Deoptimization::Action_reinterpret, |
|
98 |
NULL, "!static_field_ok_in_clinit"); |
|
99 |
return; |
|
100 |
} |
|
101 |
} |
|
102 |
||
10510
ab626d1bdf53
7085404: JSR 292: VolatileCallSites should have push notification too
twisti
parents:
10265
diff
changeset
|
103 |
// 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
|
104 |
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
|
105 |
uncommon_trap(Deoptimization::Reason_unhandled, |
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
106 |
Deoptimization::Action_reinterpret, |
10510
ab626d1bdf53
7085404: JSR 292: VolatileCallSites should have push notification too
twisti
parents:
10265
diff
changeset
|
107 |
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
|
108 |
return; |
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
109 |
} |
4c869854aebd
7071653: JSR 292: call site change notification should be pushed not pulled
twisti
parents:
10028
diff
changeset
|
110 |
|
1 | 111 |
assert(field->will_link(method()->holder(), bc()), "getfield: typeflow responsibility"); |
112 |
||
113 |
// Note: We do not check for an unloaded field type here any more. |
|
114 |
||
115 |
// Generate code for the object pointer. |
|
116 |
Node* obj; |
|
117 |
if (is_field) { |
|
118 |
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
|
119 |
obj = null_check(peek(obj_depth)); |
1 | 120 |
// Compile-time detect of null-exception? |
121 |
if (stopped()) return; |
|
122 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
123 |
#ifdef ASSERT |
1 | 124 |
const TypeInstPtr *tjp = TypeInstPtr::make(TypePtr::NotNull, iter().get_declared_field_holder()); |
125 |
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
|
126 |
#endif |
1 | 127 |
|
128 |
if (is_get) { |
|
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
129 |
(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
|
130 |
do_get_xxx(obj, field, is_field); |
1 | 131 |
} else { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
132 |
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
|
133 |
(void) pop(); // pop receiver after putting |
1 | 134 |
} |
135 |
} else { |
|
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
136 |
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
|
137 |
obj = _gvn.makecon(tip); |
1 | 138 |
if (is_get) { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
139 |
do_get_xxx(obj, field, is_field); |
1 | 140 |
} else { |
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
141 |
do_put_xxx(obj, field, is_field); |
1 | 142 |
} |
143 |
} |
|
144 |
} |
|
145 |
||
146 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
147 |
void Parse::do_get_xxx(Node* obj, ciField* field, bool is_field) { |
1 | 148 |
// Does this field have a constant value? If so, just push the value. |
4567
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
149 |
if (field->is_constant()) { |
10511
22b3580bd8bb
7071709: JSR 292: switchpoint invalidation should be pushed not pulled
twisti
parents:
10510
diff
changeset
|
150 |
// final field |
4567
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
151 |
if (field->is_static()) { |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
152 |
// final static field |
17383 | 153 |
if (C->eliminate_boxing()) { |
154 |
// The pointers in the autobox arrays are always non-null. |
|
155 |
ciSymbol* klass_name = field->holder()->name(); |
|
156 |
if (field->name() == ciSymbol::cache_field_name() && |
|
157 |
field->holder()->uses_default_loader() && |
|
158 |
(klass_name == ciSymbol::java_lang_Character_CharacterCache() || |
|
159 |
klass_name == ciSymbol::java_lang_Byte_ByteCache() || |
|
160 |
klass_name == ciSymbol::java_lang_Short_ShortCache() || |
|
161 |
klass_name == ciSymbol::java_lang_Integer_IntegerCache() || |
|
162 |
klass_name == ciSymbol::java_lang_Long_LongCache())) { |
|
163 |
bool require_const = true; |
|
164 |
bool autobox_cache = true; |
|
165 |
if (push_constant(field->constant_value(), require_const, autobox_cache)) { |
|
166 |
return; |
|
167 |
} |
|
168 |
} |
|
169 |
} |
|
4567
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
170 |
if (push_constant(field->constant_value())) |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
171 |
return; |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
172 |
} |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
173 |
else { |
10511
22b3580bd8bb
7071709: JSR 292: switchpoint invalidation should be pushed not pulled
twisti
parents:
10510
diff
changeset
|
174 |
// final non-static field |
22b3580bd8bb
7071709: JSR 292: switchpoint invalidation should be pushed not pulled
twisti
parents:
10510
diff
changeset
|
175 |
// Treat final non-static fields of trusted classes (classes in |
22b3580bd8bb
7071709: JSR 292: switchpoint invalidation should be pushed not pulled
twisti
parents:
10510
diff
changeset
|
176 |
// java.lang.invoke and sun.invoke packages and subpackages) as |
22b3580bd8bb
7071709: JSR 292: switchpoint invalidation should be pushed not pulled
twisti
parents:
10510
diff
changeset
|
177 |
// compile time constants. |
4567
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
178 |
if (obj->is_Con()) { |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
179 |
const TypeOopPtr* oop_ptr = obj->bottom_type()->isa_oopptr(); |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
180 |
ciObject* constant_oop = oop_ptr->const_oop(); |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
181 |
ciConstant constant = field->constant_value_of(constant_oop); |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
182 |
if (push_constant(constant, true)) |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
183 |
return; |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
184 |
} |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
185 |
} |
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
186 |
} |
1 | 187 |
|
188 |
ciType* field_klass = field->type(); |
|
189 |
bool is_vol = field->is_volatile(); |
|
190 |
||
191 |
// Compute address and memory type. |
|
192 |
int offset = field->offset_in_bytes(); |
|
193 |
const TypePtr* adr_type = C->alias_type(field)->adr_type(); |
|
194 |
Node *adr = basic_plus_adr(obj, obj, offset); |
|
195 |
BasicType bt = field->layout_type(); |
|
196 |
||
197 |
// Build the resultant type of the load |
|
198 |
const Type *type; |
|
199 |
||
200 |
bool must_assert_null = false; |
|
201 |
||
202 |
if( bt == T_OBJECT ) { |
|
203 |
if (!field->type()->is_loaded()) { |
|
204 |
type = TypeInstPtr::BOTTOM; |
|
205 |
must_assert_null = true; |
|
4567
7fc02fbe5c7a
6893268: additional dynamic language related optimizations in C2
twisti
parents:
4470
diff
changeset
|
206 |
} else if (field->is_constant() && field->is_static()) { |
1 | 207 |
// This can happen if the constant oop is non-perm. |
208 |
ciObject* con = field->constant_value().as_object(); |
|
209 |
// Do not "join" in the previous type; it doesn't add value, |
|
210 |
// and may yield a vacuous result if the field is of interface type. |
|
211 |
type = TypeOopPtr::make_from_constant(con)->isa_oopptr(); |
|
212 |
assert(type != NULL, "field singleton type must be consistent"); |
|
213 |
} else { |
|
214 |
type = TypeOopPtr::make_from_klass(field_klass->as_klass()); |
|
215 |
} |
|
216 |
} else { |
|
217 |
type = Type::get_const_basic_type(bt); |
|
218 |
} |
|
219 |
// Build the load. |
|
220 |
Node* ld = make_load(NULL, adr, type, bt, adr_type, is_vol); |
|
221 |
||
222 |
// Adjust Java stack |
|
223 |
if (type2size[bt] == 1) |
|
224 |
push(ld); |
|
225 |
else |
|
226 |
push_pair(ld); |
|
227 |
||
228 |
if (must_assert_null) { |
|
229 |
// Do not take a trap here. It's possible that the program |
|
230 |
// will never load the field's class, and will happily see |
|
231 |
// null values in this field forever. Don't stumble into a |
|
232 |
// trap for such a program, or we might get a long series |
|
233 |
// of useless recompilations. (Or, we might load a class |
|
234 |
// which should not be loaded.) If we ever see a non-null |
|
235 |
// value, we will then trap and recompile. (The trap will |
|
236 |
// not need to mention the class index, since the class will |
|
237 |
// already have been loaded if we ever see a non-null value.) |
|
238 |
// uncommon_trap(iter().get_field_signature_index()); |
|
239 |
#ifndef PRODUCT |
|
240 |
if (PrintOpto && (Verbose || WizardMode)) { |
|
241 |
method()->print_name(); tty->print_cr(" asserting nullness of field at bci: %d", bci()); |
|
242 |
} |
|
243 |
#endif |
|
244 |
if (C->log() != NULL) { |
|
245 |
C->log()->elem("assert_null reason='field' klass='%d'", |
|
246 |
C->log()->identify(field->type())); |
|
247 |
} |
|
248 |
// If there is going to be a trap, put it at the next bytecode: |
|
249 |
set_bci(iter().next_bci()); |
|
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
250 |
null_assert(peek()); |
1 | 251 |
set_bci(iter().cur_bci()); // put it back |
252 |
} |
|
253 |
||
254 |
// If reference is volatile, prevent following memory ops from |
|
255 |
// floating up past the volatile read. Also prevents commoning |
|
256 |
// another volatile read. |
|
257 |
if (field->is_volatile()) { |
|
258 |
// Memory barrier includes bogus read of value to force load BEFORE membar |
|
259 |
insert_mem_bar(Op_MemBarAcquire, ld); |
|
260 |
} |
|
261 |
} |
|
262 |
||
8725
8c1e3dd5fe1b
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
8676
diff
changeset
|
263 |
void Parse::do_put_xxx(Node* obj, ciField* field, bool is_field) { |
1 | 264 |
bool is_vol = field->is_volatile(); |
265 |
// If reference is volatile, prevent following memory ops from |
|
266 |
// floating down past the volatile write. Also prevents commoning |
|
267 |
// another volatile read. |
|
268 |
if (is_vol) insert_mem_bar(Op_MemBarRelease); |
|
269 |
||
270 |
// Compute address and memory type. |
|
271 |
int offset = field->offset_in_bytes(); |
|
272 |
const TypePtr* adr_type = C->alias_type(field)->adr_type(); |
|
273 |
Node* adr = basic_plus_adr(obj, obj, offset); |
|
274 |
BasicType bt = field->layout_type(); |
|
275 |
// Value to be stored |
|
276 |
Node* val = type2size[bt] == 1 ? pop() : pop_pair(); |
|
277 |
// Round doubles before storing |
|
278 |
if (bt == T_DOUBLE) val = dstore_rounding(val); |
|
279 |
||
280 |
// Store the value. |
|
281 |
Node* store; |
|
282 |
if (bt == T_OBJECT) { |
|
3178 | 283 |
const TypeOopPtr* field_type; |
1 | 284 |
if (!field->type()->is_loaded()) { |
285 |
field_type = TypeInstPtr::BOTTOM; |
|
286 |
} else { |
|
287 |
field_type = TypeOopPtr::make_from_klass(field->type()->as_klass()); |
|
288 |
} |
|
289 |
store = store_oop_to_object( control(), obj, adr, adr_type, val, field_type, bt); |
|
290 |
} else { |
|
291 |
store = store_to_memory( control(), adr, val, bt, adr_type, is_vol ); |
|
292 |
} |
|
293 |
||
294 |
// If reference is volatile, prevent following volatiles ops from |
|
295 |
// floating up before the volatile write. |
|
296 |
if (is_vol) { |
|
18956
f8fc5dd18a1d
8007898: Incorrect optimization of Memory Barriers in Matcher::post_store_load_barrier()
kvn
parents:
17383
diff
changeset
|
297 |
insert_mem_bar(Op_MemBarVolatile); // Use fat membar |
1 | 298 |
} |
299 |
||
300 |
// If the field is final, the rules of Java say we are in <init> or <clinit>. |
|
301 |
// Note the presence of writes to final non-static fields, so that we |
|
302 |
// can insert a memory barrier later on to keep the writes from floating |
|
303 |
// out of the constructor. |
|
304 |
if (is_field && field->is_final()) { |
|
305 |
set_wrote_final(true); |
|
17383 | 306 |
// Preserve allocation ptr to create precedent edge to it in membar |
307 |
// generated on exit from constructor. |
|
308 |
if (C->eliminate_boxing() && |
|
309 |
adr_type->isa_oopptr() && adr_type->is_oopptr()->is_ptr_to_boxed_value() && |
|
310 |
AllocateNode::Ideal_allocation(obj, &_gvn) != NULL) { |
|
311 |
set_alloc_with_final(obj); |
|
312 |
} |
|
1 | 313 |
} |
314 |
} |
|
315 |
||
316 |
||
17383 | 317 |
bool Parse::push_constant(ciConstant constant, bool require_constant, bool is_autobox_cache) { |
1 | 318 |
switch (constant.basic_type()) { |
319 |
case T_BOOLEAN: push( intcon(constant.as_boolean()) ); break; |
|
320 |
case T_INT: push( intcon(constant.as_int()) ); break; |
|
321 |
case T_CHAR: push( intcon(constant.as_char()) ); break; |
|
322 |
case T_BYTE: push( intcon(constant.as_byte()) ); break; |
|
323 |
case T_SHORT: push( intcon(constant.as_short()) ); break; |
|
324 |
case T_FLOAT: push( makecon(TypeF::make(constant.as_float())) ); break; |
|
325 |
case T_DOUBLE: push_pair( makecon(TypeD::make(constant.as_double())) ); break; |
|
326 |
case T_LONG: push_pair( longcon(constant.as_long()) ); break; |
|
327 |
case T_ARRAY: |
|
328 |
case T_OBJECT: { |
|
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3261
diff
changeset
|
329 |
// cases: |
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3261
diff
changeset
|
330 |
// can_be_constant = (oop not scavengable || ScavengeRootsInCode != 0) |
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3261
diff
changeset
|
331 |
// should_be_constant = (oop not scavengable || ScavengeRootsInCode >= 2) |
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3261
diff
changeset
|
332 |
// An oop is not scavengable if it is in the perm gen. |
1 | 333 |
ciObject* oop_constant = constant.as_object(); |
334 |
if (oop_constant->is_null_object()) { |
|
335 |
push( zerocon(T_OBJECT) ); |
|
336 |
break; |
|
3908
24b55ad4c228
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
3261
diff
changeset
|
337 |
} else if (require_constant || oop_constant->should_be_constant()) { |
17383 | 338 |
push( makecon(TypeOopPtr::make_from_constant(oop_constant, require_constant, is_autobox_cache)) ); |
1 | 339 |
break; |
340 |
} else { |
|
341 |
// we cannot inline the oop, but we can use it later to narrow a type |
|
342 |
return false; |
|
343 |
} |
|
344 |
} |
|
345 |
case T_ILLEGAL: { |
|
346 |
// Invalid ciConstant returned due to OutOfMemoryError in the CI |
|
347 |
assert(C->env()->failing(), "otherwise should not see this"); |
|
348 |
// These always occur because of object types; we are going to |
|
349 |
// bail out anyway, so make the stack depths match up |
|
350 |
push( zerocon(T_OBJECT) ); |
|
351 |
return false; |
|
352 |
} |
|
353 |
default: |
|
354 |
ShouldNotReachHere(); |
|
355 |
return false; |
|
356 |
} |
|
357 |
||
358 |
// success |
|
359 |
return true; |
|
360 |
} |
|
361 |
||
362 |
||
363 |
||
364 |
//============================================================================= |
|
365 |
void Parse::do_anewarray() { |
|
366 |
bool will_link; |
|
367 |
ciKlass* klass = iter().get_klass(will_link); |
|
368 |
||
369 |
// Uncommon Trap when class that array contains is not loaded |
|
370 |
// we need the loaded class for the rest of graph; do not |
|
371 |
// initialize the container class (see Java spec)!!! |
|
372 |
assert(will_link, "anewarray: typeflow responsibility"); |
|
373 |
||
374 |
ciObjArrayKlass* array_klass = ciObjArrayKlass::make(klass); |
|
375 |
// Check that array_klass object is loaded |
|
376 |
if (!array_klass->is_loaded()) { |
|
377 |
// Generate uncommon_trap for unloaded array_class |
|
378 |
uncommon_trap(Deoptimization::Reason_unloaded, |
|
379 |
Deoptimization::Action_reinterpret, |
|
380 |
array_klass); |
|
381 |
return; |
|
382 |
} |
|
383 |
||
384 |
kill_dead_locals(); |
|
385 |
||
386 |
const TypeKlassPtr* array_klass_type = TypeKlassPtr::make(array_klass); |
|
387 |
Node* count_val = pop(); |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
388 |
Node* obj = new_array(makecon(array_klass_type), count_val, 1); |
1 | 389 |
push(obj); |
390 |
} |
|
391 |
||
392 |
||
393 |
void Parse::do_newarray(BasicType elem_type) { |
|
394 |
kill_dead_locals(); |
|
395 |
||
396 |
Node* count_val = pop(); |
|
397 |
const TypeKlassPtr* array_klass = TypeKlassPtr::make(ciTypeArrayKlass::make(elem_type)); |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
398 |
Node* obj = new_array(makecon(array_klass), count_val, 1); |
1 | 399 |
// Push resultant oop onto stack |
400 |
push(obj); |
|
401 |
} |
|
402 |
||
403 |
// Expand simple expressions like new int[3][5] and new Object[2][nonConLen]. |
|
404 |
// Also handle the degenerate 1-dimensional case of anewarray. |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
405 |
Node* Parse::expand_multianewarray(ciArrayKlass* array_klass, Node* *lengths, int ndimensions, int nargs) { |
1 | 406 |
Node* length = lengths[0]; |
407 |
assert(length != NULL, ""); |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
408 |
Node* array = new_array(makecon(TypeKlassPtr::make(array_klass)), length, nargs); |
1 | 409 |
if (ndimensions > 1) { |
410 |
jint length_con = find_int_con(length, -1); |
|
411 |
guarantee(length_con >= 0, "non-constant multianewarray"); |
|
412 |
ciArrayKlass* array_klass_1 = array_klass->as_obj_array_klass()->element_klass()->as_array_klass(); |
|
413 |
const TypePtr* adr_type = TypeAryPtr::OOPS; |
|
3180
c589129153a4
6856025: assert(_base >= OopPtr && _base <= KlassPtr,"Not a Java pointer")
never
parents:
3178
diff
changeset
|
414 |
const TypeOopPtr* elemtype = _gvn.type(array)->is_aryptr()->elem()->make_oopptr(); |
1 | 415 |
const intptr_t header = arrayOopDesc::base_offset_in_bytes(T_OBJECT); |
416 |
for (jint i = 0; i < length_con; i++) { |
|
2574
1d5f85c2d755
6589834: deoptimization problem with -XX:+DeoptimizeALot
cfang
parents:
670
diff
changeset
|
417 |
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
|
418 |
intptr_t offset = header + ((intptr_t)i << LogBytesPerHeapOop); |
1 | 419 |
Node* eaddr = basic_plus_adr(array, offset); |
420 |
store_oop_to_array(control(), array, eaddr, adr_type, elem, elemtype, T_OBJECT); |
|
421 |
} |
|
422 |
} |
|
423 |
return array; |
|
424 |
} |
|
425 |
||
426 |
void Parse::do_multianewarray() { |
|
427 |
int ndimensions = iter().get_dimensions(); |
|
428 |
||
429 |
// the m-dimensional array |
|
430 |
bool will_link; |
|
431 |
ciArrayKlass* array_klass = iter().get_klass(will_link)->as_array_klass(); |
|
432 |
assert(will_link, "multianewarray: typeflow responsibility"); |
|
433 |
||
434 |
// Note: Array classes are always initialized; no is_initialized check. |
|
435 |
||
436 |
kill_dead_locals(); |
|
437 |
||
438 |
// 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
|
439 |
Node** length = NEW_RESOURCE_ARRAY(Node*, ndimensions + 1); |
1 | 440 |
length[ndimensions] = NULL; // terminating null for make_runtime_call |
441 |
int j; |
|
442 |
for (j = ndimensions-1; j >= 0 ; j--) length[j] = pop(); |
|
443 |
||
444 |
// The original expression was of this form: new T[length0][length1]... |
|
445 |
// It is often the case that the lengths are small (except the last). |
|
446 |
// If that happens, use the fast 1-d creator a constant number of times. |
|
447 |
const jint expand_limit = MIN2((juint)MultiArrayExpandLimit, (juint)100); |
|
448 |
jint expand_count = 1; // count of allocations in the expansion |
|
449 |
jint expand_fanout = 1; // running total fanout |
|
450 |
for (j = 0; j < ndimensions-1; j++) { |
|
451 |
jint dim_con = find_int_con(length[j], -1); |
|
452 |
expand_fanout *= dim_con; |
|
453 |
expand_count += expand_fanout; // count the level-J sub-arrays |
|
353 | 454 |
if (dim_con <= 0 |
1 | 455 |
|| dim_con > expand_limit |
456 |
|| expand_count > expand_limit) { |
|
457 |
expand_count = 0; |
|
458 |
break; |
|
459 |
} |
|
460 |
} |
|
461 |
||
462 |
// Can use multianewarray instead of [a]newarray if only one dimension, |
|
463 |
// 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
|
464 |
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
|
465 |
Node* obj = NULL; |
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
466 |
// 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
|
467 |
// 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
|
468 |
// 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
|
469 |
// 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
|
470 |
// 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
|
471 |
{ PreserveReexecuteState preexecs(this); |
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
472 |
inc_sp(ndimensions); |
4893
fedc27b54caa
6910605: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
kvn
parents:
4567
diff
changeset
|
473 |
// 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
|
474 |
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
|
475 |
} //original reexecute and sp are set back here |
1 | 476 |
push(obj); |
477 |
return; |
|
478 |
} |
|
479 |
||
480 |
address fun = NULL; |
|
481 |
switch (ndimensions) { |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
482 |
case 1: ShouldNotReachHere(); break; |
1 | 483 |
case 2: fun = OptoRuntime::multianewarray2_Java(); break; |
484 |
case 3: fun = OptoRuntime::multianewarray3_Java(); break; |
|
485 |
case 4: fun = OptoRuntime::multianewarray4_Java(); break; |
|
486 |
case 5: fun = OptoRuntime::multianewarray5_Java(); break; |
|
487 |
}; |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
488 |
Node* c = NULL; |
1 | 489 |
|
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
490 |
if (fun != NULL) { |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
491 |
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
|
492 |
OptoRuntime::multianewarray_Type(ndimensions), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
493 |
fun, NULL, TypeRawPtr::BOTTOM, |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
494 |
makecon(TypeKlassPtr::make(array_klass)), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
495 |
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
|
496 |
(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
|
497 |
(ndimensions > 3) ? length[4] : NULL); |
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
498 |
} else { |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
499 |
// Create a java array for dimension sizes |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
500 |
Node* dims = NULL; |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
501 |
{ PreserveReexecuteState preexecs(this); |
14621
fd9265ab0f67
7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents:
13963
diff
changeset
|
502 |
inc_sp(ndimensions); |
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
503 |
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
|
504 |
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
|
505 |
|
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
506 |
// Fill-in it with values |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
507 |
for (j = 0; j < ndimensions; j++) { |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
508 |
Node *dims_elem = array_element_address(dims, intcon(j), T_INT); |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
509 |
store_to_memory(control(), dims_elem, length[j], T_INT, TypeAryPtr::INTS); |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
510 |
} |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
511 |
} |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
512 |
|
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
513 |
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
|
514 |
OptoRuntime::multianewarrayN_Type(), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
515 |
OptoRuntime::multianewarrayN_Java(), NULL, TypeRawPtr::BOTTOM, |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
516 |
makecon(TypeKlassPtr::make(array_klass)), |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
517 |
dims); |
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
518 |
} |
14835
70896cb93c35
8004741: Missing compiled exception handle table entry for multidimensional array allocation
kvn
parents:
14621
diff
changeset
|
519 |
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
|
520 |
|
13895
f6dfe4123709
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
10511
diff
changeset
|
521 |
Node* res = _gvn.transform(new (C) ProjNode(c, TypeFunc::Parms)); |
1 | 522 |
|
523 |
const Type* type = TypeOopPtr::make_from_klass_raw(array_klass); |
|
524 |
||
525 |
// Improve the type: We know it's not null, exact, and of a given length. |
|
526 |
type = type->is_ptr()->cast_to_ptr_type(TypePtr::NotNull); |
|
527 |
type = type->is_aryptr()->cast_to_exactness(true); |
|
528 |
||
529 |
const TypeInt* ltype = _gvn.find_int_type(length[0]); |
|
530 |
if (ltype != NULL) |
|
531 |
type = type->is_aryptr()->cast_to_size(ltype); |
|
532 |
||
10028
035159a868a1
7058510: multinewarray with 6 dimensions uncommon traps in server compiler
iveresov
parents:
8725
diff
changeset
|
533 |
// We cannot sharpen the nested sub-arrays, since the top level is mutable. |
1 | 534 |
|
13895
f6dfe4123709
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
10511
diff
changeset
|
535 |
Node* cast = _gvn.transform( new (C) CheckCastPPNode(control(), res, type) ); |
1 | 536 |
push(cast); |
537 |
||
538 |
// Possible improvements: |
|
539 |
// - Make a fast path for small multi-arrays. (W/ implicit init. loops.) |
|
540 |
// - Issue CastII against length[*] values, to TypeInt::POS. |
|
541 |
} |