| File: | jdk/src/hotspot/share/opto/idealKit.cpp |
| Warning: | line 522, column 9 Value stored to 'c' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /* |
| 2 | * Copyright (c) 2005, 2021, 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 "opto/addnode.hpp" |
| 27 | #include "opto/callnode.hpp" |
| 28 | #include "opto/cfgnode.hpp" |
| 29 | #include "opto/idealKit.hpp" |
| 30 | #include "opto/runtime.hpp" |
| 31 | |
| 32 | // Static initialization |
| 33 | |
| 34 | // This declares the position where vars are kept in the cvstate |
| 35 | // For some degree of consistency we use the TypeFunc enum to |
| 36 | // soak up spots in the inputs even though we only use early Control |
| 37 | // and Memory slots. (So far.) |
| 38 | const uint IdealKit::first_var = TypeFunc::Parms + 1; |
| 39 | |
| 40 | //----------------------------IdealKit----------------------------------------- |
| 41 | IdealKit::IdealKit(GraphKit* gkit, bool delay_all_transforms, bool has_declarations) : |
| 42 | C(gkit->C), _gvn(gkit->gvn()) { |
| 43 | _initial_ctrl = gkit->control(); |
| 44 | _initial_memory = gkit->merged_memory(); |
| 45 | _initial_i_o = gkit->i_o(); |
| 46 | _delay_all_transforms = delay_all_transforms; |
| 47 | _var_ct = 0; |
| 48 | _cvstate = NULL__null; |
| 49 | // We can go memory state free or else we need the entire memory state |
| 50 | assert(_initial_memory == NULL || _initial_memory->Opcode() == Op_MergeMem, "memory must be pre-split")do { if (!(_initial_memory == __null || _initial_memory->Opcode () == Op_MergeMem)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 50, "assert(" "_initial_memory == __null || _initial_memory->Opcode() == Op_MergeMem" ") failed", "memory must be pre-split"); ::breakpoint(); } } while (0); |
| 51 | assert(!_gvn.is_IterGVN(), "IdealKit can't be used during Optimize phase")do { if (!(!_gvn.is_IterGVN())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 51, "assert(" "!_gvn.is_IterGVN()" ") failed", "IdealKit can't be used during Optimize phase" ); ::breakpoint(); } } while (0); |
| 52 | int init_size = 5; |
| 53 | _pending_cvstates = new (C->node_arena()) GrowableArray<Node*>(C->node_arena(), init_size, 0, 0); |
| 54 | DEBUG_ONLY(_state = new (C->node_arena()) GrowableArray<int>(C->node_arena(), init_size, 0, 0))_state = new (C->node_arena()) GrowableArray<int>(C-> node_arena(), init_size, 0, 0); |
| 55 | if (!has_declarations) { |
| 56 | declarations_done(); |
| 57 | } |
| 58 | } |
| 59 | |
| 60 | //----------------------------sync_kit----------------------------------------- |
| 61 | void IdealKit::sync_kit(GraphKit* gkit) { |
| 62 | set_all_memory(gkit->merged_memory()); |
| 63 | set_i_o(gkit->i_o()); |
| 64 | set_ctrl(gkit->control()); |
| 65 | } |
| 66 | |
| 67 | //-------------------------------if_then------------------------------------- |
| 68 | // Create: if(left relop right) |
| 69 | // / \ |
| 70 | // iffalse iftrue |
| 71 | // Push the iffalse cvstate onto the stack. The iftrue becomes the current cvstate. |
| 72 | void IdealKit::if_then(Node* left, BoolTest::mask relop, |
| 73 | Node* right, float prob, float cnt, bool push_new_state) { |
| 74 | assert((state() & (BlockS|LoopS|IfThenS|ElseS)), "bad state for new If")do { if (!((state() & (BlockS|LoopS|IfThenS|ElseS)))) { ( *g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 74, "assert(" "(state() & (BlockS|LoopS|IfThenS|ElseS))" ") failed", "bad state for new If"); ::breakpoint(); } } while (0); |
| 75 | Node* bol; |
| 76 | if (left->bottom_type()->isa_ptr() == NULL__null) { |
| 77 | if (left->bottom_type()->isa_int() != NULL__null) { |
| 78 | bol = Bool(CmpI(left, right), relop); |
| 79 | } else { |
| 80 | assert(left->bottom_type()->isa_long() != NULL, "what else?")do { if (!(left->bottom_type()->isa_long() != __null)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 80, "assert(" "left->bottom_type()->isa_long() != __null" ") failed", "what else?"); ::breakpoint(); } } while (0); |
| 81 | bol = Bool(CmpL(left, right), relop); |
| 82 | } |
| 83 | |
| 84 | } else { |
| 85 | bol = Bool(CmpP(left, right), relop); |
| 86 | } |
| 87 | // Delay gvn.tranform on if-nodes until construction is finished |
| 88 | // to prevent a constant bool input from discarding a control output. |
| 89 | IfNode* iff = delay_transform(new IfNode(ctrl(), bol, prob, cnt))->as_If(); |
| 90 | Node* then = IfTrue(iff); |
| 91 | Node* elsen = IfFalse(iff); |
| 92 | Node* else_cvstate = copy_cvstate(); |
| 93 | else_cvstate->set_req(TypeFunc::Control, elsen); |
| 94 | _pending_cvstates->push(else_cvstate); |
| 95 | DEBUG_ONLY(if (push_new_state) _state->push(IfThenS))if (push_new_state) _state->push(IfThenS); |
| 96 | set_ctrl(then); |
| 97 | } |
| 98 | |
| 99 | //-------------------------------else_------------------------------------- |
| 100 | // Pop the else cvstate off the stack, and push the (current) then cvstate. |
| 101 | // The else cvstate becomes the current cvstate. |
| 102 | void IdealKit::else_() { |
| 103 | assert(state() == IfThenS, "bad state for new Else")do { if (!(state() == IfThenS)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 103, "assert(" "state() == IfThenS" ") failed", "bad state for new Else" ); ::breakpoint(); } } while (0); |
| 104 | Node* else_cvstate = _pending_cvstates->pop(); |
| 105 | DEBUG_ONLY(_state->pop())_state->pop(); |
| 106 | // save current (then) cvstate for later use at endif |
| 107 | _pending_cvstates->push(_cvstate); |
| 108 | DEBUG_ONLY(_state->push(ElseS))_state->push(ElseS); |
| 109 | _cvstate = else_cvstate; |
| 110 | } |
| 111 | |
| 112 | //-------------------------------end_if------------------------------------- |
| 113 | // Merge the "then" and "else" cvstates. |
| 114 | // |
| 115 | // The if_then() pushed a copy of the current state for later use |
| 116 | // as the initial state for a future "else" clause. The |
| 117 | // current state then became the initial state for the |
| 118 | // then clause. If an "else" clause was encountered, it will |
| 119 | // pop the top state and use it for it's initial state. |
| 120 | // It will also push the current state (the state at the end of |
| 121 | // the "then" clause) for latter use at the end_if. |
| 122 | // |
| 123 | // At the endif, the states are: |
| 124 | // 1) else exists a) current state is end of "else" clause |
| 125 | // b) top stack state is end of "then" clause |
| 126 | // |
| 127 | // 2) no else: a) current state is end of "then" clause |
| 128 | // b) top stack state is from the "if_then" which |
| 129 | // would have been the initial state of the else. |
| 130 | // |
| 131 | // Merging the states is accomplished by: |
| 132 | // 1) make a label for the merge |
| 133 | // 2) terminate the current state with a goto to the label |
| 134 | // 3) pop the top state from the stack and make it the |
| 135 | // current state |
| 136 | // 4) bind the label at the current state. Binding a label |
| 137 | // terminates the current state with a goto to the |
| 138 | // label and makes the label's state the current state. |
| 139 | // |
| 140 | void IdealKit::end_if() { |
| 141 | assert(state() & (IfThenS|ElseS), "bad state for new Endif")do { if (!(state() & (IfThenS|ElseS))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 141, "assert(" "state() & (IfThenS|ElseS)" ") failed", "bad state for new Endif" ); ::breakpoint(); } } while (0); |
| 142 | Node* lab = make_label(1); |
| 143 | |
| 144 | // Node* join_state = _pending_cvstates->pop(); |
| 145 | /* merging, join */ |
| 146 | goto_(lab); |
| 147 | _cvstate = _pending_cvstates->pop(); |
| 148 | |
| 149 | bind(lab); |
| 150 | DEBUG_ONLY(_state->pop())_state->pop(); |
| 151 | } |
| 152 | |
| 153 | //-------------------------------loop------------------------------------- |
| 154 | // Create the loop head portion (*) of: |
| 155 | // * iv = init |
| 156 | // * top: (region node) |
| 157 | // * if (iv relop limit) { |
| 158 | // loop body |
| 159 | // i = i + 1 |
| 160 | // goto top |
| 161 | // * } else // exits loop |
| 162 | // |
| 163 | // Pushes the loop top cvstate first, then the else (loop exit) cvstate |
| 164 | // onto the stack. |
| 165 | void IdealKit::loop(GraphKit* gkit, int nargs, IdealVariable& iv, Node* init, BoolTest::mask relop, Node* limit, float prob, float cnt) { |
| 166 | assert((state() & (BlockS|LoopS|IfThenS|ElseS)), "bad state for new loop")do { if (!((state() & (BlockS|LoopS|IfThenS|ElseS)))) { ( *g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 166, "assert(" "(state() & (BlockS|LoopS|IfThenS|ElseS))" ") failed", "bad state for new loop"); ::breakpoint(); } } while (0); |
| 167 | if (UseLoopPredicate) { |
| 168 | // Sync IdealKit and graphKit. |
| 169 | gkit->sync_kit(*this); |
| 170 | // Add loop predicate. |
| 171 | gkit->add_empty_predicates(nargs); |
| 172 | // Update IdealKit memory. |
| 173 | sync_kit(gkit); |
| 174 | } |
| 175 | set(iv, init); |
| 176 | Node* head = make_label(1); |
| 177 | bind(head); |
| 178 | _pending_cvstates->push(head); // push for use at end_loop |
| 179 | _cvstate = copy_cvstate(); |
| 180 | if_then(value(iv), relop, limit, prob, cnt, false /* no new state */); |
| 181 | DEBUG_ONLY(_state->push(LoopS))_state->push(LoopS); |
| 182 | assert(ctrl()->is_IfTrue(), "true branch stays in loop")do { if (!(ctrl()->is_IfTrue())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 182, "assert(" "ctrl()->is_IfTrue()" ") failed", "true branch stays in loop" ); ::breakpoint(); } } while (0); |
| 183 | assert(_pending_cvstates->top()->in(TypeFunc::Control)->is_IfFalse(), "false branch exits loop")do { if (!(_pending_cvstates->top()->in(TypeFunc::Control )->is_IfFalse())) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 183, "assert(" "_pending_cvstates->top()->in(TypeFunc::Control)->is_IfFalse()" ") failed", "false branch exits loop"); ::breakpoint(); } } while (0); |
| 184 | } |
| 185 | |
| 186 | //-------------------------------end_loop------------------------------------- |
| 187 | // Creates the goto top label. |
| 188 | // Expects the else (loop exit) cvstate to be on top of the |
| 189 | // stack, and the loop top cvstate to be 2nd. |
| 190 | void IdealKit::end_loop() { |
| 191 | assert((state() == LoopS), "bad state for new end_loop")do { if (!((state() == LoopS))) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 191, "assert(" "(state() == LoopS)" ") failed", "bad state for new end_loop" ); ::breakpoint(); } } while (0); |
| 192 | Node* exit = _pending_cvstates->pop(); |
| 193 | Node* head = _pending_cvstates->pop(); |
| 194 | goto_(head); |
| 195 | clear(head); |
| 196 | DEBUG_ONLY(_state->pop())_state->pop(); |
| 197 | _cvstate = exit; |
| 198 | } |
| 199 | |
| 200 | //-------------------------------make_label------------------------------------- |
| 201 | // Creates a label. The number of goto's |
| 202 | // must be specified (which should be 1 less than |
| 203 | // the number of precedessors.) |
| 204 | Node* IdealKit::make_label(int goto_ct) { |
| 205 | assert(_cvstate != NULL, "must declare variables before labels")do { if (!(_cvstate != __null)) { (*g_assert_poison) = 'X';; report_vm_error ("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 205, "assert(" "_cvstate != __null" ") failed", "must declare variables before labels" ); ::breakpoint(); } } while (0); |
| 206 | Node* lab = new_cvstate(); |
| 207 | int sz = 1 + goto_ct + 1 /* fall thru */; |
| 208 | Node* reg = delay_transform(new RegionNode(sz)); |
| 209 | lab->init_req(TypeFunc::Control, reg); |
| 210 | return lab; |
| 211 | } |
| 212 | |
| 213 | //-------------------------------bind------------------------------------- |
| 214 | // Bind a label at the current cvstate by simulating |
| 215 | // a goto to the label. |
| 216 | void IdealKit::bind(Node* lab) { |
| 217 | goto_(lab, true /* bind */); |
| 218 | _cvstate = lab; |
| 219 | } |
| 220 | |
| 221 | //-------------------------------goto_------------------------------------- |
| 222 | // Make the current cvstate a predecessor of the label, |
| 223 | // creating phi's to merge values. If bind is true and |
| 224 | // this is not the last control edge, then ensure that |
| 225 | // all live values have phis created. Used to create phis |
| 226 | // at loop-top regions. |
| 227 | void IdealKit::goto_(Node* lab, bool bind) { |
| 228 | Node* reg = lab->in(TypeFunc::Control); |
| 229 | // find next empty slot in region |
| 230 | uint slot = 1; |
| 231 | while (slot < reg->req() && reg->in(slot) != NULL__null) slot++; |
| 232 | assert(slot < reg->req(), "too many gotos")do { if (!(slot < reg->req())) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 232, "assert(" "slot < reg->req()" ") failed", "too many gotos" ); ::breakpoint(); } } while (0); |
| 233 | // If this is last predecessor, then don't force phi creation |
| 234 | if (slot == reg->req() - 1) bind = false; |
| 235 | reg->init_req(slot, ctrl()); |
| 236 | assert(first_var + _var_ct == _cvstate->req(), "bad _cvstate size")do { if (!(first_var + _var_ct == _cvstate->req())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 236, "assert(" "first_var + _var_ct == _cvstate->req()" ") failed" , "bad _cvstate size"); ::breakpoint(); } } while (0); |
| 237 | for (uint i = first_var; i < _cvstate->req(); i++) { |
| 238 | |
| 239 | // l is the value of var reaching the label. Could be a single value |
| 240 | // reaching the label, or a phi that merges multiples values reaching |
| 241 | // the label. The latter is true if the label's input: in(..) is |
| 242 | // a phi whose control input is the region node for the label. |
| 243 | |
| 244 | Node* l = lab->in(i); |
| 245 | // Get the current value of the var |
| 246 | Node* m = _cvstate->in(i); |
| 247 | // If the var went unused no need for a phi |
| 248 | if (m == NULL__null) { |
| 249 | continue; |
| 250 | } else if (l == NULL__null || m == l) { |
| 251 | // Only one unique value "m" is known to reach this label so a phi |
| 252 | // is not yet necessary unless: |
| 253 | // the label is being bound and all predecessors have not been seen, |
| 254 | // in which case "bind" will be true. |
| 255 | if (bind) { |
| 256 | m = promote_to_phi(m, reg); |
| 257 | } |
| 258 | // Record the phi/value used for this var in the label's cvstate |
| 259 | lab->set_req(i, m); |
| 260 | } else { |
| 261 | // More than one value for the variable reaches this label so |
| 262 | // a create a phi if one does not already exist. |
| 263 | if (!was_promoted_to_phi(l, reg)) { |
| 264 | l = promote_to_phi(l, reg); |
| 265 | lab->set_req(i, l); |
| 266 | } |
| 267 | // Record in the phi, the var's value from the current state |
| 268 | l->set_req(slot, m); |
| 269 | } |
| 270 | } |
| 271 | do_memory_merge(_cvstate, lab); |
| 272 | stop(); |
| 273 | } |
| 274 | |
| 275 | //-----------------------------promote_to_phi----------------------------------- |
| 276 | Node* IdealKit::promote_to_phi(Node* n, Node* reg) { |
| 277 | assert(!was_promoted_to_phi(n, reg), "n already promoted to phi on this region")do { if (!(!was_promoted_to_phi(n, reg))) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 277, "assert(" "!was_promoted_to_phi(n, reg)" ") failed", "n already promoted to phi on this region" ); ::breakpoint(); } } while (0); |
| 278 | // Get a conservative type for the phi |
| 279 | const BasicType bt = n->bottom_type()->basic_type(); |
| 280 | const Type* ct = Type::get_const_basic_type(bt); |
| 281 | return delay_transform(PhiNode::make(reg, n, ct)); |
| 282 | } |
| 283 | |
| 284 | //-----------------------------declarations_done------------------------------- |
| 285 | void IdealKit::declarations_done() { |
| 286 | _cvstate = new_cvstate(); // initialize current cvstate |
| 287 | set_ctrl(_initial_ctrl); // initialize control in current cvstate |
| 288 | set_all_memory(_initial_memory);// initialize memory in current cvstate |
| 289 | set_i_o(_initial_i_o); // initialize i_o in current cvstate |
| 290 | DEBUG_ONLY(_state->push(BlockS))_state->push(BlockS); |
| 291 | } |
| 292 | |
| 293 | //-----------------------------transform----------------------------------- |
| 294 | Node* IdealKit::transform(Node* n) { |
| 295 | if (_delay_all_transforms) { |
| 296 | return delay_transform(n); |
| 297 | } else { |
| 298 | n = gvn().transform(n); |
| 299 | C->record_for_igvn(n); |
| 300 | return n; |
| 301 | } |
| 302 | } |
| 303 | |
| 304 | //-----------------------------delay_transform----------------------------------- |
| 305 | Node* IdealKit::delay_transform(Node* n) { |
| 306 | // Delay transform until IterativeGVN |
| 307 | gvn().set_type(n, n->bottom_type()); |
| 308 | C->record_for_igvn(n); |
| 309 | return n; |
| 310 | } |
| 311 | |
| 312 | //-----------------------------new_cvstate----------------------------------- |
| 313 | Node* IdealKit::new_cvstate() { |
| 314 | uint sz = _var_ct + first_var; |
| 315 | return new Node(sz); |
| 316 | } |
| 317 | |
| 318 | //-----------------------------copy_cvstate----------------------------------- |
| 319 | Node* IdealKit::copy_cvstate() { |
| 320 | Node* ns = new_cvstate(); |
| 321 | for (uint i = 0; i < ns->req(); i++) ns->init_req(i, _cvstate->in(i)); |
| 322 | // We must clone memory since it will be updated as we do stores. |
| 323 | ns->set_req(TypeFunc::Memory, MergeMemNode::make(ns->in(TypeFunc::Memory))); |
| 324 | return ns; |
| 325 | } |
| 326 | |
| 327 | //-----------------------------clear----------------------------------- |
| 328 | void IdealKit::clear(Node* m) { |
| 329 | for (uint i = 0; i < m->req(); i++) m->set_req(i, NULL__null); |
| 330 | } |
| 331 | |
| 332 | //-----------------------------IdealVariable---------------------------- |
| 333 | IdealVariable::IdealVariable(IdealKit &k) { |
| 334 | k.declare(this); |
| 335 | } |
| 336 | |
| 337 | Node* IdealKit::memory(uint alias_idx) { |
| 338 | MergeMemNode* mem = merged_memory(); |
| 339 | Node* p = mem->memory_at(alias_idx); |
| 340 | _gvn.set_type(p, Type::MEMORY); // must be mapped |
| 341 | return p; |
| 342 | } |
| 343 | |
| 344 | void IdealKit::set_memory(Node* mem, uint alias_idx) { |
| 345 | merged_memory()->set_memory_at(alias_idx, mem); |
| 346 | } |
| 347 | |
| 348 | //----------------------------- make_load ---------------------------- |
| 349 | Node* IdealKit::load(Node* ctl, |
| 350 | Node* adr, |
| 351 | const Type* t, |
| 352 | BasicType bt, |
| 353 | int adr_idx, |
| 354 | bool require_atomic_access, |
| 355 | MemNode::MemOrd mo) { |
| 356 | |
| 357 | assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" )do { if (!(adr_idx != Compile::AliasIdxTop)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 357, "assert(" "adr_idx != Compile::AliasIdxTop" ") failed" , "use other make_load factory"); ::breakpoint(); } } while ( 0); |
| 358 | const TypePtr* adr_type = NULL__null; // debug-mode-only argument |
| 359 | debug_only(adr_type = C->get_adr_type(adr_idx))adr_type = C->get_adr_type(adr_idx); |
| 360 | Node* mem = memory(adr_idx); |
| 361 | Node* ld; |
| 362 | if (require_atomic_access && bt == T_LONG) { |
| 363 | ld = LoadLNode::make_atomic(ctl, mem, adr, adr_type, t, mo); |
| 364 | } else { |
| 365 | ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo); |
| 366 | } |
| 367 | return transform(ld); |
| 368 | } |
| 369 | |
| 370 | Node* IdealKit::store(Node* ctl, Node* adr, Node *val, BasicType bt, |
| 371 | int adr_idx, |
| 372 | MemNode::MemOrd mo, bool require_atomic_access, |
| 373 | bool mismatched) { |
| 374 | assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory")do { if (!(adr_idx != Compile::AliasIdxTop)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 374, "assert(" "adr_idx != Compile::AliasIdxTop" ") failed" , "use other store_to_memory factory"); ::breakpoint(); } } while (0); |
| 375 | const TypePtr* adr_type = NULL__null; |
| 376 | debug_only(adr_type = C->get_adr_type(adr_idx))adr_type = C->get_adr_type(adr_idx); |
| 377 | Node *mem = memory(adr_idx); |
| 378 | Node* st; |
| 379 | if (require_atomic_access && bt == T_LONG) { |
| 380 | st = StoreLNode::make_atomic(ctl, mem, adr, adr_type, val, mo); |
| 381 | } else { |
| 382 | st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt, mo); |
| 383 | } |
| 384 | if (mismatched) { |
| 385 | st->as_Store()->set_mismatched_access(); |
| 386 | } |
| 387 | st = transform(st); |
| 388 | set_memory(st, adr_idx); |
| 389 | |
| 390 | return st; |
| 391 | } |
| 392 | |
| 393 | // Card mark store. Must be ordered so that it will come after the store of |
| 394 | // the oop. |
| 395 | Node* IdealKit::storeCM(Node* ctl, Node* adr, Node *val, Node* oop_store, int oop_adr_idx, |
| 396 | BasicType bt, |
| 397 | int adr_idx) { |
| 398 | assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory" )do { if (!(adr_idx != Compile::AliasIdxTop)) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 398, "assert(" "adr_idx != Compile::AliasIdxTop" ") failed" , "use other store_to_memory factory"); ::breakpoint(); } } while (0); |
| 399 | const TypePtr* adr_type = NULL__null; |
| 400 | debug_only(adr_type = C->get_adr_type(adr_idx))adr_type = C->get_adr_type(adr_idx); |
| 401 | Node *mem = memory(adr_idx); |
| 402 | |
| 403 | // Add required edge to oop_store, optimizer does not support precedence edges. |
| 404 | // Convert required edge to precedence edge before allocation. |
| 405 | Node* st = new StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx); |
| 406 | |
| 407 | st = transform(st); |
| 408 | set_memory(st, adr_idx); |
| 409 | |
| 410 | return st; |
| 411 | } |
| 412 | |
| 413 | //---------------------------- do_memory_merge -------------------------------- |
| 414 | // The memory from one merging cvstate needs to be merged with the memory for another |
| 415 | // join cvstate. If the join cvstate doesn't have a merged memory yet then we |
| 416 | // can just copy the state from the merging cvstate |
| 417 | |
| 418 | // Merge one slow path into the rest of memory. |
| 419 | void IdealKit::do_memory_merge(Node* merging, Node* join) { |
| 420 | |
| 421 | // Get the region for the join state |
| 422 | Node* join_region = join->in(TypeFunc::Control); |
| 423 | assert(join_region != NULL, "join region must exist")do { if (!(join_region != __null)) { (*g_assert_poison) = 'X' ;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 423, "assert(" "join_region != __null" ") failed", "join region must exist" ); ::breakpoint(); } } while (0); |
| 424 | if (join->in(TypeFunc::I_O) == NULL__null ) { |
| 425 | join->set_req(TypeFunc::I_O, merging->in(TypeFunc::I_O)); |
| 426 | } |
| 427 | if (join->in(TypeFunc::Memory) == NULL__null ) { |
| 428 | join->set_req(TypeFunc::Memory, merging->in(TypeFunc::Memory)); |
| 429 | return; |
| 430 | } |
| 431 | |
| 432 | // The control flow for merging must have already been attached to the join region |
| 433 | // we need its index for the phis. |
| 434 | uint slot; |
| 435 | for (slot = 1; slot < join_region->req() ; slot ++ ) { |
| 436 | if (join_region->in(slot) == merging->in(TypeFunc::Control)) break; |
| 437 | } |
| 438 | assert(slot != join_region->req(), "edge must already exist")do { if (!(slot != join_region->req())) { (*g_assert_poison ) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 438, "assert(" "slot != join_region->req()" ") failed", "edge must already exist" ); ::breakpoint(); } } while (0); |
| 439 | |
| 440 | MergeMemNode* join_m = join->in(TypeFunc::Memory)->as_MergeMem(); |
| 441 | MergeMemNode* merging_m = merging->in(TypeFunc::Memory)->as_MergeMem(); |
| 442 | |
| 443 | // join_m should be an ancestor mergemem of merging |
| 444 | // Slow path memory comes from the current map (which is from a slow call) |
| 445 | // Fast path/null path memory comes from the call's input |
| 446 | |
| 447 | // Merge the other fast-memory inputs with the new slow-default memory. |
| 448 | // for (MergeMemStream mms(merged_memory(), fast_mem->as_MergeMem()); mms.next_non_empty2(); ) { |
| 449 | for (MergeMemStream mms(join_m, merging_m); mms.next_non_empty2(); ) { |
| 450 | Node* join_slice = mms.force_memory(); |
| 451 | Node* merging_slice = mms.memory2(); |
| 452 | if (join_slice != merging_slice) { |
| 453 | PhiNode* phi; |
| 454 | // bool new_phi = false; |
| 455 | // Is the phi for this slice one that we created for this join region or simply |
| 456 | // one we copied? If it is ours then add |
| 457 | if (join_slice->is_Phi() && join_slice->as_Phi()->region() == join_region) { |
| 458 | phi = join_slice->as_Phi(); |
| 459 | } else { |
| 460 | // create the phi with join_slice filling supplying memory for all of the |
| 461 | // control edges to the join region |
| 462 | phi = PhiNode::make(join_region, join_slice, Type::MEMORY, mms.adr_type(C)); |
| 463 | phi = (PhiNode*) delay_transform(phi); |
| 464 | // gvn().set_type(phi, Type::MEMORY); |
| 465 | // new_phi = true; |
| 466 | } |
| 467 | // Now update the phi with the slice for the merging slice |
| 468 | phi->set_req(slot, merging_slice/* slow_path, slow_slice */); |
| 469 | // this updates join_m with the phi |
| 470 | mms.set_memory(phi); |
| 471 | } |
| 472 | } |
| 473 | |
| 474 | Node* join_io = join->in(TypeFunc::I_O); |
| 475 | Node* merging_io = merging->in(TypeFunc::I_O); |
| 476 | if (join_io != merging_io) { |
| 477 | PhiNode* phi; |
| 478 | if (join_io->is_Phi() && join_io->as_Phi()->region() == join_region) { |
| 479 | phi = join_io->as_Phi(); |
| 480 | } else { |
| 481 | phi = PhiNode::make(join_region, join_io, Type::ABIO); |
| 482 | phi = (PhiNode*) delay_transform(phi); |
| 483 | join->set_req(TypeFunc::I_O, phi); |
| 484 | } |
| 485 | phi->set_req(slot, merging_io); |
| 486 | } |
| 487 | } |
| 488 | |
| 489 | |
| 490 | //----------------------------- make_call ---------------------------- |
| 491 | // Trivial runtime call |
| 492 | Node* IdealKit::make_leaf_call(const TypeFunc *slow_call_type, |
| 493 | address slow_call, |
| 494 | const char *leaf_name, |
| 495 | Node* parm0, |
| 496 | Node* parm1, |
| 497 | Node* parm2, |
| 498 | Node* parm3) { |
| 499 | |
| 500 | // We only handle taking in RawMem and modifying RawMem |
| 501 | const TypePtr* adr_type = TypeRawPtr::BOTTOM; |
| 502 | uint adr_idx = C->get_alias_index(adr_type); |
| 503 | |
| 504 | // Slow-path leaf call |
| 505 | CallNode *call = (CallNode*)new CallLeafNode( slow_call_type, slow_call, leaf_name, adr_type); |
| 506 | |
| 507 | // Set fixed predefined input arguments |
| 508 | call->init_req( TypeFunc::Control, ctrl() ); |
| 509 | call->init_req( TypeFunc::I_O , top() ) ; // does no i/o |
| 510 | // Narrow memory as only memory input |
| 511 | call->init_req( TypeFunc::Memory , memory(adr_idx)); |
| 512 | call->init_req( TypeFunc::FramePtr, top() /* frameptr() */ ); |
| 513 | call->init_req( TypeFunc::ReturnAdr, top() ); |
| 514 | |
| 515 | if (parm0 != NULL__null) call->init_req(TypeFunc::Parms+0, parm0); |
| 516 | if (parm1 != NULL__null) call->init_req(TypeFunc::Parms+1, parm1); |
| 517 | if (parm2 != NULL__null) call->init_req(TypeFunc::Parms+2, parm2); |
| 518 | if (parm3 != NULL__null) call->init_req(TypeFunc::Parms+3, parm3); |
| 519 | |
| 520 | // Node *c = _gvn.transform(call); |
| 521 | call = (CallNode *) _gvn.transform(call); |
| 522 | Node *c = call; // dbx gets confused with call call->dump() |
Value stored to 'c' during its initialization is never read | |
| 523 | |
| 524 | // Slow leaf call has no side-effects, sets few values |
| 525 | |
| 526 | set_ctrl(transform( new ProjNode(call,TypeFunc::Control) )); |
| 527 | |
| 528 | // Make memory for the call |
| 529 | Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) ); |
| 530 | |
| 531 | // Set the RawPtr memory state only. |
| 532 | set_memory(mem, adr_idx); |
| 533 | |
| 534 | assert(C->alias_type(call->adr_type()) == C->alias_type(adr_type),do { if (!(C->alias_type(call->adr_type()) == C->alias_type (adr_type))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 535, "assert(" "C->alias_type(call->adr_type()) == C->alias_type(adr_type)" ") failed", "call node must be constructed correctly"); ::breakpoint (); } } while (0) |
| 535 | "call node must be constructed correctly")do { if (!(C->alias_type(call->adr_type()) == C->alias_type (adr_type))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 535, "assert(" "C->alias_type(call->adr_type()) == C->alias_type(adr_type)" ") failed", "call node must be constructed correctly"); ::breakpoint (); } } while (0); |
| 536 | Node* res = NULL__null; |
| 537 | if (slow_call_type->range()->cnt() > TypeFunc::Parms) { |
| 538 | assert(slow_call_type->range()->cnt() == TypeFunc::Parms+1, "only one return value")do { if (!(slow_call_type->range()->cnt() == TypeFunc:: Parms+1)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 538, "assert(" "slow_call_type->range()->cnt() == TypeFunc::Parms+1" ") failed", "only one return value"); ::breakpoint(); } } while (0); |
| 539 | res = transform(new ProjNode(call, TypeFunc::Parms)); |
| 540 | } |
| 541 | return res; |
| 542 | } |
| 543 | |
| 544 | void IdealKit::make_leaf_call_no_fp(const TypeFunc *slow_call_type, |
| 545 | address slow_call, |
| 546 | const char *leaf_name, |
| 547 | const TypePtr* adr_type, |
| 548 | Node* parm0, |
| 549 | Node* parm1, |
| 550 | Node* parm2, |
| 551 | Node* parm3) { |
| 552 | |
| 553 | // We only handle taking in RawMem and modifying RawMem |
| 554 | uint adr_idx = C->get_alias_index(adr_type); |
| 555 | |
| 556 | // Slow-path leaf call |
| 557 | CallNode *call = (CallNode*)new CallLeafNoFPNode( slow_call_type, slow_call, leaf_name, adr_type); |
| 558 | |
| 559 | // Set fixed predefined input arguments |
| 560 | call->init_req( TypeFunc::Control, ctrl() ); |
| 561 | call->init_req( TypeFunc::I_O , top() ) ; // does no i/o |
| 562 | // Narrow memory as only memory input |
| 563 | call->init_req( TypeFunc::Memory , memory(adr_idx)); |
| 564 | call->init_req( TypeFunc::FramePtr, top() /* frameptr() */ ); |
| 565 | call->init_req( TypeFunc::ReturnAdr, top() ); |
| 566 | |
| 567 | if (parm0 != NULL__null) call->init_req(TypeFunc::Parms+0, parm0); |
| 568 | if (parm1 != NULL__null) call->init_req(TypeFunc::Parms+1, parm1); |
| 569 | if (parm2 != NULL__null) call->init_req(TypeFunc::Parms+2, parm2); |
| 570 | if (parm3 != NULL__null) call->init_req(TypeFunc::Parms+3, parm3); |
| 571 | |
| 572 | // Node *c = _gvn.transform(call); |
| 573 | call = (CallNode *) _gvn.transform(call); |
| 574 | Node *c = call; // dbx gets confused with call call->dump() |
| 575 | |
| 576 | // Slow leaf call has no side-effects, sets few values |
| 577 | |
| 578 | set_ctrl(transform( new ProjNode(call,TypeFunc::Control) )); |
| 579 | |
| 580 | // Make memory for the call |
| 581 | Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) ); |
| 582 | |
| 583 | // Set the RawPtr memory state only. |
| 584 | set_memory(mem, adr_idx); |
| 585 | |
| 586 | assert(C->alias_type(call->adr_type()) == C->alias_type(adr_type),do { if (!(C->alias_type(call->adr_type()) == C->alias_type (adr_type))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 587, "assert(" "C->alias_type(call->adr_type()) == C->alias_type(adr_type)" ") failed", "call node must be constructed correctly"); ::breakpoint (); } } while (0) |
| 587 | "call node must be constructed correctly")do { if (!(C->alias_type(call->adr_type()) == C->alias_type (adr_type))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/opto/idealKit.cpp" , 587, "assert(" "C->alias_type(call->adr_type()) == C->alias_type(adr_type)" ") failed", "call node must be constructed correctly"); ::breakpoint (); } } while (0); |
| 588 | } |