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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "ci/ciSymbols.hpp"
27 #include "compiler/compileLog.hpp"
28 #include "oops/objArrayKlass.hpp"
29 #include "opto/addnode.hpp"
30 #include "opto/memnode.hpp"
31 #include "opto/mulnode.hpp"
32 #include "opto/parse.hpp"
33 #include "opto/rootnode.hpp"
34 #include "opto/runtime.hpp"
35 #include "runtime/sharedRuntime.hpp"
36
37 //------------------------------make_dtrace_method_entry_exit ----------------
38 // Dtrace -- record entry or exit of a method if compiled with dtrace support
39 void GraphKit::make_dtrace_method_entry_exit(ciMethod* method, bool is_entry) {
40 const TypeFunc *call_type = OptoRuntime::dtrace_method_entry_exit_Type();
41 address call_address = is_entry ? CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry) :
42 CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit);
43 const char *call_name = is_entry ? "dtrace_method_entry" : "dtrace_method_exit";
44
45 // Get base of thread-local storage area
46 Node* thread = _gvn.transform( new ThreadLocalNode() );
47
48 // Get method
49 const TypePtr* method_type = TypeMetadataPtr::make(method);
50 Node *method_node = _gvn.transform(ConNode::make(method_type));
51
52 kill_dead_locals();
53
54 // For some reason, this call reads only raw memory.
55 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
56 make_runtime_call(RC_LEAF | RC_NARROW_MEM,
57 call_type, call_address,
58 call_name, raw_adr_type,
59 thread, method_node);
60 }
61
62
63 //=============================================================================
64 //------------------------------do_checkcast-----------------------------------
65 void Parse::do_checkcast() {
66 bool will_link;
67 ciKlass* klass = iter().get_klass(will_link);
68
69 Node *obj = peek();
70
71 // Throw uncommon trap if class is not loaded or the value we are casting
72 // _from_ is not loaded, and value is not null. If the value _is_ null,
73 // then the checkcast does nothing.
74 const TypeOopPtr *tp = _gvn.type(obj)->isa_oopptr();
75 if (!will_link || (tp && !tp->is_loaded())) {
76 if (C->log() != nullptr) {
77 if (!will_link) {
78 C->log()->elem("assert_null reason='checkcast' klass='%d'",
79 C->log()->identify(klass));
80 }
81 if (tp && !tp->is_loaded()) {
82 // %%% Cannot happen?
83 ciKlass* klass = tp->unloaded_klass();
84 C->log()->elem("assert_null reason='checkcast source' klass='%d'",
85 C->log()->identify(klass));
86 }
87 }
88 null_assert(obj);
121 assert( stopped() || _gvn.type(peek())->higher_equal(TypePtr::NULL_PTR), "what's left behind is null" );
122 if (!stopped()) {
123 // The object is now known to be null.
124 // Shortcut the effect of gen_instanceof and return "false" directly.
125 pop(); // pop the null
126 push(_gvn.intcon(0)); // push false answer
127 }
128 return;
129 }
130
131 // Push the bool result back on stack
132 Node* res = gen_instanceof(peek(), makecon(TypeKlassPtr::make(klass, Type::trust_interfaces)), true);
133
134 // Pop from stack AFTER gen_instanceof because it can uncommon trap.
135 pop();
136 push(res);
137 }
138
139 //------------------------------array_store_check------------------------------
140 // pull array from stack and check that the store is valid
141 void Parse::array_store_check() {
142
143 // Shorthand access to array store elements without popping them.
144 Node *obj = peek(0);
145 Node *idx = peek(1);
146 Node *ary = peek(2);
147
148 if (_gvn.type(obj) == TypePtr::NULL_PTR) {
149 // There's never a type check on null values.
150 // This cutout lets us avoid the uncommon_trap(Reason_array_check)
151 // below, which turns into a performance liability if the
152 // gen_checkcast folds up completely.
153 return;
154 }
155
156 // Extract the array klass type
157 int klass_offset = oopDesc::klass_offset_in_bytes();
158 Node* p = basic_plus_adr( ary, ary, klass_offset );
159 // p's type is array-of-OOPS plus klass_offset
160 Node* array_klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS));
161 // Get the array klass
162 const TypeKlassPtr *tak = _gvn.type(array_klass)->is_klassptr();
163
164 // The type of array_klass is usually INexact array-of-oop. Heroically
165 // cast array_klass to EXACT array and uncommon-trap if the cast fails.
166 // Make constant out of the inexact array klass, but use it only if the cast
167 // succeeds.
168 bool always_see_exact_class = false;
169 if (MonomorphicArrayCheck
170 && !too_many_traps(Deoptimization::Reason_array_check)
171 && !tak->klass_is_exact()
172 && tak != TypeInstKlassPtr::OBJECT) {
173 // Regarding the fourth condition in the if-statement from above:
174 //
175 // If the compiler has determined that the type of array 'ary' (represented
176 // by 'array_klass') is java/lang/Object, the compiler must not assume that
177 // the array 'ary' is monomorphic.
178 //
179 // If 'ary' were of type java/lang/Object, this arraystore would have to fail,
180 // because it is not possible to perform a arraystore into an object that is not
181 // a "proper" array.
182 //
183 // Therefore, let's obtain at runtime the type of 'ary' and check if we can still
184 // successfully perform the store.
185 //
186 // The implementation reasons for the condition are the following:
187 //
188 // java/lang/Object is the superclass of all arrays, but it is represented by the VM
189 // as an InstanceKlass. The checks generated by gen_checkcast() (see below) expect
190 // 'array_klass' to be ObjArrayKlass, which can result in invalid memory accesses.
191 //
192 // See issue JDK-8057622 for details.
193
194 always_see_exact_class = true;
195 // (If no MDO at all, hope for the best, until a trap actually occurs.)
196
197 // Make a constant out of the inexact array klass
198 const TypeKlassPtr *extak = tak->cast_to_exactness(true);
199
200 if (extak->exact_klass(true) != nullptr) {
201 Node* con = makecon(extak);
202 Node* cmp = _gvn.transform(new CmpPNode( array_klass, con ));
203 Node* bol = _gvn.transform(new BoolNode( cmp, BoolTest::eq ));
204 Node* ctrl= control();
205 { BuildCutout unless(this, bol, PROB_MAX);
206 uncommon_trap(Deoptimization::Reason_array_check,
207 Deoptimization::Action_maybe_recompile,
208 extak->exact_klass());
209 }
210 if (stopped()) { // MUST uncommon-trap?
211 set_control(ctrl); // Then Don't Do It, just fall into the normal checking
212 } else { // Cast array klass to exactness:
213 // Use the exact constant value we know it is.
214 replace_in_map(array_klass,con);
215 CompileLog* log = C->log();
216 if (log != nullptr) {
217 log->elem("cast_up reason='monomorphic_array' from='%d' to='(exact)'",
218 log->identify(extak->exact_klass()));
219 }
220 array_klass = con; // Use cast value moving forward
221 }
222 }
223 }
224
225 // Come here for polymorphic array klasses
226
227 // Extract the array element class
228 int element_klass_offset = in_bytes(ObjArrayKlass::element_klass_offset());
229 Node *p2 = basic_plus_adr(array_klass, array_klass, element_klass_offset);
230 // We are allowed to use the constant type only if cast succeeded. If always_see_exact_class is true,
231 // we must set a control edge from the IfTrue node created by the uncommon_trap above to the
232 // LoadKlassNode.
233 Node* a_e_klass = _gvn.transform(LoadKlassNode::make(_gvn, always_see_exact_class ? control() : nullptr,
234 immutable_memory(), p2, tak));
235
236 // Check (the hard way) and throw if not a subklass.
237 // Result is ignored, we just need the CFG effects.
238 gen_checkcast(obj, a_e_klass);
239 }
240
241
242 //------------------------------do_new-----------------------------------------
243 void Parse::do_new() {
244 kill_dead_locals();
245
246 bool will_link;
247 ciInstanceKlass* klass = iter().get_klass(will_link)->as_instance_klass();
248 assert(will_link, "_new: typeflow responsibility");
249
250 // Should throw an InstantiationError?
251 if (klass->is_abstract() || klass->is_interface() ||
252 klass->name() == ciSymbols::java_lang_Class() ||
253 iter().is_unresolved_klass()) {
254 uncommon_trap(Deoptimization::Reason_unhandled,
255 Deoptimization::Action_none,
256 klass);
257 return;
258 }
259
260 if (C->needs_clinit_barrier(klass, method())) {
261 clinit_barrier(klass, method());
262 if (stopped()) return;
263 }
264
265 Node* kls = makecon(TypeKlassPtr::make(klass));
266 Node* obj = new_instance(kls);
267
268 // Push resultant oop onto stack
269 push(obj);
270
271 // Keep track of whether opportunities exist for StringBuilder
272 // optimizations.
273 if (OptimizeStringConcat &&
274 (klass == C->env()->StringBuilder_klass() ||
275 klass == C->env()->StringBuffer_klass())) {
276 C->set_has_stringbuilder(true);
277 }
278
279 // Keep track of boxed values for EliminateAutoBox optimizations.
280 if (C->eliminate_boxing() && klass->is_box_klass()) {
281 C->set_has_boxed_value(true);
282 }
283 }
284
|
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "ci/ciInlineKlass.hpp"
27 #include "ci/ciSymbols.hpp"
28 #include "compiler/compileLog.hpp"
29 #include "oops/flatArrayKlass.hpp"
30 #include "oops/objArrayKlass.hpp"
31 #include "opto/addnode.hpp"
32 #include "opto/castnode.hpp"
33 #include "opto/inlinetypenode.hpp"
34 #include "opto/memnode.hpp"
35 #include "opto/mulnode.hpp"
36 #include "opto/parse.hpp"
37 #include "opto/rootnode.hpp"
38 #include "opto/runtime.hpp"
39 #include "runtime/sharedRuntime.hpp"
40
41 //------------------------------make_dtrace_method_entry_exit ----------------
42 // Dtrace -- record entry or exit of a method if compiled with dtrace support
43 void GraphKit::make_dtrace_method_entry_exit(ciMethod* method, bool is_entry) {
44 const TypeFunc *call_type = OptoRuntime::dtrace_method_entry_exit_Type();
45 address call_address = is_entry ? CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry) :
46 CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit);
47 const char *call_name = is_entry ? "dtrace_method_entry" : "dtrace_method_exit";
48
49 // Get base of thread-local storage area
50 Node* thread = _gvn.transform( new ThreadLocalNode() );
51
52 // Get method
53 const TypePtr* method_type = TypeMetadataPtr::make(method);
54 Node *method_node = _gvn.transform(ConNode::make(method_type));
55
56 kill_dead_locals();
57
58 // For some reason, this call reads only raw memory.
59 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
60 make_runtime_call(RC_LEAF | RC_NARROW_MEM,
61 call_type, call_address,
62 call_name, raw_adr_type,
63 thread, method_node);
64 }
65
66
67 //=============================================================================
68 //------------------------------do_checkcast-----------------------------------
69 void Parse::do_checkcast() {
70 bool will_link;
71 ciKlass* klass = iter().get_klass(will_link);
72 Node *obj = peek();
73
74 // Throw uncommon trap if class is not loaded or the value we are casting
75 // _from_ is not loaded, and value is not null. If the value _is_ null,
76 // then the checkcast does nothing.
77 const TypeOopPtr *tp = _gvn.type(obj)->isa_oopptr();
78 if (!will_link || (tp && !tp->is_loaded())) {
79 if (C->log() != nullptr) {
80 if (!will_link) {
81 C->log()->elem("assert_null reason='checkcast' klass='%d'",
82 C->log()->identify(klass));
83 }
84 if (tp && !tp->is_loaded()) {
85 // %%% Cannot happen?
86 ciKlass* klass = tp->unloaded_klass();
87 C->log()->elem("assert_null reason='checkcast source' klass='%d'",
88 C->log()->identify(klass));
89 }
90 }
91 null_assert(obj);
124 assert( stopped() || _gvn.type(peek())->higher_equal(TypePtr::NULL_PTR), "what's left behind is null" );
125 if (!stopped()) {
126 // The object is now known to be null.
127 // Shortcut the effect of gen_instanceof and return "false" directly.
128 pop(); // pop the null
129 push(_gvn.intcon(0)); // push false answer
130 }
131 return;
132 }
133
134 // Push the bool result back on stack
135 Node* res = gen_instanceof(peek(), makecon(TypeKlassPtr::make(klass, Type::trust_interfaces)), true);
136
137 // Pop from stack AFTER gen_instanceof because it can uncommon trap.
138 pop();
139 push(res);
140 }
141
142 //------------------------------array_store_check------------------------------
143 // pull array from stack and check that the store is valid
144 Node* Parse::array_store_check(Node*& adr, const Type*& elemtype) {
145 // Shorthand access to array store elements without popping them.
146 Node *obj = peek(0);
147 Node *idx = peek(1);
148 Node *ary = peek(2);
149
150 if (_gvn.type(obj) == TypePtr::NULL_PTR) {
151 // There's never a type check on null values.
152 // This cutout lets us avoid the uncommon_trap(Reason_array_check)
153 // below, which turns into a performance liability if the
154 // gen_checkcast folds up completely.
155 if (_gvn.type(ary)->is_aryptr()->is_null_free()) {
156 null_check(obj);
157 }
158 return obj;
159 }
160
161 // Extract the array klass type
162 Node* array_klass = load_object_klass(ary);
163 // Get the array klass
164 const TypeKlassPtr* tak = _gvn.type(array_klass)->is_klassptr();
165
166 // The type of array_klass is usually INexact array-of-oop. Heroically
167 // cast array_klass to EXACT array and uncommon-trap if the cast fails.
168 // Make constant out of the inexact array klass, but use it only if the cast
169 // succeeds.
170 bool always_see_exact_class = false;
171 if (MonomorphicArrayCheck && !tak->klass_is_exact()) {
172 // Make a constant out of the inexact array klass
173 const TypeKlassPtr* extak = nullptr;
174 const TypeOopPtr* ary_t = _gvn.type(ary)->is_oopptr();
175 ciKlass* ary_spec = ary_t->speculative_type();
176 Deoptimization::DeoptReason reason = Deoptimization::Reason_none;
177 // Try to cast the array to an exact type from profile data. First
178 // check the speculative type.
179 if (ary_spec != nullptr && !too_many_traps(Deoptimization::Reason_speculate_class_check)) {
180 extak = TypeKlassPtr::make(ary_spec);
181 reason = Deoptimization::Reason_speculate_class_check;
182 } else if (UseArrayLoadStoreProfile) {
183 // No speculative type: check profile data at this bci.
184 reason = Deoptimization::Reason_class_check;
185 if (!too_many_traps(reason)) {
186 ciKlass* array_type = nullptr;
187 ciKlass* element_type = nullptr;
188 ProfilePtrKind element_ptr = ProfileMaybeNull;
189 bool flat_array = true;
190 bool null_free_array = true;
191 method()->array_access_profiled_type(bci(), array_type, element_type, element_ptr, flat_array, null_free_array);
192 if (array_type != nullptr) {
193 extak = TypeKlassPtr::make(array_type);
194 }
195 }
196 } else if (!too_many_traps(Deoptimization::Reason_array_check) && tak != TypeInstKlassPtr::OBJECT) {
197 // If the compiler has determined that the type of array 'ary' (represented
198 // by 'array_klass') is java/lang/Object, the compiler must not assume that
199 // the array 'ary' is monomorphic.
200 //
201 // If 'ary' were of type java/lang/Object, this arraystore would have to fail,
202 // because it is not possible to perform a arraystore into an object that is not
203 // a "proper" array.
204 //
205 // Therefore, let's obtain at runtime the type of 'ary' and check if we can still
206 // successfully perform the store.
207 //
208 // The implementation reasons for the condition are the following:
209 //
210 // java/lang/Object is the superclass of all arrays, but it is represented by the VM
211 // as an InstanceKlass. The checks generated by gen_checkcast() (see below) expect
212 // 'array_klass' to be ObjArrayKlass, which can result in invalid memory accesses.
213 //
214 // See issue JDK-8057622 for details.
215 extak = tak->cast_to_exactness(true);
216 reason = Deoptimization::Reason_array_check;
217 }
218 if (extak != nullptr && extak->exact_klass(true) != nullptr) {
219 Node* con = makecon(extak);
220 Node* cmp = _gvn.transform(new CmpPNode(array_klass, con));
221 Node* bol = _gvn.transform(new BoolNode(cmp, BoolTest::eq));
222 // Only do it if the check does not always pass/fail
223 if (!bol->is_Con()) {
224 always_see_exact_class = true;
225 { BuildCutout unless(this, bol, PROB_MAX);
226 uncommon_trap(reason,
227 Deoptimization::Action_maybe_recompile,
228 extak->exact_klass());
229 }
230 // Cast array klass to exactness
231 replace_in_map(array_klass, con);
232 array_klass = con;
233 Node* cast = _gvn.transform(new CheckCastPPNode(control(), ary, extak->as_instance_type()));
234 replace_in_map(ary, cast);
235 ary = cast;
236
237 // Recompute element type and address
238 const TypeAryPtr* arytype = _gvn.type(ary)->is_aryptr();
239 elemtype = arytype->elem();
240 adr = array_element_address(ary, idx, T_OBJECT, arytype->size(), control());
241
242 CompileLog* log = C->log();
243 if (log != nullptr) {
244 log->elem("cast_up reason='monomorphic_array' from='%d' to='(exact)'",
245 log->identify(extak->exact_klass()));
246 }
247 }
248 }
249 }
250
251 // Come here for polymorphic array klasses
252
253 // Extract the array element class
254 int element_klass_offset = in_bytes(ArrayKlass::element_klass_offset());
255
256 Node *p2 = basic_plus_adr(array_klass, array_klass, element_klass_offset);
257 // We are allowed to use the constant type only if cast succeeded. If always_see_exact_class is true,
258 // we must set a control edge from the IfTrue node created by the uncommon_trap above to the
259 // LoadKlassNode.
260 Node* a_e_klass = _gvn.transform(LoadKlassNode::make(_gvn, always_see_exact_class ? control() : nullptr,
261 immutable_memory(), p2, tak));
262
263 // If we statically know that this is an inline type array, use precise element klass for checkcast
264 const TypeAryPtr* arytype = _gvn.type(ary)->is_aryptr();
265 const TypePtr* elem_ptr = elemtype->make_ptr();
266 bool null_free;
267 if (elem_ptr->is_inlinetypeptr()) {
268 // We statically know that this is an inline type array, use precise klass ptr
269 null_free = arytype->is_flat() || !elem_ptr->maybe_null();
270 a_e_klass = makecon(TypeKlassPtr::make(elemtype->inline_klass()));
271 } else {
272 // TODO: Should move to TypeAry::is_null_free() with JDK-8345681
273 TypePtr::PTR ptr = elem_ptr->ptr();
274 null_free = ((ptr == TypePtr::NotNull) || (ptr == TypePtr::AnyNull));
275 #ifdef ASSERT
276 // If the element type is exact, the array can be null-free (i.e. the element type is NotNull) if:
277 // - The elements are inline types
278 // - The array is from an autobox cache.
279 // If the element type is inexact, it could represent multiple null-free arrays. Since autobox cache arrays
280 // are local to very few cache classes and are only used in the valueOf() methods, they are always exact and are not
281 // merged or hidden behind super types. Therefore, an inexact null-free array always represents some kind of
282 // inline type array - either of an abstract value class or Object.
283 if (null_free) {
284 ciKlass* klass = elem_ptr->is_instptr()->instance_klass();
285 if (klass->exact_klass()) {
286 assert(elem_ptr->is_inlinetypeptr() || arytype->is_autobox_cache(), "elements must be inline type or autobox cache");
287 } else {
288 assert(!arytype->is_autobox_cache() && elem_ptr->can_be_inline_type() &&
289 (klass->is_java_lang_Object() || klass->is_abstract()), "cannot have inexact non-inline type elements");
290 }
291 }
292 #endif // ASSERT
293 }
294
295 // Check (the hard way) and throw if not a subklass.
296 return gen_checkcast(obj, a_e_klass, nullptr, null_free);
297 }
298
299
300 //------------------------------do_new-----------------------------------------
301 void Parse::do_new() {
302 kill_dead_locals();
303
304 bool will_link;
305 ciInstanceKlass* klass = iter().get_klass(will_link)->as_instance_klass();
306 assert(will_link, "_new: typeflow responsibility");
307
308 // Should throw an InstantiationError?
309 if (klass->is_abstract() || klass->is_interface() ||
310 klass->name() == ciSymbols::java_lang_Class() ||
311 iter().is_unresolved_klass()) {
312 uncommon_trap(Deoptimization::Reason_unhandled,
313 Deoptimization::Action_none,
314 klass);
315 return;
316 }
317
318 if (C->needs_clinit_barrier(klass, method())) {
319 clinit_barrier(klass, method());
320 if (stopped()) return;
321 }
322
323 if (klass->is_inlinetype()) {
324 push(InlineTypeNode::make_default(_gvn, klass->as_inline_klass(), /* is_larval */ true));
325 return;
326 }
327
328 Node* kls = makecon(TypeKlassPtr::make(klass));
329 Node* obj = new_instance(kls);
330
331 // Push resultant oop onto stack
332 push(obj);
333
334 // Keep track of whether opportunities exist for StringBuilder
335 // optimizations.
336 if (OptimizeStringConcat &&
337 (klass == C->env()->StringBuilder_klass() ||
338 klass == C->env()->StringBuffer_klass())) {
339 C->set_has_stringbuilder(true);
340 }
341
342 // Keep track of boxed values for EliminateAutoBox optimizations.
343 if (C->eliminate_boxing() && klass->is_box_klass()) {
344 C->set_has_boxed_value(true);
345 }
346 }
347
|