graal-compiler: src/share/vm/opto/reg

comparison src/share/vm/opto/reg_split.cpp @ 14909:4ca6dc0799b6

Backout jdk9 merge

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Tue, 01 Apr 2014 13:57:07 +0200
parents	04e7587c97dc
children	89152779163c

comparison

equal deleted inserted replaced

-:8db6e76cb658
+:4ca6dc0799b6
 /*
-* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 //------------------------------get_spillcopy_wide-----------------------------
 // Get a SpillCopy node with wide-enough masks.  Use the 'wide-mask', the
 // wide ideal-register spill-mask if possible.  If the 'wide-mask' does
 // not cover the input (or output), use the input (or output) mask instead.
-Node *PhaseChaitin::get_spillcopy_wide(MachSpillCopyNode::SpillType spill_type, Node *def, Node *use, uint uidx ) {
+Node *PhaseChaitin::get_spillcopy_wide( Node *def, Node *use, uint uidx ) {
 // If ideal reg doesn't exist we've got a bad schedule happening
 // that is forcing us to spill something that isn't spillable.
 // Bail rather than abort
 int ireg = def->ideal_reg();
 if( ireg == 0 || ireg == Op_RegFlags ) {
 // (and thus through memory)?
 if( !C->matcher()->idealreg2regmask[ireg]->overlap( *o_mask) && o_mask->is_UP() )
 // Here we assume a trip through memory is required.
 w_i_mask = &C->FIRST_STACK_mask();
 }
-return new (C) MachSpillCopyNode(spill_type, def, *w_i_mask, *w_o_mask );
+return new (C) MachSpillCopyNode( def, *w_i_mask, *w_o_mask );
 }
 //------------------------------insert_proj------------------------------------
 // Insert the spill at chosen location.  Skip over any intervening Proj's or
 // Phis.  Skip over a CatchNode and projs, inserting in the fall-through block
 loc = 0;                    // Just past the Region
 }
 assert( loc >= 0, "must insert past block head" );
 // Get a def-side SpillCopy
-Node *spill = get_spillcopy_wide(MachSpillCopyNode::Definition, def, NULL, 0);
+Node *spill = get_spillcopy_wide(def,NULL,0);
 // Did we fail to split?, then bail
 if (!spill) {
 return 0;
 }
 }
 //------------------------------split_USE--------------------------------------
 // Splits at uses can involve redeffing the LRG, so no CISC Spilling there.
 // Debug uses want to know if def is already stack enabled.
-uint PhaseChaitin::split_USE(MachSpillCopyNode::SpillType spill_type, Node *def, Block *b, Node *use, uint useidx, uint maxlrg, bool def_down, bool cisc_sp, GrowableArray<uint> splits, int slidx ) {
+uint PhaseChaitin::split_USE( Node *def, Block *b, Node *use, uint useidx, uint maxlrg, bool def_down, bool cisc_sp, GrowableArray<uint> splits, int slidx ) {
 #ifdef ASSERT
 // Increment the counter for this lrg
 splits.at_put(slidx, splits.at(slidx)+1);
 #endif
 // Put the clone just prior to use
 int bindex = b->find_node(use);
 // DEF is UP, so must copy it DOWN and hook in USE
 // Insert SpillCopy before the USE, which uses DEF as its input,
 // and defs a new live range, which is used by this node.
-Node *spill = get_spillcopy_wide(spill_type, def,use,useidx);
+Node *spill = get_spillcopy_wide(def,use,useidx);
 // did we fail to split?
 if (!spill) {
 // Bail
 return 0;
 }
 } else {
 // Put the clone just prior to use
 bindex = b->find_node(use);
 }
-Node *spill = get_spillcopy_wide(spill_type, def, use, useidx );
+Node *spill = get_spillcopy_wide( def, use, useidx );
 if( !spill ) return 0;        // Bailed out
 // Insert SpillCopy before the USE, which uses the reaching DEF as
 // its input, and defs a new live range, which is used by this node.
 insert_proj( b, bindex, spill, maxlrg++ );
 // Use the spill/clone
 continue;
 }
 Block *b_def = _cfg.get_block_for_node(def);
 int idx_def = b_def->find_node(def);
-Node *in_spill = get_spillcopy_wide(MachSpillCopyNode::InputToRematerialization, in, def, i );
+Node *in_spill = get_spillcopy_wide( in, def, i );
 if( !in_spill ) return 0; // Bailed out
 insert_proj(b_def,idx_def,in_spill,maxlrg++);
 if( b_def == b )
 insidx++;
 def->set_req(i,in_spill);
 (mach && mach->ideal_Opcode() == Op_AddP && inpidx == AddPNode::Base)) {
 if (def->rematerialize() && lrgs(useidx)._was_spilled2) {
 // This def has been rematerialized a couple of times without
 // progress. It doesn't care if it lives UP or DOWN, so
 // spill it down now.
-maxlrg = split_USE(MachSpillCopyNode::BasePointerToMem, def,b,n,inpidx,maxlrg,false,false,splits,slidx);
+maxlrg = split_USE(def,b,n,inpidx,maxlrg,false,false,splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 insidx++;  // Reset iterator to skip USE side split
 (int)umask.Size() <= lrgs(useidx).num_regs() &&
 (!def->rematerialize() ||
 !is_vect && umask.is_misaligned_pair())) {
 // These need a Split regardless of overlap or pressure
 // SPLIT - NO DEF - NO CISC SPILL
-maxlrg = split_USE(MachSpillCopyNode::Bound, def,b,n,inpidx,maxlrg,dup,false, splits,slidx);
+maxlrg = split_USE(def,b,n,inpidx,maxlrg,dup,false, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 insidx++;  // Reset iterator to skip USE side split
 }
 if (UseFPUForSpilling && n->is_MachCall() && !uup && !dup ) {
 // The use at the call can force the def down so insert
 // a split before the use to allow the def more freedom.
-maxlrg = split_USE(MachSpillCopyNode::CallUse, def,b,n,inpidx,maxlrg,dup,false, splits,slidx);
+maxlrg = split_USE(def,b,n,inpidx,maxlrg,dup,false, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 insidx++;  // Reset iterator to skip USE side split
 n->set_req(inpidx, def);
 }
 else {  // Both are either up or down, and there is no overlap
 if( dup ) {  // If UP, reg->reg copy
 // COPY ACROSS HERE - NO DEF - NO CISC SPILL
-maxlrg = split_USE(MachSpillCopyNode::RegToReg, def,b,n,inpidx,maxlrg,false,false, splits,slidx);
+maxlrg = split_USE(def,b,n,inpidx,maxlrg,false,false, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 insidx++;  // Reset iterator to skip USE side split
 else {       // DOWN, mem->mem copy
 // COPY UP & DOWN HERE - NO DEF - NO CISC SPILL
 // First Split-UP to move value into Register
 uint def_ideal = def->ideal_reg();
 const RegMask* tmp_rm = Matcher::idealreg2regmask[def_ideal];
-Node *spill = new (C) MachSpillCopyNode(MachSpillCopyNode::MemToReg, def, dmask, *tmp_rm);
+Node *spill = new (C) MachSpillCopyNode(def, dmask, *tmp_rm);
 insert_proj( b, insidx, spill, maxlrg );
 // Then Split-DOWN as if previous Split was DEF
-maxlrg = split_USE(MachSpillCopyNode::RegToMem, spill,b,n,inpidx,maxlrg,false,false, splits,slidx);
+maxlrg = split_USE(spill,b,n,inpidx,maxlrg,false,false, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 insidx += 2;  // Reset iterator to skip USE side splits
 }
 continue;
 }
 }
 // COPY DOWN HERE - NO DEF - NO CISC SPILL
-maxlrg = split_USE(MachSpillCopyNode::RegToMem, def,b,n,inpidx,maxlrg,false,false, splits,slidx);
+maxlrg = split_USE(def,b,n,inpidx,maxlrg,false,false, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 insidx++;  // Reset iterator to skip USE side split
 }
 else {       // DOWN, Split-UP and check register pressure
 if( is_high_pressure( b, &lrgs(useidx), insidx ) ) {
 // COPY UP HERE - NO DEF - CISC SPILL
-maxlrg = split_USE(MachSpillCopyNode::MemToReg, def,b,n,inpidx,maxlrg,true,true, splits,slidx);
+maxlrg = split_USE(def,b,n,inpidx,maxlrg,true,true, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 insidx++;  // Reset iterator to skip USE side split
 } else {                          // LRP
 // COPY UP HERE - WITH DEF - NO CISC SPILL
-maxlrg = split_USE(MachSpillCopyNode::MemToReg, def,b,n,inpidx,maxlrg,true,false, splits,slidx);
+maxlrg = split_USE(def,b,n,inpidx,maxlrg,true,false, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 // Flag this lift-up in a low-pressure block as
 const RegMask &use_rm = n->in_RegMask(copyidx);
 if( def_rm.overlap(use_rm) && n->is_SpillCopy() ) {  // Bug 4707800, 'n' may be a storeSSL
 if (C->check_node_count(NodeLimitFudgeFactor, out_of_nodes)) {  // Check when generating nodes
 return 0;
 }
-Node *spill = new (C) MachSpillCopyNode(MachSpillCopyNode::MemToReg, use,use_rm,def_rm);
+Node *spill = new (C) MachSpillCopyNode(use,use_rm,def_rm);
 n->set_req(copyidx,spill);
 n->as_MachSpillCopy()->set_in_RegMask(def_rm);
 // Put the spill just before the copy
 insert_proj( b, insidx++, spill, maxlrg++ );
 }
 // Update the Phi's input edge array
 phi->set_req(i,def);
 // Grab the UP/DOWN sense for the input
 u1 = UP[pidx][slidx];
 if( u1 != (phi_up != 0)) {
-maxlrg = split_USE(MachSpillCopyNode::PhiLocationDifferToInputLocation, def, b, phi, i, maxlrg, !u1, false, splits,slidx);
+maxlrg = split_USE(def, b, phi, i, maxlrg, !u1, false, splits,slidx);
 // If it wasn't split bail
 if (!maxlrg) {
 return 0;
 }
 }

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/reg_split.cpp @ 14909:4ca6dc0799b6