1 /*
2 * Copyright (c) 2020, 2024, 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 "gc/shared/barrierSet.hpp"
28 #include "opto/castnode.hpp"
29 #include "opto/graphKit.hpp"
30 #include "opto/phaseX.hpp"
31 #include "opto/rootnode.hpp"
32 #include "opto/vector.hpp"
33 #include "utilities/macros.hpp"
34
35 static bool is_vector_mask(ciKlass* klass) {
36 return klass->is_subclass_of(ciEnv::current()->vector_VectorMask_klass());
37 }
38
39 static bool is_vector_shuffle(ciKlass* klass) {
40 return klass->is_subclass_of(ciEnv::current()->vector_VectorShuffle_klass());
41 }
42
43
44 void PhaseVector::optimize_vector_boxes() {
45 Compile::TracePhase tp("vector_elimination", &timers[_t_vector_elimination]);
46
47 // Signal GraphKit it's post-parse phase.
48 assert(C->inlining_incrementally() == false, "sanity");
49 C->set_inlining_incrementally(true);
50
51 C->igvn_worklist()->ensure_empty(); // should be done with igvn
52
53 expand_vunbox_nodes();
54 scalarize_vbox_nodes();
55
56 C->inline_vector_reboxing_calls();
57
58 expand_vbox_nodes();
59 eliminate_vbox_alloc_nodes();
60
61 C->set_inlining_incrementally(false);
62
63 do_cleanup();
64 }
65
66 void PhaseVector::do_cleanup() {
67 if (C->failing()) return;
68 {
69 Compile::TracePhase tp("vector_pru", &timers[_t_vector_pru]);
70 ResourceMark rm;
71 PhaseRemoveUseless pru(C->initial_gvn(), *C->igvn_worklist());
72 if (C->failing()) return;
73 }
74 {
75 Compile::TracePhase tp("incrementalInline_igvn", &timers[_t_vector_igvn]);
76 _igvn.reset_from_gvn(C->initial_gvn());
77 _igvn.optimize();
78 if (C->failing()) return;
79 }
80 C->print_method(PHASE_ITER_GVN_BEFORE_EA, 3);
81 }
82
83 void PhaseVector::scalarize_vbox_nodes() {
84 if (C->failing()) return;
85
86 if (!EnableVectorReboxing) {
87 return; // don't scalarize vector boxes
88 }
89
90 int macro_idx = C->macro_count() - 1;
91 while (macro_idx >= 0) {
92 Node * n = C->macro_node(macro_idx);
93 assert(n->is_macro(), "only macro nodes expected here");
94 if (n->Opcode() == Op_VectorBox) {
95 VectorBoxNode* vbox = static_cast<VectorBoxNode*>(n);
96 scalarize_vbox_node(vbox);
97 if (C->failing()) return;
98 C->print_method(PHASE_SCALARIZE_VBOX, 3, vbox);
99 }
100 if (C->failing()) return;
101 macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
102 }
103 }
104
105 void PhaseVector::expand_vbox_nodes() {
106 if (C->failing()) return;
107
108 int macro_idx = C->macro_count() - 1;
109 while (macro_idx >= 0) {
110 Node * n = C->macro_node(macro_idx);
111 assert(n->is_macro(), "only macro nodes expected here");
112 if (n->Opcode() == Op_VectorBox) {
113 VectorBoxNode* vbox = static_cast<VectorBoxNode*>(n);
114 expand_vbox_node(vbox);
115 if (C->failing()) return;
116 }
117 if (C->failing()) return;
118 macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
119 }
120 }
121
122 void PhaseVector::expand_vunbox_nodes() {
123 if (C->failing()) return;
124
125 int macro_idx = C->macro_count() - 1;
126 while (macro_idx >= 0) {
127 Node * n = C->macro_node(macro_idx);
128 assert(n->is_macro(), "only macro nodes expected here");
129 if (n->Opcode() == Op_VectorUnbox) {
130 VectorUnboxNode* vec_unbox = static_cast<VectorUnboxNode*>(n);
131 expand_vunbox_node(vec_unbox);
132 if (C->failing()) return;
133 C->print_method(PHASE_EXPAND_VUNBOX, 3, vec_unbox);
134 }
135 if (C->failing()) return;
136 macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
137 }
138 }
139
140 void PhaseVector::eliminate_vbox_alloc_nodes() {
141 if (C->failing()) return;
142
143 int macro_idx = C->macro_count() - 1;
144 while (macro_idx >= 0) {
145 Node * n = C->macro_node(macro_idx);
146 assert(n->is_macro(), "only macro nodes expected here");
147 if (n->Opcode() == Op_VectorBoxAllocate) {
148 VectorBoxAllocateNode* vbox_alloc = static_cast<VectorBoxAllocateNode*>(n);
149 eliminate_vbox_alloc_node(vbox_alloc);
150 if (C->failing()) return;
151 C->print_method(PHASE_ELIMINATE_VBOX_ALLOC, 3, vbox_alloc);
152 }
153 if (C->failing()) return;
154 macro_idx = MIN2(macro_idx - 1, C->macro_count() - 1);
155 }
156 }
157
158 static JVMState* clone_jvms(Compile* C, SafePointNode* sfpt) {
159 JVMState* new_jvms = sfpt->jvms()->clone_shallow(C);
160 uint size = sfpt->req();
161 SafePointNode* map = new SafePointNode(size, new_jvms);
162 for (uint i = 0; i < size; i++) {
163 map->init_req(i, sfpt->in(i));
164 }
165 Node* mem = map->memory();
166 if (!mem->is_MergeMem()) {
167 // Since we are not in parsing, the SafePointNode does not guarantee that the memory
168 // input is necessarily a MergeMemNode. But we need to ensure that there is that
169 // MergeMemNode, since the GraphKit assumes the memory input of the map to be a
170 // MergeMemNode, so that it can directly access the memory slices.
171 PhaseGVN& gvn = *C->initial_gvn();
172 Node* mergemem = MergeMemNode::make(mem);
173 gvn.set_type_bottom(mergemem);
174 map->set_memory(mergemem);
175 }
176 new_jvms->set_map(map);
177 return new_jvms;
178 }
179
180 void PhaseVector::scalarize_vbox_node(VectorBoxNode* vec_box) {
181 Node* vec_value = vec_box->in(VectorBoxNode::Value);
182 PhaseGVN& gvn = *C->initial_gvn();
183
184 // Process merged VBAs
185
186 if (EnableVectorAggressiveReboxing) {
187 Unique_Node_List calls;
188 for (DUIterator_Fast imax, i = vec_box->fast_outs(imax); i < imax; i++) {
189 Node* use = vec_box->fast_out(i);
190 if (use->is_CallJava()) {
191 CallJavaNode* call = use->as_CallJava();
192 if (call->has_non_debug_use(vec_box) && vec_box->in(VectorBoxNode::Box)->is_Phi()) {
193 calls.push(call);
194 }
195 }
196 }
197
198 while (calls.size() > 0) {
199 CallJavaNode* call = calls.pop()->as_CallJava();
200 // Attach new VBA to the call and use it instead of Phi (VBA ... VBA).
201
202 JVMState* jvms = clone_jvms(C, call);
203 GraphKit kit(jvms);
204 PhaseGVN& gvn = kit.gvn();
205
206 // Adjust JVMS from post-call to pre-call state: put args on stack
207 uint nargs = call->method()->arg_size();
208 kit.ensure_stack(kit.sp() + nargs);
209 for (uint i = TypeFunc::Parms; i < call->tf()->domain_sig()->cnt(); i++) {
210 kit.push(call->in(i));
211 }
212 jvms = kit.sync_jvms();
213
214 Node* new_vbox = nullptr;
215 {
216 Node* vect = vec_box->in(VectorBoxNode::Value);
217 const TypeInstPtr* vbox_type = vec_box->box_type();
218 const TypeVect* vt = vec_box->vec_type();
219 BasicType elem_bt = vt->element_basic_type();
220 int num_elem = vt->length();
221
222 new_vbox = kit.box_vector(vect, vbox_type, elem_bt, num_elem, /*deoptimize=*/true);
223
224 kit.replace_in_map(vec_box, new_vbox);
225 }
226
227 kit.dec_sp(nargs);
228 jvms = kit.sync_jvms();
229
230 call->set_req(TypeFunc::Control , kit.control());
231 call->set_req(TypeFunc::I_O , kit.i_o());
232 call->set_req(TypeFunc::Memory , kit.reset_memory());
233 call->set_req(TypeFunc::FramePtr, kit.frameptr());
234 call->replace_edge(vec_box, new_vbox);
235
236 C->record_for_igvn(call);
237 }
238 }
239
240 // Process debug uses at safepoints
241 Unique_Node_List safepoints;
242
243 Unique_Node_List worklist;
244 worklist.push(vec_box);
245 while (worklist.size() > 0) {
246 Node* n = worklist.pop();
247 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
248 Node* use = n->fast_out(i);
249 if (use->is_SafePoint()) {
250 SafePointNode* sfpt = use->as_SafePoint();
251 if (!sfpt->is_Call() || !sfpt->as_Call()->has_non_debug_use(n)) {
252 safepoints.push(sfpt);
253 }
254 } else if (use->is_ConstraintCast()) {
255 worklist.push(use); // reversed version of Node::uncast()
256 }
257 }
258 }
259
260 ciInstanceKlass* iklass = vec_box->box_type()->instance_klass();
261 int n_fields = iklass->nof_nonstatic_fields();
262 assert(n_fields == 1, "sanity");
263
264 // If a mask is feeding into safepoint[s], then its value should be
265 // packed into a boolean/byte vector first, this will simplify the
266 // re-materialization logic for both predicated and non-predicated
267 // targets.
268 bool is_mask = is_vector_mask(iklass);
269 if (is_mask && vec_value->Opcode() != Op_VectorStoreMask) {
270 const TypeVect* vt = vec_value->bottom_type()->is_vect();
271 BasicType bt = vt->element_basic_type();
272 vec_value = gvn.transform(VectorStoreMaskNode::make(gvn, vec_value, bt, vt->length()));
273 }
274
275 while (safepoints.size() > 0) {
276 SafePointNode* sfpt = safepoints.pop()->as_SafePoint();
277
278 uint first_ind = (sfpt->req() - sfpt->jvms()->scloff());
279 Node* sobj = new SafePointScalarObjectNode(vec_box->box_type(), vec_box, first_ind, sfpt->jvms()->depth(), n_fields);
280 sobj->init_req(0, C->root());
281 sfpt->add_req(vec_value);
282
283 sobj = gvn.transform(sobj);
284
285 JVMState *jvms = sfpt->jvms();
286
287 jvms->set_endoff(sfpt->req());
288 // Now make a pass over the debug information replacing any references
289 // to the allocated object with vector value.
290 for (uint i = jvms->debug_start(); i < jvms->debug_end(); i++) {
291 Node* debug = sfpt->in(i);
292 if (debug != nullptr && debug->uncast(/*keep_deps*/false) == vec_box) {
293 sfpt->set_req(i, sobj);
294 }
295 }
296 C->record_for_igvn(sfpt);
297 }
298 }
299
300 void PhaseVector::expand_vbox_node(VectorBoxNode* vec_box) {
301 if (vec_box->outcnt() > 0) {
302 VectorSet visited;
303 Node* vbox = vec_box->in(VectorBoxNode::Box);
304 Node* vect = vec_box->in(VectorBoxNode::Value);
305 Node* result = expand_vbox_node_helper(vbox, vect, vec_box->box_type(),
306 vec_box->vec_type(), visited);
307 C->gvn_replace_by(vec_box, result);
308 C->print_method(PHASE_EXPAND_VBOX, 3, vec_box);
309 }
310 C->remove_macro_node(vec_box);
311 }
312
313 Node* PhaseVector::expand_vbox_node_helper(Node* vbox,
314 Node* vect,
315 const TypeInstPtr* box_type,
316 const TypeVect* vect_type,
317 VectorSet &visited) {
318 // JDK-8304948 shows an example that there may be a cycle in the graph.
319 if (visited.test_set(vbox->_idx)) {
320 assert(vbox->is_Phi(), "should be phi");
321 return vbox; // already visited
322 }
323
324 // Handle the case when the allocation input to VectorBoxNode is a Proj.
325 // This is the normal case before expanding.
326 if (vbox->is_Proj() && vbox->in(0)->Opcode() == Op_VectorBoxAllocate) {
327 VectorBoxAllocateNode* vbox_alloc = static_cast<VectorBoxAllocateNode*>(vbox->in(0));
328 return expand_vbox_alloc_node(vbox_alloc, vect, box_type, vect_type);
329 }
330
331 // Handle the case when both the allocation input and vector input to
332 // VectorBoxNode are Phi. This case is generated after the transformation of
333 // Phi: Phi (VectorBox1 VectorBox2) => VectorBox (Phi1 Phi2).
334 // With this optimization, the relative two allocation inputs of VectorBox1 and
335 // VectorBox2 are gathered into Phi1 now. Similarly, the original vector
336 // inputs of two VectorBox nodes are in Phi2.
337 //
338 // See PhiNode::merge_through_phi in cfg.cpp for more details.
339 if (vbox->is_Phi() && vect->is_Phi()) {
340 assert(vbox->as_Phi()->region() == vect->as_Phi()->region(), "");
341 for (uint i = 1; i < vbox->req(); i++) {
342 Node* new_box = expand_vbox_node_helper(vbox->in(i), vect->in(i),
343 box_type, vect_type, visited);
344 if (!new_box->is_Phi()) {
345 C->initial_gvn()->hash_delete(vbox);
346 vbox->set_req(i, new_box);
347 }
348 }
349 return C->initial_gvn()->transform(vbox);
350 }
351
352 // Handle the case when the allocation input to VectorBoxNode is a phi
353 // but the vector input is not, which can definitely be the case if the
354 // vector input has been value-numbered. It seems to be safe to do by
355 // construction because VectorBoxNode and VectorBoxAllocate come in a
356 // specific order as a result of expanding an intrinsic call. After that, if
357 // any of the inputs to VectorBoxNode are value-numbered they can only
358 // move up and are guaranteed to dominate.
359 if (vbox->is_Phi() && (vect->is_Vector() || vect->is_LoadVector())) {
360 for (uint i = 1; i < vbox->req(); i++) {
361 Node* new_box = expand_vbox_node_helper(vbox->in(i), vect,
362 box_type, vect_type, visited);
363 if (!new_box->is_Phi()) {
364 C->initial_gvn()->hash_delete(vbox);
365 vbox->set_req(i, new_box);
366 }
367 }
368 return C->initial_gvn()->transform(vbox);
369 }
370
371 assert(!vbox->is_Phi(), "should be expanded");
372 // TODO: assert that expanded vbox is initialized with the same value (vect).
373 return vbox; // already expanded
374 }
375
376 Node* PhaseVector::expand_vbox_alloc_node(VectorBoxAllocateNode* vbox_alloc,
377 Node* value,
378 const TypeInstPtr* box_type,
379 const TypeVect* vect_type) {
380 JVMState* jvms = clone_jvms(C, vbox_alloc);
381 GraphKit kit(jvms);
382 PhaseGVN& gvn = kit.gvn();
383
384 ciInstanceKlass* box_klass = box_type->instance_klass();
385 BasicType bt = vect_type->element_basic_type();
386 int num_elem = vect_type->length();
387
388 bool is_mask = is_vector_mask(box_klass);
389 // If boxed mask value is present in a predicate register, it must be
390 // spilled to a vector though a VectorStoreMaskOperation before actual StoreVector
391 // operation to vector payload field.
392 if (is_mask && (value->bottom_type()->isa_vectmask() || bt != T_BOOLEAN)) {
393 value = gvn.transform(VectorStoreMaskNode::make(gvn, value, bt, num_elem));
394 // Although type of mask depends on its definition, in terms of storage everything is stored in boolean array.
395 bt = T_BOOLEAN;
396 assert(value->bottom_type()->is_vect()->element_basic_type() == bt,
397 "must be consistent with mask representation");
398 }
399
400 // Generate array allocation for the field which holds the values.
401 const TypeKlassPtr* array_klass = TypeKlassPtr::make(ciTypeArrayKlass::make(bt));
402 Node* arr = kit.new_array(kit.makecon(array_klass), kit.intcon(num_elem), 1);
403
404 // Store the vector value into the array.
405 // (The store should be captured by InitializeNode and turned into initialized store later.)
406 Node* arr_adr = kit.array_element_address(arr, kit.intcon(0), bt);
407 const TypePtr* arr_adr_type = arr_adr->bottom_type()->is_ptr();
408 Node* arr_mem = kit.memory(arr_adr);
409 Node* vstore = gvn.transform(StoreVectorNode::make(0,
410 kit.control(),
411 arr_mem,
412 arr_adr,
413 arr_adr_type,
414 value,
415 num_elem));
416 kit.set_memory(vstore, arr_adr_type);
417
418 C->set_max_vector_size(MAX2(C->max_vector_size(), vect_type->length_in_bytes()));
419
420 // Generate the allocate for the Vector object.
421 const TypeKlassPtr* klass_type = box_type->as_klass_type();
422 Node* klass_node = kit.makecon(klass_type);
423 Node* vec_obj = kit.new_instance(klass_node);
424
425 // Store the allocated array into object.
426 ciField* field = ciEnv::current()->vector_VectorPayload_klass()->get_field_by_name(ciSymbols::payload_name(),
427 ciSymbols::object_signature(),
428 false);
429 assert(field != nullptr, "");
430 Node* vec_field = kit.basic_plus_adr(vec_obj, field->offset_in_bytes());
431 const TypePtr* vec_adr_type = vec_field->bottom_type()->is_ptr();
432
433 // The store should be captured by InitializeNode and turned into initialized store later.
434 Node* field_store = gvn.transform(kit.access_store_at(vec_obj,
435 vec_field,
436 vec_adr_type,
437 arr,
438 TypeOopPtr::make_from_klass(field->type()->as_klass()),
439 T_OBJECT,
440 IN_HEAP));
441 kit.set_memory(field_store, vec_adr_type);
442
443 kit.replace_call(vbox_alloc, vec_obj, true);
444 C->remove_macro_node(vbox_alloc);
445
446 return vec_obj;
447 }
448
449 void PhaseVector::expand_vunbox_node(VectorUnboxNode* vec_unbox) {
450 if (vec_unbox->outcnt() > 0) {
451 GraphKit kit;
452 PhaseGVN& gvn = kit.gvn();
453
454 Node* obj = vec_unbox->obj();
455 const TypeInstPtr* tinst = gvn.type(obj)->isa_instptr();
456 ciInstanceKlass* from_kls = tinst->instance_klass();
457 const TypeVect* vt = vec_unbox->bottom_type()->is_vect();
458 BasicType bt = vt->element_basic_type();
459 BasicType masktype = bt;
460
461 if (is_vector_mask(from_kls)) {
462 bt = T_BOOLEAN;
463 } else if (is_vector_shuffle(from_kls)) {
464 bt = T_BYTE;
465 }
466
467 ciField* field = ciEnv::current()->vector_VectorPayload_klass()->get_field_by_name(ciSymbols::payload_name(),
468 ciSymbols::object_signature(),
469 false);
470 assert(field != nullptr, "");
471 int offset = field->offset_in_bytes();
472 Node* vec_adr = kit.basic_plus_adr(obj, offset);
473
474 Node* mem = vec_unbox->mem();
475 Node* ctrl = vec_unbox->in(0);
476 Node* vec_field_ld;
477 {
478 DecoratorSet decorators = MO_UNORDERED | IN_HEAP;
479 C2AccessValuePtr addr(vec_adr, vec_adr->bottom_type()->is_ptr());
480 MergeMemNode* local_mem = MergeMemNode::make(mem);
481 gvn.record_for_igvn(local_mem);
482 BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
483 C2OptAccess access(gvn, ctrl, local_mem, decorators, T_OBJECT, obj, addr);
484 const Type* type = TypeOopPtr::make_from_klass(field->type()->as_klass());
485 vec_field_ld = bs->load_at(access, type);
486 }
487
488 // For proper aliasing, attach concrete payload type.
489 ciKlass* payload_klass = ciTypeArrayKlass::make(bt);
490 const Type* payload_type = TypeAryPtr::make_from_klass(payload_klass)->cast_to_ptr_type(TypePtr::NotNull);
491 vec_field_ld = gvn.transform(new CastPPNode(nullptr, vec_field_ld, payload_type));
492
493 Node* adr = kit.array_element_address(vec_field_ld, gvn.intcon(0), bt);
494 const TypePtr* adr_type = adr->bottom_type()->is_ptr();
495 int num_elem = vt->length();
496 Node* vec_val_load = LoadVectorNode::make(0,
497 ctrl,
498 mem,
499 adr,
500 adr_type,
501 num_elem,
502 bt);
503 vec_val_load = gvn.transform(vec_val_load);
504
505 C->set_max_vector_size(MAX2(C->max_vector_size(), vt->length_in_bytes()));
506
507 if (is_vector_mask(from_kls)) {
508 vec_val_load = gvn.transform(new VectorLoadMaskNode(vec_val_load, TypeVect::makemask(masktype, num_elem)));
509 } else if (is_vector_shuffle(from_kls) && !vec_unbox->is_shuffle_to_vector()) {
510 assert(vec_unbox->bottom_type()->is_vect()->element_basic_type() == masktype, "expect shuffle type consistency");
511 vec_val_load = gvn.transform(new VectorLoadShuffleNode(vec_val_load, TypeVect::make(masktype, num_elem)));
512 }
513
514 gvn.hash_delete(vec_unbox);
515 vec_unbox->disconnect_inputs(C);
516 C->gvn_replace_by(vec_unbox, vec_val_load);
517 }
518 C->remove_macro_node(vec_unbox);
519 }
520
521 void PhaseVector::eliminate_vbox_alloc_node(VectorBoxAllocateNode* vbox_alloc) {
522 JVMState* jvms = clone_jvms(C, vbox_alloc);
523 GraphKit kit(jvms);
524 // Remove VBA, but leave a safepoint behind.
525 // Otherwise, it may end up with a loop without any safepoint polls.
526 kit.replace_call(vbox_alloc, kit.map(), true);
527 C->remove_macro_node(vbox_alloc);
528 }