< prev index next >

src/hotspot/share/adlc/formssel.cpp

Print this page

2264 
2265 
2266 bool OperandForm::is_bound_register() const {
2267   RegClass* reg_class = get_RegClass();
2268   if (reg_class == NULL) {
2269     return false;
2270   }
2271 
2272   const char* name = ideal_type(globalAD->globalNames());
2273   if (name == NULL) {
2274     return false;
2275   }
2276 
2277   uint size = 0;
2278   if (strcmp(name, "RegFlags") == 0) size = 1;
2279   if (strcmp(name, "RegI") == 0) size = 1;
2280   if (strcmp(name, "RegF") == 0) size = 1;
2281   if (strcmp(name, "RegD") == 0) size = 2;
2282   if (strcmp(name, "RegL") == 0) size = 2;
2283   if (strcmp(name, "RegN") == 0) size = 1;

2284   if (strcmp(name, "VecX") == 0) size = 4;
2285   if (strcmp(name, "VecY") == 0) size = 8;
2286   if (strcmp(name, "VecZ") == 0) size = 16;
2287   if (strcmp(name, "RegP") == 0) size = globalAD->get_preproc_def("_LP64") ? 2 : 1;
2288   if (size == 0) {
2289     return false;
2290   }
2291   return size == reg_class->size();
2292 }
2293 
2294 
2295 // Check if this is a valid field for this operand,
2296 // Return 'true' if valid, and set the value to the string the user provided.
2297 bool  OperandForm::is_interface_field(const char *field,
2298                                       const char * &value) const {
2299   return false;
2300 }
2301 
2302 
2303 // Return register class name if a constraint specifies the register class.

