truffle: src/share/vm/opto/parse3.cpp annotate

annotate src/share/vm/opto/parse3.cpp @ 17716:cdb71841f4bc

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	de95063c0e34
children	45467c53f178

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

Mercurial > hg > truffle

annotate src/share/vm/opto/parse3.cpp @ 17716:cdb71841f4bc