Lines Matching refs:operand
53 _cisc_spill_operand = Not_cisc_spillable;// Which operand may cisc-spill
85 _cisc_spill_operand = Not_cisc_spillable;// Which operand may cisc-spill
179 // operand ideal Opcode instead.
183 assert( src_op, "Not operand class of chain rule" );
610 // Check if instruction has a USE of a memory operand class, but no defs
654 // Check if instruction has a USE of a memory operand class, or a def.
829 // Return the number of leaves below this complex operand
892 // by writing the operand names into the _components list.
916 // uses so their operand numbering must directly follow the real
1034 // because it did not check contents of operand classes.
1036 // Add 1 to reloc info for each operand class in the component list.
1091 // Return the name of the operand on the right hand side of the binary match
1193 fprintf(stderr, " using operand %s %s at index %d\n", reg_type, op_name, cisc_spill_operand);
1198 assert( oper != NULL, "cisc-spilling non operand");
1311 // Output the format call for this operand
1359 // leave space for the result operand!
1395 // Generate index values needed for determining the operand position
1397 uint idx = 0; // position of operand in match rule
1400 // Compute the index into vector of operand pointers:
1433 // Check that a "label" operand occurs last in the operand list, if present
1468 // Build instruction predicates. If the user uses the same operand name
1587 // Verify operand types in parameter list
1890 // iterate over the operand list
1954 OperandForm *operand = form->is_operand();
1955 assert( operand, "Entry in operand class that is not an operand");
1958 interface = operand->interface_type(globals);
1960 interface = (interface == operand->interface_type(globals) ? interface : Form::no_interface);
1974 OperandForm *operand = form->is_operand();
1975 assert( operand, "Entry in operand class that is not an operand");
1976 if( !operand->stack_slots_only(globals) ) return false;
2060 // Return the number of leaves below this complex operand
2068 // Return the number of constants contained within this complex operand
2084 // Return the number of pointer constants contained within this complex operand
2121 // Check if this operand is usable for cisc-spilling
2157 // Return ideal type, if there is a single ideal type for this operand
2185 // This operand matches a single type, at the top level.
2205 // Check if "field" is valid for this operand's interface
2243 // Check if this is a valid field for this operand,
2336 // Special case for operands that take a single user-defined operand
2341 // Lookup operand form for replacement variable's type
2375 // Special case for operands that take a single user-defined operand
2380 // Lookup operand form for component's type
2398 // Return the name of the operand on the right hand side of the binary match
2421 // Lookup replacement variable in operand's component list
2425 // Lookup operand form for replacement variable's type
2430 assert( op, "Memory Interface 'disp' can only emit an operand form");
2471 // Similar to "int_format" but for cases where data is external to operand
2512 // Return the operand form corresponding to the given index, else NULL.
2525 // Current operand is THE operand
2551 // If this operand has a single ideal type, return its type
2565 // "true" if this operand is a simple type that is swallowed
2579 assert( oper, "Index exceeds number of constants in operand");
2952 // then we add '1' to hold a space for the 'result' operand.
2955 uint count = 1; // result operand
2969 // Return zero-based position of operand 'name' in list; -1 if not in list.
2980 // leave space for the result operand!
3035 // leave space for the result operand!
3065 // leave space for the result operand!
3088 // leave space for the result operand!
3182 // Add non-ideals that are operands, operand-classes,
3197 // Find the n'th base-operand in the match node,
3225 // User operand or instruction?
3235 // User-defined operand and instruction forms have a match-rule.
3416 // Add the internal operand name to the MatchNode
3428 fprintf(fp," %s",_name); // operand
3432 if(_lChild) _lChild->output(fp); // left operand
3433 if(_rChild) _rChild->output(fp); // right operand
3491 assert( src_op, "Not operand class of chain rule" );
3543 int MatchNode::cisc_spill_match(FormDict& globals, RegisterForm* registers, MatchNode* mRule2, const char* &operand, const char* ®_type) {
3579 operand = _name;
3589 operand = _name;
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);
3628 MatchRule* mRule2, const char* &operand,
3651 // Check right operands: recursive walk to identify reg->mem operand
3655 right_spillable = _rChild->cisc_spill_match(globals, registers, mRule2->_rChild, operand, reg_type);
3750 // Don't swap if right operand is an immediate constant.
3795 // If not the root, reduce this subtree to an internal operand