3497 }
3498 
3499 void MatchNode::output(FILE *fp) {
3500   if (_lChild==0 && _rChild==0) {
3501     fprintf(fp," %s",_name);    // operand
3502   }
3503   else {
3504     fprintf(fp," (%s ",_name);  // " (opcodeName "
3505     if(_lChild) _lChild->output(fp); //               left operand
3506     if(_rChild) _rChild->output(fp); //                    right operand
3507     fprintf(fp,")");                 //                                 ")"
3508   }
3509 }
3510 
3511 int MatchNode::needs_ideal_memory_edge(FormDict &globals) const {
3512   static const char *needs_ideal_memory_list[] = {
3513     "StoreI","StoreL","StoreP","StoreN","StoreNKlass","StoreD","StoreF" ,
3514     "StoreB","StoreC","Store" ,"StoreFP",
3515     "LoadI", "LoadL", "LoadP" ,"LoadN", "LoadD" ,"LoadF"  ,
3516     "LoadB" , "LoadUB", "LoadUS" ,"LoadS" ,"Load" ,
3517     "StoreVector", "LoadVector", "LoadVectorGather", "StoreVectorScatter", "LoadVectorMasked", "StoreVectorMasked",

3518     "LoadRange", "LoadKlass", "LoadNKlass", "LoadL_unaligned", "LoadD_unaligned",
3519     "LoadPLocked",
3520     "StorePConditional", "StoreIConditional", "StoreLConditional",
3521     "CompareAndSwapB", "CompareAndSwapS", "CompareAndSwapI", "CompareAndSwapL", "CompareAndSwapP", "CompareAndSwapN",
3522     "WeakCompareAndSwapB", "WeakCompareAndSwapS", "WeakCompareAndSwapI", "WeakCompareAndSwapL", "WeakCompareAndSwapP", "WeakCompareAndSwapN",
3523     "CompareAndExchangeB", "CompareAndExchangeS", "CompareAndExchangeI", "CompareAndExchangeL", "CompareAndExchangeP", "CompareAndExchangeN",
3524 #if INCLUDE_SHENANDOAHGC
3525     "ShenandoahCompareAndSwapN", "ShenandoahCompareAndSwapP", "ShenandoahWeakCompareAndSwapP", "ShenandoahWeakCompareAndSwapN", "ShenandoahCompareAndExchangeP", "ShenandoahCompareAndExchangeN",
3526 #endif
3527     "StoreCM",
3528     "GetAndSetB", "GetAndSetS", "GetAndAddI", "GetAndSetI", "GetAndSetP",
3529     "GetAndAddB", "GetAndAddS", "GetAndAddL", "GetAndSetL", "GetAndSetN",
3530     "ClearArray"
3531   };
3532   int cnt = sizeof(needs_ideal_memory_list)/sizeof(char*);
3533   if( strcmp(_opType,"PrefetchAllocation")==0 )
3534     return 1;
3535   if( strcmp(_opType,"CacheWB")==0 )
3536     return 1;
3537   if( strcmp(_opType,"CacheWBPreSync")==0 )

3801 
3802   // Check that their children also match
3803   if (_lChild ) {
3804     if( !_lChild->equivalent(globals, mNode2->_lChild) )
3805       return false;
3806   } else if (mNode2->_lChild) {
3807     return false; // I have NULL left child, mNode2 has non-NULL left child.
3808   }
3809 
3810   if (_rChild ) {
3811     if( !_rChild->equivalent(globals, mNode2->_rChild) )
3812       return false;
3813   } else if (mNode2->_rChild) {
3814     return false; // I have NULL right child, mNode2 has non-NULL right child.
3815   }
3816 
3817   // We've made it through the gauntlet.
3818   return true;
3819 }
3820 
3821 //-------------------------- has_commutative_op -------------------------------
3822 // Recursively check for commutative operations with subtree operands
3823 // which could be swapped.
3824 void MatchNode::count_commutative_op(int& count) {
3825   static const char *commut_op_list[] = {
3826     "AddI","AddL","AddF","AddD",
3827     "AddVB","AddVS","AddVI","AddVL","AddVF","AddVD",
3828     "AndI","AndL",
3829     "AndV",
3830     "MaxI","MinI","MaxF","MinF","MaxD","MinD",
3831     "MaxV", "MinV",
3832     "MulI","MulL","MulF","MulD",
3833     "MulVB","MulVS","MulVI","MulVL","MulVF","MulVD",
3834     "OrI","OrL",
3835     "OrV",
3836     "XorI","XorL",
3837     "XorV"
3838   };
3839   int cnt = sizeof(commut_op_list)/sizeof(char*);
3840 
3841   if( _lChild && _rChild && (_lChild->_lChild || _rChild->_lChild) ) {







3842     // Don't swap if right operand is an immediate constant.
3843     bool is_const = false;
3844     if( _rChild->_lChild == NULL && _rChild->_rChild == NULL ) {
3845       FormDict &globals = _AD.globalNames();
3846       const Form *form = globals[_rChild->_opType];
3847       if ( form ) {
3848         OperandForm  *oper = form->is_operand();
3849         if( oper && oper->interface_type(globals) == Form::constant_interface )
3850           is_const = true;
3851       }
3852     }
3853     if( !is_const ) {
3854       for( int i=0; i<cnt; i++ ) {
3855         if( strcmp(_opType, commut_op_list[i]) == 0 ) {
3856           count++;
3857           _commutative_id = count; // id should be > 0














3858           break;
3859         }
3860       }












3861     }
3862   }
3863   if( _lChild )
3864     _lChild->count_commutative_op(count);
3865   if( _rChild )
3866     _rChild->count_commutative_op(count);
3867 }
3868 
3869 //-------------------------- swap_commutative_op ------------------------------
3870 // Recursively swap specified commutative operation with subtree operands.
3871 void MatchNode::swap_commutative_op(bool atroot, int id) {
3872   if( _commutative_id == id ) { // id should be > 0
3873     assert(_lChild && _rChild && (_lChild->_lChild || _rChild->_lChild ),
3874             "not swappable operation");
3875     MatchNode* tmp = _lChild;
3876     _lChild = _rChild;
3877     _rChild = tmp;
3878     // Don't exit here since we need to build internalop.
3879   }
3880 
3881   bool is_set = ( strcmp(_opType, "Set") == 0 );
3882   if( _lChild )
3883     _lChild->swap_commutative_op(is_set, id);
3884   if( _rChild )
3885     _rChild->swap_commutative_op(is_set, id);

4071         strcmp(opType,"ReverseBytesS")==0 ||
4072         strcmp(opType,"ReplicateB")==0 ||
4073         strcmp(opType,"ReplicateS")==0 ||
4074         strcmp(opType,"ReplicateI")==0 ||
4075         strcmp(opType,"ReplicateL")==0 ||
4076         strcmp(opType,"ReplicateF")==0 ||
4077         strcmp(opType,"ReplicateD")==0 ||
4078         strcmp(opType,"AddReductionVI")==0 ||
4079         strcmp(opType,"AddReductionVL")==0 ||
4080         strcmp(opType,"AddReductionVF")==0 ||
4081         strcmp(opType,"AddReductionVD")==0 ||
4082         strcmp(opType,"MulReductionVI")==0 ||
4083         strcmp(opType,"MulReductionVL")==0 ||
4084         strcmp(opType,"MulReductionVF")==0 ||
4085         strcmp(opType,"MulReductionVD")==0 ||
4086         strcmp(opType,"MinReductionV")==0 ||
4087         strcmp(opType,"MaxReductionV")==0 ||
4088         strcmp(opType,"AndReductionV")==0 ||
4089         strcmp(opType,"OrReductionV")==0 ||
4090         strcmp(opType,"XorReductionV")==0 ||

4091         0 /* 0 to line up columns nicely */ )
4092       return 1;
4093   }
4094   return 0;
4095 }
4096 
4097 bool MatchRule::is_ideal_if() const {
4098   if( !_opType ) return false;
4099   return
4100     !strcmp(_opType,"If"            ) ||
4101     !strcmp(_opType,"CountedLoopEnd");
4102 }
4103 
4104 bool MatchRule::is_ideal_fastlock() const {
4105   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4106     return (strcmp(_rChild->_opType,"FastLock") == 0);
4107   }
4108   return false;
4109 }
4110 

