Lines Matching defs:globals
196 bool InstructForm::is_pinned(FormDict &globals) {
210 return is_parm(globals);
214 bool InstructForm::is_projection(FormDict &globals) {
229 bool InstructForm::is_parm(FormDict &globals) {
448 uint InstructForm::two_address(FormDict &globals) {
458 const Form *form = globals[def_type];
462 op->interface_type(globals) == Form::register_interface ) {
480 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals) {
483 return is_chain_of_constant(globals, dummy, dummy2);
485 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,
489 return is_chain_of_constant(globals, opTypeParam, result);
492 Form::DataType InstructForm::is_chain_of_constant(FormDict &globals,
504 if ( _matrule->is_chain_rule(globals)
505 && _matrule->base_operand(position, globals, result, name, opType) ) {
521 bool InstructForm::is_simple_chain_rule(FormDict &globals) const {
524 && globals[_matrule->_rChild->_opType]
525 && globals[_matrule->_rChild->_opType]->is_opclass() ) {
532 bool InstructForm::rematerialize(FormDict &globals, RegisterForm *registers ) {
535 Form::DataType data_type = is_chain_of_constant(globals);
570 const Form *form = globals[c->_type];
578 const char *type = opform->ideal_type( globals, registers );
591 bool InstructForm::needs_anti_dependence_check(FormDict &globals) const {
599 // if( is_simple_chain_rule(globals) ) return false;
618 const Form *form = globals[comp->_type];
622 if( form->interface_type(globals) == Form::memory_interface ) {
639 bool InstructForm::is_wide_memory_kill(FormDict &globals) const {
652 int InstructForm::memory_operand(FormDict &globals) const {
664 const Form *form = globals[comp->_type];
668 if( op->stack_slots_only(globals) ) continue;
669 if( form->interface_type(globals) == Form::memory_interface ) {
691 if( is_simple_chain_rule(globals) ) {
756 bool InstructForm::captures_bottom_type(FormDict &globals) const {
771 if (needs_base_oop_edge(globals)) return true;
830 uint InstructForm::num_consts(FormDict &globals) const {
834 return _matrule->num_consts(globals);
838 uint InstructForm::num_consts(FormDict &globals, Form::DataType type) const {
842 return _matrule->num_consts(globals, type);
847 const char *InstructForm::out_reg_class(FormDict &globals) {
848 assert( false, "InstructForm::out_reg_class(FormDict &globals); Not Implemented");
856 uint InstructForm::oper_input_base(FormDict &globals) {
882 base += _matrule->needs_ideal_memory_edge(globals);
886 base += needs_base_oop_edge(globals);
1006 uint InstructForm::reloc(FormDict &globals) {
1021 while (_matrule->base_operand(position, globals, result, name, opType)) {
1040 const Form *form = globals[comp->_type];
1048 Form::DataType type = oper->is_base_constant(globals);
1059 Form::DataType data_type = is_chain_of_constant(globals);
1093 const char *InstructForm::reduce_right(FormDict &globals) const {
1095 return _matrule->reduce_right(globals);
1099 const char *InstructForm::reduce_left(FormDict &globals) const {
1101 return _matrule->reduce_left(globals);
1106 const char *InstructForm::mach_base_class(FormDict &globals) const {
1143 else if (captures_bottom_type(globals)) {
1181 FormDict &globals = AD.globalNames();
1182 cisc_spill_operand = _matrule->matchrule_cisc_spill_match(globals, AD.get_registers(), instr->_matrule, op_name, reg_type);
1197 OperandForm *oper = (OperandForm*)(globals[reg_type]->is_operand());
1396 void InstructForm::index_temps(FILE *fp, FormDict &globals, const char *prefix, const char *receiver) {
1405 fprintf(fp," unsigned %sidx0 = %d;\n", prefix, oper_input_base(globals));
1406 fprintf(fp," unsigned %sidx1 = %d;", prefix, oper_input_base(globals));
1588 bool EncClass::check_parameter_types(FormDict &globals) {
1943 Form::InterfaceType OpClassForm::interface_type(FormDict &globals) const {
1953 const Form *form = globals[op_name];
1958 interface = operand->interface_type(globals);
1960 interface = (interface == operand->interface_type(globals) ? interface : Form::no_interface);
1966 bool OpClassForm::stack_slots_only(FormDict &globals) const {
1973 const Form *form = globals[op_name];
1976 if( !operand->stack_slots_only(globals) ) return false;
2037 Form::InterfaceType OperandForm::interface_type(FormDict &globals) const {
2040 return _interface->interface_type(globals);
2044 bool OperandForm::stack_slots_only(FormDict &globals) const {
2069 uint OperandForm::num_consts(FormDict &globals) const {
2073 return _matrule->num_consts(globals);
2077 uint OperandForm::num_consts(FormDict &globals, Form::DataType type) const {
2081 return _matrule->num_consts(globals, type);
2085 uint OperandForm::num_const_ptrs(FormDict &globals) const {
2089 return _matrule->num_const_ptrs(globals);
2092 uint OperandForm::num_edges(FormDict &globals) const {
2095 uint consts = num_consts(globals);
2108 const Form *form = globals[_matrule->_opType];
2111 return oper->num_edges(globals);
2122 bool OperandForm::is_cisc_reg(FormDict &globals) const {
2123 const char *ideal = ideal_type(globals);
2128 bool OpClassForm::is_cisc_mem(FormDict &globals) const {
2129 Form::InterfaceType my_interface = interface_type(globals);
2158 const char *OperandForm::ideal_type(FormDict &globals, RegisterForm *registers) const {
2191 const Form *frm = globals[type];
2193 type = op->ideal_type(globals, registers);
2200 const char *OperandForm::interface_ideal_type(FormDict &globals,
2267 const char *OperandForm::in_reg_class(uint leaf, FormDict &globals) {
2270 if((_matrule == NULL) || (_matrule->is_chain_rule(globals))) {
2281 for(uint idx = 0;_matrule->base_operand(idx,globals,result,name,type);++idx) {
2282 const Form *form = (_localNames[name] ? _localNames[name] : globals[result]);
2330 int OperandForm::constant_position(FormDict &globals, const Component *last) {
2342 const Form *form = globals[type];
2346 if( oper->_matrule->is_base_constant(globals) != Form::none ) {
2358 int OperandForm::constant_position(FormDict &globals, const char *name) {
2360 int idx = constant_position( globals, comp );
2368 int OperandForm::register_position(FormDict &globals, const char *reg_name) {
2381 const Form *form = globals[type];
2385 if( oper->_matrule->is_base_register(globals) ) {
2400 const char *OperandForm::reduce_right(FormDict &globals) const {
2401 return ( _matrule ? _matrule->reduce_right(globals) : NULL );
2405 const char *OperandForm::reduce_left(FormDict &globals) const {
2406 return ( _matrule ? _matrule->reduce_left(globals) : NULL );
2413 void OperandForm::disp_is_oop(FILE *fp, FormDict &globals) {
2427 Form *form = (Form*)globals[type];
2432 if ( op->is_base_constant(globals) == Form::idealP ) {
2434 uint idx = op->constant_position( globals, rep_var);
2445 void OperandForm::int_format(FILE *fp, FormDict &globals, uint index) {
2447 if (_matrule && (_matrule->is_base_register(globals) ||
2454 } else if (_matrule && (dtype = _matrule->is_base_constant(globals)) != Form::none) {
2473 void OperandForm::ext_format(FILE *fp, FormDict &globals, uint index) {
2475 if (_matrule && (_matrule->is_base_register(globals) ||
2483 } else if (_matrule && (dtype = _matrule->is_base_constant(globals)) != Form::none) {
2513 OperandForm *OperandForm::constant_operand(FormDict &globals,
2517 uint n_consts = num_consts(globals);
2533 type = comp->base_type(globals);
2538 return globals[comp->_type]->is_operand();
2552 Form::DataType OperandForm::simple_type(FormDict &globals) const {
2553 const char *type_name = ideal_type(globals);
2559 Form::DataType OperandForm::is_base_constant(FormDict &globals) const {
2562 return _matrule->is_base_constant(globals);
2566 bool OperandForm::swallowed(FormDict &globals) const {
2567 Form::DataType type = simple_type(globals);
2576 void OperandForm::access_constant(FILE *fp, FormDict &globals,
2578 OperandForm *oper = constant_operand(globals, const_index);
2580 Form::DataType dtype = oper->is_base_constant(globals);
2650 Form::InterfaceType Interface::interface_type(FormDict &globals) const {
2859 const char *Component::base_type(FormDict &globals) {
2860 const Form *frm = globals[_type];
2865 return (char *)op->ideal_type(globals);
3174 FormDict &globals = _AD.globalNames();
3180 const Form *f = globals[_opType];
3202 bool MatchNode::base_operand(uint &position, FormDict &globals,
3221 const Form *form = globals[_opType];
3237 return (matchNode->base_operand(position,globals,result,name,opType));
3254 if (_lChild->base_operand(position, globals, result, name, opType))
3259 if (_rChild->base_operand(position, globals, result, name, opType))
3268 uint MatchNode::num_consts(FormDict &globals) const {
3276 base_operand(position,globals,result,name,opType); position = index) {
3286 uint MatchNode::num_consts(FormDict &globals, Form::DataType type) const {
3294 base_operand(position,globals,result,name,opType); position = index) {
3303 uint MatchNode::num_const_ptrs(FormDict &globals) const {
3304 return num_consts( globals, Form::idealP );
3311 const char *MatchNode::reduce_right(FormDict &globals) const {
3329 const char *MatchNode::reduce_left(FormDict &globals) const {
3345 OperandForm *oper = globals[mnode->_opType]->is_operand();
3438 int MatchNode::needs_ideal_memory_edge(FormDict &globals) const {
3464 if( _lChild->needs_ideal_memory_edge(globals) )
3472 if( _rChild->needs_ideal_memory_edge(globals) )
3487 int InstructForm::needs_base_oop_edge(FormDict &globals) const {
3488 if( is_simple_chain_rule(globals) ) {
3490 OperandForm *src_op = globals[src]->is_operand();
3531 bool static root_ops_match(FormDict &globals, const char *op1, const char *op2) {
3535 const Form *form1 = globals[op1];
3536 const Form *form2 = globals[op2];
3543 int MatchNode::cisc_spill_match(FormDict& globals, RegisterForm* registers, MatchNode* mRule2, const char* &operand, const char* ®_type) {
3556 const Form *form = globals[_opType];
3557 const Form *form2 = globals[mRule2->_opType];
3567 data_type = form->ideal_to_Reg_type(form->is_operand()->ideal_type(globals));
3570 if( form->is_cisc_reg(globals)
3576 const Form *form2_left = name_left ? globals[name_left] : NULL;
3577 if( form2_left && form2_left->is_cisc_mem(globals) ) {
3587 else if( form->is_cisc_reg(globals) && form2->is_cisc_mem(globals) ) {
3606 left_spillable = _lChild->cisc_spill_match(globals, registers, mRule2->_lChild, operand, reg_type);
3613 right_spillable = _rChild->cisc_spill_match(globals, registers, mRule2->_rChild, operand, reg_type);
3627 int MatchRule::matchrule_cisc_spill_match(FormDict& globals, RegisterForm* registers,
3644 if( root_ops_match(globals, _lChild->_opType, mRule2->_lChild->_opType) ) {
3655 right_spillable = _rChild->cisc_spill_match(globals, registers, mRule2->_rChild, operand, reg_type);
3667 bool MatchRule::equivalent(FormDict &globals, MatchNode *mRule2) {
3676 const Form *form = globals[_opType];
3677 const Form *form2 = globals[mRule2->_opType];
3683 if( !_lChild->equivalent(globals, mRule2->_lChild) )
3690 if( !_rChild->equivalent(globals, mRule2->_rChild) )
3703 bool MatchNode::equivalent(FormDict &globals, MatchNode *mNode2) {
3710 const Form *form = globals[_opType];
3711 const Form *form2 = globals[mNode2->_opType];
3718 if( !_lChild->equivalent(globals, mNode2->_lChild) )
3725 if( !_rChild->equivalent(globals, mNode2->_rChild) )
3753 FormDict &globals = _AD.globalNames();
3754 const Form *form = globals[_rChild->_opType];
3757 if( oper && oper->interface_type(globals) == Form::constant_interface )
3860 bool MatchRule::base_operand(uint &position0, FormDict &globals,
3865 return (MatchNode::base_operand( position, globals, result, name, opType));
3869 bool MatchRule::is_base_register(FormDict &globals) const {
3874 if (!base_operand(position, globals, result, name, opType)) {
3876 if( base_operand(position, globals, result, name, opType) &&
3894 Form::DataType MatchRule::is_base_constant(FormDict &globals) const {
3899 if (!base_operand(position, globals, result, name, opType)) {
3901 if (base_operand(position, globals, result, name, opType)) {
3908 bool MatchRule::is_chain_rule(FormDict &globals) const {
3912 const Form *form = globals[_opType];
3921 const Form *form = globals[rch];