Mon, 25 May 2020 14:24:27 +0800
8244407: JVM crashes after transformation in C2 IdealLoopTree::split_fall_in
Reviewed-by: thartmann, kvn, andrew
Contributed-by: zhouyong44@huawei.com
duke@435 | 1 | /* |
kevinw@9333 | 2 | * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved. |
duke@435 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
duke@435 | 4 | * |
duke@435 | 5 | * This code is free software; you can redistribute it and/or modify it |
duke@435 | 6 | * under the terms of the GNU General Public License version 2 only, as |
duke@435 | 7 | * published by the Free Software Foundation. |
duke@435 | 8 | * |
duke@435 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
duke@435 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
duke@435 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
duke@435 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
duke@435 | 13 | * accompanied this code). |
duke@435 | 14 | * |
duke@435 | 15 | * You should have received a copy of the GNU General Public License version |
duke@435 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
duke@435 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
duke@435 | 18 | * |
trims@1907 | 19 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
trims@1907 | 20 | * or visit www.oracle.com if you need additional information or have any |
trims@1907 | 21 | * questions. |
duke@435 | 22 | * |
duke@435 | 23 | */ |
duke@435 | 24 | |
stefank@2314 | 25 | #include "precompiled.hpp" |
stefank@2314 | 26 | #include "memory/allocation.inline.hpp" |
stefank@2314 | 27 | #include "opto/addnode.hpp" |
stefank@2314 | 28 | #include "opto/callnode.hpp" |
stefank@2314 | 29 | #include "opto/connode.hpp" |
stefank@2314 | 30 | #include "opto/idealGraphPrinter.hpp" |
stefank@2314 | 31 | #include "opto/matcher.hpp" |
stefank@2314 | 32 | #include "opto/memnode.hpp" |
stefank@2314 | 33 | #include "opto/opcodes.hpp" |
stefank@2314 | 34 | #include "opto/regmask.hpp" |
stefank@2314 | 35 | #include "opto/rootnode.hpp" |
stefank@2314 | 36 | #include "opto/runtime.hpp" |
stefank@2314 | 37 | #include "opto/type.hpp" |
kvn@3882 | 38 | #include "opto/vectornode.hpp" |
stefank@2314 | 39 | #include "runtime/atomic.hpp" |
stefank@2314 | 40 | #include "runtime/os.hpp" |
dlong@7598 | 41 | #if defined AD_MD_HPP |
dlong@7598 | 42 | # include AD_MD_HPP |
dlong@7598 | 43 | #elif defined TARGET_ARCH_MODEL_x86_32 |
stefank@2314 | 44 | # include "adfiles/ad_x86_32.hpp" |
dlong@7598 | 45 | #elif defined TARGET_ARCH_MODEL_x86_64 |
stefank@2314 | 46 | # include "adfiles/ad_x86_64.hpp" |
dlong@7598 | 47 | #elif defined TARGET_ARCH_MODEL_sparc |
stefank@2314 | 48 | # include "adfiles/ad_sparc.hpp" |
dlong@7598 | 49 | #elif defined TARGET_ARCH_MODEL_zero |
stefank@2314 | 50 | # include "adfiles/ad_zero.hpp" |
dlong@7598 | 51 | #elif defined TARGET_ARCH_MODEL_ppc_64 |
goetz@6441 | 52 | # include "adfiles/ad_ppc_64.hpp" |
jcoomes@2993 | 53 | #endif |
duke@435 | 54 | |
duke@435 | 55 | OptoReg::Name OptoReg::c_frame_pointer; |
duke@435 | 56 | |
duke@435 | 57 | const RegMask *Matcher::idealreg2regmask[_last_machine_leaf]; |
duke@435 | 58 | RegMask Matcher::mreg2regmask[_last_Mach_Reg]; |
duke@435 | 59 | RegMask Matcher::STACK_ONLY_mask; |
duke@435 | 60 | RegMask Matcher::c_frame_ptr_mask; |
duke@435 | 61 | const uint Matcher::_begin_rematerialize = _BEGIN_REMATERIALIZE; |
duke@435 | 62 | const uint Matcher::_end_rematerialize = _END_REMATERIALIZE; |
duke@435 | 63 | |
duke@435 | 64 | //---------------------------Matcher------------------------------------------- |
adlertz@5539 | 65 | Matcher::Matcher() |
adlertz@5539 | 66 | : PhaseTransform( Phase::Ins_Select ), |
duke@435 | 67 | #ifdef ASSERT |
duke@435 | 68 | _old2new_map(C->comp_arena()), |
never@657 | 69 | _new2old_map(C->comp_arena()), |
duke@435 | 70 | #endif |
kvn@603 | 71 | _shared_nodes(C->comp_arena()), |
duke@435 | 72 | _reduceOp(reduceOp), _leftOp(leftOp), _rightOp(rightOp), |
duke@435 | 73 | _swallowed(swallowed), |
duke@435 | 74 | _begin_inst_chain_rule(_BEGIN_INST_CHAIN_RULE), |
duke@435 | 75 | _end_inst_chain_rule(_END_INST_CHAIN_RULE), |
adlertz@5539 | 76 | _must_clone(must_clone), |
duke@435 | 77 | _register_save_policy(register_save_policy), |
duke@435 | 78 | _c_reg_save_policy(c_reg_save_policy), |
duke@435 | 79 | _register_save_type(register_save_type), |
duke@435 | 80 | _ruleName(ruleName), |
duke@435 | 81 | _allocation_started(false), |
zgu@9055 | 82 | _states_arena(Chunk::medium_size, mtCompiler), |
duke@435 | 83 | _visited(&_states_arena), |
duke@435 | 84 | _shared(&_states_arena), |
duke@435 | 85 | _dontcare(&_states_arena) { |
duke@435 | 86 | C->set_matcher(this); |
duke@435 | 87 | |
twisti@1572 | 88 | idealreg2spillmask [Op_RegI] = NULL; |
twisti@1572 | 89 | idealreg2spillmask [Op_RegN] = NULL; |
twisti@1572 | 90 | idealreg2spillmask [Op_RegL] = NULL; |
twisti@1572 | 91 | idealreg2spillmask [Op_RegF] = NULL; |
twisti@1572 | 92 | idealreg2spillmask [Op_RegD] = NULL; |
twisti@1572 | 93 | idealreg2spillmask [Op_RegP] = NULL; |
kvn@3882 | 94 | idealreg2spillmask [Op_VecS] = NULL; |
kvn@3882 | 95 | idealreg2spillmask [Op_VecD] = NULL; |
kvn@3882 | 96 | idealreg2spillmask [Op_VecX] = NULL; |
kvn@3882 | 97 | idealreg2spillmask [Op_VecY] = NULL; |
thartmann@9513 | 98 | idealreg2spillmask [Op_RegFlags] = NULL; |
duke@435 | 99 | |
twisti@1572 | 100 | idealreg2debugmask [Op_RegI] = NULL; |
twisti@1572 | 101 | idealreg2debugmask [Op_RegN] = NULL; |
twisti@1572 | 102 | idealreg2debugmask [Op_RegL] = NULL; |
twisti@1572 | 103 | idealreg2debugmask [Op_RegF] = NULL; |
twisti@1572 | 104 | idealreg2debugmask [Op_RegD] = NULL; |
twisti@1572 | 105 | idealreg2debugmask [Op_RegP] = NULL; |
kvn@3882 | 106 | idealreg2debugmask [Op_VecS] = NULL; |
kvn@3882 | 107 | idealreg2debugmask [Op_VecD] = NULL; |
kvn@3882 | 108 | idealreg2debugmask [Op_VecX] = NULL; |
kvn@3882 | 109 | idealreg2debugmask [Op_VecY] = NULL; |
thartmann@9513 | 110 | idealreg2debugmask [Op_RegFlags] = NULL; |
twisti@1572 | 111 | |
twisti@1572 | 112 | idealreg2mhdebugmask[Op_RegI] = NULL; |
twisti@1572 | 113 | idealreg2mhdebugmask[Op_RegN] = NULL; |
twisti@1572 | 114 | idealreg2mhdebugmask[Op_RegL] = NULL; |
twisti@1572 | 115 | idealreg2mhdebugmask[Op_RegF] = NULL; |
twisti@1572 | 116 | idealreg2mhdebugmask[Op_RegD] = NULL; |
twisti@1572 | 117 | idealreg2mhdebugmask[Op_RegP] = NULL; |
kvn@3882 | 118 | idealreg2mhdebugmask[Op_VecS] = NULL; |
kvn@3882 | 119 | idealreg2mhdebugmask[Op_VecD] = NULL; |
kvn@3882 | 120 | idealreg2mhdebugmask[Op_VecX] = NULL; |
kvn@3882 | 121 | idealreg2mhdebugmask[Op_VecY] = NULL; |
thartmann@9513 | 122 | idealreg2mhdebugmask[Op_RegFlags] = NULL; |
twisti@1572 | 123 | |
kvn@651 | 124 | debug_only(_mem_node = NULL;) // Ideal memory node consumed by mach node |
duke@435 | 125 | } |
duke@435 | 126 | |
duke@435 | 127 | //------------------------------warp_incoming_stk_arg------------------------ |
duke@435 | 128 | // This warps a VMReg into an OptoReg::Name |
duke@435 | 129 | OptoReg::Name Matcher::warp_incoming_stk_arg( VMReg reg ) { |
duke@435 | 130 | OptoReg::Name warped; |
duke@435 | 131 | if( reg->is_stack() ) { // Stack slot argument? |
duke@435 | 132 | warped = OptoReg::add(_old_SP, reg->reg2stack() ); |
duke@435 | 133 | warped = OptoReg::add(warped, C->out_preserve_stack_slots()); |
duke@435 | 134 | if( warped >= _in_arg_limit ) |
duke@435 | 135 | _in_arg_limit = OptoReg::add(warped, 1); // Bump max stack slot seen |
kvn@3882 | 136 | if (!RegMask::can_represent_arg(warped)) { |
duke@435 | 137 | // the compiler cannot represent this method's calling sequence |
duke@435 | 138 | C->record_method_not_compilable_all_tiers("unsupported incoming calling sequence"); |
duke@435 | 139 | return OptoReg::Bad; |
duke@435 | 140 | } |
duke@435 | 141 | return warped; |
duke@435 | 142 | } |
duke@435 | 143 | return OptoReg::as_OptoReg(reg); |
duke@435 | 144 | } |
duke@435 | 145 | |
duke@435 | 146 | //---------------------------compute_old_SP------------------------------------ |
duke@435 | 147 | OptoReg::Name Compile::compute_old_SP() { |
duke@435 | 148 | int fixed = fixed_slots(); |
duke@435 | 149 | int preserve = in_preserve_stack_slots(); |
duke@435 | 150 | return OptoReg::stack2reg(round_to(fixed + preserve, Matcher::stack_alignment_in_slots())); |
duke@435 | 151 | } |
duke@435 | 152 | |
duke@435 | 153 | |
duke@435 | 154 | |
duke@435 | 155 | #ifdef ASSERT |
duke@435 | 156 | void Matcher::verify_new_nodes_only(Node* xroot) { |
duke@435 | 157 | // Make sure that the new graph only references new nodes |
duke@435 | 158 | ResourceMark rm; |
duke@435 | 159 | Unique_Node_List worklist; |
duke@435 | 160 | VectorSet visited(Thread::current()->resource_area()); |
duke@435 | 161 | worklist.push(xroot); |
duke@435 | 162 | while (worklist.size() > 0) { |
duke@435 | 163 | Node* n = worklist.pop(); |
duke@435 | 164 | visited <<= n->_idx; |
duke@435 | 165 | assert(C->node_arena()->contains(n), "dead node"); |
duke@435 | 166 | for (uint j = 0; j < n->req(); j++) { |
duke@435 | 167 | Node* in = n->in(j); |
duke@435 | 168 | if (in != NULL) { |
duke@435 | 169 | assert(C->node_arena()->contains(in), "dead node"); |
duke@435 | 170 | if (!visited.test(in->_idx)) { |
duke@435 | 171 | worklist.push(in); |
duke@435 | 172 | } |
duke@435 | 173 | } |
duke@435 | 174 | } |
duke@435 | 175 | } |
duke@435 | 176 | } |
duke@435 | 177 | #endif |
duke@435 | 178 | |
duke@435 | 179 | |
duke@435 | 180 | //---------------------------match--------------------------------------------- |
duke@435 | 181 | void Matcher::match( ) { |
kvn@1258 | 182 | if( MaxLabelRootDepth < 100 ) { // Too small? |
kvn@1258 | 183 | assert(false, "invalid MaxLabelRootDepth, increase it to 100 minimum"); |
kvn@1258 | 184 | MaxLabelRootDepth = 100; |
kvn@1258 | 185 | } |
duke@435 | 186 | // One-time initialization of some register masks. |
duke@435 | 187 | init_spill_mask( C->root()->in(1) ); |
duke@435 | 188 | _return_addr_mask = return_addr(); |
duke@435 | 189 | #ifdef _LP64 |
duke@435 | 190 | // Pointers take 2 slots in 64-bit land |
duke@435 | 191 | _return_addr_mask.Insert(OptoReg::add(return_addr(),1)); |
duke@435 | 192 | #endif |
duke@435 | 193 | |
duke@435 | 194 | // Map a Java-signature return type into return register-value |
duke@435 | 195 | // machine registers for 0, 1 and 2 returned values. |
duke@435 | 196 | const TypeTuple *range = C->tf()->range(); |
duke@435 | 197 | if( range->cnt() > TypeFunc::Parms ) { // If not a void function |
duke@435 | 198 | // Get ideal-register return type |
kevinw@9333 | 199 | uint ireg = range->field_at(TypeFunc::Parms)->ideal_reg(); |
duke@435 | 200 | // Get machine return register |
duke@435 | 201 | uint sop = C->start()->Opcode(); |
duke@435 | 202 | OptoRegPair regs = return_value(ireg, false); |
duke@435 | 203 | |
duke@435 | 204 | // And mask for same |
duke@435 | 205 | _return_value_mask = RegMask(regs.first()); |
duke@435 | 206 | if( OptoReg::is_valid(regs.second()) ) |
duke@435 | 207 | _return_value_mask.Insert(regs.second()); |
duke@435 | 208 | } |
duke@435 | 209 | |
duke@435 | 210 | // --------------- |
duke@435 | 211 | // Frame Layout |
duke@435 | 212 | |
duke@435 | 213 | // Need the method signature to determine the incoming argument types, |
duke@435 | 214 | // because the types determine which registers the incoming arguments are |
duke@435 | 215 | // in, and this affects the matched code. |
duke@435 | 216 | const TypeTuple *domain = C->tf()->domain(); |
duke@435 | 217 | uint argcnt = domain->cnt() - TypeFunc::Parms; |
duke@435 | 218 | BasicType *sig_bt = NEW_RESOURCE_ARRAY( BasicType, argcnt ); |
duke@435 | 219 | VMRegPair *vm_parm_regs = NEW_RESOURCE_ARRAY( VMRegPair, argcnt ); |
duke@435 | 220 | _parm_regs = NEW_RESOURCE_ARRAY( OptoRegPair, argcnt ); |
duke@435 | 221 | _calling_convention_mask = NEW_RESOURCE_ARRAY( RegMask, argcnt ); |
duke@435 | 222 | uint i; |
duke@435 | 223 | for( i = 0; i<argcnt; i++ ) { |
duke@435 | 224 | sig_bt[i] = domain->field_at(i+TypeFunc::Parms)->basic_type(); |
duke@435 | 225 | } |
duke@435 | 226 | |
duke@435 | 227 | // Pass array of ideal registers and length to USER code (from the AD file) |
duke@435 | 228 | // that will convert this to an array of register numbers. |
duke@435 | 229 | const StartNode *start = C->start(); |
duke@435 | 230 | start->calling_convention( sig_bt, vm_parm_regs, argcnt ); |
duke@435 | 231 | #ifdef ASSERT |
duke@435 | 232 | // Sanity check users' calling convention. Real handy while trying to |
duke@435 | 233 | // get the initial port correct. |
duke@435 | 234 | { for (uint i = 0; i<argcnt; i++) { |
duke@435 | 235 | if( !vm_parm_regs[i].first()->is_valid() && !vm_parm_regs[i].second()->is_valid() ) { |
duke@435 | 236 | assert(domain->field_at(i+TypeFunc::Parms)==Type::HALF, "only allowed on halve" ); |
duke@435 | 237 | _parm_regs[i].set_bad(); |
duke@435 | 238 | continue; |
duke@435 | 239 | } |
duke@435 | 240 | VMReg parm_reg = vm_parm_regs[i].first(); |
duke@435 | 241 | assert(parm_reg->is_valid(), "invalid arg?"); |
duke@435 | 242 | if (parm_reg->is_reg()) { |
duke@435 | 243 | OptoReg::Name opto_parm_reg = OptoReg::as_OptoReg(parm_reg); |
duke@435 | 244 | assert(can_be_java_arg(opto_parm_reg) || |
duke@435 | 245 | C->stub_function() == CAST_FROM_FN_PTR(address, OptoRuntime::rethrow_C) || |
duke@435 | 246 | opto_parm_reg == inline_cache_reg(), |
duke@435 | 247 | "parameters in register must be preserved by runtime stubs"); |
duke@435 | 248 | } |
duke@435 | 249 | for (uint j = 0; j < i; j++) { |
duke@435 | 250 | assert(parm_reg != vm_parm_regs[j].first(), |
duke@435 | 251 | "calling conv. must produce distinct regs"); |
duke@435 | 252 | } |
duke@435 | 253 | } |
duke@435 | 254 | } |
duke@435 | 255 | #endif |
duke@435 | 256 | |
duke@435 | 257 | // Do some initial frame layout. |
duke@435 | 258 | |
duke@435 | 259 | // Compute the old incoming SP (may be called FP) as |
duke@435 | 260 | // OptoReg::stack0() + locks + in_preserve_stack_slots + pad2. |
duke@435 | 261 | _old_SP = C->compute_old_SP(); |
duke@435 | 262 | assert( is_even(_old_SP), "must be even" ); |
duke@435 | 263 | |
duke@435 | 264 | // Compute highest incoming stack argument as |
duke@435 | 265 | // _old_SP + out_preserve_stack_slots + incoming argument size. |
duke@435 | 266 | _in_arg_limit = OptoReg::add(_old_SP, C->out_preserve_stack_slots()); |
duke@435 | 267 | assert( is_even(_in_arg_limit), "out_preserve must be even" ); |
duke@435 | 268 | for( i = 0; i < argcnt; i++ ) { |
duke@435 | 269 | // Permit args to have no register |
duke@435 | 270 | _calling_convention_mask[i].Clear(); |
duke@435 | 271 | if( !vm_parm_regs[i].first()->is_valid() && !vm_parm_regs[i].second()->is_valid() ) { |
duke@435 | 272 | continue; |
duke@435 | 273 | } |
duke@435 | 274 | // calling_convention returns stack arguments as a count of |
duke@435 | 275 | // slots beyond OptoReg::stack0()/VMRegImpl::stack0. We need to convert this to |
duke@435 | 276 | // the allocators point of view, taking into account all the |
duke@435 | 277 | // preserve area, locks & pad2. |
duke@435 | 278 | |
duke@435 | 279 | OptoReg::Name reg1 = warp_incoming_stk_arg(vm_parm_regs[i].first()); |
duke@435 | 280 | if( OptoReg::is_valid(reg1)) |
duke@435 | 281 | _calling_convention_mask[i].Insert(reg1); |
duke@435 | 282 | |
duke@435 | 283 | OptoReg::Name reg2 = warp_incoming_stk_arg(vm_parm_regs[i].second()); |
duke@435 | 284 | if( OptoReg::is_valid(reg2)) |
duke@435 | 285 | _calling_convention_mask[i].Insert(reg2); |
duke@435 | 286 | |
duke@435 | 287 | // Saved biased stack-slot register number |
duke@435 | 288 | _parm_regs[i].set_pair(reg2, reg1); |
duke@435 | 289 | } |
duke@435 | 290 | |
duke@435 | 291 | // Finally, make sure the incoming arguments take up an even number of |
duke@435 | 292 | // words, in case the arguments or locals need to contain doubleword stack |
duke@435 | 293 | // slots. The rest of the system assumes that stack slot pairs (in |
duke@435 | 294 | // particular, in the spill area) which look aligned will in fact be |
duke@435 | 295 | // aligned relative to the stack pointer in the target machine. Double |
duke@435 | 296 | // stack slots will always be allocated aligned. |
duke@435 | 297 | _new_SP = OptoReg::Name(round_to(_in_arg_limit, RegMask::SlotsPerLong)); |
duke@435 | 298 | |
duke@435 | 299 | // Compute highest outgoing stack argument as |
duke@435 | 300 | // _new_SP + out_preserve_stack_slots + max(outgoing argument size). |
duke@435 | 301 | _out_arg_limit = OptoReg::add(_new_SP, C->out_preserve_stack_slots()); |
duke@435 | 302 | assert( is_even(_out_arg_limit), "out_preserve must be even" ); |
duke@435 | 303 | |
kvn@3882 | 304 | if (!RegMask::can_represent_arg(OptoReg::add(_out_arg_limit,-1))) { |
duke@435 | 305 | // the compiler cannot represent this method's calling sequence |
duke@435 | 306 | C->record_method_not_compilable("must be able to represent all call arguments in reg mask"); |
duke@435 | 307 | } |
duke@435 | 308 | |
duke@435 | 309 | if (C->failing()) return; // bailed out on incoming arg failure |
duke@435 | 310 | |
duke@435 | 311 | // --------------- |
duke@435 | 312 | // Collect roots of matcher trees. Every node for which |
duke@435 | 313 | // _shared[_idx] is cleared is guaranteed to not be shared, and thus |
duke@435 | 314 | // can be a valid interior of some tree. |
duke@435 | 315 | find_shared( C->root() ); |
duke@435 | 316 | find_shared( C->top() ); |
duke@435 | 317 | |
sla@5237 | 318 | C->print_method(PHASE_BEFORE_MATCHING); |
duke@435 | 319 | |
kvn@1164 | 320 | // Create new ideal node ConP #NULL even if it does exist in old space |
kvn@1164 | 321 | // to avoid false sharing if the corresponding mach node is not used. |
kvn@1164 | 322 | // The corresponding mach node is only used in rare cases for derived |
kvn@1164 | 323 | // pointers. |
kvn@1164 | 324 | Node* new_ideal_null = ConNode::make(C, TypePtr::NULL_PTR); |
kvn@1164 | 325 | |
duke@435 | 326 | // Swap out to old-space; emptying new-space |
duke@435 | 327 | Arena *old = C->node_arena()->move_contents(C->old_arena()); |
duke@435 | 328 | |
duke@435 | 329 | // Save debug and profile information for nodes in old space: |
duke@435 | 330 | _old_node_note_array = C->node_note_array(); |
duke@435 | 331 | if (_old_node_note_array != NULL) { |
duke@435 | 332 | C->set_node_note_array(new(C->comp_arena()) GrowableArray<Node_Notes*> |
duke@435 | 333 | (C->comp_arena(), _old_node_note_array->length(), |
duke@435 | 334 | 0, NULL)); |
duke@435 | 335 | } |
duke@435 | 336 | |
duke@435 | 337 | // Pre-size the new_node table to avoid the need for range checks. |
duke@435 | 338 | grow_new_node_array(C->unique()); |
duke@435 | 339 | |
duke@435 | 340 | // Reset node counter so MachNodes start with _idx at 0 |
zmajo@8068 | 341 | int live_nodes = C->live_nodes(); |
duke@435 | 342 | C->set_unique(0); |
bharadwaj@4315 | 343 | C->reset_dead_node_list(); |
duke@435 | 344 | |
duke@435 | 345 | // Recursively match trees from old space into new space. |
duke@435 | 346 | // Correct leaves of new-space Nodes; they point to old-space. |
duke@435 | 347 | _visited.Clear(); // Clear visit bits for xform call |
zmajo@8068 | 348 | C->set_cached_top_node(xform( C->top(), live_nodes)); |
duke@435 | 349 | if (!C->failing()) { |
duke@435 | 350 | Node* xroot = xform( C->root(), 1 ); |
duke@435 | 351 | if (xroot == NULL) { |
duke@435 | 352 | Matcher::soft_match_failure(); // recursive matching process failed |
duke@435 | 353 | C->record_method_not_compilable("instruction match failed"); |
duke@435 | 354 | } else { |
duke@435 | 355 | // During matching shared constants were attached to C->root() |
duke@435 | 356 | // because xroot wasn't available yet, so transfer the uses to |
duke@435 | 357 | // the xroot. |
duke@435 | 358 | for( DUIterator_Fast jmax, j = C->root()->fast_outs(jmax); j < jmax; j++ ) { |
duke@435 | 359 | Node* n = C->root()->fast_out(j); |
duke@435 | 360 | if (C->node_arena()->contains(n)) { |
duke@435 | 361 | assert(n->in(0) == C->root(), "should be control user"); |
duke@435 | 362 | n->set_req(0, xroot); |
duke@435 | 363 | --j; |
duke@435 | 364 | --jmax; |
duke@435 | 365 | } |
duke@435 | 366 | } |
duke@435 | 367 | |
kvn@1164 | 368 | // Generate new mach node for ConP #NULL |
kvn@1164 | 369 | assert(new_ideal_null != NULL, "sanity"); |
kvn@1164 | 370 | _mach_null = match_tree(new_ideal_null); |
kvn@1164 | 371 | // Don't set control, it will confuse GCM since there are no uses. |
kvn@1164 | 372 | // The control will be set when this node is used first time |
kvn@1164 | 373 | // in find_base_for_derived(). |
kvn@1164 | 374 | assert(_mach_null != NULL, ""); |
kvn@1164 | 375 | |
duke@435 | 376 | C->set_root(xroot->is_Root() ? xroot->as_Root() : NULL); |
kvn@1164 | 377 | |
duke@435 | 378 | #ifdef ASSERT |
duke@435 | 379 | verify_new_nodes_only(xroot); |
duke@435 | 380 | #endif |
duke@435 | 381 | } |
duke@435 | 382 | } |
duke@435 | 383 | if (C->top() == NULL || C->root() == NULL) { |
duke@435 | 384 | C->record_method_not_compilable("graph lost"); // %%% cannot happen? |
duke@435 | 385 | } |
duke@435 | 386 | if (C->failing()) { |
duke@435 | 387 | // delete old; |
duke@435 | 388 | old->destruct_contents(); |
duke@435 | 389 | return; |
duke@435 | 390 | } |
duke@435 | 391 | assert( C->top(), "" ); |
duke@435 | 392 | assert( C->root(), "" ); |
duke@435 | 393 | validate_null_checks(); |
duke@435 | 394 | |
duke@435 | 395 | // Now smoke old-space |
duke@435 | 396 | NOT_DEBUG( old->destruct_contents() ); |
duke@435 | 397 | |
duke@435 | 398 | // ------------------------ |
duke@435 | 399 | // Set up save-on-entry registers |
duke@435 | 400 | Fixup_Save_On_Entry( ); |
duke@435 | 401 | } |
duke@435 | 402 | |
duke@435 | 403 | |
duke@435 | 404 | //------------------------------Fixup_Save_On_Entry---------------------------- |
duke@435 | 405 | // The stated purpose of this routine is to take care of save-on-entry |
duke@435 | 406 | // registers. However, the overall goal of the Match phase is to convert into |
duke@435 | 407 | // machine-specific instructions which have RegMasks to guide allocation. |
duke@435 | 408 | // So what this procedure really does is put a valid RegMask on each input |
duke@435 | 409 | // to the machine-specific variations of all Return, TailCall and Halt |
duke@435 | 410 | // instructions. It also adds edgs to define the save-on-entry values (and of |
duke@435 | 411 | // course gives them a mask). |
duke@435 | 412 | |
duke@435 | 413 | static RegMask *init_input_masks( uint size, RegMask &ret_adr, RegMask &fp ) { |
duke@435 | 414 | RegMask *rms = NEW_RESOURCE_ARRAY( RegMask, size ); |
duke@435 | 415 | // Do all the pre-defined register masks |
duke@435 | 416 | rms[TypeFunc::Control ] = RegMask::Empty; |
duke@435 | 417 | rms[TypeFunc::I_O ] = RegMask::Empty; |
duke@435 | 418 | rms[TypeFunc::Memory ] = RegMask::Empty; |
duke@435 | 419 | rms[TypeFunc::ReturnAdr] = ret_adr; |
duke@435 | 420 | rms[TypeFunc::FramePtr ] = fp; |
duke@435 | 421 | return rms; |
duke@435 | 422 | } |
duke@435 | 423 | |
duke@435 | 424 | //---------------------------init_first_stack_mask----------------------------- |
duke@435 | 425 | // Create the initial stack mask used by values spilling to the stack. |
duke@435 | 426 | // Disallow any debug info in outgoing argument areas by setting the |
duke@435 | 427 | // initial mask accordingly. |
duke@435 | 428 | void Matcher::init_first_stack_mask() { |
duke@435 | 429 | |
duke@435 | 430 | // Allocate storage for spill masks as masks for the appropriate load type. |
kvn@3882 | 431 | RegMask *rms = (RegMask*)C->comp_arena()->Amalloc_D(sizeof(RegMask) * (3*6+4)); |
twisti@1572 | 432 | |
twisti@1572 | 433 | idealreg2spillmask [Op_RegN] = &rms[0]; |
twisti@1572 | 434 | idealreg2spillmask [Op_RegI] = &rms[1]; |
twisti@1572 | 435 | idealreg2spillmask [Op_RegL] = &rms[2]; |
twisti@1572 | 436 | idealreg2spillmask [Op_RegF] = &rms[3]; |
twisti@1572 | 437 | idealreg2spillmask [Op_RegD] = &rms[4]; |
twisti@1572 | 438 | idealreg2spillmask [Op_RegP] = &rms[5]; |
twisti@1572 | 439 | |
twisti@1572 | 440 | idealreg2debugmask [Op_RegN] = &rms[6]; |
twisti@1572 | 441 | idealreg2debugmask [Op_RegI] = &rms[7]; |
twisti@1572 | 442 | idealreg2debugmask [Op_RegL] = &rms[8]; |
twisti@1572 | 443 | idealreg2debugmask [Op_RegF] = &rms[9]; |
twisti@1572 | 444 | idealreg2debugmask [Op_RegD] = &rms[10]; |
twisti@1572 | 445 | idealreg2debugmask [Op_RegP] = &rms[11]; |
twisti@1572 | 446 | |
twisti@1572 | 447 | idealreg2mhdebugmask[Op_RegN] = &rms[12]; |
twisti@1572 | 448 | idealreg2mhdebugmask[Op_RegI] = &rms[13]; |
twisti@1572 | 449 | idealreg2mhdebugmask[Op_RegL] = &rms[14]; |
twisti@1572 | 450 | idealreg2mhdebugmask[Op_RegF] = &rms[15]; |
twisti@1572 | 451 | idealreg2mhdebugmask[Op_RegD] = &rms[16]; |
twisti@1572 | 452 | idealreg2mhdebugmask[Op_RegP] = &rms[17]; |
duke@435 | 453 | |
kvn@3882 | 454 | idealreg2spillmask [Op_VecS] = &rms[18]; |
kvn@3882 | 455 | idealreg2spillmask [Op_VecD] = &rms[19]; |
kvn@3882 | 456 | idealreg2spillmask [Op_VecX] = &rms[20]; |
kvn@3882 | 457 | idealreg2spillmask [Op_VecY] = &rms[21]; |
kvn@3882 | 458 | |
duke@435 | 459 | OptoReg::Name i; |
duke@435 | 460 | |
duke@435 | 461 | // At first, start with the empty mask |
duke@435 | 462 | C->FIRST_STACK_mask().Clear(); |
duke@435 | 463 | |
duke@435 | 464 | // Add in the incoming argument area |
kvn@6098 | 465 | OptoReg::Name init_in = OptoReg::add(_old_SP, C->out_preserve_stack_slots()); |
kvn@6098 | 466 | for (i = init_in; i < _in_arg_limit; i = OptoReg::add(i,1)) { |
duke@435 | 467 | C->FIRST_STACK_mask().Insert(i); |
kvn@6098 | 468 | } |
duke@435 | 469 | // Add in all bits past the outgoing argument area |
kvn@3882 | 470 | guarantee(RegMask::can_represent_arg(OptoReg::add(_out_arg_limit,-1)), |
duke@435 | 471 | "must be able to represent all call arguments in reg mask"); |
kvn@6098 | 472 | OptoReg::Name init = _out_arg_limit; |
kvn@6098 | 473 | for (i = init; RegMask::can_represent(i); i = OptoReg::add(i,1)) { |
duke@435 | 474 | C->FIRST_STACK_mask().Insert(i); |
kvn@6098 | 475 | } |
duke@435 | 476 | // Finally, set the "infinite stack" bit. |
duke@435 | 477 | C->FIRST_STACK_mask().set_AllStack(); |
duke@435 | 478 | |
duke@435 | 479 | // Make spill masks. Registers for their class, plus FIRST_STACK_mask. |
kvn@3882 | 480 | RegMask aligned_stack_mask = C->FIRST_STACK_mask(); |
kvn@3882 | 481 | // Keep spill masks aligned. |
kvn@3882 | 482 | aligned_stack_mask.clear_to_pairs(); |
kvn@3882 | 483 | assert(aligned_stack_mask.is_AllStack(), "should be infinite stack"); |
kvn@3882 | 484 | |
kvn@3882 | 485 | *idealreg2spillmask[Op_RegP] = *idealreg2regmask[Op_RegP]; |
coleenp@548 | 486 | #ifdef _LP64 |
coleenp@548 | 487 | *idealreg2spillmask[Op_RegN] = *idealreg2regmask[Op_RegN]; |
coleenp@548 | 488 | idealreg2spillmask[Op_RegN]->OR(C->FIRST_STACK_mask()); |
kvn@3882 | 489 | idealreg2spillmask[Op_RegP]->OR(aligned_stack_mask); |
kvn@3882 | 490 | #else |
kvn@3882 | 491 | idealreg2spillmask[Op_RegP]->OR(C->FIRST_STACK_mask()); |
coleenp@548 | 492 | #endif |
duke@435 | 493 | *idealreg2spillmask[Op_RegI] = *idealreg2regmask[Op_RegI]; |
duke@435 | 494 | idealreg2spillmask[Op_RegI]->OR(C->FIRST_STACK_mask()); |
duke@435 | 495 | *idealreg2spillmask[Op_RegL] = *idealreg2regmask[Op_RegL]; |
kvn@3882 | 496 | idealreg2spillmask[Op_RegL]->OR(aligned_stack_mask); |
duke@435 | 497 | *idealreg2spillmask[Op_RegF] = *idealreg2regmask[Op_RegF]; |
duke@435 | 498 | idealreg2spillmask[Op_RegF]->OR(C->FIRST_STACK_mask()); |
duke@435 | 499 | *idealreg2spillmask[Op_RegD] = *idealreg2regmask[Op_RegD]; |
kvn@3882 | 500 | idealreg2spillmask[Op_RegD]->OR(aligned_stack_mask); |
duke@435 | 501 | |
kvn@3882 | 502 | if (Matcher::vector_size_supported(T_BYTE,4)) { |
kvn@3882 | 503 | *idealreg2spillmask[Op_VecS] = *idealreg2regmask[Op_VecS]; |
kvn@3882 | 504 | idealreg2spillmask[Op_VecS]->OR(C->FIRST_STACK_mask()); |
kvn@3882 | 505 | } |
kvn@3882 | 506 | if (Matcher::vector_size_supported(T_FLOAT,2)) { |
kvn@6098 | 507 | // For VecD we need dual alignment and 8 bytes (2 slots) for spills. |
kvn@6098 | 508 | // RA guarantees such alignment since it is needed for Double and Long values. |
kvn@3882 | 509 | *idealreg2spillmask[Op_VecD] = *idealreg2regmask[Op_VecD]; |
kvn@3882 | 510 | idealreg2spillmask[Op_VecD]->OR(aligned_stack_mask); |
kvn@3882 | 511 | } |
kvn@3882 | 512 | if (Matcher::vector_size_supported(T_FLOAT,4)) { |
kvn@6098 | 513 | // For VecX we need quadro alignment and 16 bytes (4 slots) for spills. |
kvn@6098 | 514 | // |
kvn@6098 | 515 | // RA can use input arguments stack slots for spills but until RA |
kvn@6098 | 516 | // we don't know frame size and offset of input arg stack slots. |
kvn@6098 | 517 | // |
kvn@6098 | 518 | // Exclude last input arg stack slots to avoid spilling vectors there |
kvn@6098 | 519 | // otherwise vector spills could stomp over stack slots in caller frame. |
kvn@6098 | 520 | OptoReg::Name in = OptoReg::add(_in_arg_limit, -1); |
kvn@6098 | 521 | for (int k = 1; (in >= init_in) && (k < RegMask::SlotsPerVecX); k++) { |
kvn@6098 | 522 | aligned_stack_mask.Remove(in); |
kvn@6098 | 523 | in = OptoReg::add(in, -1); |
kvn@6098 | 524 | } |
kvn@3882 | 525 | aligned_stack_mask.clear_to_sets(RegMask::SlotsPerVecX); |
kvn@3882 | 526 | assert(aligned_stack_mask.is_AllStack(), "should be infinite stack"); |
kvn@3882 | 527 | *idealreg2spillmask[Op_VecX] = *idealreg2regmask[Op_VecX]; |
kvn@3882 | 528 | idealreg2spillmask[Op_VecX]->OR(aligned_stack_mask); |
kvn@3882 | 529 | } |
kvn@3882 | 530 | if (Matcher::vector_size_supported(T_FLOAT,8)) { |
kvn@6098 | 531 | // For VecY we need octo alignment and 32 bytes (8 slots) for spills. |
kvn@6098 | 532 | OptoReg::Name in = OptoReg::add(_in_arg_limit, -1); |
kvn@6098 | 533 | for (int k = 1; (in >= init_in) && (k < RegMask::SlotsPerVecY); k++) { |
kvn@6098 | 534 | aligned_stack_mask.Remove(in); |
kvn@6098 | 535 | in = OptoReg::add(in, -1); |
kvn@6098 | 536 | } |
kvn@3882 | 537 | aligned_stack_mask.clear_to_sets(RegMask::SlotsPerVecY); |
kvn@3882 | 538 | assert(aligned_stack_mask.is_AllStack(), "should be infinite stack"); |
kvn@3882 | 539 | *idealreg2spillmask[Op_VecY] = *idealreg2regmask[Op_VecY]; |
kvn@3882 | 540 | idealreg2spillmask[Op_VecY]->OR(aligned_stack_mask); |
kvn@3882 | 541 | } |
never@2085 | 542 | if (UseFPUForSpilling) { |
never@2085 | 543 | // This mask logic assumes that the spill operations are |
never@2085 | 544 | // symmetric and that the registers involved are the same size. |
never@2085 | 545 | // On sparc for instance we may have to use 64 bit moves will |
never@2085 | 546 | // kill 2 registers when used with F0-F31. |
never@2085 | 547 | idealreg2spillmask[Op_RegI]->OR(*idealreg2regmask[Op_RegF]); |
never@2085 | 548 | idealreg2spillmask[Op_RegF]->OR(*idealreg2regmask[Op_RegI]); |
never@2085 | 549 | #ifdef _LP64 |
never@2085 | 550 | idealreg2spillmask[Op_RegN]->OR(*idealreg2regmask[Op_RegF]); |
never@2085 | 551 | idealreg2spillmask[Op_RegL]->OR(*idealreg2regmask[Op_RegD]); |
never@2085 | 552 | idealreg2spillmask[Op_RegD]->OR(*idealreg2regmask[Op_RegL]); |
never@2085 | 553 | idealreg2spillmask[Op_RegP]->OR(*idealreg2regmask[Op_RegD]); |
never@2085 | 554 | #else |
never@2085 | 555 | idealreg2spillmask[Op_RegP]->OR(*idealreg2regmask[Op_RegF]); |
roland@3109 | 556 | #ifdef ARM |
roland@3109 | 557 | // ARM has support for moving 64bit values between a pair of |
roland@3109 | 558 | // integer registers and a double register |
roland@3109 | 559 | idealreg2spillmask[Op_RegL]->OR(*idealreg2regmask[Op_RegD]); |
roland@3109 | 560 | idealreg2spillmask[Op_RegD]->OR(*idealreg2regmask[Op_RegL]); |
roland@3109 | 561 | #endif |
never@2085 | 562 | #endif |
never@2085 | 563 | } |
never@2085 | 564 | |
duke@435 | 565 | // Make up debug masks. Any spill slot plus callee-save registers. |
duke@435 | 566 | // Caller-save registers are assumed to be trashable by the various |
duke@435 | 567 | // inline-cache fixup routines. |
twisti@1572 | 568 | *idealreg2debugmask [Op_RegN]= *idealreg2spillmask[Op_RegN]; |
twisti@1572 | 569 | *idealreg2debugmask [Op_RegI]= *idealreg2spillmask[Op_RegI]; |
twisti@1572 | 570 | *idealreg2debugmask [Op_RegL]= *idealreg2spillmask[Op_RegL]; |
twisti@1572 | 571 | *idealreg2debugmask [Op_RegF]= *idealreg2spillmask[Op_RegF]; |
twisti@1572 | 572 | *idealreg2debugmask [Op_RegD]= *idealreg2spillmask[Op_RegD]; |
twisti@1572 | 573 | *idealreg2debugmask [Op_RegP]= *idealreg2spillmask[Op_RegP]; |
twisti@1572 | 574 | |
twisti@1572 | 575 | *idealreg2mhdebugmask[Op_RegN]= *idealreg2spillmask[Op_RegN]; |
twisti@1572 | 576 | *idealreg2mhdebugmask[Op_RegI]= *idealreg2spillmask[Op_RegI]; |
twisti@1572 | 577 | *idealreg2mhdebugmask[Op_RegL]= *idealreg2spillmask[Op_RegL]; |
twisti@1572 | 578 | *idealreg2mhdebugmask[Op_RegF]= *idealreg2spillmask[Op_RegF]; |
twisti@1572 | 579 | *idealreg2mhdebugmask[Op_RegD]= *idealreg2spillmask[Op_RegD]; |
twisti@1572 | 580 | *idealreg2mhdebugmask[Op_RegP]= *idealreg2spillmask[Op_RegP]; |
duke@435 | 581 | |
duke@435 | 582 | // Prevent stub compilations from attempting to reference |
duke@435 | 583 | // callee-saved registers from debug info |
duke@435 | 584 | bool exclude_soe = !Compile::current()->is_method_compilation(); |
duke@435 | 585 | |
duke@435 | 586 | for( i=OptoReg::Name(0); i<OptoReg::Name(_last_Mach_Reg); i = OptoReg::add(i,1) ) { |
duke@435 | 587 | // registers the caller has to save do not work |
duke@435 | 588 | if( _register_save_policy[i] == 'C' || |
duke@435 | 589 | _register_save_policy[i] == 'A' || |
duke@435 | 590 | (_register_save_policy[i] == 'E' && exclude_soe) ) { |
twisti@1572 | 591 | idealreg2debugmask [Op_RegN]->Remove(i); |
twisti@1572 | 592 | idealreg2debugmask [Op_RegI]->Remove(i); // Exclude save-on-call |
twisti@1572 | 593 | idealreg2debugmask [Op_RegL]->Remove(i); // registers from debug |
twisti@1572 | 594 | idealreg2debugmask [Op_RegF]->Remove(i); // masks |
twisti@1572 | 595 | idealreg2debugmask [Op_RegD]->Remove(i); |
twisti@1572 | 596 | idealreg2debugmask [Op_RegP]->Remove(i); |
twisti@1572 | 597 | |
twisti@1572 | 598 | idealreg2mhdebugmask[Op_RegN]->Remove(i); |
twisti@1572 | 599 | idealreg2mhdebugmask[Op_RegI]->Remove(i); |
twisti@1572 | 600 | idealreg2mhdebugmask[Op_RegL]->Remove(i); |
twisti@1572 | 601 | idealreg2mhdebugmask[Op_RegF]->Remove(i); |
twisti@1572 | 602 | idealreg2mhdebugmask[Op_RegD]->Remove(i); |
twisti@1572 | 603 | idealreg2mhdebugmask[Op_RegP]->Remove(i); |
duke@435 | 604 | } |
duke@435 | 605 | } |
twisti@1572 | 606 | |
twisti@1572 | 607 | // Subtract the register we use to save the SP for MethodHandle |
twisti@1572 | 608 | // invokes to from the debug mask. |
twisti@1572 | 609 | const RegMask save_mask = method_handle_invoke_SP_save_mask(); |
twisti@1572 | 610 | idealreg2mhdebugmask[Op_RegN]->SUBTRACT(save_mask); |
twisti@1572 | 611 | idealreg2mhdebugmask[Op_RegI]->SUBTRACT(save_mask); |
twisti@1572 | 612 | idealreg2mhdebugmask[Op_RegL]->SUBTRACT(save_mask); |
twisti@1572 | 613 | idealreg2mhdebugmask[Op_RegF]->SUBTRACT(save_mask); |
twisti@1572 | 614 | idealreg2mhdebugmask[Op_RegD]->SUBTRACT(save_mask); |
twisti@1572 | 615 | idealreg2mhdebugmask[Op_RegP]->SUBTRACT(save_mask); |
duke@435 | 616 | } |
duke@435 | 617 | |
duke@435 | 618 | //---------------------------is_save_on_entry---------------------------------- |
duke@435 | 619 | bool Matcher::is_save_on_entry( int reg ) { |
duke@435 | 620 | return |
duke@435 | 621 | _register_save_policy[reg] == 'E' || |
duke@435 | 622 | _register_save_policy[reg] == 'A' || // Save-on-entry register? |
duke@435 | 623 | // Also save argument registers in the trampolining stubs |
duke@435 | 624 | (C->save_argument_registers() && is_spillable_arg(reg)); |
duke@435 | 625 | } |
duke@435 | 626 | |
duke@435 | 627 | //---------------------------Fixup_Save_On_Entry------------------------------- |
duke@435 | 628 | void Matcher::Fixup_Save_On_Entry( ) { |
duke@435 | 629 | init_first_stack_mask(); |
duke@435 | 630 | |
duke@435 | 631 | Node *root = C->root(); // Short name for root |
duke@435 | 632 | // Count number of save-on-entry registers. |
duke@435 | 633 | uint soe_cnt = number_of_saved_registers(); |
duke@435 | 634 | uint i; |
duke@435 | 635 | |
duke@435 | 636 | // Find the procedure Start Node |
duke@435 | 637 | StartNode *start = C->start(); |
duke@435 | 638 | assert( start, "Expect a start node" ); |
duke@435 | 639 | |
duke@435 | 640 | // Save argument registers in the trampolining stubs |
duke@435 | 641 | if( C->save_argument_registers() ) |
duke@435 | 642 | for( i = 0; i < _last_Mach_Reg; i++ ) |
duke@435 | 643 | if( is_spillable_arg(i) ) |
duke@435 | 644 | soe_cnt++; |
duke@435 | 645 | |
duke@435 | 646 | // Input RegMask array shared by all Returns. |
duke@435 | 647 | // The type for doubles and longs has a count of 2, but |
duke@435 | 648 | // there is only 1 returned value |
duke@435 | 649 | uint ret_edge_cnt = TypeFunc::Parms + ((C->tf()->range()->cnt() == TypeFunc::Parms) ? 0 : 1); |
duke@435 | 650 | RegMask *ret_rms = init_input_masks( ret_edge_cnt + soe_cnt, _return_addr_mask, c_frame_ptr_mask ); |
duke@435 | 651 | // Returns have 0 or 1 returned values depending on call signature. |
duke@435 | 652 | // Return register is specified by return_value in the AD file. |
duke@435 | 653 | if (ret_edge_cnt > TypeFunc::Parms) |
duke@435 | 654 | ret_rms[TypeFunc::Parms+0] = _return_value_mask; |
duke@435 | 655 | |
duke@435 | 656 | // Input RegMask array shared by all Rethrows. |
duke@435 | 657 | uint reth_edge_cnt = TypeFunc::Parms+1; |
duke@435 | 658 | RegMask *reth_rms = init_input_masks( reth_edge_cnt + soe_cnt, _return_addr_mask, c_frame_ptr_mask ); |
duke@435 | 659 | // Rethrow takes exception oop only, but in the argument 0 slot. |
duke@435 | 660 | reth_rms[TypeFunc::Parms] = mreg2regmask[find_receiver(false)]; |
duke@435 | 661 | #ifdef _LP64 |
duke@435 | 662 | // Need two slots for ptrs in 64-bit land |
duke@435 | 663 | reth_rms[TypeFunc::Parms].Insert(OptoReg::add(OptoReg::Name(find_receiver(false)),1)); |
duke@435 | 664 | #endif |
duke@435 | 665 | |
duke@435 | 666 | // Input RegMask array shared by all TailCalls |
duke@435 | 667 | uint tail_call_edge_cnt = TypeFunc::Parms+2; |
duke@435 | 668 | RegMask *tail_call_rms = init_input_masks( tail_call_edge_cnt + soe_cnt, _return_addr_mask, c_frame_ptr_mask ); |
duke@435 | 669 | |
duke@435 | 670 | // Input RegMask array shared by all TailJumps |
duke@435 | 671 | uint tail_jump_edge_cnt = TypeFunc::Parms+2; |
duke@435 | 672 | RegMask *tail_jump_rms = init_input_masks( tail_jump_edge_cnt + soe_cnt, _return_addr_mask, c_frame_ptr_mask ); |
duke@435 | 673 | |
duke@435 | 674 | // TailCalls have 2 returned values (target & moop), whose masks come |
duke@435 | 675 | // from the usual MachNode/MachOper mechanism. Find a sample |
duke@435 | 676 | // TailCall to extract these masks and put the correct masks into |
duke@435 | 677 | // the tail_call_rms array. |
duke@435 | 678 | for( i=1; i < root->req(); i++ ) { |
duke@435 | 679 | MachReturnNode *m = root->in(i)->as_MachReturn(); |
duke@435 | 680 | if( m->ideal_Opcode() == Op_TailCall ) { |
duke@435 | 681 | tail_call_rms[TypeFunc::Parms+0] = m->MachNode::in_RegMask(TypeFunc::Parms+0); |
duke@435 | 682 | tail_call_rms[TypeFunc::Parms+1] = m->MachNode::in_RegMask(TypeFunc::Parms+1); |
duke@435 | 683 | break; |
duke@435 | 684 | } |
duke@435 | 685 | } |
duke@435 | 686 | |
duke@435 | 687 | // TailJumps have 2 returned values (target & ex_oop), whose masks come |
duke@435 | 688 | // from the usual MachNode/MachOper mechanism. Find a sample |
duke@435 | 689 | // TailJump to extract these masks and put the correct masks into |
duke@435 | 690 | // the tail_jump_rms array. |
duke@435 | 691 | for( i=1; i < root->req(); i++ ) { |
duke@435 | 692 | MachReturnNode *m = root->in(i)->as_MachReturn(); |
duke@435 | 693 | if( m->ideal_Opcode() == Op_TailJump ) { |
duke@435 | 694 | tail_jump_rms[TypeFunc::Parms+0] = m->MachNode::in_RegMask(TypeFunc::Parms+0); |
duke@435 | 695 | tail_jump_rms[TypeFunc::Parms+1] = m->MachNode::in_RegMask(TypeFunc::Parms+1); |
duke@435 | 696 | break; |
duke@435 | 697 | } |
duke@435 | 698 | } |
duke@435 | 699 | |
duke@435 | 700 | // Input RegMask array shared by all Halts |
duke@435 | 701 | uint halt_edge_cnt = TypeFunc::Parms; |
duke@435 | 702 | RegMask *halt_rms = init_input_masks( halt_edge_cnt + soe_cnt, _return_addr_mask, c_frame_ptr_mask ); |
duke@435 | 703 | |
duke@435 | 704 | // Capture the return input masks into each exit flavor |
duke@435 | 705 | for( i=1; i < root->req(); i++ ) { |
duke@435 | 706 | MachReturnNode *exit = root->in(i)->as_MachReturn(); |
duke@435 | 707 | switch( exit->ideal_Opcode() ) { |
duke@435 | 708 | case Op_Return : exit->_in_rms = ret_rms; break; |
duke@435 | 709 | case Op_Rethrow : exit->_in_rms = reth_rms; break; |
duke@435 | 710 | case Op_TailCall : exit->_in_rms = tail_call_rms; break; |
duke@435 | 711 | case Op_TailJump : exit->_in_rms = tail_jump_rms; break; |
duke@435 | 712 | case Op_Halt : exit->_in_rms = halt_rms; break; |
duke@435 | 713 | default : ShouldNotReachHere(); |
duke@435 | 714 | } |
duke@435 | 715 | } |
duke@435 | 716 | |
duke@435 | 717 | // Next unused projection number from Start. |
duke@435 | 718 | int proj_cnt = C->tf()->domain()->cnt(); |
duke@435 | 719 | |
duke@435 | 720 | // Do all the save-on-entry registers. Make projections from Start for |
duke@435 | 721 | // them, and give them a use at the exit points. To the allocator, they |
duke@435 | 722 | // look like incoming register arguments. |
duke@435 | 723 | for( i = 0; i < _last_Mach_Reg; i++ ) { |
duke@435 | 724 | if( is_save_on_entry(i) ) { |
duke@435 | 725 | |
duke@435 | 726 | // Add the save-on-entry to the mask array |
duke@435 | 727 | ret_rms [ ret_edge_cnt] = mreg2regmask[i]; |
duke@435 | 728 | reth_rms [ reth_edge_cnt] = mreg2regmask[i]; |
duke@435 | 729 | tail_call_rms[tail_call_edge_cnt] = mreg2regmask[i]; |
duke@435 | 730 | tail_jump_rms[tail_jump_edge_cnt] = mreg2regmask[i]; |
duke@435 | 731 | // Halts need the SOE registers, but only in the stack as debug info. |
duke@435 | 732 | // A just-prior uncommon-trap or deoptimization will use the SOE regs. |
duke@435 | 733 | halt_rms [ halt_edge_cnt] = *idealreg2spillmask[_register_save_type[i]]; |
duke@435 | 734 | |
duke@435 | 735 | Node *mproj; |
duke@435 | 736 | |
duke@435 | 737 | // Is this a RegF low half of a RegD? Double up 2 adjacent RegF's |
duke@435 | 738 | // into a single RegD. |
duke@435 | 739 | if( (i&1) == 0 && |
duke@435 | 740 | _register_save_type[i ] == Op_RegF && |
duke@435 | 741 | _register_save_type[i+1] == Op_RegF && |
duke@435 | 742 | is_save_on_entry(i+1) ) { |
duke@435 | 743 | // Add other bit for double |
duke@435 | 744 | ret_rms [ ret_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 745 | reth_rms [ reth_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 746 | tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 747 | tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 748 | halt_rms [ halt_edge_cnt].Insert(OptoReg::Name(i+1)); |
kvn@4115 | 749 | mproj = new (C) MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegD ); |
duke@435 | 750 | proj_cnt += 2; // Skip 2 for doubles |
duke@435 | 751 | } |
duke@435 | 752 | else if( (i&1) == 1 && // Else check for high half of double |
duke@435 | 753 | _register_save_type[i-1] == Op_RegF && |
duke@435 | 754 | _register_save_type[i ] == Op_RegF && |
duke@435 | 755 | is_save_on_entry(i-1) ) { |
duke@435 | 756 | ret_rms [ ret_edge_cnt] = RegMask::Empty; |
duke@435 | 757 | reth_rms [ reth_edge_cnt] = RegMask::Empty; |
duke@435 | 758 | tail_call_rms[tail_call_edge_cnt] = RegMask::Empty; |
duke@435 | 759 | tail_jump_rms[tail_jump_edge_cnt] = RegMask::Empty; |
duke@435 | 760 | halt_rms [ halt_edge_cnt] = RegMask::Empty; |
duke@435 | 761 | mproj = C->top(); |
duke@435 | 762 | } |
duke@435 | 763 | // Is this a RegI low half of a RegL? Double up 2 adjacent RegI's |
duke@435 | 764 | // into a single RegL. |
duke@435 | 765 | else if( (i&1) == 0 && |
duke@435 | 766 | _register_save_type[i ] == Op_RegI && |
duke@435 | 767 | _register_save_type[i+1] == Op_RegI && |
duke@435 | 768 | is_save_on_entry(i+1) ) { |
duke@435 | 769 | // Add other bit for long |
duke@435 | 770 | ret_rms [ ret_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 771 | reth_rms [ reth_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 772 | tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 773 | tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1)); |
duke@435 | 774 | halt_rms [ halt_edge_cnt].Insert(OptoReg::Name(i+1)); |
kvn@4115 | 775 | mproj = new (C) MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegL ); |
duke@435 | 776 | proj_cnt += 2; // Skip 2 for longs |
duke@435 | 777 | } |
duke@435 | 778 | else if( (i&1) == 1 && // Else check for high half of long |
duke@435 | 779 | _register_save_type[i-1] == Op_RegI && |
duke@435 | 780 | _register_save_type[i ] == Op_RegI && |
duke@435 | 781 | is_save_on_entry(i-1) ) { |
duke@435 | 782 | ret_rms [ ret_edge_cnt] = RegMask::Empty; |
duke@435 | 783 | reth_rms [ reth_edge_cnt] = RegMask::Empty; |
duke@435 | 784 | tail_call_rms[tail_call_edge_cnt] = RegMask::Empty; |
duke@435 | 785 | tail_jump_rms[tail_jump_edge_cnt] = RegMask::Empty; |
duke@435 | 786 | halt_rms [ halt_edge_cnt] = RegMask::Empty; |
duke@435 | 787 | mproj = C->top(); |
duke@435 | 788 | } else { |
duke@435 | 789 | // Make a projection for it off the Start |
kvn@4115 | 790 | mproj = new (C) MachProjNode( start, proj_cnt++, ret_rms[ret_edge_cnt], _register_save_type[i] ); |
duke@435 | 791 | } |
duke@435 | 792 | |
duke@435 | 793 | ret_edge_cnt ++; |
duke@435 | 794 | reth_edge_cnt ++; |
duke@435 | 795 | tail_call_edge_cnt ++; |
duke@435 | 796 | tail_jump_edge_cnt ++; |
duke@435 | 797 | halt_edge_cnt ++; |
duke@435 | 798 | |
duke@435 | 799 | // Add a use of the SOE register to all exit paths |
duke@435 | 800 | for( uint j=1; j < root->req(); j++ ) |
duke@435 | 801 | root->in(j)->add_req(mproj); |
duke@435 | 802 | } // End of if a save-on-entry register |
duke@435 | 803 | } // End of for all machine registers |
duke@435 | 804 | } |
duke@435 | 805 | |
duke@435 | 806 | //------------------------------init_spill_mask-------------------------------- |
duke@435 | 807 | void Matcher::init_spill_mask( Node *ret ) { |
duke@435 | 808 | if( idealreg2regmask[Op_RegI] ) return; // One time only init |
duke@435 | 809 | |
duke@435 | 810 | OptoReg::c_frame_pointer = c_frame_pointer(); |
duke@435 | 811 | c_frame_ptr_mask = c_frame_pointer(); |
duke@435 | 812 | #ifdef _LP64 |
duke@435 | 813 | // pointers are twice as big |
duke@435 | 814 | c_frame_ptr_mask.Insert(OptoReg::add(c_frame_pointer(),1)); |
duke@435 | 815 | #endif |
duke@435 | 816 | |
duke@435 | 817 | // Start at OptoReg::stack0() |
duke@435 | 818 | STACK_ONLY_mask.Clear(); |
duke@435 | 819 | OptoReg::Name init = OptoReg::stack2reg(0); |
duke@435 | 820 | // STACK_ONLY_mask is all stack bits |
duke@435 | 821 | OptoReg::Name i; |
duke@435 | 822 | for (i = init; RegMask::can_represent(i); i = OptoReg::add(i,1)) |
duke@435 | 823 | STACK_ONLY_mask.Insert(i); |
duke@435 | 824 | // Also set the "infinite stack" bit. |
duke@435 | 825 | STACK_ONLY_mask.set_AllStack(); |
duke@435 | 826 | |
duke@435 | 827 | // Copy the register names over into the shared world |
duke@435 | 828 | for( i=OptoReg::Name(0); i<OptoReg::Name(_last_Mach_Reg); i = OptoReg::add(i,1) ) { |
duke@435 | 829 | // SharedInfo::regName[i] = regName[i]; |
duke@435 | 830 | // Handy RegMasks per machine register |
duke@435 | 831 | mreg2regmask[i].Insert(i); |
duke@435 | 832 | } |
duke@435 | 833 | |
duke@435 | 834 | // Grab the Frame Pointer |
duke@435 | 835 | Node *fp = ret->in(TypeFunc::FramePtr); |
duke@435 | 836 | Node *mem = ret->in(TypeFunc::Memory); |
duke@435 | 837 | const TypePtr* atp = TypePtr::BOTTOM; |
duke@435 | 838 | // Share frame pointer while making spill ops |
duke@435 | 839 | set_shared(fp); |
duke@435 | 840 | |
duke@435 | 841 | // Compute generic short-offset Loads |
coleenp@548 | 842 | #ifdef _LP64 |
goetz@6479 | 843 | MachNode *spillCP = match_tree(new (C) LoadNNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered)); |
coleenp@548 | 844 | #endif |
goetz@6479 | 845 | MachNode *spillI = match_tree(new (C) LoadINode(NULL,mem,fp,atp,TypeInt::INT,MemNode::unordered)); |
roland@7859 | 846 | MachNode *spillL = match_tree(new (C) LoadLNode(NULL,mem,fp,atp,TypeLong::LONG,MemNode::unordered, LoadNode::DependsOnlyOnTest,false)); |
goetz@6479 | 847 | MachNode *spillF = match_tree(new (C) LoadFNode(NULL,mem,fp,atp,Type::FLOAT,MemNode::unordered)); |
goetz@6479 | 848 | MachNode *spillD = match_tree(new (C) LoadDNode(NULL,mem,fp,atp,Type::DOUBLE,MemNode::unordered)); |
goetz@6479 | 849 | MachNode *spillP = match_tree(new (C) LoadPNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered)); |
duke@435 | 850 | assert(spillI != NULL && spillL != NULL && spillF != NULL && |
duke@435 | 851 | spillD != NULL && spillP != NULL, ""); |
duke@435 | 852 | // Get the ADLC notion of the right regmask, for each basic type. |
coleenp@548 | 853 | #ifdef _LP64 |
coleenp@548 | 854 | idealreg2regmask[Op_RegN] = &spillCP->out_RegMask(); |
coleenp@548 | 855 | #endif |
duke@435 | 856 | idealreg2regmask[Op_RegI] = &spillI->out_RegMask(); |
duke@435 | 857 | idealreg2regmask[Op_RegL] = &spillL->out_RegMask(); |
duke@435 | 858 | idealreg2regmask[Op_RegF] = &spillF->out_RegMask(); |
duke@435 | 859 | idealreg2regmask[Op_RegD] = &spillD->out_RegMask(); |
duke@435 | 860 | idealreg2regmask[Op_RegP] = &spillP->out_RegMask(); |
kvn@3882 | 861 | |
kvn@3882 | 862 | // Vector regmasks. |
kvn@3882 | 863 | if (Matcher::vector_size_supported(T_BYTE,4)) { |
kvn@3882 | 864 | TypeVect::VECTS = TypeVect::make(T_BYTE, 4); |
kvn@4115 | 865 | MachNode *spillVectS = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTS)); |
kvn@3882 | 866 | idealreg2regmask[Op_VecS] = &spillVectS->out_RegMask(); |
kvn@3882 | 867 | } |
kvn@3882 | 868 | if (Matcher::vector_size_supported(T_FLOAT,2)) { |
kvn@4115 | 869 | MachNode *spillVectD = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTD)); |
kvn@3882 | 870 | idealreg2regmask[Op_VecD] = &spillVectD->out_RegMask(); |
kvn@3882 | 871 | } |
kvn@3882 | 872 | if (Matcher::vector_size_supported(T_FLOAT,4)) { |
kvn@4115 | 873 | MachNode *spillVectX = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTX)); |
kvn@3882 | 874 | idealreg2regmask[Op_VecX] = &spillVectX->out_RegMask(); |
kvn@3882 | 875 | } |
kvn@3882 | 876 | if (Matcher::vector_size_supported(T_FLOAT,8)) { |
kvn@4115 | 877 | MachNode *spillVectY = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTY)); |
kvn@3882 | 878 | idealreg2regmask[Op_VecY] = &spillVectY->out_RegMask(); |
kvn@3882 | 879 | } |
duke@435 | 880 | } |
duke@435 | 881 | |
duke@435 | 882 | #ifdef ASSERT |
duke@435 | 883 | static void match_alias_type(Compile* C, Node* n, Node* m) { |
duke@435 | 884 | if (!VerifyAliases) return; // do not go looking for trouble by default |
duke@435 | 885 | const TypePtr* nat = n->adr_type(); |
duke@435 | 886 | const TypePtr* mat = m->adr_type(); |
duke@435 | 887 | int nidx = C->get_alias_index(nat); |
duke@435 | 888 | int midx = C->get_alias_index(mat); |
duke@435 | 889 | // Detune the assert for cases like (AndI 0xFF (LoadB p)). |
duke@435 | 890 | if (nidx == Compile::AliasIdxTop && midx >= Compile::AliasIdxRaw) { |
duke@435 | 891 | for (uint i = 1; i < n->req(); i++) { |
duke@435 | 892 | Node* n1 = n->in(i); |
duke@435 | 893 | const TypePtr* n1at = n1->adr_type(); |
duke@435 | 894 | if (n1at != NULL) { |
duke@435 | 895 | nat = n1at; |
duke@435 | 896 | nidx = C->get_alias_index(n1at); |
duke@435 | 897 | } |
duke@435 | 898 | } |
duke@435 | 899 | } |
duke@435 | 900 | // %%% Kludgery. Instead, fix ideal adr_type methods for all these cases: |
duke@435 | 901 | if (nidx == Compile::AliasIdxTop && midx == Compile::AliasIdxRaw) { |
duke@435 | 902 | switch (n->Opcode()) { |
duke@435 | 903 | case Op_PrefetchRead: |
duke@435 | 904 | case Op_PrefetchWrite: |
kvn@3052 | 905 | case Op_PrefetchAllocation: |
duke@435 | 906 | nidx = Compile::AliasIdxRaw; |
duke@435 | 907 | nat = TypeRawPtr::BOTTOM; |
duke@435 | 908 | break; |
duke@435 | 909 | } |
duke@435 | 910 | } |
duke@435 | 911 | if (nidx == Compile::AliasIdxRaw && midx == Compile::AliasIdxTop) { |
duke@435 | 912 | switch (n->Opcode()) { |
duke@435 | 913 | case Op_ClearArray: |
duke@435 | 914 | midx = Compile::AliasIdxRaw; |
duke@435 | 915 | mat = TypeRawPtr::BOTTOM; |
duke@435 | 916 | break; |
duke@435 | 917 | } |
duke@435 | 918 | } |
duke@435 | 919 | if (nidx == Compile::AliasIdxTop && midx == Compile::AliasIdxBot) { |
duke@435 | 920 | switch (n->Opcode()) { |
duke@435 | 921 | case Op_Return: |
duke@435 | 922 | case Op_Rethrow: |
duke@435 | 923 | case Op_Halt: |
duke@435 | 924 | case Op_TailCall: |
duke@435 | 925 | case Op_TailJump: |
duke@435 | 926 | nidx = Compile::AliasIdxBot; |
duke@435 | 927 | nat = TypePtr::BOTTOM; |
duke@435 | 928 | break; |
duke@435 | 929 | } |
duke@435 | 930 | } |
duke@435 | 931 | if (nidx == Compile::AliasIdxBot && midx == Compile::AliasIdxTop) { |
duke@435 | 932 | switch (n->Opcode()) { |
duke@435 | 933 | case Op_StrComp: |
cfang@1116 | 934 | case Op_StrEquals: |
cfang@1116 | 935 | case Op_StrIndexOf: |
rasbold@604 | 936 | case Op_AryEq: |
duke@435 | 937 | case Op_MemBarVolatile: |
duke@435 | 938 | case Op_MemBarCPUOrder: // %%% these ideals should have narrower adr_type? |
kvn@4479 | 939 | case Op_EncodeISOArray: |
duke@435 | 940 | nidx = Compile::AliasIdxTop; |
duke@435 | 941 | nat = NULL; |
duke@435 | 942 | break; |
duke@435 | 943 | } |
duke@435 | 944 | } |
duke@435 | 945 | if (nidx != midx) { |
duke@435 | 946 | if (PrintOpto || (PrintMiscellaneous && (WizardMode || Verbose))) { |
duke@435 | 947 | tty->print_cr("==== Matcher alias shift %d => %d", nidx, midx); |
duke@435 | 948 | n->dump(); |
duke@435 | 949 | m->dump(); |
duke@435 | 950 | } |
duke@435 | 951 | assert(C->subsume_loads() && C->must_alias(nat, midx), |
duke@435 | 952 | "must not lose alias info when matching"); |
duke@435 | 953 | } |
duke@435 | 954 | } |
duke@435 | 955 | #endif |
duke@435 | 956 | |
duke@435 | 957 | |
duke@435 | 958 | //------------------------------MStack----------------------------------------- |
duke@435 | 959 | // State and MStack class used in xform() and find_shared() iterative methods. |
duke@435 | 960 | enum Node_State { Pre_Visit, // node has to be pre-visited |
duke@435 | 961 | Visit, // visit node |
duke@435 | 962 | Post_Visit, // post-visit node |
duke@435 | 963 | Alt_Post_Visit // alternative post-visit path |
duke@435 | 964 | }; |
duke@435 | 965 | |
duke@435 | 966 | class MStack: public Node_Stack { |
duke@435 | 967 | public: |
duke@435 | 968 | MStack(int size) : Node_Stack(size) { } |
duke@435 | 969 | |
duke@435 | 970 | void push(Node *n, Node_State ns) { |
duke@435 | 971 | Node_Stack::push(n, (uint)ns); |
duke@435 | 972 | } |
duke@435 | 973 | void push(Node *n, Node_State ns, Node *parent, int indx) { |
duke@435 | 974 | ++_inode_top; |
duke@435 | 975 | if ((_inode_top + 1) >= _inode_max) grow(); |
duke@435 | 976 | _inode_top->node = parent; |
duke@435 | 977 | _inode_top->indx = (uint)indx; |
duke@435 | 978 | ++_inode_top; |
duke@435 | 979 | _inode_top->node = n; |
duke@435 | 980 | _inode_top->indx = (uint)ns; |
duke@435 | 981 | } |
duke@435 | 982 | Node *parent() { |
duke@435 | 983 | pop(); |
duke@435 | 984 | return node(); |
duke@435 | 985 | } |
duke@435 | 986 | Node_State state() const { |
duke@435 | 987 | return (Node_State)index(); |
duke@435 | 988 | } |
duke@435 | 989 | void set_state(Node_State ns) { |
duke@435 | 990 | set_index((uint)ns); |
duke@435 | 991 | } |
duke@435 | 992 | }; |
duke@435 | 993 | |
duke@435 | 994 | |
duke@435 | 995 | //------------------------------xform------------------------------------------ |
duke@435 | 996 | // Given a Node in old-space, Match him (Label/Reduce) to produce a machine |
duke@435 | 997 | // Node in new-space. Given a new-space Node, recursively walk his children. |
duke@435 | 998 | Node *Matcher::transform( Node *n ) { ShouldNotCallThis(); return n; } |
duke@435 | 999 | Node *Matcher::xform( Node *n, int max_stack ) { |
duke@435 | 1000 | // Use one stack to keep both: child's node/state and parent's node/index |
zmajo@8068 | 1001 | MStack mstack(max_stack * 2 * 2); // usually: C->live_nodes() * 2 * 2 |
duke@435 | 1002 | mstack.push(n, Visit, NULL, -1); // set NULL as parent to indicate root |
duke@435 | 1003 | |
duke@435 | 1004 | while (mstack.is_nonempty()) { |
drchase@5285 | 1005 | C->check_node_count(NodeLimitFudgeFactor, "too many nodes matching instructions"); |
drchase@5285 | 1006 | if (C->failing()) return NULL; |
duke@435 | 1007 | n = mstack.node(); // Leave node on stack |
duke@435 | 1008 | Node_State nstate = mstack.state(); |
duke@435 | 1009 | if (nstate == Visit) { |
duke@435 | 1010 | mstack.set_state(Post_Visit); |
duke@435 | 1011 | Node *oldn = n; |
duke@435 | 1012 | // Old-space or new-space check |
duke@435 | 1013 | if (!C->node_arena()->contains(n)) { |
duke@435 | 1014 | // Old space! |
duke@435 | 1015 | Node* m; |
duke@435 | 1016 | if (has_new_node(n)) { // Not yet Label/Reduced |
duke@435 | 1017 | m = new_node(n); |
duke@435 | 1018 | } else { |
duke@435 | 1019 | if (!is_dontcare(n)) { // Matcher can match this guy |
duke@435 | 1020 | // Calls match special. They match alone with no children. |
duke@435 | 1021 | // Their children, the incoming arguments, match normally. |
duke@435 | 1022 | m = n->is_SafePoint() ? match_sfpt(n->as_SafePoint()):match_tree(n); |
duke@435 | 1023 | if (C->failing()) return NULL; |
duke@435 | 1024 | if (m == NULL) { Matcher::soft_match_failure(); return NULL; } |
duke@435 | 1025 | } else { // Nothing the matcher cares about |
thartmann@8771 | 1026 | if (n->is_Proj() && n->in(0) != NULL && n->in(0)->is_Multi()) { // Projections? |
duke@435 | 1027 | // Convert to machine-dependent projection |
duke@435 | 1028 | m = n->in(0)->as_Multi()->match( n->as_Proj(), this ); |
never@657 | 1029 | #ifdef ASSERT |
never@657 | 1030 | _new2old_map.map(m->_idx, n); |
never@657 | 1031 | #endif |
duke@435 | 1032 | if (m->in(0) != NULL) // m might be top |
kvn@803 | 1033 | collect_null_checks(m, n); |
duke@435 | 1034 | } else { // Else just a regular 'ol guy |
duke@435 | 1035 | m = n->clone(); // So just clone into new-space |
never@657 | 1036 | #ifdef ASSERT |
never@657 | 1037 | _new2old_map.map(m->_idx, n); |
never@657 | 1038 | #endif |
duke@435 | 1039 | // Def-Use edges will be added incrementally as Uses |
duke@435 | 1040 | // of this node are matched. |
duke@435 | 1041 | assert(m->outcnt() == 0, "no Uses of this clone yet"); |
duke@435 | 1042 | } |
duke@435 | 1043 | } |
duke@435 | 1044 | |
duke@435 | 1045 | set_new_node(n, m); // Map old to new |
duke@435 | 1046 | if (_old_node_note_array != NULL) { |
duke@435 | 1047 | Node_Notes* nn = C->locate_node_notes(_old_node_note_array, |
duke@435 | 1048 | n->_idx); |
duke@435 | 1049 | C->set_node_notes_at(m->_idx, nn); |
duke@435 | 1050 | } |
duke@435 | 1051 | debug_only(match_alias_type(C, n, m)); |
duke@435 | 1052 | } |
duke@435 | 1053 | n = m; // n is now a new-space node |
duke@435 | 1054 | mstack.set_node(n); |
duke@435 | 1055 | } |
duke@435 | 1056 | |
duke@435 | 1057 | // New space! |
duke@435 | 1058 | if (_visited.test_set(n->_idx)) continue; // while(mstack.is_nonempty()) |
duke@435 | 1059 | |
duke@435 | 1060 | int i; |
duke@435 | 1061 | // Put precedence edges on stack first (match them last). |
duke@435 | 1062 | for (i = oldn->req(); (uint)i < oldn->len(); i++) { |
duke@435 | 1063 | Node *m = oldn->in(i); |
duke@435 | 1064 | if (m == NULL) break; |
duke@435 | 1065 | // set -1 to call add_prec() instead of set_req() during Step1 |
duke@435 | 1066 | mstack.push(m, Visit, n, -1); |
duke@435 | 1067 | } |
duke@435 | 1068 | |
duke@435 | 1069 | // For constant debug info, I'd rather have unmatched constants. |
duke@435 | 1070 | int cnt = n->req(); |
duke@435 | 1071 | JVMState* jvms = n->jvms(); |
duke@435 | 1072 | int debug_cnt = jvms ? jvms->debug_start() : cnt; |
duke@435 | 1073 | |
duke@435 | 1074 | // Now do only debug info. Clone constants rather than matching. |
duke@435 | 1075 | // Constants are represented directly in the debug info without |
duke@435 | 1076 | // the need for executable machine instructions. |
duke@435 | 1077 | // Monitor boxes are also represented directly. |
duke@435 | 1078 | for (i = cnt - 1; i >= debug_cnt; --i) { // For all debug inputs do |
duke@435 | 1079 | Node *m = n->in(i); // Get input |
duke@435 | 1080 | int op = m->Opcode(); |
duke@435 | 1081 | assert((op == Op_BoxLock) == jvms->is_monitor_use(i), "boxes only at monitor sites"); |
roland@4159 | 1082 | if( op == Op_ConI || op == Op_ConP || op == Op_ConN || op == Op_ConNKlass || |
duke@435 | 1083 | op == Op_ConF || op == Op_ConD || op == Op_ConL |
duke@435 | 1084 | // || op == Op_BoxLock // %%%% enable this and remove (+++) in chaitin.cpp |
duke@435 | 1085 | ) { |
duke@435 | 1086 | m = m->clone(); |
never@657 | 1087 | #ifdef ASSERT |
never@657 | 1088 | _new2old_map.map(m->_idx, n); |
never@657 | 1089 | #endif |
twisti@1040 | 1090 | mstack.push(m, Post_Visit, n, i); // Don't need to visit |
duke@435 | 1091 | mstack.push(m->in(0), Visit, m, 0); |
duke@435 | 1092 | } else { |
duke@435 | 1093 | mstack.push(m, Visit, n, i); |
duke@435 | 1094 | } |
duke@435 | 1095 | } |
duke@435 | 1096 | |
duke@435 | 1097 | // And now walk his children, and convert his inputs to new-space. |
duke@435 | 1098 | for( ; i >= 0; --i ) { // For all normal inputs do |
duke@435 | 1099 | Node *m = n->in(i); // Get input |
duke@435 | 1100 | if(m != NULL) |
duke@435 | 1101 | mstack.push(m, Visit, n, i); |
duke@435 | 1102 | } |
duke@435 | 1103 | |
duke@435 | 1104 | } |
duke@435 | 1105 | else if (nstate == Post_Visit) { |
duke@435 | 1106 | // Set xformed input |
duke@435 | 1107 | Node *p = mstack.parent(); |
duke@435 | 1108 | if (p != NULL) { // root doesn't have parent |
duke@435 | 1109 | int i = (int)mstack.index(); |
duke@435 | 1110 | if (i >= 0) |
duke@435 | 1111 | p->set_req(i, n); // required input |
duke@435 | 1112 | else if (i == -1) |
duke@435 | 1113 | p->add_prec(n); // precedence input |
duke@435 | 1114 | else |
duke@435 | 1115 | ShouldNotReachHere(); |
duke@435 | 1116 | } |
duke@435 | 1117 | mstack.pop(); // remove processed node from stack |
duke@435 | 1118 | } |
duke@435 | 1119 | else { |
duke@435 | 1120 | ShouldNotReachHere(); |
duke@435 | 1121 | } |
duke@435 | 1122 | } // while (mstack.is_nonempty()) |
duke@435 | 1123 | return n; // Return new-space Node |
duke@435 | 1124 | } |
duke@435 | 1125 | |
duke@435 | 1126 | //------------------------------warp_outgoing_stk_arg------------------------ |
duke@435 | 1127 | OptoReg::Name Matcher::warp_outgoing_stk_arg( VMReg reg, OptoReg::Name begin_out_arg_area, OptoReg::Name &out_arg_limit_per_call ) { |
duke@435 | 1128 | // Convert outgoing argument location to a pre-biased stack offset |
duke@435 | 1129 | if (reg->is_stack()) { |
duke@435 | 1130 | OptoReg::Name warped = reg->reg2stack(); |
duke@435 | 1131 | // Adjust the stack slot offset to be the register number used |
duke@435 | 1132 | // by the allocator. |
duke@435 | 1133 | warped = OptoReg::add(begin_out_arg_area, warped); |
duke@435 | 1134 | // Keep track of the largest numbered stack slot used for an arg. |
duke@435 | 1135 | // Largest used slot per call-site indicates the amount of stack |
duke@435 | 1136 | // that is killed by the call. |
duke@435 | 1137 | if( warped >= out_arg_limit_per_call ) |
duke@435 | 1138 | out_arg_limit_per_call = OptoReg::add(warped,1); |
kvn@3882 | 1139 | if (!RegMask::can_represent_arg(warped)) { |
duke@435 | 1140 | C->record_method_not_compilable_all_tiers("unsupported calling sequence"); |
duke@435 | 1141 | return OptoReg::Bad; |
duke@435 | 1142 | } |
duke@435 | 1143 | return warped; |
duke@435 | 1144 | } |
duke@435 | 1145 | return OptoReg::as_OptoReg(reg); |
duke@435 | 1146 | } |
duke@435 | 1147 | |
duke@435 | 1148 | |
duke@435 | 1149 | //------------------------------match_sfpt------------------------------------- |
duke@435 | 1150 | // Helper function to match call instructions. Calls match special. |
duke@435 | 1151 | // They match alone with no children. Their children, the incoming |
duke@435 | 1152 | // arguments, match normally. |
duke@435 | 1153 | MachNode *Matcher::match_sfpt( SafePointNode *sfpt ) { |
duke@435 | 1154 | MachSafePointNode *msfpt = NULL; |
duke@435 | 1155 | MachCallNode *mcall = NULL; |
duke@435 | 1156 | uint cnt; |
duke@435 | 1157 | // Split out case for SafePoint vs Call |
duke@435 | 1158 | CallNode *call; |
duke@435 | 1159 | const TypeTuple *domain; |
duke@435 | 1160 | ciMethod* method = NULL; |
twisti@1572 | 1161 | bool is_method_handle_invoke = false; // for special kill effects |
duke@435 | 1162 | if( sfpt->is_Call() ) { |
duke@435 | 1163 | call = sfpt->as_Call(); |
duke@435 | 1164 | domain = call->tf()->domain(); |
duke@435 | 1165 | cnt = domain->cnt(); |
duke@435 | 1166 | |
duke@435 | 1167 | // Match just the call, nothing else |
duke@435 | 1168 | MachNode *m = match_tree(call); |
duke@435 | 1169 | if (C->failing()) return NULL; |
duke@435 | 1170 | if( m == NULL ) { Matcher::soft_match_failure(); return NULL; } |
duke@435 | 1171 | |
duke@435 | 1172 | // Copy data from the Ideal SafePoint to the machine version |
duke@435 | 1173 | mcall = m->as_MachCall(); |
duke@435 | 1174 | |
duke@435 | 1175 | mcall->set_tf( call->tf()); |
duke@435 | 1176 | mcall->set_entry_point(call->entry_point()); |
duke@435 | 1177 | mcall->set_cnt( call->cnt()); |
duke@435 | 1178 | |
duke@435 | 1179 | if( mcall->is_MachCallJava() ) { |
duke@435 | 1180 | MachCallJavaNode *mcall_java = mcall->as_MachCallJava(); |
duke@435 | 1181 | const CallJavaNode *call_java = call->as_CallJava(); |
duke@435 | 1182 | method = call_java->method(); |
duke@435 | 1183 | mcall_java->_method = method; |
duke@435 | 1184 | mcall_java->_bci = call_java->_bci; |
duke@435 | 1185 | mcall_java->_optimized_virtual = call_java->is_optimized_virtual(); |
twisti@1572 | 1186 | is_method_handle_invoke = call_java->is_method_handle_invoke(); |
twisti@1572 | 1187 | mcall_java->_method_handle_invoke = is_method_handle_invoke; |
never@3105 | 1188 | if (is_method_handle_invoke) { |
never@3105 | 1189 | C->set_has_method_handle_invokes(true); |
never@3105 | 1190 | } |
duke@435 | 1191 | if( mcall_java->is_MachCallStaticJava() ) |
duke@435 | 1192 | mcall_java->as_MachCallStaticJava()->_name = |
duke@435 | 1193 | call_java->as_CallStaticJava()->_name; |
duke@435 | 1194 | if( mcall_java->is_MachCallDynamicJava() ) |
duke@435 | 1195 | mcall_java->as_MachCallDynamicJava()->_vtable_index = |
duke@435 | 1196 | call_java->as_CallDynamicJava()->_vtable_index; |
duke@435 | 1197 | } |
duke@435 | 1198 | else if( mcall->is_MachCallRuntime() ) { |
duke@435 | 1199 | mcall->as_MachCallRuntime()->_name = call->as_CallRuntime()->_name; |
duke@435 | 1200 | } |
duke@435 | 1201 | msfpt = mcall; |
duke@435 | 1202 | } |
duke@435 | 1203 | // This is a non-call safepoint |
duke@435 | 1204 | else { |
duke@435 | 1205 | call = NULL; |
duke@435 | 1206 | domain = NULL; |
duke@435 | 1207 | MachNode *mn = match_tree(sfpt); |
duke@435 | 1208 | if (C->failing()) return NULL; |
duke@435 | 1209 | msfpt = mn->as_MachSafePoint(); |
duke@435 | 1210 | cnt = TypeFunc::Parms; |
duke@435 | 1211 | } |
duke@435 | 1212 | |
duke@435 | 1213 | // Advertise the correct memory effects (for anti-dependence computation). |
duke@435 | 1214 | msfpt->set_adr_type(sfpt->adr_type()); |
duke@435 | 1215 | |
duke@435 | 1216 | // Allocate a private array of RegMasks. These RegMasks are not shared. |
duke@435 | 1217 | msfpt->_in_rms = NEW_RESOURCE_ARRAY( RegMask, cnt ); |
duke@435 | 1218 | // Empty them all. |
duke@435 | 1219 | memset( msfpt->_in_rms, 0, sizeof(RegMask)*cnt ); |
duke@435 | 1220 | |
duke@435 | 1221 | // Do all the pre-defined non-Empty register masks |
duke@435 | 1222 | msfpt->_in_rms[TypeFunc::ReturnAdr] = _return_addr_mask; |
duke@435 | 1223 | msfpt->_in_rms[TypeFunc::FramePtr ] = c_frame_ptr_mask; |
duke@435 | 1224 | |
duke@435 | 1225 | // Place first outgoing argument can possibly be put. |
duke@435 | 1226 | OptoReg::Name begin_out_arg_area = OptoReg::add(_new_SP, C->out_preserve_stack_slots()); |
duke@435 | 1227 | assert( is_even(begin_out_arg_area), "" ); |
duke@435 | 1228 | // Compute max outgoing register number per call site. |
duke@435 | 1229 | OptoReg::Name out_arg_limit_per_call = begin_out_arg_area; |
duke@435 | 1230 | // Calls to C may hammer extra stack slots above and beyond any arguments. |
duke@435 | 1231 | // These are usually backing store for register arguments for varargs. |
duke@435 | 1232 | if( call != NULL && call->is_CallRuntime() ) |
duke@435 | 1233 | out_arg_limit_per_call = OptoReg::add(out_arg_limit_per_call,C->varargs_C_out_slots_killed()); |
duke@435 | 1234 | |
duke@435 | 1235 | |
duke@435 | 1236 | // Do the normal argument list (parameters) register masks |
duke@435 | 1237 | int argcnt = cnt - TypeFunc::Parms; |
duke@435 | 1238 | if( argcnt > 0 ) { // Skip it all if we have no args |
duke@435 | 1239 | BasicType *sig_bt = NEW_RESOURCE_ARRAY( BasicType, argcnt ); |
duke@435 | 1240 | VMRegPair *parm_regs = NEW_RESOURCE_ARRAY( VMRegPair, argcnt ); |
duke@435 | 1241 | int i; |
duke@435 | 1242 | for( i = 0; i < argcnt; i++ ) { |
duke@435 | 1243 | sig_bt[i] = domain->field_at(i+TypeFunc::Parms)->basic_type(); |
duke@435 | 1244 | } |
duke@435 | 1245 | // V-call to pick proper calling convention |
duke@435 | 1246 | call->calling_convention( sig_bt, parm_regs, argcnt ); |
duke@435 | 1247 | |
duke@435 | 1248 | #ifdef ASSERT |
duke@435 | 1249 | // Sanity check users' calling convention. Really handy during |
duke@435 | 1250 | // the initial porting effort. Fairly expensive otherwise. |
duke@435 | 1251 | { for (int i = 0; i<argcnt; i++) { |
duke@435 | 1252 | if( !parm_regs[i].first()->is_valid() && |
duke@435 | 1253 | !parm_regs[i].second()->is_valid() ) continue; |
duke@435 | 1254 | VMReg reg1 = parm_regs[i].first(); |
duke@435 | 1255 | VMReg reg2 = parm_regs[i].second(); |
duke@435 | 1256 | for (int j = 0; j < i; j++) { |
duke@435 | 1257 | if( !parm_regs[j].first()->is_valid() && |
duke@435 | 1258 | !parm_regs[j].second()->is_valid() ) continue; |
duke@435 | 1259 | VMReg reg3 = parm_regs[j].first(); |
duke@435 | 1260 | VMReg reg4 = parm_regs[j].second(); |
duke@435 | 1261 | if( !reg1->is_valid() ) { |
duke@435 | 1262 | assert( !reg2->is_valid(), "valid halvsies" ); |
duke@435 | 1263 | } else if( !reg3->is_valid() ) { |
duke@435 | 1264 | assert( !reg4->is_valid(), "valid halvsies" ); |
duke@435 | 1265 | } else { |
duke@435 | 1266 | assert( reg1 != reg2, "calling conv. must produce distinct regs"); |
duke@435 | 1267 | assert( reg1 != reg3, "calling conv. must produce distinct regs"); |
duke@435 | 1268 | assert( reg1 != reg4, "calling conv. must produce distinct regs"); |
duke@435 | 1269 | assert( reg2 != reg3, "calling conv. must produce distinct regs"); |
duke@435 | 1270 | assert( reg2 != reg4 || !reg2->is_valid(), "calling conv. must produce distinct regs"); |
duke@435 | 1271 | assert( reg3 != reg4, "calling conv. must produce distinct regs"); |
duke@435 | 1272 | } |
duke@435 | 1273 | } |
duke@435 | 1274 | } |
duke@435 | 1275 | } |
duke@435 | 1276 | #endif |
duke@435 | 1277 | |
duke@435 | 1278 | // Visit each argument. Compute its outgoing register mask. |
duke@435 | 1279 | // Return results now can have 2 bits returned. |
duke@435 | 1280 | // Compute max over all outgoing arguments both per call-site |
duke@435 | 1281 | // and over the entire method. |
duke@435 | 1282 | for( i = 0; i < argcnt; i++ ) { |
duke@435 | 1283 | // Address of incoming argument mask to fill in |
duke@435 | 1284 | RegMask *rm = &mcall->_in_rms[i+TypeFunc::Parms]; |
duke@435 | 1285 | if( !parm_regs[i].first()->is_valid() && |
duke@435 | 1286 | !parm_regs[i].second()->is_valid() ) { |
duke@435 | 1287 | continue; // Avoid Halves |
duke@435 | 1288 | } |
duke@435 | 1289 | // Grab first register, adjust stack slots and insert in mask. |
duke@435 | 1290 | OptoReg::Name reg1 = warp_outgoing_stk_arg(parm_regs[i].first(), begin_out_arg_area, out_arg_limit_per_call ); |
duke@435 | 1291 | if (OptoReg::is_valid(reg1)) |
duke@435 | 1292 | rm->Insert( reg1 ); |
duke@435 | 1293 | // Grab second register (if any), adjust stack slots and insert in mask. |
duke@435 | 1294 | OptoReg::Name reg2 = warp_outgoing_stk_arg(parm_regs[i].second(), begin_out_arg_area, out_arg_limit_per_call ); |
duke@435 | 1295 | if (OptoReg::is_valid(reg2)) |
duke@435 | 1296 | rm->Insert( reg2 ); |
duke@435 | 1297 | } // End of for all arguments |
duke@435 | 1298 | |
duke@435 | 1299 | // Compute number of stack slots needed to restore stack in case of |
duke@435 | 1300 | // Pascal-style argument popping. |
duke@435 | 1301 | mcall->_argsize = out_arg_limit_per_call - begin_out_arg_area; |
duke@435 | 1302 | } |
duke@435 | 1303 | |
duke@435 | 1304 | // Compute the max stack slot killed by any call. These will not be |
duke@435 | 1305 | // available for debug info, and will be used to adjust FIRST_STACK_mask |
duke@435 | 1306 | // after all call sites have been visited. |
duke@435 | 1307 | if( _out_arg_limit < out_arg_limit_per_call) |
duke@435 | 1308 | _out_arg_limit = out_arg_limit_per_call; |
duke@435 | 1309 | |
duke@435 | 1310 | if (mcall) { |
duke@435 | 1311 | // Kill the outgoing argument area, including any non-argument holes and |
duke@435 | 1312 | // any legacy C-killed slots. Use Fat-Projections to do the killing. |
duke@435 | 1313 | // Since the max-per-method covers the max-per-call-site and debug info |
duke@435 | 1314 | // is excluded on the max-per-method basis, debug info cannot land in |
duke@435 | 1315 | // this killed area. |
duke@435 | 1316 | uint r_cnt = mcall->tf()->range()->cnt(); |
kvn@4115 | 1317 | MachProjNode *proj = new (C) MachProjNode( mcall, r_cnt+10000, RegMask::Empty, MachProjNode::fat_proj ); |
kvn@3882 | 1318 | if (!RegMask::can_represent_arg(OptoReg::Name(out_arg_limit_per_call-1))) { |
duke@435 | 1319 | C->record_method_not_compilable_all_tiers("unsupported outgoing calling sequence"); |
duke@435 | 1320 | } else { |
duke@435 | 1321 | for (int i = begin_out_arg_area; i < out_arg_limit_per_call; i++) |
duke@435 | 1322 | proj->_rout.Insert(OptoReg::Name(i)); |
duke@435 | 1323 | } |
adlertz@5539 | 1324 | if (proj->_rout.is_NotEmpty()) { |
adlertz@5539 | 1325 | push_projection(proj); |
adlertz@5539 | 1326 | } |
duke@435 | 1327 | } |
duke@435 | 1328 | // Transfer the safepoint information from the call to the mcall |
duke@435 | 1329 | // Move the JVMState list |
duke@435 | 1330 | msfpt->set_jvms(sfpt->jvms()); |
duke@435 | 1331 | for (JVMState* jvms = msfpt->jvms(); jvms; jvms = jvms->caller()) { |
duke@435 | 1332 | jvms->set_map(sfpt); |
duke@435 | 1333 | } |
duke@435 | 1334 | |
duke@435 | 1335 | // Debug inputs begin just after the last incoming parameter |
goetz@6499 | 1336 | assert((mcall == NULL) || (mcall->jvms() == NULL) || |
goetz@6499 | 1337 | (mcall->jvms()->debug_start() + mcall->_jvmadj == mcall->tf()->domain()->cnt()), ""); |
duke@435 | 1338 | |
duke@435 | 1339 | // Move the OopMap |
duke@435 | 1340 | msfpt->_oop_map = sfpt->_oop_map; |
duke@435 | 1341 | |
goetz@6499 | 1342 | // Add additional edges. |
goetz@6499 | 1343 | if (msfpt->mach_constant_base_node_input() != (uint)-1 && !msfpt->is_MachCallLeaf()) { |
goetz@6499 | 1344 | // For these calls we can not add MachConstantBase in expand(), as the |
goetz@6499 | 1345 | // ins are not complete then. |
goetz@6499 | 1346 | msfpt->ins_req(msfpt->mach_constant_base_node_input(), C->mach_constant_base_node()); |
goetz@6499 | 1347 | if (msfpt->jvms() && |
goetz@6499 | 1348 | msfpt->mach_constant_base_node_input() <= msfpt->jvms()->debug_start() + msfpt->_jvmadj) { |
goetz@6499 | 1349 | // We added an edge before jvms, so we must adapt the position of the ins. |
goetz@6499 | 1350 | msfpt->jvms()->adapt_position(+1); |
goetz@6499 | 1351 | } |
goetz@6499 | 1352 | } |
goetz@6499 | 1353 | |
duke@435 | 1354 | // Registers killed by the call are set in the local scheduling pass |
duke@435 | 1355 | // of Global Code Motion. |
duke@435 | 1356 | return msfpt; |
duke@435 | 1357 | } |
duke@435 | 1358 | |
duke@435 | 1359 | //---------------------------match_tree---------------------------------------- |
duke@435 | 1360 | // Match a Ideal Node DAG - turn it into a tree; Label & Reduce. Used as part |
duke@435 | 1361 | // of the whole-sale conversion from Ideal to Mach Nodes. Also used for |
duke@435 | 1362 | // making GotoNodes while building the CFG and in init_spill_mask() to identify |
duke@435 | 1363 | // a Load's result RegMask for memoization in idealreg2regmask[] |
duke@435 | 1364 | MachNode *Matcher::match_tree( const Node *n ) { |
duke@435 | 1365 | assert( n->Opcode() != Op_Phi, "cannot match" ); |
duke@435 | 1366 | assert( !n->is_block_start(), "cannot match" ); |
duke@435 | 1367 | // Set the mark for all locally allocated State objects. |
duke@435 | 1368 | // When this call returns, the _states_arena arena will be reset |
duke@435 | 1369 | // freeing all State objects. |
duke@435 | 1370 | ResourceMark rm( &_states_arena ); |
duke@435 | 1371 | |
duke@435 | 1372 | LabelRootDepth = 0; |
duke@435 | 1373 | |
duke@435 | 1374 | // StoreNodes require their Memory input to match any LoadNodes |
duke@435 | 1375 | Node *mem = n->is_Store() ? n->in(MemNode::Memory) : (Node*)1 ; |
kvn@651 | 1376 | #ifdef ASSERT |
kvn@651 | 1377 | Node* save_mem_node = _mem_node; |
kvn@651 | 1378 | _mem_node = n->is_Store() ? (Node*)n : NULL; |
kvn@651 | 1379 | #endif |
duke@435 | 1380 | // State object for root node of match tree |
duke@435 | 1381 | // Allocate it on _states_arena - stack allocation can cause stack overflow. |
duke@435 | 1382 | State *s = new (&_states_arena) State; |
duke@435 | 1383 | s->_kids[0] = NULL; |
duke@435 | 1384 | s->_kids[1] = NULL; |
duke@435 | 1385 | s->_leaf = (Node*)n; |
duke@435 | 1386 | // Label the input tree, allocating labels from top-level arena |
duke@435 | 1387 | Label_Root( n, s, n->in(0), mem ); |
duke@435 | 1388 | if (C->failing()) return NULL; |
duke@435 | 1389 | |
duke@435 | 1390 | // The minimum cost match for the whole tree is found at the root State |
duke@435 | 1391 | uint mincost = max_juint; |
duke@435 | 1392 | uint cost = max_juint; |
duke@435 | 1393 | uint i; |
duke@435 | 1394 | for( i = 0; i < NUM_OPERANDS; i++ ) { |
duke@435 | 1395 | if( s->valid(i) && // valid entry and |
duke@435 | 1396 | s->_cost[i] < cost && // low cost and |
duke@435 | 1397 | s->_rule[i] >= NUM_OPERANDS ) // not an operand |
duke@435 | 1398 | cost = s->_cost[mincost=i]; |
duke@435 | 1399 | } |
duke@435 | 1400 | if (mincost == max_juint) { |
duke@435 | 1401 | #ifndef PRODUCT |
duke@435 | 1402 | tty->print("No matching rule for:"); |
duke@435 | 1403 | s->dump(); |
duke@435 | 1404 | #endif |
duke@435 | 1405 | Matcher::soft_match_failure(); |
duke@435 | 1406 | return NULL; |
duke@435 | 1407 | } |
duke@435 | 1408 | // Reduce input tree based upon the state labels to machine Nodes |
duke@435 | 1409 | MachNode *m = ReduceInst( s, s->_rule[mincost], mem ); |
duke@435 | 1410 | #ifdef ASSERT |
duke@435 | 1411 | _old2new_map.map(n->_idx, m); |
never@657 | 1412 | _new2old_map.map(m->_idx, (Node*)n); |
duke@435 | 1413 | #endif |
duke@435 | 1414 | |
duke@435 | 1415 | // Add any Matcher-ignored edges |
duke@435 | 1416 | uint cnt = n->req(); |
duke@435 | 1417 | uint start = 1; |
duke@435 | 1418 | if( mem != (Node*)1 ) start = MemNode::Memory+1; |
kvn@603 | 1419 | if( n->is_AddP() ) { |
duke@435 | 1420 | assert( mem == (Node*)1, "" ); |
duke@435 | 1421 | start = AddPNode::Base+1; |
duke@435 | 1422 | } |
duke@435 | 1423 | for( i = start; i < cnt; i++ ) { |
duke@435 | 1424 | if( !n->match_edge(i) ) { |
duke@435 | 1425 | if( i < m->req() ) |
duke@435 | 1426 | m->ins_req( i, n->in(i) ); |
duke@435 | 1427 | else |
duke@435 | 1428 | m->add_req( n->in(i) ); |
duke@435 | 1429 | } |
duke@435 | 1430 | } |
duke@435 | 1431 | |
kvn@651 | 1432 | debug_only( _mem_node = save_mem_node; ) |
duke@435 | 1433 | return m; |
duke@435 | 1434 | } |
duke@435 | 1435 | |
duke@435 | 1436 | |
duke@435 | 1437 | //------------------------------match_into_reg--------------------------------- |
duke@435 | 1438 | // Choose to either match this Node in a register or part of the current |
duke@435 | 1439 | // match tree. Return true for requiring a register and false for matching |
duke@435 | 1440 | // as part of the current match tree. |
duke@435 | 1441 | static bool match_into_reg( const Node *n, Node *m, Node *control, int i, bool shared ) { |
duke@435 | 1442 | |
duke@435 | 1443 | const Type *t = m->bottom_type(); |
duke@435 | 1444 | |
kvn@3390 | 1445 | if (t->singleton()) { |
duke@435 | 1446 | // Never force constants into registers. Allow them to match as |
duke@435 | 1447 | // constants or registers. Copies of the same value will share |
kvn@603 | 1448 | // the same register. See find_shared_node. |
duke@435 | 1449 | return false; |
duke@435 | 1450 | } else { // Not a constant |
duke@435 | 1451 | // Stop recursion if they have different Controls. |
kvn@3390 | 1452 | Node* m_control = m->in(0); |
kvn@3390 | 1453 | // Control of load's memory can post-dominates load's control. |
kvn@3390 | 1454 | // So use it since load can't float above its memory. |
kvn@3390 | 1455 | Node* mem_control = (m->is_Load()) ? m->in(MemNode::Memory)->in(0) : NULL; |
kvn@3390 | 1456 | if (control && m_control && control != m_control && control != mem_control) { |
duke@435 | 1457 | |
duke@435 | 1458 | // Actually, we can live with the most conservative control we |
duke@435 | 1459 | // find, if it post-dominates the others. This allows us to |
duke@435 | 1460 | // pick up load/op/store trees where the load can float a little |
duke@435 | 1461 | // above the store. |
duke@435 | 1462 | Node *x = control; |
kvn@3390 | 1463 | const uint max_scan = 6; // Arbitrary scan cutoff |
duke@435 | 1464 | uint j; |
kvn@3390 | 1465 | for (j=0; j<max_scan; j++) { |
kvn@3390 | 1466 | if (x->is_Region()) // Bail out at merge points |
duke@435 | 1467 | return true; |
duke@435 | 1468 | x = x->in(0); |
kvn@3390 | 1469 | if (x == m_control) // Does 'control' post-dominate |
duke@435 | 1470 | break; // m->in(0)? If so, we can use it |
kvn@3390 | 1471 | if (x == mem_control) // Does 'control' post-dominate |
kvn@3390 | 1472 | break; // mem_control? If so, we can use it |
duke@435 | 1473 | } |
kvn@3390 | 1474 | if (j == max_scan) // No post-domination before scan end? |
duke@435 | 1475 | return true; // Then break the match tree up |
duke@435 | 1476 | } |
roland@4159 | 1477 | if ((m->is_DecodeN() && Matcher::narrow_oop_use_complex_address()) || |
roland@4159 | 1478 | (m->is_DecodeNKlass() && Matcher::narrow_klass_use_complex_address())) { |
coleenp@548 | 1479 | // These are commonly used in address expressions and can |
kvn@603 | 1480 | // efficiently fold into them on X64 in some cases. |
kvn@603 | 1481 | return false; |
coleenp@548 | 1482 | } |
duke@435 | 1483 | } |
duke@435 | 1484 | |
twisti@1040 | 1485 | // Not forceable cloning. If shared, put it into a register. |
duke@435 | 1486 | return shared; |
duke@435 | 1487 | } |
duke@435 | 1488 | |
duke@435 | 1489 | |
duke@435 | 1490 | //------------------------------Instruction Selection-------------------------- |
duke@435 | 1491 | // Label method walks a "tree" of nodes, using the ADLC generated DFA to match |
duke@435 | 1492 | // ideal nodes to machine instructions. Trees are delimited by shared Nodes, |
duke@435 | 1493 | // things the Matcher does not match (e.g., Memory), and things with different |
duke@435 | 1494 | // Controls (hence forced into different blocks). We pass in the Control |
duke@435 | 1495 | // selected for this entire State tree. |
duke@435 | 1496 | |
duke@435 | 1497 | // The Matcher works on Trees, but an Intel add-to-memory requires a DAG: the |
duke@435 | 1498 | // Store and the Load must have identical Memories (as well as identical |
duke@435 | 1499 | // pointers). Since the Matcher does not have anything for Memory (and |
duke@435 | 1500 | // does not handle DAGs), I have to match the Memory input myself. If the |
duke@435 | 1501 | // Tree root is a Store, I require all Loads to have the identical memory. |
duke@435 | 1502 | Node *Matcher::Label_Root( const Node *n, State *svec, Node *control, const Node *mem){ |
duke@435 | 1503 | // Since Label_Root is a recursive function, its possible that we might run |
duke@435 | 1504 | // out of stack space. See bugs 6272980 & 6227033 for more info. |
duke@435 | 1505 | LabelRootDepth++; |
duke@435 | 1506 | if (LabelRootDepth > MaxLabelRootDepth) { |
duke@435 | 1507 | C->record_method_not_compilable_all_tiers("Out of stack space, increase MaxLabelRootDepth"); |
duke@435 | 1508 | return NULL; |
duke@435 | 1509 | } |
duke@435 | 1510 | uint care = 0; // Edges matcher cares about |
duke@435 | 1511 | uint cnt = n->req(); |
duke@435 | 1512 | uint i = 0; |
duke@435 | 1513 | |
duke@435 | 1514 | // Examine children for memory state |
duke@435 | 1515 | // Can only subsume a child into your match-tree if that child's memory state |
duke@435 | 1516 | // is not modified along the path to another input. |
duke@435 | 1517 | // It is unsafe even if the other inputs are separate roots. |
duke@435 | 1518 | Node *input_mem = NULL; |
duke@435 | 1519 | for( i = 1; i < cnt; i++ ) { |
duke@435 | 1520 | if( !n->match_edge(i) ) continue; |
duke@435 | 1521 | Node *m = n->in(i); // Get ith input |
duke@435 | 1522 | assert( m, "expect non-null children" ); |
duke@435 | 1523 | if( m->is_Load() ) { |
duke@435 | 1524 | if( input_mem == NULL ) { |
duke@435 | 1525 | input_mem = m->in(MemNode::Memory); |
duke@435 | 1526 | } else if( input_mem != m->in(MemNode::Memory) ) { |
duke@435 | 1527 | input_mem = NodeSentinel; |
duke@435 | 1528 | } |
duke@435 | 1529 | } |
duke@435 | 1530 | } |
duke@435 | 1531 | |
duke@435 | 1532 | for( i = 1; i < cnt; i++ ){// For my children |
duke@435 | 1533 | if( !n->match_edge(i) ) continue; |
duke@435 | 1534 | Node *m = n->in(i); // Get ith input |
duke@435 | 1535 | // Allocate states out of a private arena |
duke@435 | 1536 | State *s = new (&_states_arena) State; |
duke@435 | 1537 | svec->_kids[care++] = s; |
duke@435 | 1538 | assert( care <= 2, "binary only for now" ); |
duke@435 | 1539 | |
duke@435 | 1540 | // Recursively label the State tree. |
duke@435 | 1541 | s->_kids[0] = NULL; |
duke@435 | 1542 | s->_kids[1] = NULL; |
duke@435 | 1543 | s->_leaf = m; |
duke@435 | 1544 | |
duke@435 | 1545 | // Check for leaves of the State Tree; things that cannot be a part of |
duke@435 | 1546 | // the current tree. If it finds any, that value is matched as a |
duke@435 | 1547 | // register operand. If not, then the normal matching is used. |
duke@435 | 1548 | if( match_into_reg(n, m, control, i, is_shared(m)) || |
duke@435 | 1549 | // |
duke@435 | 1550 | // Stop recursion if this is LoadNode and the root of this tree is a |
duke@435 | 1551 | // StoreNode and the load & store have different memories. |
duke@435 | 1552 | ((mem!=(Node*)1) && m->is_Load() && m->in(MemNode::Memory) != mem) || |
duke@435 | 1553 | // Can NOT include the match of a subtree when its memory state |
duke@435 | 1554 | // is used by any of the other subtrees |
duke@435 | 1555 | (input_mem == NodeSentinel) ) { |
duke@435 | 1556 | #ifndef PRODUCT |
duke@435 | 1557 | // Print when we exclude matching due to different memory states at input-loads |
duke@435 | 1558 | if( PrintOpto && (Verbose && WizardMode) && (input_mem == NodeSentinel) |
duke@435 | 1559 | && !((mem!=(Node*)1) && m->is_Load() && m->in(MemNode::Memory) != mem) ) { |
duke@435 | 1560 | tty->print_cr("invalid input_mem"); |
duke@435 | 1561 | } |
duke@435 | 1562 | #endif |
duke@435 | 1563 | // Switch to a register-only opcode; this value must be in a register |
duke@435 | 1564 | // and cannot be subsumed as part of a larger instruction. |
duke@435 | 1565 | s->DFA( m->ideal_reg(), m ); |
duke@435 | 1566 | |
duke@435 | 1567 | } else { |
duke@435 | 1568 | // If match tree has no control and we do, adopt it for entire tree |
duke@435 | 1569 | if( control == NULL && m->in(0) != NULL && m->req() > 1 ) |
duke@435 | 1570 | control = m->in(0); // Pick up control |
duke@435 | 1571 | // Else match as a normal part of the match tree. |
duke@435 | 1572 | control = Label_Root(m,s,control,mem); |
duke@435 | 1573 | if (C->failing()) return NULL; |
duke@435 | 1574 | } |
duke@435 | 1575 | } |
duke@435 | 1576 | |
duke@435 | 1577 | |
duke@435 | 1578 | // Call DFA to match this node, and return |
duke@435 | 1579 | svec->DFA( n->Opcode(), n ); |
duke@435 | 1580 | |
duke@435 | 1581 | #ifdef ASSERT |
duke@435 | 1582 | uint x; |
duke@435 | 1583 | for( x = 0; x < _LAST_MACH_OPER; x++ ) |
duke@435 | 1584 | if( svec->valid(x) ) |
duke@435 | 1585 | break; |
duke@435 | 1586 | |
duke@435 | 1587 | if (x >= _LAST_MACH_OPER) { |
duke@435 | 1588 | n->dump(); |
duke@435 | 1589 | svec->dump(); |
duke@435 | 1590 | assert( false, "bad AD file" ); |
duke@435 | 1591 | } |
duke@435 | 1592 | #endif |
duke@435 | 1593 | return control; |
duke@435 | 1594 | } |
duke@435 | 1595 | |
duke@435 | 1596 | |
duke@435 | 1597 | // Con nodes reduced using the same rule can share their MachNode |
duke@435 | 1598 | // which reduces the number of copies of a constant in the final |
duke@435 | 1599 | // program. The register allocator is free to split uses later to |
duke@435 | 1600 | // split live ranges. |
kvn@603 | 1601 | MachNode* Matcher::find_shared_node(Node* leaf, uint rule) { |
roland@4159 | 1602 | if (!leaf->is_Con() && !leaf->is_DecodeNarrowPtr()) return NULL; |
duke@435 | 1603 | |
duke@435 | 1604 | // See if this Con has already been reduced using this rule. |
kvn@603 | 1605 | if (_shared_nodes.Size() <= leaf->_idx) return NULL; |
kvn@603 | 1606 | MachNode* last = (MachNode*)_shared_nodes.at(leaf->_idx); |
duke@435 | 1607 | if (last != NULL && rule == last->rule()) { |
kvn@603 | 1608 | // Don't expect control change for DecodeN |
roland@4159 | 1609 | if (leaf->is_DecodeNarrowPtr()) |
kvn@603 | 1610 | return last; |
duke@435 | 1611 | // Get the new space root. |
duke@435 | 1612 | Node* xroot = new_node(C->root()); |
duke@435 | 1613 | if (xroot == NULL) { |
duke@435 | 1614 | // This shouldn't happen give the order of matching. |
duke@435 | 1615 | return NULL; |
duke@435 | 1616 | } |
duke@435 | 1617 | |
duke@435 | 1618 | // Shared constants need to have their control be root so they |
duke@435 | 1619 | // can be scheduled properly. |
duke@435 | 1620 | Node* control = last->in(0); |
duke@435 | 1621 | if (control != xroot) { |
duke@435 | 1622 | if (control == NULL || control == C->root()) { |
duke@435 | 1623 | last->set_req(0, xroot); |
duke@435 | 1624 | } else { |
duke@435 | 1625 | assert(false, "unexpected control"); |
duke@435 | 1626 | return NULL; |
duke@435 | 1627 | } |
duke@435 | 1628 | } |
duke@435 | 1629 | return last; |
duke@435 | 1630 | } |
duke@435 | 1631 | return NULL; |
duke@435 | 1632 | } |
duke@435 | 1633 | |
duke@435 | 1634 | |
duke@435 | 1635 | //------------------------------ReduceInst------------------------------------- |
duke@435 | 1636 | // Reduce a State tree (with given Control) into a tree of MachNodes. |
duke@435 | 1637 | // This routine (and it's cohort ReduceOper) convert Ideal Nodes into |
duke@435 | 1638 | // complicated machine Nodes. Each MachNode covers some tree of Ideal Nodes. |
duke@435 | 1639 | // Each MachNode has a number of complicated MachOper operands; each |
duke@435 | 1640 | // MachOper also covers a further tree of Ideal Nodes. |
duke@435 | 1641 | |
duke@435 | 1642 | // The root of the Ideal match tree is always an instruction, so we enter |
duke@435 | 1643 | // the recursion here. After building the MachNode, we need to recurse |
duke@435 | 1644 | // the tree checking for these cases: |
duke@435 | 1645 | // (1) Child is an instruction - |
duke@435 | 1646 | // Build the instruction (recursively), add it as an edge. |
duke@435 | 1647 | // Build a simple operand (register) to hold the result of the instruction. |
duke@435 | 1648 | // (2) Child is an interior part of an instruction - |
duke@435 | 1649 | // Skip over it (do nothing) |
duke@435 | 1650 | // (3) Child is the start of a operand - |
duke@435 | 1651 | // Build the operand, place it inside the instruction |
duke@435 | 1652 | // Call ReduceOper. |
duke@435 | 1653 | MachNode *Matcher::ReduceInst( State *s, int rule, Node *&mem ) { |
duke@435 | 1654 | assert( rule >= NUM_OPERANDS, "called with operand rule" ); |
duke@435 | 1655 | |
kvn@603 | 1656 | MachNode* shared_node = find_shared_node(s->_leaf, rule); |
kvn@603 | 1657 | if (shared_node != NULL) { |
kvn@603 | 1658 | return shared_node; |
duke@435 | 1659 | } |
duke@435 | 1660 | |
duke@435 | 1661 | // Build the object to represent this state & prepare for recursive calls |
duke@435 | 1662 | MachNode *mach = s->MachNodeGenerator( rule, C ); |
thartmann@8770 | 1663 | guarantee(mach != NULL, "Missing MachNode"); |
duke@435 | 1664 | mach->_opnds[0] = s->MachOperGenerator( _reduceOp[rule], C ); |
duke@435 | 1665 | assert( mach->_opnds[0] != NULL, "Missing result operand" ); |
duke@435 | 1666 | Node *leaf = s->_leaf; |
duke@435 | 1667 | // Check for instruction or instruction chain rule |
duke@435 | 1668 | if( rule >= _END_INST_CHAIN_RULE || rule < _BEGIN_INST_CHAIN_RULE ) { |
never@744 | 1669 | assert(C->node_arena()->contains(s->_leaf) || !has_new_node(s->_leaf), |
never@744 | 1670 | "duplicating node that's already been matched"); |
duke@435 | 1671 | // Instruction |
duke@435 | 1672 | mach->add_req( leaf->in(0) ); // Set initial control |
duke@435 | 1673 | // Reduce interior of complex instruction |
duke@435 | 1674 | ReduceInst_Interior( s, rule, mem, mach, 1 ); |
duke@435 | 1675 | } else { |
duke@435 | 1676 | // Instruction chain rules are data-dependent on their inputs |
duke@435 | 1677 | mach->add_req(0); // Set initial control to none |
duke@435 | 1678 | ReduceInst_Chain_Rule( s, rule, mem, mach ); |
duke@435 | 1679 | } |
duke@435 | 1680 | |
duke@435 | 1681 | // If a Memory was used, insert a Memory edge |
kvn@651 | 1682 | if( mem != (Node*)1 ) { |
duke@435 | 1683 | mach->ins_req(MemNode::Memory,mem); |
kvn@651 | 1684 | #ifdef ASSERT |
kvn@651 | 1685 | // Verify adr type after matching memory operation |
kvn@651 | 1686 | const MachOper* oper = mach->memory_operand(); |
kvn@1286 | 1687 | if (oper != NULL && oper != (MachOper*)-1) { |
kvn@651 | 1688 | // It has a unique memory operand. Find corresponding ideal mem node. |
kvn@651 | 1689 | Node* m = NULL; |
kvn@651 | 1690 | if (leaf->is_Mem()) { |
kvn@651 | 1691 | m = leaf; |
kvn@651 | 1692 | } else { |
kvn@651 | 1693 | m = _mem_node; |
kvn@651 | 1694 | assert(m != NULL && m->is_Mem(), "expecting memory node"); |
kvn@651 | 1695 | } |
kvn@803 | 1696 | const Type* mach_at = mach->adr_type(); |
kvn@803 | 1697 | // DecodeN node consumed by an address may have different type |
kvn@803 | 1698 | // then its input. Don't compare types for such case. |
kvn@1077 | 1699 | if (m->adr_type() != mach_at && |
roland@4159 | 1700 | (m->in(MemNode::Address)->is_DecodeNarrowPtr() || |
kvn@1077 | 1701 | m->in(MemNode::Address)->is_AddP() && |
roland@4159 | 1702 | m->in(MemNode::Address)->in(AddPNode::Address)->is_DecodeNarrowPtr() || |
kvn@1077 | 1703 | m->in(MemNode::Address)->is_AddP() && |
kvn@1077 | 1704 | m->in(MemNode::Address)->in(AddPNode::Address)->is_AddP() && |
roland@4159 | 1705 | m->in(MemNode::Address)->in(AddPNode::Address)->in(AddPNode::Address)->is_DecodeNarrowPtr())) { |
kvn@803 | 1706 | mach_at = m->adr_type(); |
kvn@803 | 1707 | } |
kvn@803 | 1708 | if (m->adr_type() != mach_at) { |
kvn@651 | 1709 | m->dump(); |
kvn@651 | 1710 | tty->print_cr("mach:"); |
kvn@651 | 1711 | mach->dump(1); |
kvn@651 | 1712 | } |
kvn@803 | 1713 | assert(m->adr_type() == mach_at, "matcher should not change adr type"); |
kvn@651 | 1714 | } |
kvn@651 | 1715 | #endif |
kvn@651 | 1716 | } |
duke@435 | 1717 | |
duke@435 | 1718 | // If the _leaf is an AddP, insert the base edge |
adlertz@5539 | 1719 | if (leaf->is_AddP()) { |
duke@435 | 1720 | mach->ins_req(AddPNode::Base,leaf->in(AddPNode::Base)); |
adlertz@5539 | 1721 | } |
duke@435 | 1722 | |
adlertz@5539 | 1723 | uint number_of_projections_prior = number_of_projections(); |
duke@435 | 1724 | |
duke@435 | 1725 | // Perform any 1-to-many expansions required |
adlertz@5539 | 1726 | MachNode *ex = mach->Expand(s, _projection_list, mem); |
adlertz@5539 | 1727 | if (ex != mach) { |
duke@435 | 1728 | assert(ex->ideal_reg() == mach->ideal_reg(), "ideal types should match"); |
duke@435 | 1729 | if( ex->in(1)->is_Con() ) |
duke@435 | 1730 | ex->in(1)->set_req(0, C->root()); |
duke@435 | 1731 | // Remove old node from the graph |
duke@435 | 1732 | for( uint i=0; i<mach->req(); i++ ) { |
duke@435 | 1733 | mach->set_req(i,NULL); |
duke@435 | 1734 | } |
never@657 | 1735 | #ifdef ASSERT |
never@657 | 1736 | _new2old_map.map(ex->_idx, s->_leaf); |
never@657 | 1737 | #endif |
duke@435 | 1738 | } |
duke@435 | 1739 | |
duke@435 | 1740 | // PhaseChaitin::fixup_spills will sometimes generate spill code |
duke@435 | 1741 | // via the matcher. By the time, nodes have been wired into the CFG, |
duke@435 | 1742 | // and any further nodes generated by expand rules will be left hanging |
duke@435 | 1743 | // in space, and will not get emitted as output code. Catch this. |
duke@435 | 1744 | // Also, catch any new register allocation constraints ("projections") |
duke@435 | 1745 | // generated belatedly during spill code generation. |
duke@435 | 1746 | if (_allocation_started) { |
duke@435 | 1747 | guarantee(ex == mach, "no expand rules during spill generation"); |
adlertz@5539 | 1748 | guarantee(number_of_projections_prior == number_of_projections(), "no allocation during spill generation"); |
duke@435 | 1749 | } |
duke@435 | 1750 | |
roland@4159 | 1751 | if (leaf->is_Con() || leaf->is_DecodeNarrowPtr()) { |
duke@435 | 1752 | // Record the con for sharing |
kvn@603 | 1753 | _shared_nodes.map(leaf->_idx, ex); |
duke@435 | 1754 | } |
duke@435 | 1755 | |
duke@435 | 1756 | return ex; |
duke@435 | 1757 | } |
duke@435 | 1758 | |
duke@435 | 1759 | void Matcher::ReduceInst_Chain_Rule( State *s, int rule, Node *&mem, MachNode *mach ) { |
duke@435 | 1760 | // 'op' is what I am expecting to receive |
duke@435 | 1761 | int op = _leftOp[rule]; |
duke@435 | 1762 | // Operand type to catch childs result |
duke@435 | 1763 | // This is what my child will give me. |
duke@435 | 1764 | int opnd_class_instance = s->_rule[op]; |
duke@435 | 1765 | // Choose between operand class or not. |
twisti@1040 | 1766 | // This is what I will receive. |
duke@435 | 1767 | int catch_op = (FIRST_OPERAND_CLASS <= op && op < NUM_OPERANDS) ? opnd_class_instance : op; |
duke@435 | 1768 | // New rule for child. Chase operand classes to get the actual rule. |
duke@435 | 1769 | int newrule = s->_rule[catch_op]; |
duke@435 | 1770 | |
duke@435 | 1771 | if( newrule < NUM_OPERANDS ) { |
duke@435 | 1772 | // Chain from operand or operand class, may be output of shared node |
duke@435 | 1773 | assert( 0 <= opnd_class_instance && opnd_class_instance < NUM_OPERANDS, |
duke@435 | 1774 | "Bad AD file: Instruction chain rule must chain from operand"); |
duke@435 | 1775 | // Insert operand into array of operands for this instruction |
duke@435 | 1776 | mach->_opnds[1] = s->MachOperGenerator( opnd_class_instance, C ); |
duke@435 | 1777 | |
duke@435 | 1778 | ReduceOper( s, newrule, mem, mach ); |
duke@435 | 1779 | } else { |
duke@435 | 1780 | // Chain from the result of an instruction |
duke@435 | 1781 | assert( newrule >= _LAST_MACH_OPER, "Do NOT chain from internal operand"); |
duke@435 | 1782 | mach->_opnds[1] = s->MachOperGenerator( _reduceOp[catch_op], C ); |
duke@435 | 1783 | Node *mem1 = (Node*)1; |
kvn@651 | 1784 | debug_only(Node *save_mem_node = _mem_node;) |
duke@435 | 1785 | mach->add_req( ReduceInst(s, newrule, mem1) ); |
kvn@651 | 1786 | debug_only(_mem_node = save_mem_node;) |
duke@435 | 1787 | } |
duke@435 | 1788 | return; |
duke@435 | 1789 | } |
duke@435 | 1790 | |
duke@435 | 1791 | |
duke@435 | 1792 | uint Matcher::ReduceInst_Interior( State *s, int rule, Node *&mem, MachNode *mach, uint num_opnds ) { |
duke@435 | 1793 | if( s->_leaf->is_Load() ) { |
duke@435 | 1794 | Node *mem2 = s->_leaf->in(MemNode::Memory); |
duke@435 | 1795 | assert( mem == (Node*)1 || mem == mem2, "multiple Memories being matched at once?" ); |
kvn@651 | 1796 | debug_only( if( mem == (Node*)1 ) _mem_node = s->_leaf;) |
duke@435 | 1797 | mem = mem2; |
duke@435 | 1798 | } |
duke@435 | 1799 | if( s->_leaf->in(0) != NULL && s->_leaf->req() > 1) { |
duke@435 | 1800 | if( mach->in(0) == NULL ) |
duke@435 | 1801 | mach->set_req(0, s->_leaf->in(0)); |
duke@435 | 1802 | } |
duke@435 | 1803 | |
duke@435 | 1804 | // Now recursively walk the state tree & add operand list. |
duke@435 | 1805 | for( uint i=0; i<2; i++ ) { // binary tree |
duke@435 | 1806 | State *newstate = s->_kids[i]; |
duke@435 | 1807 | if( newstate == NULL ) break; // Might only have 1 child |
duke@435 | 1808 | // 'op' is what I am expecting to receive |
duke@435 | 1809 | int op; |
duke@435 | 1810 | if( i == 0 ) { |
duke@435 | 1811 | op = _leftOp[rule]; |
duke@435 | 1812 | } else { |
duke@435 | 1813 | op = _rightOp[rule]; |
duke@435 | 1814 | } |
duke@435 | 1815 | // Operand type to catch childs result |
duke@435 | 1816 | // This is what my child will give me. |
duke@435 | 1817 | int opnd_class_instance = newstate->_rule[op]; |
duke@435 | 1818 | // Choose between operand class or not. |
duke@435 | 1819 | // This is what I will receive. |
duke@435 | 1820 | int catch_op = (op >= FIRST_OPERAND_CLASS && op < NUM_OPERANDS) ? opnd_class_instance : op; |
duke@435 | 1821 | // New rule for child. Chase operand classes to get the actual rule. |
duke@435 | 1822 | int newrule = newstate->_rule[catch_op]; |
duke@435 | 1823 | |
duke@435 | 1824 | if( newrule < NUM_OPERANDS ) { // Operand/operandClass or internalOp/instruction? |
duke@435 | 1825 | // Operand/operandClass |
duke@435 | 1826 | // Insert operand into array of operands for this instruction |
duke@435 | 1827 | mach->_opnds[num_opnds++] = newstate->MachOperGenerator( opnd_class_instance, C ); |
duke@435 | 1828 | ReduceOper( newstate, newrule, mem, mach ); |
duke@435 | 1829 | |
duke@435 | 1830 | } else { // Child is internal operand or new instruction |
duke@435 | 1831 | if( newrule < _LAST_MACH_OPER ) { // internal operand or instruction? |
duke@435 | 1832 | // internal operand --> call ReduceInst_Interior |
duke@435 | 1833 | // Interior of complex instruction. Do nothing but recurse. |
duke@435 | 1834 | num_opnds = ReduceInst_Interior( newstate, newrule, mem, mach, num_opnds ); |
duke@435 | 1835 | } else { |
duke@435 | 1836 | // instruction --> call build operand( ) to catch result |
duke@435 | 1837 | // --> ReduceInst( newrule ) |
duke@435 | 1838 | mach->_opnds[num_opnds++] = s->MachOperGenerator( _reduceOp[catch_op], C ); |
duke@435 | 1839 | Node *mem1 = (Node*)1; |
kvn@651 | 1840 | debug_only(Node *save_mem_node = _mem_node;) |
duke@435 | 1841 | mach->add_req( ReduceInst( newstate, newrule, mem1 ) ); |
kvn@651 | 1842 | debug_only(_mem_node = save_mem_node;) |
duke@435 | 1843 | } |
duke@435 | 1844 | } |
duke@435 | 1845 | assert( mach->_opnds[num_opnds-1], "" ); |
duke@435 | 1846 | } |
duke@435 | 1847 | return num_opnds; |
duke@435 | 1848 | } |
duke@435 | 1849 | |
duke@435 | 1850 | // This routine walks the interior of possible complex operands. |
duke@435 | 1851 | // At each point we check our children in the match tree: |
duke@435 | 1852 | // (1) No children - |
duke@435 | 1853 | // We are a leaf; add _leaf field as an input to the MachNode |
duke@435 | 1854 | // (2) Child is an internal operand - |
duke@435 | 1855 | // Skip over it ( do nothing ) |
duke@435 | 1856 | // (3) Child is an instruction - |
duke@435 | 1857 | // Call ReduceInst recursively and |
duke@435 | 1858 | // and instruction as an input to the MachNode |
duke@435 | 1859 | void Matcher::ReduceOper( State *s, int rule, Node *&mem, MachNode *mach ) { |
duke@435 | 1860 | assert( rule < _LAST_MACH_OPER, "called with operand rule" ); |
duke@435 | 1861 | State *kid = s->_kids[0]; |
duke@435 | 1862 | assert( kid == NULL || s->_leaf->in(0) == NULL, "internal operands have no control" ); |
duke@435 | 1863 | |
duke@435 | 1864 | // Leaf? And not subsumed? |
duke@435 | 1865 | if( kid == NULL && !_swallowed[rule] ) { |
duke@435 | 1866 | mach->add_req( s->_leaf ); // Add leaf pointer |
duke@435 | 1867 | return; // Bail out |
duke@435 | 1868 | } |
duke@435 | 1869 | |
duke@435 | 1870 | if( s->_leaf->is_Load() ) { |
duke@435 | 1871 | assert( mem == (Node*)1, "multiple Memories being matched at once?" ); |
duke@435 | 1872 | mem = s->_leaf->in(MemNode::Memory); |
kvn@651 | 1873 | debug_only(_mem_node = s->_leaf;) |
duke@435 | 1874 | } |
duke@435 | 1875 | if( s->_leaf->in(0) && s->_leaf->req() > 1) { |
duke@435 | 1876 | if( !mach->in(0) ) |
duke@435 | 1877 | mach->set_req(0,s->_leaf->in(0)); |
duke@435 | 1878 | else { |
duke@435 | 1879 | assert( s->_leaf->in(0) == mach->in(0), "same instruction, differing controls?" ); |
duke@435 | 1880 | } |
duke@435 | 1881 | } |
duke@435 | 1882 | |
duke@435 | 1883 | for( uint i=0; kid != NULL && i<2; kid = s->_kids[1], i++ ) { // binary tree |
duke@435 | 1884 | int newrule; |
sla@5237 | 1885 | if( i == 0) |
duke@435 | 1886 | newrule = kid->_rule[_leftOp[rule]]; |
duke@435 | 1887 | else |
duke@435 | 1888 | newrule = kid->_rule[_rightOp[rule]]; |
duke@435 | 1889 | |
duke@435 | 1890 | if( newrule < _LAST_MACH_OPER ) { // Operand or instruction? |
duke@435 | 1891 | // Internal operand; recurse but do nothing else |
duke@435 | 1892 | ReduceOper( kid, newrule, mem, mach ); |
duke@435 | 1893 | |
duke@435 | 1894 | } else { // Child is a new instruction |
duke@435 | 1895 | // Reduce the instruction, and add a direct pointer from this |
duke@435 | 1896 | // machine instruction to the newly reduced one. |
duke@435 | 1897 | Node *mem1 = (Node*)1; |
kvn@651 | 1898 | debug_only(Node *save_mem_node = _mem_node;) |
duke@435 | 1899 | mach->add_req( ReduceInst( kid, newrule, mem1 ) ); |
kvn@651 | 1900 | debug_only(_mem_node = save_mem_node;) |
duke@435 | 1901 | } |
duke@435 | 1902 | } |
duke@435 | 1903 | } |
duke@435 | 1904 | |
duke@435 | 1905 | |
duke@435 | 1906 | // ------------------------------------------------------------------------- |
duke@435 | 1907 | // Java-Java calling convention |
duke@435 | 1908 | // (what you use when Java calls Java) |
duke@435 | 1909 | |
duke@435 | 1910 | //------------------------------find_receiver---------------------------------- |
duke@435 | 1911 | // For a given signature, return the OptoReg for parameter 0. |
duke@435 | 1912 | OptoReg::Name Matcher::find_receiver( bool is_outgoing ) { |
duke@435 | 1913 | VMRegPair regs; |
duke@435 | 1914 | BasicType sig_bt = T_OBJECT; |
duke@435 | 1915 | calling_convention(&sig_bt, ®s, 1, is_outgoing); |
duke@435 | 1916 | // Return argument 0 register. In the LP64 build pointers |
duke@435 | 1917 | // take 2 registers, but the VM wants only the 'main' name. |
duke@435 | 1918 | return OptoReg::as_OptoReg(regs.first()); |
duke@435 | 1919 | } |
duke@435 | 1920 | |
iveresov@6378 | 1921 | // This function identifies sub-graphs in which a 'load' node is |
iveresov@6378 | 1922 | // input to two different nodes, and such that it can be matched |
iveresov@6378 | 1923 | // with BMI instructions like blsi, blsr, etc. |
iveresov@6378 | 1924 | // Example : for b = -a[i] & a[i] can be matched to blsi r32, m32. |
iveresov@6378 | 1925 | // The graph is (AndL (SubL Con0 LoadL*) LoadL*), where LoadL* |
iveresov@6378 | 1926 | // refers to the same node. |
iveresov@6378 | 1927 | #ifdef X86 |
iveresov@6378 | 1928 | // Match the generic fused operations pattern (op1 (op2 Con{ConType} mop) mop) |
iveresov@6378 | 1929 | // This is a temporary solution until we make DAGs expressible in ADL. |
iveresov@6378 | 1930 | template<typename ConType> |
iveresov@6378 | 1931 | class FusedPatternMatcher { |
iveresov@6378 | 1932 | Node* _op1_node; |
iveresov@6378 | 1933 | Node* _mop_node; |
iveresov@6378 | 1934 | int _con_op; |
iveresov@6378 | 1935 | |
iveresov@6378 | 1936 | static int match_next(Node* n, int next_op, int next_op_idx) { |
iveresov@6378 | 1937 | if (n->in(1) == NULL || n->in(2) == NULL) { |
iveresov@6378 | 1938 | return -1; |
iveresov@6378 | 1939 | } |
iveresov@6378 | 1940 | |
iveresov@6378 | 1941 | if (next_op_idx == -1) { // n is commutative, try rotations |
iveresov@6378 | 1942 | if (n->in(1)->Opcode() == next_op) { |
iveresov@6378 | 1943 | return 1; |
iveresov@6378 | 1944 | } else if (n->in(2)->Opcode() == next_op) { |
iveresov@6378 | 1945 | return 2; |
iveresov@6378 | 1946 | } |
iveresov@6378 | 1947 | } else { |
iveresov@6378 | 1948 | assert(next_op_idx > 0 && next_op_idx <= 2, "Bad argument index"); |
iveresov@6378 | 1949 | if (n->in(next_op_idx)->Opcode() == next_op) { |
iveresov@6378 | 1950 | return next_op_idx; |
iveresov@6378 | 1951 | } |
iveresov@6378 | 1952 | } |
iveresov@6378 | 1953 | return -1; |
iveresov@6378 | 1954 | } |
iveresov@6378 | 1955 | public: |
iveresov@6378 | 1956 | FusedPatternMatcher(Node* op1_node, Node *mop_node, int con_op) : |
iveresov@6378 | 1957 | _op1_node(op1_node), _mop_node(mop_node), _con_op(con_op) { } |
iveresov@6378 | 1958 | |
iveresov@6378 | 1959 | bool match(int op1, int op1_op2_idx, // op1 and the index of the op1->op2 edge, -1 if op1 is commutative |
iveresov@6378 | 1960 | int op2, int op2_con_idx, // op2 and the index of the op2->con edge, -1 if op2 is commutative |
iveresov@6378 | 1961 | typename ConType::NativeType con_value) { |
iveresov@6378 | 1962 | if (_op1_node->Opcode() != op1) { |
iveresov@6378 | 1963 | return false; |
iveresov@6378 | 1964 | } |
iveresov@6378 | 1965 | if (_mop_node->outcnt() > 2) { |
iveresov@6378 | 1966 | return false; |
iveresov@6378 | 1967 | } |
iveresov@6378 | 1968 | op1_op2_idx = match_next(_op1_node, op2, op1_op2_idx); |
iveresov@6378 | 1969 | if (op1_op2_idx == -1) { |
iveresov@6378 | 1970 | return false; |
iveresov@6378 | 1971 | } |
iveresov@6378 | 1972 | // Memory operation must be the other edge |
iveresov@6378 | 1973 | int op1_mop_idx = (op1_op2_idx & 1) + 1; |
iveresov@6378 | 1974 | |
iveresov@6378 | 1975 | // Check that the mop node is really what we want |
iveresov@6378 | 1976 | if (_op1_node->in(op1_mop_idx) == _mop_node) { |
iveresov@6378 | 1977 | Node *op2_node = _op1_node->in(op1_op2_idx); |
iveresov@6378 | 1978 | if (op2_node->outcnt() > 1) { |
iveresov@6378 | 1979 | return false; |
iveresov@6378 | 1980 | } |
iveresov@6378 | 1981 | assert(op2_node->Opcode() == op2, "Should be"); |
iveresov@6378 | 1982 | op2_con_idx = match_next(op2_node, _con_op, op2_con_idx); |
iveresov@6378 | 1983 | if (op2_con_idx == -1) { |
iveresov@6378 | 1984 | return false; |
iveresov@6378 | 1985 | } |
iveresov@6378 | 1986 | // Memory operation must be the other edge |
iveresov@6378 | 1987 | int op2_mop_idx = (op2_con_idx & 1) + 1; |
iveresov@6378 | 1988 | // Check that the memory operation is the same node |
iveresov@6378 | 1989 | if (op2_node->in(op2_mop_idx) == _mop_node) { |
iveresov@6378 | 1990 | // Now check the constant |
iveresov@6378 | 1991 | const Type* con_type = op2_node->in(op2_con_idx)->bottom_type(); |
iveresov@6378 | 1992 | if (con_type != Type::TOP && ConType::as_self(con_type)->get_con() == con_value) { |
iveresov@6378 | 1993 | return true; |
iveresov@6378 | 1994 | } |
iveresov@6378 | 1995 | } |
iveresov@6378 | 1996 | } |
iveresov@6378 | 1997 | return false; |
iveresov@6378 | 1998 | } |
iveresov@6378 | 1999 | }; |
iveresov@6378 | 2000 | |
iveresov@6378 | 2001 | |
iveresov@6378 | 2002 | bool Matcher::is_bmi_pattern(Node *n, Node *m) { |
iveresov@6378 | 2003 | if (n != NULL && m != NULL) { |
iveresov@6378 | 2004 | if (m->Opcode() == Op_LoadI) { |
iveresov@6378 | 2005 | FusedPatternMatcher<TypeInt> bmii(n, m, Op_ConI); |
iveresov@6378 | 2006 | return bmii.match(Op_AndI, -1, Op_SubI, 1, 0) || |
iveresov@6378 | 2007 | bmii.match(Op_AndI, -1, Op_AddI, -1, -1) || |
iveresov@6378 | 2008 | bmii.match(Op_XorI, -1, Op_AddI, -1, -1); |
iveresov@6378 | 2009 | } else if (m->Opcode() == Op_LoadL) { |
iveresov@6378 | 2010 | FusedPatternMatcher<TypeLong> bmil(n, m, Op_ConL); |
iveresov@6378 | 2011 | return bmil.match(Op_AndL, -1, Op_SubL, 1, 0) || |
iveresov@6378 | 2012 | bmil.match(Op_AndL, -1, Op_AddL, -1, -1) || |
iveresov@6378 | 2013 | bmil.match(Op_XorL, -1, Op_AddL, -1, -1); |
iveresov@6378 | 2014 | } |
iveresov@6378 | 2015 | } |
iveresov@6378 | 2016 | return false; |
iveresov@6378 | 2017 | } |
iveresov@6378 | 2018 | #endif // X86 |
iveresov@6378 | 2019 | |
duke@435 | 2020 | // A method-klass-holder may be passed in the inline_cache_reg |
duke@435 | 2021 | // and then expanded into the inline_cache_reg and a method_oop register |
duke@435 | 2022 | // defined in ad_<arch>.cpp |
duke@435 | 2023 | |
duke@435 | 2024 | |
duke@435 | 2025 | //------------------------------find_shared------------------------------------ |
duke@435 | 2026 | // Set bits if Node is shared or otherwise a root |
duke@435 | 2027 | void Matcher::find_shared( Node *n ) { |
zmajo@8068 | 2028 | // Allocate stack of size C->live_nodes() * 2 to avoid frequent realloc |
zmajo@8068 | 2029 | MStack mstack(C->live_nodes() * 2); |
kvn@1021 | 2030 | // Mark nodes as address_visited if they are inputs to an address expression |
kvn@1021 | 2031 | VectorSet address_visited(Thread::current()->resource_area()); |
duke@435 | 2032 | mstack.push(n, Visit); // Don't need to pre-visit root node |
duke@435 | 2033 | while (mstack.is_nonempty()) { |
duke@435 | 2034 | n = mstack.node(); // Leave node on stack |
duke@435 | 2035 | Node_State nstate = mstack.state(); |
kvn@1021 | 2036 | uint nop = n->Opcode(); |
duke@435 | 2037 | if (nstate == Pre_Visit) { |
kvn@1021 | 2038 | if (address_visited.test(n->_idx)) { // Visited in address already? |
kvn@1021 | 2039 | // Flag as visited and shared now. |
kvn@1021 | 2040 | set_visited(n); |
kvn@1021 | 2041 | } |
duke@435 | 2042 | if (is_visited(n)) { // Visited already? |
duke@435 | 2043 | // Node is shared and has no reason to clone. Flag it as shared. |
duke@435 | 2044 | // This causes it to match into a register for the sharing. |
duke@435 | 2045 | set_shared(n); // Flag as shared and |
roland@9725 | 2046 | if (n->is_DecodeNarrowPtr()) { |
roland@9725 | 2047 | // Oop field/array element loads must be shared but since |
roland@9725 | 2048 | // they are shared through a DecodeN they may appear to have |
roland@9725 | 2049 | // a single use so force sharing here. |
roland@9725 | 2050 | set_shared(n->in(1)); |
roland@9725 | 2051 | } |
duke@435 | 2052 | mstack.pop(); // remove node from stack |
duke@435 | 2053 | continue; |
duke@435 | 2054 | } |
duke@435 | 2055 | nstate = Visit; // Not already visited; so visit now |
duke@435 | 2056 | } |
duke@435 | 2057 | if (nstate == Visit) { |
duke@435 | 2058 | mstack.set_state(Post_Visit); |
duke@435 | 2059 | set_visited(n); // Flag as visited now |
duke@435 | 2060 | bool mem_op = false; |
duke@435 | 2061 | |
kvn@1021 | 2062 | switch( nop ) { // Handle some opcodes special |
duke@435 | 2063 | case Op_Phi: // Treat Phis as shared roots |
duke@435 | 2064 | case Op_Parm: |
duke@435 | 2065 | case Op_Proj: // All handled specially during matching |
kvn@498 | 2066 | case Op_SafePointScalarObject: |
duke@435 | 2067 | set_shared(n); |
duke@435 | 2068 | set_dontcare(n); |
duke@435 | 2069 | break; |
duke@435 | 2070 | case Op_If: |
duke@435 | 2071 | case Op_CountedLoopEnd: |
duke@435 | 2072 | mstack.set_state(Alt_Post_Visit); // Alternative way |
duke@435 | 2073 | // Convert (If (Bool (CmpX A B))) into (If (Bool) (CmpX A B)). Helps |
duke@435 | 2074 | // with matching cmp/branch in 1 instruction. The Matcher needs the |
duke@435 | 2075 | // Bool and CmpX side-by-side, because it can only get at constants |
duke@435 | 2076 | // that are at the leaves of Match trees, and the Bool's condition acts |
duke@435 | 2077 | // as a constant here. |
duke@435 | 2078 | mstack.push(n->in(1), Visit); // Clone the Bool |
duke@435 | 2079 | mstack.push(n->in(0), Pre_Visit); // Visit control input |
duke@435 | 2080 | continue; // while (mstack.is_nonempty()) |
duke@435 | 2081 | case Op_ConvI2D: // These forms efficiently match with a prior |
duke@435 | 2082 | case Op_ConvI2F: // Load but not a following Store |
duke@435 | 2083 | if( n->in(1)->is_Load() && // Prior load |
duke@435 | 2084 | n->outcnt() == 1 && // Not already shared |
duke@435 | 2085 | n->unique_out()->is_Store() ) // Following store |
duke@435 | 2086 | set_shared(n); // Force it to be a root |
duke@435 | 2087 | break; |
duke@435 | 2088 | case Op_ReverseBytesI: |
duke@435 | 2089 | case Op_ReverseBytesL: |
duke@435 | 2090 | if( n->in(1)->is_Load() && // Prior load |
duke@435 | 2091 | n->outcnt() == 1 ) // Not already shared |
duke@435 | 2092 | set_shared(n); // Force it to be a root |
duke@435 | 2093 | break; |
duke@435 | 2094 | case Op_BoxLock: // Cant match until we get stack-regs in ADLC |
duke@435 | 2095 | case Op_IfFalse: |
duke@435 | 2096 | case Op_IfTrue: |
duke@435 | 2097 | case Op_MachProj: |
duke@435 | 2098 | case Op_MergeMem: |
duke@435 | 2099 | case Op_Catch: |
duke@435 | 2100 | case Op_CatchProj: |
duke@435 | 2101 | case Op_CProj: |
duke@435 | 2102 | case Op_JumpProj: |
duke@435 | 2103 | case Op_JProj: |
duke@435 | 2104 | case Op_NeverBranch: |
duke@435 | 2105 | set_dontcare(n); |
duke@435 | 2106 | break; |
duke@435 | 2107 | case Op_Jump: |
kvn@3260 | 2108 | mstack.push(n->in(1), Pre_Visit); // Switch Value (could be shared) |
duke@435 | 2109 | mstack.push(n->in(0), Pre_Visit); // Visit Control input |
duke@435 | 2110 | continue; // while (mstack.is_nonempty()) |
duke@435 | 2111 | case Op_StrComp: |
cfang@1116 | 2112 | case Op_StrEquals: |
cfang@1116 | 2113 | case Op_StrIndexOf: |
rasbold@604 | 2114 | case Op_AryEq: |
kvn@4479 | 2115 | case Op_EncodeISOArray: |
duke@435 | 2116 | set_shared(n); // Force result into register (it will be anyways) |
duke@435 | 2117 | break; |
duke@435 | 2118 | case Op_ConP: { // Convert pointers above the centerline to NUL |
duke@435 | 2119 | TypeNode *tn = n->as_Type(); // Constants derive from type nodes |
duke@435 | 2120 | const TypePtr* tp = tn->type()->is_ptr(); |
duke@435 | 2121 | if (tp->_ptr == TypePtr::AnyNull) { |
duke@435 | 2122 | tn->set_type(TypePtr::NULL_PTR); |
duke@435 | 2123 | } |
duke@435 | 2124 | break; |
duke@435 | 2125 | } |
kvn@598 | 2126 | case Op_ConN: { // Convert narrow pointers above the centerline to NUL |
kvn@598 | 2127 | TypeNode *tn = n->as_Type(); // Constants derive from type nodes |
kvn@656 | 2128 | const TypePtr* tp = tn->type()->make_ptr(); |
kvn@656 | 2129 | if (tp && tp->_ptr == TypePtr::AnyNull) { |
kvn@598 | 2130 | tn->set_type(TypeNarrowOop::NULL_PTR); |
kvn@598 | 2131 | } |
kvn@598 | 2132 | break; |
kvn@598 | 2133 | } |
duke@435 | 2134 | case Op_Binary: // These are introduced in the Post_Visit state. |
duke@435 | 2135 | ShouldNotReachHere(); |
duke@435 | 2136 | break; |
duke@435 | 2137 | case Op_ClearArray: |
duke@435 | 2138 | case Op_SafePoint: |
duke@435 | 2139 | mem_op = true; |
duke@435 | 2140 | break; |
kvn@1496 | 2141 | default: |
kvn@1496 | 2142 | if( n->is_Store() ) { |
kvn@1496 | 2143 | // Do match stores, despite no ideal reg |
kvn@1496 | 2144 | mem_op = true; |
kvn@1496 | 2145 | break; |
kvn@1496 | 2146 | } |
kvn@1496 | 2147 | if( n->is_Mem() ) { // Loads and LoadStores |
kvn@1496 | 2148 | mem_op = true; |
kvn@1496 | 2149 | // Loads must be root of match tree due to prior load conflict |
kvn@1496 | 2150 | if( C->subsume_loads() == false ) |
kvn@1496 | 2151 | set_shared(n); |
duke@435 | 2152 | } |
duke@435 | 2153 | // Fall into default case |
duke@435 | 2154 | if( !n->ideal_reg() ) |
duke@435 | 2155 | set_dontcare(n); // Unmatchable Nodes |
duke@435 | 2156 | } // end_switch |
duke@435 | 2157 | |
duke@435 | 2158 | for(int i = n->req() - 1; i >= 0; --i) { // For my children |
duke@435 | 2159 | Node *m = n->in(i); // Get ith input |
duke@435 | 2160 | if (m == NULL) continue; // Ignore NULLs |
duke@435 | 2161 | uint mop = m->Opcode(); |
duke@435 | 2162 | |
duke@435 | 2163 | // Must clone all producers of flags, or we will not match correctly. |
duke@435 | 2164 | // Suppose a compare setting int-flags is shared (e.g., a switch-tree) |
duke@435 | 2165 | // then it will match into an ideal Op_RegFlags. Alas, the fp-flags |
duke@435 | 2166 | // are also there, so we may match a float-branch to int-flags and |
duke@435 | 2167 | // expect the allocator to haul the flags from the int-side to the |
duke@435 | 2168 | // fp-side. No can do. |
duke@435 | 2169 | if( _must_clone[mop] ) { |
duke@435 | 2170 | mstack.push(m, Visit); |
duke@435 | 2171 | continue; // for(int i = ...) |
duke@435 | 2172 | } |
duke@435 | 2173 | |
iveresov@6378 | 2174 | // if 'n' and 'm' are part of a graph for BMI instruction, clone this node. |
iveresov@6378 | 2175 | #ifdef X86 |
iveresov@6378 | 2176 | if (UseBMI1Instructions && is_bmi_pattern(n, m)) { |
iveresov@6378 | 2177 | mstack.push(m, Visit); |
iveresov@6378 | 2178 | continue; |
iveresov@6378 | 2179 | } |
iveresov@6378 | 2180 | #endif |
iveresov@6378 | 2181 | |
kvn@1496 | 2182 | // Clone addressing expressions as they are "free" in memory access instructions |
duke@435 | 2183 | if( mem_op && i == MemNode::Address && mop == Op_AddP ) { |
kvn@1021 | 2184 | // Some inputs for address expression are not put on stack |
kvn@1021 | 2185 | // to avoid marking them as shared and forcing them into register |
kvn@1021 | 2186 | // if they are used only in address expressions. |
kvn@1021 | 2187 | // But they should be marked as shared if there are other uses |
kvn@1021 | 2188 | // besides address expressions. |
kvn@1021 | 2189 | |
duke@435 | 2190 | Node *off = m->in(AddPNode::Offset); |
kvn@1021 | 2191 | if( off->is_Con() && |
kvn@1021 | 2192 | // When there are other uses besides address expressions |
kvn@1021 | 2193 | // put it on stack and mark as shared. |
kvn@1021 | 2194 | !is_visited(m) ) { |
kvn@1021 | 2195 | address_visited.test_set(m->_idx); // Flag as address_visited |
duke@435 | 2196 | Node *adr = m->in(AddPNode::Address); |
duke@435 | 2197 | |
duke@435 | 2198 | // Intel, ARM and friends can handle 2 adds in addressing mode |
kvn@603 | 2199 | if( clone_shift_expressions && adr->is_AddP() && |
duke@435 | 2200 | // AtomicAdd is not an addressing expression. |
duke@435 | 2201 | // Cheap to find it by looking for screwy base. |
kvn@1021 | 2202 | !adr->in(AddPNode::Base)->is_top() && |
kvn@1021 | 2203 | // Are there other uses besides address expressions? |
kvn@1021 | 2204 | !is_visited(adr) ) { |
kvn@1021 | 2205 | address_visited.set(adr->_idx); // Flag as address_visited |
duke@435 | 2206 | Node *shift = adr->in(AddPNode::Offset); |
duke@435 | 2207 | // Check for shift by small constant as well |
duke@435 | 2208 | if( shift->Opcode() == Op_LShiftX && shift->in(2)->is_Con() && |
kvn@1021 | 2209 | shift->in(2)->get_int() <= 3 && |
kvn@1021 | 2210 | // Are there other uses besides address expressions? |
kvn@1021 | 2211 | !is_visited(shift) ) { |
kvn@1021 | 2212 | address_visited.set(shift->_idx); // Flag as address_visited |
duke@435 | 2213 | mstack.push(shift->in(2), Visit); |
kvn@1021 | 2214 | Node *conv = shift->in(1); |
duke@435 | 2215 | #ifdef _LP64 |
duke@435 | 2216 | // Allow Matcher to match the rule which bypass |
duke@435 | 2217 | // ConvI2L operation for an array index on LP64 |
duke@435 | 2218 | // if the index value is positive. |
kvn@1021 | 2219 | if( conv->Opcode() == Op_ConvI2L && |
kvn@1021 | 2220 | conv->as_Type()->type()->is_long()->_lo >= 0 && |
kvn@1021 | 2221 | // Are there other uses besides address expressions? |
kvn@1021 | 2222 | !is_visited(conv) ) { |
kvn@1021 | 2223 | address_visited.set(conv->_idx); // Flag as address_visited |
kvn@1021 | 2224 | mstack.push(conv->in(1), Pre_Visit); |
duke@435 | 2225 | } else |
duke@435 | 2226 | #endif |
kvn@1021 | 2227 | mstack.push(conv, Pre_Visit); |
duke@435 | 2228 | } else { |
duke@435 | 2229 | mstack.push(shift, Pre_Visit); |
duke@435 | 2230 | } |
duke@435 | 2231 | mstack.push(adr->in(AddPNode::Address), Pre_Visit); |
duke@435 | 2232 | mstack.push(adr->in(AddPNode::Base), Pre_Visit); |
duke@435 | 2233 | } else { // Sparc, Alpha, PPC and friends |
duke@435 | 2234 | mstack.push(adr, Pre_Visit); |
duke@435 | 2235 | } |
duke@435 | 2236 | |
duke@435 | 2237 | // Clone X+offset as it also folds into most addressing expressions |
duke@435 | 2238 | mstack.push(off, Visit); |
duke@435 | 2239 | mstack.push(m->in(AddPNode::Base), Pre_Visit); |
duke@435 | 2240 | continue; // for(int i = ...) |
duke@435 | 2241 | } // if( off->is_Con() ) |
duke@435 | 2242 | } // if( mem_op && |
duke@435 | 2243 | mstack.push(m, Pre_Visit); |
duke@435 | 2244 | } // for(int i = ...) |
duke@435 | 2245 | } |
duke@435 | 2246 | else if (nstate == Alt_Post_Visit) { |
duke@435 | 2247 | mstack.pop(); // Remove node from stack |
duke@435 | 2248 | // We cannot remove the Cmp input from the Bool here, as the Bool may be |
duke@435 | 2249 | // shared and all users of the Bool need to move the Cmp in parallel. |
duke@435 | 2250 | // This leaves both the Bool and the If pointing at the Cmp. To |
duke@435 | 2251 | // prevent the Matcher from trying to Match the Cmp along both paths |
duke@435 | 2252 | // BoolNode::match_edge always returns a zero. |
duke@435 | 2253 | |
duke@435 | 2254 | // We reorder the Op_If in a pre-order manner, so we can visit without |
twisti@1040 | 2255 | // accidentally sharing the Cmp (the Bool and the If make 2 users). |
duke@435 | 2256 | n->add_req( n->in(1)->in(1) ); // Add the Cmp next to the Bool |
duke@435 | 2257 | } |
duke@435 | 2258 | else if (nstate == Post_Visit) { |
duke@435 | 2259 | mstack.pop(); // Remove node from stack |
duke@435 | 2260 | |
duke@435 | 2261 | // Now hack a few special opcodes |
duke@435 | 2262 | switch( n->Opcode() ) { // Handle some opcodes special |
duke@435 | 2263 | case Op_StorePConditional: |
kvn@855 | 2264 | case Op_StoreIConditional: |
duke@435 | 2265 | case Op_StoreLConditional: |
duke@435 | 2266 | case Op_CompareAndSwapI: |
duke@435 | 2267 | case Op_CompareAndSwapL: |
coleenp@548 | 2268 | case Op_CompareAndSwapP: |
coleenp@548 | 2269 | case Op_CompareAndSwapN: { // Convert trinary to binary-tree |
duke@435 | 2270 | Node *newval = n->in(MemNode::ValueIn ); |
roland@4106 | 2271 | Node *oldval = n->in(LoadStoreConditionalNode::ExpectedIn); |
kvn@4115 | 2272 | Node *pair = new (C) BinaryNode( oldval, newval ); |
duke@435 | 2273 | n->set_req(MemNode::ValueIn,pair); |
roland@4106 | 2274 | n->del_req(LoadStoreConditionalNode::ExpectedIn); |
duke@435 | 2275 | break; |
duke@435 | 2276 | } |
duke@435 | 2277 | case Op_CMoveD: // Convert trinary to binary-tree |
duke@435 | 2278 | case Op_CMoveF: |
duke@435 | 2279 | case Op_CMoveI: |
duke@435 | 2280 | case Op_CMoveL: |
kvn@599 | 2281 | case Op_CMoveN: |
duke@435 | 2282 | case Op_CMoveP: { |
duke@435 | 2283 | // Restructure into a binary tree for Matching. It's possible that |
duke@435 | 2284 | // we could move this code up next to the graph reshaping for IfNodes |
duke@435 | 2285 | // or vice-versa, but I do not want to debug this for Ladybird. |
duke@435 | 2286 | // 10/2/2000 CNC. |
kvn@4115 | 2287 | Node *pair1 = new (C) BinaryNode(n->in(1),n->in(1)->in(1)); |
duke@435 | 2288 | n->set_req(1,pair1); |
kvn@4115 | 2289 | Node *pair2 = new (C) BinaryNode(n->in(2),n->in(3)); |
duke@435 | 2290 | n->set_req(2,pair2); |
duke@435 | 2291 | n->del_req(3); |
duke@435 | 2292 | break; |
duke@435 | 2293 | } |
kvn@2877 | 2294 | case Op_LoopLimit: { |
kvn@4115 | 2295 | Node *pair1 = new (C) BinaryNode(n->in(1),n->in(2)); |
kvn@2877 | 2296 | n->set_req(1,pair1); |
kvn@2877 | 2297 | n->set_req(2,n->in(3)); |
kvn@2877 | 2298 | n->del_req(3); |
kvn@2877 | 2299 | break; |
kvn@2877 | 2300 | } |
kvn@1421 | 2301 | case Op_StrEquals: { |
kvn@4115 | 2302 | Node *pair1 = new (C) BinaryNode(n->in(2),n->in(3)); |
kvn@1421 | 2303 | n->set_req(2,pair1); |
kvn@1421 | 2304 | n->set_req(3,n->in(4)); |
kvn@1421 | 2305 | n->del_req(4); |
kvn@1421 | 2306 | break; |
kvn@1421 | 2307 | } |
kvn@1421 | 2308 | case Op_StrComp: |
kvn@1421 | 2309 | case Op_StrIndexOf: { |
kvn@4115 | 2310 | Node *pair1 = new (C) BinaryNode(n->in(2),n->in(3)); |
kvn@1421 | 2311 | n->set_req(2,pair1); |
kvn@4115 | 2312 | Node *pair2 = new (C) BinaryNode(n->in(4),n->in(5)); |
kvn@1421 | 2313 | n->set_req(3,pair2); |
kvn@1421 | 2314 | n->del_req(5); |
kvn@1421 | 2315 | n->del_req(4); |
kvn@1421 | 2316 | break; |
kvn@1421 | 2317 | } |
kvn@4479 | 2318 | case Op_EncodeISOArray: { |
kvn@4479 | 2319 | // Restructure into a binary tree for Matching. |
kvn@4479 | 2320 | Node* pair = new (C) BinaryNode(n->in(3), n->in(4)); |
kvn@4479 | 2321 | n->set_req(3, pair); |
kvn@4479 | 2322 | n->del_req(4); |
kvn@4479 | 2323 | break; |
kvn@4479 | 2324 | } |
duke@435 | 2325 | default: |
duke@435 | 2326 | break; |
duke@435 | 2327 | } |
duke@435 | 2328 | } |
duke@435 | 2329 | else { |
duke@435 | 2330 | ShouldNotReachHere(); |
duke@435 | 2331 | } |
duke@435 | 2332 | } // end of while (mstack.is_nonempty()) |
duke@435 | 2333 | } |
duke@435 | 2334 | |
duke@435 | 2335 | #ifdef ASSERT |
duke@435 | 2336 | // machine-independent root to machine-dependent root |
duke@435 | 2337 | void Matcher::dump_old2new_map() { |
duke@435 | 2338 | _old2new_map.dump(); |
duke@435 | 2339 | } |
duke@435 | 2340 | #endif |
duke@435 | 2341 | |
duke@435 | 2342 | //---------------------------collect_null_checks------------------------------- |
duke@435 | 2343 | // Find null checks in the ideal graph; write a machine-specific node for |
duke@435 | 2344 | // it. Used by later implicit-null-check handling. Actually collects |
duke@435 | 2345 | // either an IfTrue or IfFalse for the common NOT-null path, AND the ideal |
duke@435 | 2346 | // value being tested. |
kvn@803 | 2347 | void Matcher::collect_null_checks( Node *proj, Node *orig_proj ) { |
duke@435 | 2348 | Node *iff = proj->in(0); |
duke@435 | 2349 | if( iff->Opcode() == Op_If ) { |
duke@435 | 2350 | // During matching If's have Bool & Cmp side-by-side |
duke@435 | 2351 | BoolNode *b = iff->in(1)->as_Bool(); |
duke@435 | 2352 | Node *cmp = iff->in(2); |
coleenp@548 | 2353 | int opc = cmp->Opcode(); |
coleenp@548 | 2354 | if (opc != Op_CmpP && opc != Op_CmpN) return; |
duke@435 | 2355 | |
coleenp@548 | 2356 | const Type* ct = cmp->in(2)->bottom_type(); |
coleenp@548 | 2357 | if (ct == TypePtr::NULL_PTR || |
coleenp@548 | 2358 | (opc == Op_CmpN && ct == TypeNarrowOop::NULL_PTR)) { |
coleenp@548 | 2359 | |
kvn@803 | 2360 | bool push_it = false; |
coleenp@548 | 2361 | if( proj->Opcode() == Op_IfTrue ) { |
coleenp@548 | 2362 | extern int all_null_checks_found; |
coleenp@548 | 2363 | all_null_checks_found++; |
coleenp@548 | 2364 | if( b->_test._test == BoolTest::ne ) { |
kvn@803 | 2365 | push_it = true; |
coleenp@548 | 2366 | } |
coleenp@548 | 2367 | } else { |
coleenp@548 | 2368 | assert( proj->Opcode() == Op_IfFalse, "" ); |
coleenp@548 | 2369 | if( b->_test._test == BoolTest::eq ) { |
kvn@803 | 2370 | push_it = true; |
duke@435 | 2371 | } |
duke@435 | 2372 | } |
kvn@803 | 2373 | if( push_it ) { |
kvn@803 | 2374 | _null_check_tests.push(proj); |
kvn@803 | 2375 | Node* val = cmp->in(1); |
kvn@803 | 2376 | #ifdef _LP64 |
kvn@1930 | 2377 | if (val->bottom_type()->isa_narrowoop() && |
kvn@1930 | 2378 | !Matcher::narrow_oop_use_complex_address()) { |
kvn@803 | 2379 | // |
kvn@803 | 2380 | // Look for DecodeN node which should be pinned to orig_proj. |
kvn@803 | 2381 | // On platforms (Sparc) which can not handle 2 adds |
kvn@803 | 2382 | // in addressing mode we have to keep a DecodeN node and |
kvn@803 | 2383 | // use it to do implicit NULL check in address. |
kvn@803 | 2384 | // |
kvn@803 | 2385 | // DecodeN node was pinned to non-null path (orig_proj) during |
kvn@803 | 2386 | // CastPP transformation in final_graph_reshaping_impl(). |
kvn@803 | 2387 | // |
kvn@803 | 2388 | uint cnt = orig_proj->outcnt(); |
kvn@803 | 2389 | for (uint i = 0; i < orig_proj->outcnt(); i++) { |
kvn@803 | 2390 | Node* d = orig_proj->raw_out(i); |
kvn@803 | 2391 | if (d->is_DecodeN() && d->in(1) == val) { |
kvn@803 | 2392 | val = d; |
kvn@803 | 2393 | val->set_req(0, NULL); // Unpin now. |
kvn@1930 | 2394 | // Mark this as special case to distinguish from |
kvn@1930 | 2395 | // a regular case: CmpP(DecodeN, NULL). |
kvn@1930 | 2396 | val = (Node*)(((intptr_t)val) | 1); |
kvn@803 | 2397 | break; |
kvn@803 | 2398 | } |
kvn@803 | 2399 | } |
kvn@803 | 2400 | } |
kvn@803 | 2401 | #endif |
kvn@803 | 2402 | _null_check_tests.push(val); |
kvn@803 | 2403 | } |
duke@435 | 2404 | } |
duke@435 | 2405 | } |
duke@435 | 2406 | } |
duke@435 | 2407 | |
duke@435 | 2408 | //---------------------------validate_null_checks------------------------------ |
duke@435 | 2409 | // Its possible that the value being NULL checked is not the root of a match |
duke@435 | 2410 | // tree. If so, I cannot use the value in an implicit null check. |
duke@435 | 2411 | void Matcher::validate_null_checks( ) { |
duke@435 | 2412 | uint cnt = _null_check_tests.size(); |
duke@435 | 2413 | for( uint i=0; i < cnt; i+=2 ) { |
duke@435 | 2414 | Node *test = _null_check_tests[i]; |
duke@435 | 2415 | Node *val = _null_check_tests[i+1]; |
kvn@1930 | 2416 | bool is_decoden = ((intptr_t)val) & 1; |
kvn@1930 | 2417 | val = (Node*)(((intptr_t)val) & ~1); |
duke@435 | 2418 | if (has_new_node(val)) { |
kvn@1930 | 2419 | Node* new_val = new_node(val); |
kvn@1930 | 2420 | if (is_decoden) { |
roland@4159 | 2421 | assert(val->is_DecodeNarrowPtr() && val->in(0) == NULL, "sanity"); |
kvn@1930 | 2422 | // Note: new_val may have a control edge if |
kvn@1930 | 2423 | // the original ideal node DecodeN was matched before |
kvn@1930 | 2424 | // it was unpinned in Matcher::collect_null_checks(). |
kvn@1930 | 2425 | // Unpin the mach node and mark it. |
kvn@1930 | 2426 | new_val->set_req(0, NULL); |
kvn@1930 | 2427 | new_val = (Node*)(((intptr_t)new_val) | 1); |
kvn@1930 | 2428 | } |
duke@435 | 2429 | // Is a match-tree root, so replace with the matched value |
kvn@1930 | 2430 | _null_check_tests.map(i+1, new_val); |
duke@435 | 2431 | } else { |
duke@435 | 2432 | // Yank from candidate list |
duke@435 | 2433 | _null_check_tests.map(i+1,_null_check_tests[--cnt]); |
duke@435 | 2434 | _null_check_tests.map(i,_null_check_tests[--cnt]); |
duke@435 | 2435 | _null_check_tests.pop(); |
duke@435 | 2436 | _null_check_tests.pop(); |
duke@435 | 2437 | i-=2; |
duke@435 | 2438 | } |
duke@435 | 2439 | } |
duke@435 | 2440 | } |
duke@435 | 2441 | |
duke@435 | 2442 | // Used by the DFA in dfa_xxx.cpp. Check for a following barrier or |
duke@435 | 2443 | // atomic instruction acting as a store_load barrier without any |
duke@435 | 2444 | // intervening volatile load, and thus we don't need a barrier here. |
duke@435 | 2445 | // We retain the Node to act as a compiler ordering barrier. |
kvn@5437 | 2446 | bool Matcher::post_store_load_barrier(const Node* vmb) { |
kvn@5437 | 2447 | Compile* C = Compile::current(); |
kvn@5437 | 2448 | assert(vmb->is_MemBar(), ""); |
goetz@6489 | 2449 | assert(vmb->Opcode() != Op_MemBarAcquire && vmb->Opcode() != Op_LoadFence, ""); |
kvn@5437 | 2450 | const MemBarNode* membar = vmb->as_MemBar(); |
duke@435 | 2451 | |
kvn@5437 | 2452 | // Get the Ideal Proj node, ctrl, that can be used to iterate forward |
kvn@5437 | 2453 | Node* ctrl = NULL; |
kvn@5437 | 2454 | for (DUIterator_Fast imax, i = membar->fast_outs(imax); i < imax; i++) { |
kvn@5437 | 2455 | Node* p = membar->fast_out(i); |
kvn@5437 | 2456 | assert(p->is_Proj(), "only projections here"); |
kvn@5437 | 2457 | if ((p->as_Proj()->_con == TypeFunc::Control) && |
kvn@5437 | 2458 | !C->node_arena()->contains(p)) { // Unmatched old-space only |
kvn@5437 | 2459 | ctrl = p; |
duke@435 | 2460 | break; |
kvn@5437 | 2461 | } |
duke@435 | 2462 | } |
kvn@5437 | 2463 | assert((ctrl != NULL), "missing control projection"); |
duke@435 | 2464 | |
kvn@5437 | 2465 | for (DUIterator_Fast jmax, j = ctrl->fast_outs(jmax); j < jmax; j++) { |
duke@435 | 2466 | Node *x = ctrl->fast_out(j); |
duke@435 | 2467 | int xop = x->Opcode(); |
duke@435 | 2468 | |
duke@435 | 2469 | // We don't need current barrier if we see another or a lock |
duke@435 | 2470 | // before seeing volatile load. |
duke@435 | 2471 | // |
duke@435 | 2472 | // Op_Fastunlock previously appeared in the Op_* list below. |
duke@435 | 2473 | // With the advent of 1-0 lock operations we're no longer guaranteed |
duke@435 | 2474 | // that a monitor exit operation contains a serializing instruction. |
duke@435 | 2475 | |
duke@435 | 2476 | if (xop == Op_MemBarVolatile || |
duke@435 | 2477 | xop == Op_CompareAndSwapL || |
duke@435 | 2478 | xop == Op_CompareAndSwapP || |
coleenp@548 | 2479 | xop == Op_CompareAndSwapN || |
kvn@5437 | 2480 | xop == Op_CompareAndSwapI) { |
duke@435 | 2481 | return true; |
kvn@5437 | 2482 | } |
kvn@5437 | 2483 | |
kvn@5437 | 2484 | // Op_FastLock previously appeared in the Op_* list above. |
kvn@5437 | 2485 | // With biased locking we're no longer guaranteed that a monitor |
kvn@5437 | 2486 | // enter operation contains a serializing instruction. |
kvn@5437 | 2487 | if ((xop == Op_FastLock) && !UseBiasedLocking) { |
kvn@5437 | 2488 | return true; |
kvn@5437 | 2489 | } |
duke@435 | 2490 | |
duke@435 | 2491 | if (x->is_MemBar()) { |
duke@435 | 2492 | // We must retain this membar if there is an upcoming volatile |
kvn@5437 | 2493 | // load, which will be followed by acquire membar. |
goetz@6489 | 2494 | if (xop == Op_MemBarAcquire || xop == Op_LoadFence) { |
duke@435 | 2495 | return false; |
kvn@5437 | 2496 | } else { |
kvn@5437 | 2497 | // For other kinds of barriers, check by pretending we |
kvn@5437 | 2498 | // are them, and seeing if we can be removed. |
kvn@5437 | 2499 | return post_store_load_barrier(x->as_MemBar()); |
kvn@5437 | 2500 | } |
duke@435 | 2501 | } |
duke@435 | 2502 | |
kvn@5437 | 2503 | // probably not necessary to check for these |
kvn@5437 | 2504 | if (x->is_Call() || x->is_SafePoint() || x->is_block_proj()) { |
kvn@5437 | 2505 | return false; |
duke@435 | 2506 | } |
duke@435 | 2507 | } |
duke@435 | 2508 | return false; |
duke@435 | 2509 | } |
duke@435 | 2510 | |
goetz@6490 | 2511 | // Check whether node n is a branch to an uncommon trap that we could |
goetz@6490 | 2512 | // optimize as test with very high branch costs in case of going to |
goetz@6490 | 2513 | // the uncommon trap. The code must be able to be recompiled to use |
goetz@6490 | 2514 | // a cheaper test. |
goetz@6490 | 2515 | bool Matcher::branches_to_uncommon_trap(const Node *n) { |
goetz@6490 | 2516 | // Don't do it for natives, adapters, or runtime stubs |
goetz@6490 | 2517 | Compile *C = Compile::current(); |
goetz@6490 | 2518 | if (!C->is_method_compilation()) return false; |
goetz@6490 | 2519 | |
goetz@6490 | 2520 | assert(n->is_If(), "You should only call this on if nodes."); |
goetz@6490 | 2521 | IfNode *ifn = n->as_If(); |
goetz@6490 | 2522 | |
goetz@6490 | 2523 | Node *ifFalse = NULL; |
goetz@6490 | 2524 | for (DUIterator_Fast imax, i = ifn->fast_outs(imax); i < imax; i++) { |
goetz@6490 | 2525 | if (ifn->fast_out(i)->is_IfFalse()) { |
goetz@6490 | 2526 | ifFalse = ifn->fast_out(i); |
goetz@6490 | 2527 | break; |
goetz@6490 | 2528 | } |
goetz@6490 | 2529 | } |
goetz@6490 | 2530 | assert(ifFalse, "An If should have an ifFalse. Graph is broken."); |
goetz@6490 | 2531 | |
goetz@6490 | 2532 | Node *reg = ifFalse; |
goetz@6490 | 2533 | int cnt = 4; // We must protect against cycles. Limit to 4 iterations. |
goetz@6490 | 2534 | // Alternatively use visited set? Seems too expensive. |
goetz@6490 | 2535 | while (reg != NULL && cnt > 0) { |
goetz@6490 | 2536 | CallNode *call = NULL; |
goetz@6490 | 2537 | RegionNode *nxt_reg = NULL; |
goetz@6490 | 2538 | for (DUIterator_Fast imax, i = reg->fast_outs(imax); i < imax; i++) { |
goetz@6490 | 2539 | Node *o = reg->fast_out(i); |
goetz@6490 | 2540 | if (o->is_Call()) { |
goetz@6490 | 2541 | call = o->as_Call(); |
goetz@6490 | 2542 | } |
goetz@6490 | 2543 | if (o->is_Region()) { |
goetz@6490 | 2544 | nxt_reg = o->as_Region(); |
goetz@6490 | 2545 | } |
goetz@6490 | 2546 | } |
goetz@6490 | 2547 | |
goetz@6490 | 2548 | if (call && |
goetz@6490 | 2549 | call->entry_point() == SharedRuntime::uncommon_trap_blob()->entry_point()) { |
goetz@6490 | 2550 | const Type* trtype = call->in(TypeFunc::Parms)->bottom_type(); |
goetz@6490 | 2551 | if (trtype->isa_int() && trtype->is_int()->is_con()) { |
goetz@6490 | 2552 | jint tr_con = trtype->is_int()->get_con(); |
goetz@6490 | 2553 | Deoptimization::DeoptReason reason = Deoptimization::trap_request_reason(tr_con); |
goetz@6490 | 2554 | Deoptimization::DeoptAction action = Deoptimization::trap_request_action(tr_con); |
goetz@6490 | 2555 | assert((int)reason < (int)BitsPerInt, "recode bit map"); |
goetz@6490 | 2556 | |
goetz@6490 | 2557 | if (is_set_nth_bit(C->allowed_deopt_reasons(), (int)reason) |
goetz@6490 | 2558 | && action != Deoptimization::Action_none) { |
goetz@6490 | 2559 | // This uncommon trap is sure to recompile, eventually. |
goetz@6490 | 2560 | // When that happens, C->too_many_traps will prevent |
goetz@6490 | 2561 | // this transformation from happening again. |
goetz@6490 | 2562 | return true; |
goetz@6490 | 2563 | } |
goetz@6490 | 2564 | } |
goetz@6490 | 2565 | } |
goetz@6490 | 2566 | |
goetz@6490 | 2567 | reg = nxt_reg; |
goetz@6490 | 2568 | cnt--; |
goetz@6490 | 2569 | } |
goetz@6490 | 2570 | |
goetz@6490 | 2571 | return false; |
goetz@6490 | 2572 | } |
goetz@6490 | 2573 | |
duke@435 | 2574 | //============================================================================= |
duke@435 | 2575 | //---------------------------State--------------------------------------------- |
duke@435 | 2576 | State::State(void) { |
duke@435 | 2577 | #ifdef ASSERT |
duke@435 | 2578 | _id = 0; |
duke@435 | 2579 | _kids[0] = _kids[1] = (State*)(intptr_t) CONST64(0xcafebabecafebabe); |
duke@435 | 2580 | _leaf = (Node*)(intptr_t) CONST64(0xbaadf00dbaadf00d); |
duke@435 | 2581 | //memset(_cost, -1, sizeof(_cost)); |
duke@435 | 2582 | //memset(_rule, -1, sizeof(_rule)); |
duke@435 | 2583 | #endif |
duke@435 | 2584 | memset(_valid, 0, sizeof(_valid)); |
duke@435 | 2585 | } |
duke@435 | 2586 | |
duke@435 | 2587 | #ifdef ASSERT |
duke@435 | 2588 | State::~State() { |
duke@435 | 2589 | _id = 99; |
duke@435 | 2590 | _kids[0] = _kids[1] = (State*)(intptr_t) CONST64(0xcafebabecafebabe); |
duke@435 | 2591 | _leaf = (Node*)(intptr_t) CONST64(0xbaadf00dbaadf00d); |
duke@435 | 2592 | memset(_cost, -3, sizeof(_cost)); |
duke@435 | 2593 | memset(_rule, -3, sizeof(_rule)); |
duke@435 | 2594 | } |
duke@435 | 2595 | #endif |
duke@435 | 2596 | |
duke@435 | 2597 | #ifndef PRODUCT |
duke@435 | 2598 | //---------------------------dump---------------------------------------------- |
duke@435 | 2599 | void State::dump() { |
duke@435 | 2600 | tty->print("\n"); |
duke@435 | 2601 | dump(0); |
duke@435 | 2602 | } |
duke@435 | 2603 | |
duke@435 | 2604 | void State::dump(int depth) { |
duke@435 | 2605 | for( int j = 0; j < depth; j++ ) |
duke@435 | 2606 | tty->print(" "); |
duke@435 | 2607 | tty->print("--N: "); |
duke@435 | 2608 | _leaf->dump(); |
duke@435 | 2609 | uint i; |
duke@435 | 2610 | for( i = 0; i < _LAST_MACH_OPER; i++ ) |
duke@435 | 2611 | // Check for valid entry |
duke@435 | 2612 | if( valid(i) ) { |
duke@435 | 2613 | for( int j = 0; j < depth; j++ ) |
duke@435 | 2614 | tty->print(" "); |
duke@435 | 2615 | assert(_cost[i] != max_juint, "cost must be a valid value"); |
duke@435 | 2616 | assert(_rule[i] < _last_Mach_Node, "rule[i] must be valid rule"); |
duke@435 | 2617 | tty->print_cr("%s %d %s", |
duke@435 | 2618 | ruleName[i], _cost[i], ruleName[_rule[i]] ); |
duke@435 | 2619 | } |
drchase@6680 | 2620 | tty->cr(); |
duke@435 | 2621 | |
duke@435 | 2622 | for( i=0; i<2; i++ ) |
duke@435 | 2623 | if( _kids[i] ) |
duke@435 | 2624 | _kids[i]->dump(depth+1); |
duke@435 | 2625 | } |
duke@435 | 2626 | #endif |