4182     "CMoveVD", "CMoveVF",
4183     "DivVF","DivVD",
4184     "AbsVB","AbsVS","AbsVI","AbsVL","AbsVF","AbsVD",
4185     "NegVF","NegVD","NegVI",
4186     "SqrtVD","SqrtVF",
4187     "AndV" ,"XorV" ,"OrV",
4188     "MaxV", "MinV",
4189     "AddReductionVI", "AddReductionVL",
4190     "AddReductionVF", "AddReductionVD",
4191     "MulReductionVI", "MulReductionVL",
4192     "MulReductionVF", "MulReductionVD",
4193     "MaxReductionV", "MinReductionV",
4194     "AndReductionV", "OrReductionV", "XorReductionV",
4195     "MulAddVS2VI", "MacroLogicV",
4196     "LShiftCntV","RShiftCntV",
4197     "LShiftVB","LShiftVS","LShiftVI","LShiftVL",
4198     "RShiftVB","RShiftVS","RShiftVI","RShiftVL",
4199     "URShiftVB","URShiftVS","URShiftVI","URShiftVL",
4200     "ReplicateB","ReplicateS","ReplicateI","ReplicateL","ReplicateF","ReplicateD",
4201     "RoundDoubleModeV","RotateLeftV" , "RotateRightV", "LoadVector","StoreVector",
4202     "LoadVectorGather", "StoreVectorScatter",
4203     "VectorTest", "VectorLoadMask", "VectorStoreMask", "VectorBlend", "VectorInsert",
4204     "VectorRearrange","VectorLoadShuffle", "VectorLoadConst",
4205     "VectorCastB2X", "VectorCastS2X", "VectorCastI2X",
4206     "VectorCastL2X", "VectorCastF2X", "VectorCastD2X",
4207     "VectorMaskWrapper", "VectorMaskCmp", "VectorReinterpret","LoadVectorMasked","StoreVectorMasked",
4208     "FmaVD", "FmaVF","PopCountVI",


