1 /*
2 * Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
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 *
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/runtimeUpcalls.hpp"
36 #include "runtime/sharedRuntime.hpp"
37
38 void GraphKit::install_on_method_entry_runtime_upcalls(ciMethod* method) {
39 MethodDetails method_details(method);
40 RuntimeUpcallInfo* upcall = RuntimeUpcalls::get_first_upcall(RuntimeUpcallType::onMethodEntry, method_details);
41 while (upcall != nullptr) {
42 // Get base of thread-local storage area
43 Node* thread = _gvn.transform( new ThreadLocalNode() );
44 kill_dead_locals();
45
46 // For some reason, this call reads only raw memory.
47 const TypeFunc *call_type = OptoRuntime::runtime_up_call_Type();
48 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
49 make_runtime_call(RC_LEAF | RC_NARROW_MEM,
50 call_type, upcall->upcall_address(),
51 upcall->upcall_name(), raw_adr_type,
52 thread);
53
54 upcall = RuntimeUpcalls::get_next_upcall(RuntimeUpcallType::onMethodEntry, method_details, upcall);
55 }
56 }
57
58 //------------------------------make_dtrace_method_entry_exit ----------------
59 // Dtrace -- record entry or exit of a method if compiled with dtrace support
60 void GraphKit::make_dtrace_method_entry_exit(ciMethod* method, bool is_entry) {
61 const TypeFunc *call_type = OptoRuntime::dtrace_method_entry_exit_Type();
62 address call_address = is_entry ? CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry) :
63 CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit);
64 const char *call_name = is_entry ? "dtrace_method_entry" : "dtrace_method_exit";
65
66 // Get base of thread-local storage area
67 Node* thread = _gvn.transform( new ThreadLocalNode() );
68
69 // Get method
70 const TypePtr* method_type = TypeMetadataPtr::make(method);
71 Node *method_node = _gvn.transform(ConNode::make(method_type));
72
73 kill_dead_locals();
74
75 // For some reason, this call reads only raw memory.
76 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
77 make_runtime_call(RC_LEAF | RC_NARROW_MEM,
78 call_type, call_address,
79 call_name, raw_adr_type,
80 thread, method_node);
81 }
82
83
84 //=============================================================================
85 //------------------------------do_checkcast-----------------------------------
86 void Parse::do_checkcast() {
87 bool will_link;
88 ciKlass* klass = iter().get_klass(will_link);
89
90 Node *obj = peek();
91
92 // Throw uncommon trap if class is not loaded or the value we are casting
93 // _from_ is not loaded, and value is not null. If the value _is_ null,
94 // then the checkcast does nothing.
95 const TypeOopPtr *tp = _gvn.type(obj)->isa_oopptr();
96 if (!will_link || (tp && !tp->is_loaded())) {
97 if (C->log() != nullptr) {
98 if (!will_link) {
99 C->log()->elem("assert_null reason='checkcast' klass='%d'",
100 C->log()->identify(klass));
101 }
102 if (tp && !tp->is_loaded()) {
103 // %%% Cannot happen?
104 ciKlass* klass = tp->unloaded_klass();
105 C->log()->elem("assert_null reason='checkcast source' klass='%d'",
106 C->log()->identify(klass));
107 }
108 }
109 null_assert(obj);
110 assert( stopped() || _gvn.type(peek())->higher_equal(TypePtr::NULL_PTR), "what's left behind is null" );
111 return;
112 }
113
114 Node* res = gen_checkcast(obj, makecon(TypeKlassPtr::make(klass, Type::trust_interfaces)));
115 if (stopped()) {
116 return;
117 }
118
119 // Pop from stack AFTER gen_checkcast because it can uncommon trap and
120 // the debug info has to be correct.
121 pop();
122 push(res);
123 }
124
125
126 //------------------------------do_instanceof----------------------------------
127 void Parse::do_instanceof() {
128 if (stopped()) return;
129 // We would like to return false if class is not loaded, emitting a
130 // dependency, but Java requires instanceof to load its operand.
131
132 // Throw uncommon trap if class is not loaded
133 bool will_link;
134 ciKlass* klass = iter().get_klass(will_link);
135
136 if (!will_link) {
137 if (C->log() != nullptr) {
138 C->log()->elem("assert_null reason='instanceof' klass='%d'",
139 C->log()->identify(klass));
140 }
141 null_assert(peek());
142 assert( stopped() || _gvn.type(peek())->higher_equal(TypePtr::NULL_PTR), "what's left behind is null" );
143 if (!stopped()) {
144 // The object is now known to be null.
145 // Shortcut the effect of gen_instanceof and return "false" directly.
146 pop(); // pop the null
147 push(_gvn.intcon(0)); // push false answer
148 }
149 return;
150 }
151
152 // Push the bool result back on stack
153 Node* res = gen_instanceof(peek(), makecon(TypeKlassPtr::make(klass, Type::trust_interfaces)), true);
154
155 // Pop from stack AFTER gen_instanceof because it can uncommon trap.
156 pop();
157 push(res);
158 }
159
160 //------------------------------array_store_check------------------------------
161 // pull array from stack and check that the store is valid
162 void Parse::array_store_check() {
163
164 // Shorthand access to array store elements without popping them.
165 Node *obj = peek(0);
166 Node *idx = peek(1);
167 Node *ary = peek(2);
168
169 if (_gvn.type(obj) == TypePtr::NULL_PTR) {
170 // There's never a type check on null values.
171 // This cutout lets us avoid the uncommon_trap(Reason_array_check)
172 // below, which turns into a performance liability if the
173 // gen_checkcast folds up completely.
174 return;
175 }
176
177 // Extract the array klass type
178 int klass_offset = oopDesc::klass_offset_in_bytes();
179 Node* p = basic_plus_adr( ary, ary, klass_offset );
180 // p's type is array-of-OOPS plus klass_offset
181 Node* array_klass = _gvn.transform(LoadKlassNode::make(_gvn, nullptr, immutable_memory(), p, TypeInstPtr::KLASS));
182 // Get the array klass
183 const TypeKlassPtr *tak = _gvn.type(array_klass)->is_klassptr();
184
185 // The type of array_klass is usually INexact array-of-oop. Heroically
186 // cast array_klass to EXACT array and uncommon-trap if the cast fails.
187 // Make constant out of the inexact array klass, but use it only if the cast
188 // succeeds.
189 bool always_see_exact_class = false;
190 if (MonomorphicArrayCheck
191 && !too_many_traps(Deoptimization::Reason_array_check)
192 && !tak->klass_is_exact()
193 && tak != TypeInstKlassPtr::OBJECT) {
194 // Regarding the fourth condition in the if-statement from above:
195 //
196 // If the compiler has determined that the type of array 'ary' (represented
197 // by 'array_klass') is java/lang/Object, the compiler must not assume that
198 // the array 'ary' is monomorphic.
199 //
200 // If 'ary' were of type java/lang/Object, this arraystore would have to fail,
201 // because it is not possible to perform a arraystore into an object that is not
202 // a "proper" array.
203 //
204 // Therefore, let's obtain at runtime the type of 'ary' and check if we can still
205 // successfully perform the store.
206 //
207 // The implementation reasons for the condition are the following:
208 //
209 // java/lang/Object is the superclass of all arrays, but it is represented by the VM
210 // as an InstanceKlass. The checks generated by gen_checkcast() (see below) expect
211 // 'array_klass' to be ObjArrayKlass, which can result in invalid memory accesses.
212 //
213 // See issue JDK-8057622 for details.
214
215 always_see_exact_class = true;
216 // (If no MDO at all, hope for the best, until a trap actually occurs.)
217
218 // Make a constant out of the inexact array klass
219 const TypeKlassPtr *extak = tak->cast_to_exactness(true);
220
221 if (extak->exact_klass(true) != nullptr) {
222 Node* con = makecon(extak);
223 Node* cmp = _gvn.transform(new CmpPNode( array_klass, con ));
224 Node* bol = _gvn.transform(new BoolNode( cmp, BoolTest::eq ));
225 Node* ctrl= control();
226 { BuildCutout unless(this, bol, PROB_MAX);
227 uncommon_trap(Deoptimization::Reason_array_check,
228 Deoptimization::Action_maybe_recompile,
229 extak->exact_klass());
230 }
231 if (stopped()) { // MUST uncommon-trap?
232 set_control(ctrl); // Then Don't Do It, just fall into the normal checking
233 } else { // Cast array klass to exactness:
234 // Use the exact constant value we know it is.
235 replace_in_map(array_klass,con);
236 CompileLog* log = C->log();
237 if (log != nullptr) {
238 log->elem("cast_up reason='monomorphic_array' from='%d' to='(exact)'",
239 log->identify(extak->exact_klass()));
240 }
241 array_klass = con; // Use cast value moving forward
242 }
243 }
244 }
245
246 // Come here for polymorphic array klasses
247
248 // Extract the array element class
249 int element_klass_offset = in_bytes(ObjArrayKlass::element_klass_offset());
250 Node *p2 = basic_plus_adr(array_klass, array_klass, element_klass_offset);
251 // We are allowed to use the constant type only if cast succeeded. If always_see_exact_class is true,
252 // we must set a control edge from the IfTrue node created by the uncommon_trap above to the
253 // LoadKlassNode.
254 Node* a_e_klass = _gvn.transform(LoadKlassNode::make(_gvn, always_see_exact_class ? control() : nullptr,
255 immutable_memory(), p2, tak));
256
257 // Check (the hard way) and throw if not a subklass.
258 // Result is ignored, we just need the CFG effects.
259 gen_checkcast(obj, a_e_klass);
260 }
261
262
263 //------------------------------do_new-----------------------------------------
264 void Parse::do_new() {
265 kill_dead_locals();
266
267 bool will_link;
268 ciInstanceKlass* klass = iter().get_klass(will_link)->as_instance_klass();
269 assert(will_link, "_new: typeflow responsibility");
270
271 // Should throw an InstantiationError?
272 if (klass->is_abstract() || klass->is_interface() ||
273 klass->name() == ciSymbols::java_lang_Class() ||
274 iter().is_unresolved_klass()) {
275 uncommon_trap(Deoptimization::Reason_unhandled,
276 Deoptimization::Action_none,
277 klass);
278 return;
279 }
280
281 if (C->needs_clinit_barrier(klass, method())) {
282 clinit_barrier(klass, method());
283 if (stopped()) return;
284 }
285
286 Node* kls = makecon(TypeKlassPtr::make(klass));
287 Node* obj = new_instance(kls);
288
289 // Push resultant oop onto stack
290 push(obj);
291
292 // Keep track of whether opportunities exist for StringBuilder
293 // optimizations.
294 if (OptimizeStringConcat &&
295 (klass == C->env()->StringBuilder_klass() ||
296 klass == C->env()->StringBuffer_klass())) {
297 C->set_has_stringbuilder(true);
298 }
299
300 // Keep track of boxed values for EliminateAutoBox optimizations.
301 if (C->eliminate_boxing() && klass->is_box_klass()) {
302 C->set_has_boxed_value(true);
303 }
304 }
305
306 #ifndef PRODUCT
307 //------------------------------dump_map_adr_mem-------------------------------
308 // Debug dump of the mapping from address types to MergeMemNode indices.
309 void Parse::dump_map_adr_mem() const {
310 tty->print_cr("--- Mapping from address types to memory Nodes ---");
311 MergeMemNode *mem = map() == nullptr ? nullptr : (map()->memory()->is_MergeMem() ?
312 map()->memory()->as_MergeMem() : nullptr);
313 for (uint i = 0; i < (uint)C->num_alias_types(); i++) {
314 C->alias_type(i)->print_on(tty);
315 tty->print("\t");
316 // Node mapping, if any
317 if (mem && i < mem->req() && mem->in(i) && mem->in(i) != mem->empty_memory()) {
318 mem->in(i)->dump();
319 } else {
320 tty->cr();
321 }
322 }
323 }
324
325 #endif