1 /*
2 * Copyright (c) 2015, 2021, Red Hat, Inc. All rights reserved.
3 * Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
368 }
369 } else if (n->is_LoadStore()) {
370 if (n->in(MemNode::ValueIn)->bottom_type()->make_ptr() &&
371 !verify_helper(n->in(MemNode::ValueIn), phis, visited, ShenandoahIUBarrier ? ShenandoahOopStore : ShenandoahValue, trace, barriers_used)) {
372 report_verify_failure("Shenandoah verification: LoadStore (value) should have barriers", n);
373 }
374
375 if (n->in(MemNode::Address)->bottom_type()->make_oopptr() && !verify_helper(n->in(MemNode::Address), phis, visited, ShenandoahStore, trace, barriers_used)) {
376 report_verify_failure("Shenandoah verification: LoadStore (address) should have barriers", n);
377 }
378 } else if (n->Opcode() == Op_CallLeafNoFP || n->Opcode() == Op_CallLeaf) {
379 CallNode* call = n->as_Call();
380
381 static struct {
382 const char* name;
383 struct {
384 int pos;
385 verify_type t;
386 } args[6];
387 } calls[] = {
388 "aescrypt_encryptBlock",
389 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahStore }, { TypeFunc::Parms+2, ShenandoahLoad },
390 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
391 "aescrypt_decryptBlock",
392 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahStore }, { TypeFunc::Parms+2, ShenandoahLoad },
393 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
394 "multiplyToLen",
395 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+2, ShenandoahLoad }, { TypeFunc::Parms+4, ShenandoahStore },
396 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
397 "squareToLen",
398 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+2, ShenandoahLoad }, { -1, ShenandoahNone},
399 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
400 "montgomery_multiply",
401 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahLoad }, { TypeFunc::Parms+2, ShenandoahLoad },
402 { TypeFunc::Parms+6, ShenandoahStore }, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
403 "montgomery_square",
404 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahLoad }, { TypeFunc::Parms+5, ShenandoahStore },
405 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
406 "mulAdd",
407 { { TypeFunc::Parms, ShenandoahStore }, { TypeFunc::Parms+1, ShenandoahLoad }, { -1, ShenandoahNone},
2150 int iteration = 0;
2151 Node_List dead_phis;
2152 while (progress) {
2153 progress = false;
2154 iteration++;
2155 assert(iteration <= 2+max_depth || _phase->C->has_irreducible_loop() || has_never_branch(_phase->C->root()), "");
2156 if (trace) { tty->print_cr("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"); }
2157
2158 for (int i = rpo_list.size() - 1; i >= 0; i--) {
2159 Node* c = rpo_list.at(i);
2160
2161 Node* prev_mem = _memory_nodes[c->_idx];
2162 if (c->is_Region() && (_include_lsm || !c->is_OuterStripMinedLoop())) {
2163 Node* prev_region = regions[c->_idx];
2164 Node* unique = nullptr;
2165 for (uint j = 1; j < c->req() && unique != NodeSentinel; j++) {
2166 Node* m = _memory_nodes[c->in(j)->_idx];
2167 assert(m != nullptr || (c->is_Loop() && j == LoopNode::LoopBackControl && iteration == 1) || _phase->C->has_irreducible_loop() || has_never_branch(_phase->C->root()), "expect memory state");
2168 if (m != nullptr) {
2169 if (m == prev_region && ((c->is_Loop() && j == LoopNode::LoopBackControl) || (prev_region->is_Phi() && prev_region->in(0) == c))) {
2170 assert(c->is_Loop() && j == LoopNode::LoopBackControl || _phase->C->has_irreducible_loop() || has_never_branch(_phase->C->root()), "");
2171 // continue
2172 } else if (unique == nullptr) {
2173 unique = m;
2174 } else if (m == unique) {
2175 // continue
2176 } else {
2177 unique = NodeSentinel;
2178 }
2179 }
2180 }
2181 assert(unique != nullptr, "empty phi???");
2182 if (unique != NodeSentinel) {
2183 if (prev_region != nullptr && prev_region->is_Phi() && prev_region->in(0) == c) {
2184 dead_phis.push(prev_region);
2185 }
2186 regions.map(c->_idx, unique);
2187 } else {
2188 Node* phi = nullptr;
2189 if (prev_region != nullptr && prev_region->is_Phi() && prev_region->in(0) == c && prev_region->_idx >= last) {
2190 phi = prev_region;
|
1 /*
2 * Copyright (c) 2015, 2021, Red Hat, Inc. All rights reserved.
3 * Copyright (C) 2022 THL A29 Limited, a Tencent company. All rights reserved.
4 * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
5 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 *
7 * This code is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 only, as
9 * published by the Free Software Foundation.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 *
369 }
370 } else if (n->is_LoadStore()) {
371 if (n->in(MemNode::ValueIn)->bottom_type()->make_ptr() &&
372 !verify_helper(n->in(MemNode::ValueIn), phis, visited, ShenandoahIUBarrier ? ShenandoahOopStore : ShenandoahValue, trace, barriers_used)) {
373 report_verify_failure("Shenandoah verification: LoadStore (value) should have barriers", n);
374 }
375
376 if (n->in(MemNode::Address)->bottom_type()->make_oopptr() && !verify_helper(n->in(MemNode::Address), phis, visited, ShenandoahStore, trace, barriers_used)) {
377 report_verify_failure("Shenandoah verification: LoadStore (address) should have barriers", n);
378 }
379 } else if (n->Opcode() == Op_CallLeafNoFP || n->Opcode() == Op_CallLeaf) {
380 CallNode* call = n->as_Call();
381
382 static struct {
383 const char* name;
384 struct {
385 int pos;
386 verify_type t;
387 } args[6];
388 } calls[] = {
389 "array_partition_stub",
390 { { TypeFunc::Parms, ShenandoahStore }, { TypeFunc::Parms+4, ShenandoahStore }, { -1, ShenandoahNone },
391 { -1, ShenandoahNone }, { -1, ShenandoahNone }, { -1, ShenandoahNone } },
392 "arraysort_stub",
393 { { TypeFunc::Parms, ShenandoahStore }, { -1, ShenandoahNone }, { -1, ShenandoahNone },
394 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
395 "aescrypt_encryptBlock",
396 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahStore }, { TypeFunc::Parms+2, ShenandoahLoad },
397 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
398 "aescrypt_decryptBlock",
399 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahStore }, { TypeFunc::Parms+2, ShenandoahLoad },
400 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
401 "multiplyToLen",
402 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+2, ShenandoahLoad }, { TypeFunc::Parms+4, ShenandoahStore },
403 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
404 "squareToLen",
405 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+2, ShenandoahLoad }, { -1, ShenandoahNone},
406 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
407 "montgomery_multiply",
408 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahLoad }, { TypeFunc::Parms+2, ShenandoahLoad },
409 { TypeFunc::Parms+6, ShenandoahStore }, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
410 "montgomery_square",
411 { { TypeFunc::Parms, ShenandoahLoad }, { TypeFunc::Parms+1, ShenandoahLoad }, { TypeFunc::Parms+5, ShenandoahStore },
412 { -1, ShenandoahNone}, { -1, ShenandoahNone}, { -1, ShenandoahNone} },
413 "mulAdd",
414 { { TypeFunc::Parms, ShenandoahStore }, { TypeFunc::Parms+1, ShenandoahLoad }, { -1, ShenandoahNone},
2157 int iteration = 0;
2158 Node_List dead_phis;
2159 while (progress) {
2160 progress = false;
2161 iteration++;
2162 assert(iteration <= 2+max_depth || _phase->C->has_irreducible_loop() || has_never_branch(_phase->C->root()), "");
2163 if (trace) { tty->print_cr("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"); }
2164
2165 for (int i = rpo_list.size() - 1; i >= 0; i--) {
2166 Node* c = rpo_list.at(i);
2167
2168 Node* prev_mem = _memory_nodes[c->_idx];
2169 if (c->is_Region() && (_include_lsm || !c->is_OuterStripMinedLoop())) {
2170 Node* prev_region = regions[c->_idx];
2171 Node* unique = nullptr;
2172 for (uint j = 1; j < c->req() && unique != NodeSentinel; j++) {
2173 Node* m = _memory_nodes[c->in(j)->_idx];
2174 assert(m != nullptr || (c->is_Loop() && j == LoopNode::LoopBackControl && iteration == 1) || _phase->C->has_irreducible_loop() || has_never_branch(_phase->C->root()), "expect memory state");
2175 if (m != nullptr) {
2176 if (m == prev_region && ((c->is_Loop() && j == LoopNode::LoopBackControl) || (prev_region->is_Phi() && prev_region->in(0) == c))) {
2177 assert((c->is_Loop() && j == LoopNode::LoopBackControl) || _phase->C->has_irreducible_loop() || has_never_branch(_phase->C->root()), "");
2178 // continue
2179 } else if (unique == nullptr) {
2180 unique = m;
2181 } else if (m == unique) {
2182 // continue
2183 } else {
2184 unique = NodeSentinel;
2185 }
2186 }
2187 }
2188 assert(unique != nullptr, "empty phi???");
2189 if (unique != NodeSentinel) {
2190 if (prev_region != nullptr && prev_region->is_Phi() && prev_region->in(0) == c) {
2191 dead_phis.push(prev_region);
2192 }
2193 regions.map(c->_idx, unique);
2194 } else {
2195 Node* phi = nullptr;
2196 if (prev_region != nullptr && prev_region->is_Phi() && prev_region->in(0) == c && prev_region->_idx >= last) {
2197 phi = prev_region;
|