4209     // Next are not supported currently.
4210     "PackB","PackS","PackI","PackL","PackF","PackD","Pack2L","Pack2D",
4211     "ExtractB","ExtractUB","ExtractC","ExtractS","ExtractI","ExtractL","ExtractF","ExtractD",
4212     "VectorMaskCast"
4213   };
4214   int cnt = sizeof(vector_list)/sizeof(char*);
4215   if (_rChild) {
4216     const char  *opType = _rChild->_opType;
4217     for (int i=0; i<cnt; i++)
4218       if (strcmp(opType,vector_list[i]) == 0)
4219         return true;
4220   }
4221   return false;
4222 }
4223 
4224 
4225 bool MatchRule::skip_antidep_check() const {
4226   // Some loads operate on what is effectively immutable memory so we
4227   // should skip the anti dep computations.  For some of these nodes
4228   // the rewritable field keeps the anti dep logic from triggering but
4229   // for certain kinds of LoadKlass it does not since they are
4230   // actually reading memory which could be rewritten by the runtime,
4231   // though never by generated code.  This disables it uniformly for
4232   // the nodes that behave like this: LoadKlass, LoadNKlass and

2264 
2265 
2266 bool OperandForm::is_bound_register() const {
2267   RegClass* reg_class = get_RegClass();
2268   if (reg_class == NULL) {
2269     return false;
2270   }
2271 
2272   const char* name = ideal_type(globalAD->globalNames());
2273   if (name == NULL) {
2274     return false;
2275   }
2276 
2277   uint size = 0;
2278   if (strcmp(name, "RegFlags") == 0) size = 1;
2279   if (strcmp(name, "RegI") == 0) size = 1;
2280   if (strcmp(name, "RegF") == 0) size = 1;
2281   if (strcmp(name, "RegD") == 0) size = 2;
2282   if (strcmp(name, "RegL") == 0) size = 2;
2283   if (strcmp(name, "RegN") == 0) size = 1;
2284   if (strcmp(name, "RegVectMask") == 0) size = globalAD->get_preproc_def("AARCH64") ? 1 : 2;
2285   if (strcmp(name, "VecX") == 0) size = 4;
2286   if (strcmp(name, "VecY") == 0) size = 8;
2287   if (strcmp(name, "VecZ") == 0) size = 16;
2288   if (strcmp(name, "RegP") == 0) size = globalAD->get_preproc_def("_LP64") ? 2 : 1;
2289   if (size == 0) {
2290     return false;
2291   }
2292   return size == reg_class->size();
2293 }
2294 
2295 
2296 // Check if this is a valid field for this operand,
2297 // Return 'true' if valid, and set the value to the string the user provided.
2298 bool  OperandForm::is_interface_field(const char *field,
2299                                       const char * &value) const {
2300   return false;
2301 }
2302 
2303 
2304 // Return register class name if a constraint specifies the register class.

3498 }
3499 
3500 void MatchNode::output(FILE *fp) {
3501   if (_lChild==0 && _rChild==0) {
3502     fprintf(fp," %s",_name);    // operand
3503   }
3504   else {
3505     fprintf(fp," (%s ",_name);  // " (opcodeName "
3506     if(_lChild) _lChild->output(fp); //               left operand
3507     if(_rChild) _rChild->output(fp); //                    right operand
3508     fprintf(fp,")");                 //                                 ")"
3509   }
3510 }
3511 
3512 int MatchNode::needs_ideal_memory_edge(FormDict &globals) const {
3513   static const char *needs_ideal_memory_list[] = {
3514     "StoreI","StoreL","StoreP","StoreN","StoreNKlass","StoreD","StoreF" ,
3515     "StoreB","StoreC","Store" ,"StoreFP",
3516     "LoadI", "LoadL", "LoadP" ,"LoadN", "LoadD" ,"LoadF"  ,
3517     "LoadB" , "LoadUB", "LoadUS" ,"LoadS" ,"Load" ,
3518     "StoreVector", "LoadVector", "LoadVectorMasked", "StoreVectorMasked",
3519     "LoadVectorGather", "StoreVectorScatter", "LoadVectorGatherMasked", "StoreVectorScatterMasked",
3520     "LoadRange", "LoadKlass", "LoadNKlass", "LoadL_unaligned", "LoadD_unaligned",
3521     "LoadPLocked",
3522     "StorePConditional", "StoreIConditional", "StoreLConditional",
3523     "CompareAndSwapB", "CompareAndSwapS", "CompareAndSwapI", "CompareAndSwapL", "CompareAndSwapP", "CompareAndSwapN",
3524     "WeakCompareAndSwapB", "WeakCompareAndSwapS", "WeakCompareAndSwapI", "WeakCompareAndSwapL", "WeakCompareAndSwapP", "WeakCompareAndSwapN",
3525     "CompareAndExchangeB", "CompareAndExchangeS", "CompareAndExchangeI", "CompareAndExchangeL", "CompareAndExchangeP", "CompareAndExchangeN",
3526 #if INCLUDE_SHENANDOAHGC
3527     "ShenandoahCompareAndSwapN", "ShenandoahCompareAndSwapP", "ShenandoahWeakCompareAndSwapP", "ShenandoahWeakCompareAndSwapN", "ShenandoahCompareAndExchangeP", "ShenandoahCompareAndExchangeN",
3528 #endif
3529     "StoreCM",
3530     "GetAndSetB", "GetAndSetS", "GetAndAddI", "GetAndSetI", "GetAndSetP",
3531     "GetAndAddB", "GetAndAddS", "GetAndAddL", "GetAndSetL", "GetAndSetN",
3532     "ClearArray"
3533   };
3534   int cnt = sizeof(needs_ideal_memory_list)/sizeof(char*);
3535   if( strcmp(_opType,"PrefetchAllocation")==0 )
3536     return 1;
3537   if( strcmp(_opType,"CacheWB")==0 )
3538     return 1;
3539   if( strcmp(_opType,"CacheWBPreSync")==0 )

3803 
3804   // Check that their children also match
3805   if (_lChild ) {
3806     if( !_lChild->equivalent(globals, mNode2->_lChild) )
3807       return false;
3808   } else if (mNode2->_lChild) {
3809     return false; // I have NULL left child, mNode2 has non-NULL left child.
3810   }
3811 
3812   if (_rChild ) {
3813     if( !_rChild->equivalent(globals, mNode2->_rChild) )
3814       return false;
3815   } else if (mNode2->_rChild) {
3816     return false; // I have NULL right child, mNode2 has non-NULL right child.
3817   }
3818 
3819   // We've made it through the gauntlet.
3820   return true;
3821 }
3822 
3823 //-------------------------- count_commutative_op -------------------------------
3824 // Recursively check for commutative operations with subtree operands
3825 // which could be swapped.
3826 void MatchNode::count_commutative_op(int& count) {
3827   static const char *commut_op_list[] = {
3828     "AddI","AddL","AddF","AddD",

3829     "AndI","AndL",

3830     "MaxI","MinI","MaxF","MinF","MaxD","MinD",

3831     "MulI","MulL","MulF","MulD",

3832     "OrI","OrL",
3833     "XorI","XorL"


3834   };

3835 
3836   static const char *commut_vector_op_list[] = {
3837     "AddVB", "AddVS", "AddVI", "AddVL", "AddVF", "AddVD",
3838     "MulVB", "MulVS", "MulVI", "MulVL", "MulVF", "MulVD",
3839     "AndV", "OrV", "XorV",
3840     "MaxV", "MinV"
3841   };
3842 
3843   if (_lChild && _rChild && (_lChild->_lChild || _rChild->_lChild)) {
3844     // Don't swap if right operand is an immediate constant.
3845     bool is_const = false;
3846     if (_rChild->_lChild == NULL && _rChild->_rChild == NULL) {
3847       FormDict &globals = _AD.globalNames();
3848       const Form *form = globals[_rChild->_opType];
3849       if (form) {
3850         OperandForm *oper = form->is_operand();
3851         if (oper && oper->interface_type(globals) == Form::constant_interface)
3852           is_const = true;
3853       }
3854     }
3855 
3856     if (!is_const) {
3857       int scalar_cnt = sizeof(commut_op_list)/sizeof(char*);
3858       int vector_cnt = sizeof(commut_vector_op_list)/sizeof(char*);
3859       bool matched = false;
3860 
3861       // Check the commutative vector op first. It's noncommutative if
3862       // the current node is a masked vector op, since a mask value
3863       // is added to the original vector node's input list and the original
3864       // first two inputs are packed into one BinaryNode. So don't swap
3865       // if one of the operands is a BinaryNode.
3866       for (int i = 0; i < vector_cnt; i++) {
3867         if (strcmp(_opType, commut_vector_op_list[i]) == 0) {
3868           if (strcmp(_lChild->_opType, "Binary") != 0 &&
3869               strcmp(_rChild->_opType, "Binary") != 0) {
3870             count++;
3871             _commutative_id = count; // id should be > 0
3872           }
3873           matched = true;
3874           break;
3875         }
3876       }
3877 
3878       // Then check the scalar op if the current op is not in
3879       // the commut_vector_op_list.
3880       if (!matched) {
3881         for (int i = 0; i < scalar_cnt; i++) {
3882           if (strcmp(_opType, commut_op_list[i]) == 0) {
3883             count++;
3884             _commutative_id = count; // id should be > 0
3885             break;
3886           }
3887         }
3888       }
3889     }
3890   }
3891   if (_lChild)
3892     _lChild->count_commutative_op(count);
3893   if (_rChild)
3894     _rChild->count_commutative_op(count);
3895 }
3896 
3897 //-------------------------- swap_commutative_op ------------------------------
3898 // Recursively swap specified commutative operation with subtree operands.
3899 void MatchNode::swap_commutative_op(bool atroot, int id) {
3900   if( _commutative_id == id ) { // id should be > 0
3901     assert(_lChild && _rChild && (_lChild->_lChild || _rChild->_lChild ),
3902             "not swappable operation");
3903     MatchNode* tmp = _lChild;
3904     _lChild = _rChild;
3905     _rChild = tmp;
3906     // Don't exit here since we need to build internalop.
3907   }
3908 
3909   bool is_set = ( strcmp(_opType, "Set") == 0 );
3910   if( _lChild )
3911     _lChild->swap_commutative_op(is_set, id);
3912   if( _rChild )
3913     _rChild->swap_commutative_op(is_set, id);

4099         strcmp(opType,"ReverseBytesS")==0 ||
4100         strcmp(opType,"ReplicateB")==0 ||
4101         strcmp(opType,"ReplicateS")==0 ||
4102         strcmp(opType,"ReplicateI")==0 ||
4103         strcmp(opType,"ReplicateL")==0 ||
4104         strcmp(opType,"ReplicateF")==0 ||
4105         strcmp(opType,"ReplicateD")==0 ||
4106         strcmp(opType,"AddReductionVI")==0 ||
4107         strcmp(opType,"AddReductionVL")==0 ||
4108         strcmp(opType,"AddReductionVF")==0 ||
4109         strcmp(opType,"AddReductionVD")==0 ||
4110         strcmp(opType,"MulReductionVI")==0 ||
4111         strcmp(opType,"MulReductionVL")==0 ||
4112         strcmp(opType,"MulReductionVF")==0 ||
4113         strcmp(opType,"MulReductionVD")==0 ||
4114         strcmp(opType,"MinReductionV")==0 ||
4115         strcmp(opType,"MaxReductionV")==0 ||
4116         strcmp(opType,"AndReductionV")==0 ||
4117         strcmp(opType,"OrReductionV")==0 ||
4118         strcmp(opType,"XorReductionV")==0 ||
4119         strcmp(opType,"MaskAll")==0 ||
4120         0 /* 0 to line up columns nicely */ )
4121       return 1;
4122   }
4123   return 0;
4124 }
4125 
4126 bool MatchRule::is_ideal_if() const {
4127   if( !_opType ) return false;
4128   return
4129     !strcmp(_opType,"If"            ) ||
4130     !strcmp(_opType,"CountedLoopEnd");
4131 }
4132 
4133 bool MatchRule::is_ideal_fastlock() const {
4134   if ( _opType && (strcmp(_opType,"Set") == 0) && _rChild ) {
4135     return (strcmp(_rChild->_opType,"FastLock") == 0);
4136   }
4137   return false;
4138 }
4139 

