482 alloc_node_regs(_names.Size()); |
482 alloc_node_regs(_names.Size()); |
483 for (uint i=0; i < _names.Size(); i++) { |
483 for (uint i=0; i < _names.Size(); i++) { |
484 if (_names[i]) { // Live range associated with Node? |
484 if (_names[i]) { // Live range associated with Node? |
485 LRG &lrg = lrgs(_names[i]); |
485 LRG &lrg = lrgs(_names[i]); |
486 if (!lrg.alive()) { |
486 if (!lrg.alive()) { |
487 _node_regs[i].set_bad(); |
487 set_bad(i); |
488 } else if (lrg.num_regs() == 1) { |
488 } else if (lrg.num_regs() == 1) { |
489 _node_regs[i].set1(lrg.reg()); |
489 set1(i, lrg.reg()); |
490 } else { // Must be a register-pair |
490 } else { // Must be a register-set |
491 if (!lrg._fat_proj) { // Must be aligned adjacent register pair |
491 if (!lrg._fat_proj) { // Must be aligned adjacent register set |
492 // Live ranges record the highest register in their mask. |
492 // Live ranges record the highest register in their mask. |
493 // We want the low register for the AD file writer's convenience. |
493 // We want the low register for the AD file writer's convenience. |
494 _node_regs[i].set2( OptoReg::add(lrg.reg(),(1-lrg.num_regs())) ); |
494 OptoReg::Name hi = lrg.reg(); // Get hi register |
|
495 OptoReg::Name lo = OptoReg::add(hi, (1-lrg.num_regs())); // Find lo |
|
496 // We have to use pair [lo,lo+1] even for wide vectors because |
|
497 // the rest of code generation works only with pairs. It is safe |
|
498 // since for registers encoding only 'lo' is used. |
|
499 // Second reg from pair is used in ScheduleAndBundle on SPARC where |
|
500 // vector max size is 8 which corresponds to registers pair. |
|
501 // It is also used in BuildOopMaps but oop operations are not |
|
502 // vectorized. |
|
503 set2(i, lo); |
495 } else { // Misaligned; extract 2 bits |
504 } else { // Misaligned; extract 2 bits |
496 OptoReg::Name hi = lrg.reg(); // Get hi register |
505 OptoReg::Name hi = lrg.reg(); // Get hi register |
497 lrg.Remove(hi); // Yank from mask |
506 lrg.Remove(hi); // Yank from mask |
498 int lo = lrg.mask().find_first_elem(); // Find lo |
507 int lo = lrg.mask().find_first_elem(); // Find lo |
499 _node_regs[i].set_pair( hi, lo ); |
508 set_pair(i, hi, lo); |
500 } |
509 } |
501 } |
510 } |
502 if( lrg._is_oop ) _node_oops.set(i); |
511 if( lrg._is_oop ) _node_oops.set(i); |
503 } else { |
512 } else { |
504 _node_regs[i].set_bad(); |
513 set_bad(i); |
505 } |
514 } |
506 } |
515 } |
507 |
516 |
508 // Done! |
517 // Done! |
509 _live = NULL; |
518 _live = NULL; |
1119 |
1128 |
1120 } // End of while not simplified everything |
1129 } // End of while not simplified everything |
1121 |
1130 |
1122 } |
1131 } |
1123 |
1132 |
|
1133 //------------------------------is_legal_reg----------------------------------- |
|
1134 // Is 'reg' register legal for 'lrg'? |
|
1135 static bool is_legal_reg(LRG &lrg, OptoReg::Name reg, int chunk) { |
|
1136 if (reg >= chunk && reg < (chunk + RegMask::CHUNK_SIZE) && |
|
1137 lrg.mask().Member(OptoReg::add(reg,-chunk))) { |
|
1138 // RA uses OptoReg which represent the highest element of a registers set. |
|
1139 // For example, vectorX (128bit) on x86 uses [XMM,XMMb,XMMc,XMMd] set |
|
1140 // in which XMMd is used by RA to represent such vectors. A double value |
|
1141 // uses [XMM,XMMb] pairs and XMMb is used by RA for it. |
|
1142 // The register mask uses largest bits set of overlapping register sets. |
|
1143 // On x86 with AVX it uses 8 bits for each XMM registers set. |
|
1144 // |
|
1145 // The 'lrg' already has cleared-to-set register mask (done in Select() |
|
1146 // before calling choose_color()). Passing mask.Member(reg) check above |
|
1147 // indicates that the size (num_regs) of 'reg' set is less or equal to |
|
1148 // 'lrg' set size. |
|
1149 // For set size 1 any register which is member of 'lrg' mask is legal. |
|
1150 if (lrg.num_regs()==1) |
|
1151 return true; |
|
1152 // For larger sets only an aligned register with the same set size is legal. |
|
1153 int mask = lrg.num_regs()-1; |
|
1154 if ((reg&mask) == mask) |
|
1155 return true; |
|
1156 } |
|
1157 return false; |
|
1158 } |
|
1159 |
1124 //------------------------------bias_color------------------------------------- |
1160 //------------------------------bias_color------------------------------------- |
1125 // Choose a color using the biasing heuristic |
1161 // Choose a color using the biasing heuristic |
1126 OptoReg::Name PhaseChaitin::bias_color( LRG &lrg, int chunk ) { |
1162 OptoReg::Name PhaseChaitin::bias_color( LRG &lrg, int chunk ) { |
1127 |
1163 |
1128 // Check for "at_risk" LRG's |
1164 // Check for "at_risk" LRG's |
1135 IndexSetIterator elements(_ifg->neighbors(risk_lrg)); |
1171 IndexSetIterator elements(_ifg->neighbors(risk_lrg)); |
1136 uint datum; |
1172 uint datum; |
1137 while ((datum = elements.next()) != 0) { |
1173 while ((datum = elements.next()) != 0) { |
1138 OptoReg::Name reg = lrgs(datum).reg(); |
1174 OptoReg::Name reg = lrgs(datum).reg(); |
1139 // If this LRG's register is legal for us, choose it |
1175 // If this LRG's register is legal for us, choose it |
1140 if( reg >= chunk && reg < chunk + RegMask::CHUNK_SIZE && |
1176 if (is_legal_reg(lrg, reg, chunk)) |
1141 lrg.mask().Member(OptoReg::add(reg,-chunk)) && |
|
1142 (lrg.num_regs()==1 || // either size 1 |
|
1143 (reg&1) == 1) ) // or aligned (adjacent reg is available since we already cleared-to-pairs) |
|
1144 return reg; |
1177 return reg; |
1145 } |
1178 } |
1146 } |
1179 } |
1147 |
1180 |
1148 uint copy_lrg = Find(lrg._copy_bias); |
1181 uint copy_lrg = Find(lrg._copy_bias); |
1149 if( copy_lrg != 0 ) { |
1182 if( copy_lrg != 0 ) { |
1150 // If he has a color, |
1183 // If he has a color, |
1151 if( !(*(_ifg->_yanked))[copy_lrg] ) { |
1184 if( !(*(_ifg->_yanked))[copy_lrg] ) { |
1152 OptoReg::Name reg = lrgs(copy_lrg).reg(); |
1185 OptoReg::Name reg = lrgs(copy_lrg).reg(); |
1153 // And it is legal for you, |
1186 // And it is legal for you, |
1154 if( reg >= chunk && reg < chunk + RegMask::CHUNK_SIZE && |
1187 if (is_legal_reg(lrg, reg, chunk)) |
1155 lrg.mask().Member(OptoReg::add(reg,-chunk)) && |
|
1156 (lrg.num_regs()==1 || // either size 1 |
|
1157 (reg&1) == 1) ) // or aligned (adjacent reg is available since we already cleared-to-pairs) |
|
1158 return reg; |
1188 return reg; |
1159 } else if( chunk == 0 ) { |
1189 } else if( chunk == 0 ) { |
1160 // Choose a color which is legal for him |
1190 // Choose a color which is legal for him |
1161 RegMask tempmask = lrg.mask(); |
1191 RegMask tempmask = lrg.mask(); |
1162 tempmask.AND(lrgs(copy_lrg).mask()); |
1192 tempmask.AND(lrgs(copy_lrg).mask()); |