1.1 --- a/src/share/vm/opto/postaloc.cpp Thu Jun 14 14:59:52 2012 -0700
1.2 +++ b/src/share/vm/opto/postaloc.cpp Fri Jun 15 01:25:19 2012 -0700
1.3 @@ -1,5 +1,5 @@
1.4 /*
1.5 - * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
1.6 + * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
1.7 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
1.8 *
1.9 * This code is free software; you can redistribute it and/or modify it
1.10 @@ -27,13 +27,15 @@
1.11 #include "opto/chaitin.hpp"
1.12 #include "opto/machnode.hpp"
1.13
1.14 -// see if this register kind does not requires two registers
1.15 -static bool is_single_register(uint x) {
1.16 -#ifdef _LP64
1.17 - return (x != Op_RegD && x != Op_RegL && x != Op_RegP);
1.18 -#else
1.19 - return (x != Op_RegD && x != Op_RegL);
1.20 -#endif
1.21 +// See if this register (or pairs, or vector) already contains the value.
1.22 +static bool register_contains_value(Node* val, OptoReg::Name reg, int n_regs,
1.23 + Node_List& value) {
1.24 + for (int i = 0; i < n_regs; i++) {
1.25 + OptoReg::Name nreg = OptoReg::add(reg,-i);
1.26 + if (value[nreg] != val)
1.27 + return false;
1.28 + }
1.29 + return true;
1.30 }
1.31
1.32 //---------------------------may_be_copy_of_callee-----------------------------
1.33 @@ -167,9 +169,11 @@
1.34 const RegMask &use_mask = n->in_RegMask(idx);
1.35 bool can_use = ( RegMask::can_represent(def_reg) ? (use_mask.Member(def_reg) != 0)
1.36 : (use_mask.is_AllStack() != 0));
1.37 - // Check for a copy to or from a misaligned pair.
1.38 - can_use = can_use && !use_mask.is_misaligned_Pair() && !def_lrg.mask().is_misaligned_Pair();
1.39 -
1.40 + if (!RegMask::is_vector(def->ideal_reg())) {
1.41 + // Check for a copy to or from a misaligned pair.
1.42 + // It is workaround for a sparc with misaligned pairs.
1.43 + can_use = can_use && !use_mask.is_misaligned_pair() && !def_lrg.mask().is_misaligned_pair();
1.44 + }
1.45 if (!can_use)
1.46 return 0;
1.47
1.48 @@ -263,18 +267,16 @@
1.49 val = skip_copies(n->in(k));
1.50 }
1.51
1.52 - if( val == x ) return blk_adjust; // No progress?
1.53 + if (val == x) return blk_adjust; // No progress?
1.54
1.55 - bool single = is_single_register(val->ideal_reg());
1.56 + int n_regs = RegMask::num_registers(val->ideal_reg());
1.57 uint val_idx = n2lidx(val);
1.58 OptoReg::Name val_reg = lrgs(val_idx).reg();
1.59
1.60 // See if it happens to already be in the correct register!
1.61 // (either Phi's direct register, or the common case of the name
1.62 // never-clobbered original-def register)
1.63 - if( value[val_reg] == val &&
1.64 - // Doubles check both halves
1.65 - ( single || value[val_reg-1] == val ) ) {
1.66 + if (register_contains_value(val, val_reg, n_regs, value)) {
1.67 blk_adjust += use_prior_register(n,k,regnd[val_reg],current_block,value,regnd);
1.68 if( n->in(k) == regnd[val_reg] ) // Success! Quit trying
1.69 return blk_adjust;
1.70 @@ -306,7 +308,7 @@
1.71 }
1.72
1.73 Node *vv = value[reg];
1.74 - if( !single ) { // Doubles check for aligned-adjacent pair
1.75 + if (n_regs > 1) { // Doubles check for aligned-adjacent pair
1.76 if( (reg&1)==0 ) continue; // Wrong half of a pair
1.77 if( vv != value[reg-1] ) continue; // Not a complete pair
1.78 }
1.79 @@ -526,8 +528,9 @@
1.80 if( pidx ) {
1.81 value.map(preg,phi);
1.82 regnd.map(preg,phi);
1.83 - OptoReg::Name preg_lo = OptoReg::add(preg,-1);
1.84 - if( !is_single_register(phi->ideal_reg()) ) {
1.85 + int n_regs = RegMask::num_registers(phi->ideal_reg());
1.86 + for (int l = 1; l < n_regs; l++) {
1.87 + OptoReg::Name preg_lo = OptoReg::add(preg,-l);
1.88 value.map(preg_lo,phi);
1.89 regnd.map(preg_lo,phi);
1.90 }
1.91 @@ -568,13 +571,17 @@
1.92 value.map(ureg,valdef); // record improved reaching-def info
1.93 regnd.map(ureg, def);
1.94 // Record other half of doubles
1.95 - OptoReg::Name ureg_lo = OptoReg::add(ureg,-1);
1.96 - if( !is_single_register(def->ideal_reg()) &&
1.97 - ( !RegMask::can_represent(ureg_lo) ||
1.98 - lrgs(useidx).mask().Member(ureg_lo) ) && // Nearly always adjacent
1.99 - !value[ureg_lo] ) {
1.100 - value.map(ureg_lo,valdef); // record improved reaching-def info
1.101 - regnd.map(ureg_lo, def);
1.102 + uint def_ideal_reg = def->ideal_reg();
1.103 + int n_regs = RegMask::num_registers(def_ideal_reg);
1.104 + bool is_vec = RegMask::is_vector(def_ideal_reg);
1.105 + for (int l = 1; l < n_regs; l++) {
1.106 + OptoReg::Name ureg_lo = OptoReg::add(ureg,-l);
1.107 + if (!value[ureg_lo] &&
1.108 + (!RegMask::can_represent(ureg_lo) ||
1.109 + lrgs(useidx).mask().Member(ureg_lo))) { // Nearly always adjacent
1.110 + value.map(ureg_lo,valdef); // record improved reaching-def info
1.111 + regnd.map(ureg_lo, def);
1.112 + }
1.113 }
1.114 }
1.115 }
1.116 @@ -607,7 +614,8 @@
1.117 }
1.118
1.119 uint n_ideal_reg = n->ideal_reg();
1.120 - if( is_single_register(n_ideal_reg) ) {
1.121 + int n_regs = RegMask::num_registers(n_ideal_reg);
1.122 + if (n_regs == 1) {
1.123 // If Node 'n' does not change the value mapped by the register,
1.124 // then 'n' is a useless copy. Do not update the register->node
1.125 // mapping so 'n' will go dead.
1.126 @@ -625,6 +633,25 @@
1.127 assert( n->is_Copy(), "" );
1.128 j -= replace_and_yank_if_dead(n, nreg, b, value, regnd);
1.129 }
1.130 + } else if (RegMask::is_vector(n_ideal_reg)) {
1.131 + // If Node 'n' does not change the value mapped by the register,
1.132 + // then 'n' is a useless copy. Do not update the register->node
1.133 + // mapping so 'n' will go dead.
1.134 + if (!register_contains_value(val, nreg, n_regs, value)) {
1.135 + // Update the mapping: record new Node defined by the register
1.136 + regnd.map(nreg,n);
1.137 + // Update mapping for defined *value*, which is the defined
1.138 + // Node after skipping all copies.
1.139 + value.map(nreg,val);
1.140 + for (int l = 1; l < n_regs; l++) {
1.141 + OptoReg::Name nreg_lo = OptoReg::add(nreg,-l);
1.142 + regnd.map(nreg_lo, n );
1.143 + value.map(nreg_lo,val);
1.144 + }
1.145 + } else if (n->is_Copy()) {
1.146 + // Note: vector can't be constant and can't be copy of calee.
1.147 + j -= replace_and_yank_if_dead(n, nreg, b, value, regnd);
1.148 + }
1.149 } else {
1.150 // If the value occupies a register pair, record same info
1.151 // in both registers.