4211     "CMoveVD", "CMoveVF",
4212     "DivVF","DivVD",
4213     "AbsVB","AbsVS","AbsVI","AbsVL","AbsVF","AbsVD",
4214     "NegVF","NegVD","NegVI",
4215     "SqrtVD","SqrtVF",
4216     "AndV" ,"XorV" ,"OrV",
4217     "MaxV", "MinV",
4218     "AddReductionVI", "AddReductionVL",
4219     "AddReductionVF", "AddReductionVD",
4220     "MulReductionVI", "MulReductionVL",
4221     "MulReductionVF", "MulReductionVD",
4222     "MaxReductionV", "MinReductionV",
4223     "AndReductionV", "OrReductionV", "XorReductionV",
4224     "MulAddVS2VI", "MacroLogicV",
4225     "LShiftCntV","RShiftCntV",
4226     "LShiftVB","LShiftVS","LShiftVI","LShiftVL",
4227     "RShiftVB","RShiftVS","RShiftVI","RShiftVL",
4228     "URShiftVB","URShiftVS","URShiftVI","URShiftVL",
4229     "ReplicateB","ReplicateS","ReplicateI","ReplicateL","ReplicateF","ReplicateD",
4230     "RoundDoubleModeV","RotateLeftV" , "RotateRightV", "LoadVector","StoreVector",
4231     "LoadVectorGather", "StoreVectorScatter", "LoadVectorGatherMasked", "StoreVectorScatterMasked",
4232     "VectorTest", "VectorLoadMask", "VectorStoreMask", "VectorBlend", "VectorInsert",
4233     "VectorRearrange","VectorLoadShuffle", "VectorLoadConst",
4234     "VectorCastB2X", "VectorCastS2X", "VectorCastI2X",
4235     "VectorCastL2X", "VectorCastF2X", "VectorCastD2X",
4236     "VectorMaskWrapper", "VectorMaskCmp", "VectorReinterpret","LoadVectorMasked","StoreVectorMasked",
4237     "FmaVD", "FmaVF","PopCountVI",
4238     // Next are vector mask ops.
4239     "MaskAll", "AndVMask", "OrVMask", "XorVMask", "VectorMaskCast",
4240     // Next are not supported currently.
4241     "PackB","PackS","PackI","PackL","PackF","PackD","Pack2L","Pack2D",
4242     "ExtractB","ExtractUB","ExtractC","ExtractS","ExtractI","ExtractL","ExtractF","ExtractD"

4243   };
4244   int cnt = sizeof(vector_list)/sizeof(char*);
4245   if (_rChild) {
4246     const char  *opType = _rChild->_opType;
4247     for (int i=0; i<cnt; i++)
4248       if (strcmp(opType,vector_list[i]) == 0)
4249         return true;
4250   }
4251   return false;
4252 }
4253 
4254 
4255 bool MatchRule::skip_antidep_check() const {
4256   // Some loads operate on what is effectively immutable memory so we
4257   // should skip the anti dep computations.  For some of these nodes
4258   // the rewritable field keeps the anti dep logic from triggering but
4259   // for certain kinds of LoadKlass it does not since they are
4260   // actually reading memory which could be rewritten by the runtime,
4261   // though never by generated code.  This disables it uniformly for
4262   // the nodes that behave like this: LoadKlass, LoadNKlass and
< prev index next >