Lines Matching defs:is
5 * This code is free software; you can redistribute it and/or modify it
9 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * version 2 for more details (a copy is included in the LICENSE file that
127 // Examine each component to see if it is a TEMP
247 // Return 'true' if this instruction is too complex to rematerialize.
249 // We can prove it is cheap if it has an empty encoding.
262 // Has an empty encoding if _size is a constant zero or there
360 // Check MatchRule to see if the first entry is the ideal "Return" node
397 // Check MatchRule to see if the first entry is the ideal "Call" node
447 // If this is not required, return 0
454 // Check if there is a DEF
456 // Check that this is a register
465 // Check if a component has the same name and is a USE
498 // The source of the chain rule is 'position = 1'
503 // Here base_operand is looking for an ideal type to be returned (opType).
539 // Ugly: until a better fix is implemented, disable rematerialization for
546 if( _components.count() == 1 && _components[0]->is(Component::USE_DEF) )
555 _components[0]->is(Component::DEF) &&
676 assert(0 == strcmp(last_memory_DEF, comp->_name), "every memory DEF is followed by a USE of the same name");
692 //fprintf(stderr, "Warning: chain rule is not really a memory user.\n");
721 // process the unique DEF or USE, if there is one
755 // Expected use is for pointer vs oop determination for LoadP
833 // This is a recursive invocation on all operands in the matchrule
841 // This is a recursive invocation on all operands in the matchrule
880 // The AD file writer is shielded from knowledge of these edges.
885 // The AD file writer is shielded from knowledge of these edges.
913 has_temp |= e->is(Component::TEMP);
954 // Check if there is a new effect that requires an extra component.
955 // This happens when adding 'USE' to a component that is not yet one.
1033 // Above is only a conservative estimate
1083 // Override this if the rule is a store operation:
1092 // Return NULL if there is no right hand side
1195 // Record that a stack-version of the reg_mask is needed
1337 // Do it only if there is a match rule and no expand rule. With an
1338 // expand rule it is done by creating new mach node in Expand()
1356 // The next code is copied from the method operand_position().
1358 // When the first component is not a DEF,
1401 // idx0=0 is used to indicate that info comes from this same node, not from input edge.
1422 // This value is used by generate_peepreplace when copying a node.
1546 assert( encClass != NULL, "Encode Class is missing.");
1622 // is actually a local variable for this encode class, or a reserved name
1837 // True if this component is equal to the parameter.
1838 bool Effect::is(int use_def_kill_enum) const {
1841 // True if this component is used/def'd/kill'd as the parameter suggests.
1955 assert( operand, "Entry in operand class that is not an operand");
1975 assert( operand, "Entry in operand class that is not an operand");
2072 // This is a recursive invocation on all operands in the matchrule
2080 // This is a recursive invocation on all operands in the matchrule
2088 // This is a recursive invocation on all operands in the matchrule
2121 // Check if this operand is usable for cisc-spilling
2157 // Return ideal type, if there is a single ideal type for this operand
2170 assert( reg_class != NULL, "Register class is not defined");
2199 // If there is a single ideal type for this interface field, return it.
2205 // Check if "field" is valid for this operand's interface
2243 // Check if this is a valid field for this operand,
2279 // This function is not looking for an ideal type. It needs the first
2295 // Increment our target leaf position if current leaf is not a candidate.
2299 // May iterate through all base operands if reg_class for 'leaf' is NULL
2399 // Return NULL if there is no right hand side
2414 // Check it is a memory interface with a non-user-constant disp field
2431 // Check if this is a ConP, which may require relocation
2471 // Similar to "int_format" but for cases where data is external to operand
2525 // Current operand is THE operand
2534 // Check that "type" is a 'ConI', 'ConP', ...
2565 // "true" if this operand is a simple type that is swallowed
2842 // True if this component is equal to the parameter.
2843 bool Component::is(int use_def_kill_enum) const {
2846 // True if this component is used/def'd/kill'd as the parameter suggests.
2951 // When there are no components, or the first component is a USE,
2970 // if parameter 'usedef' is ::USE, it will match USE, USE_DEF, ...
2979 // When the first component is not a DEF,
2986 // When the first entry in the component list is a DEF and a USE
3002 fprintf(stderr, "the name '%s' is too late in its name list", name);
3034 // When the first component is not a DEF,
3064 // When the first component is not a DEF,
3087 // When the first component is not a DEF,
3179 // If _opType is not an operation, do not build a component for it #####
3234 // if this is user-defined, recurse on match rule
3312 // If there is no right reduction, return NULL.
3320 // If our right child exists, it is the right reduction
3330 // If there is no left reduction, return NULL.
3338 // If our left child exists, it is the left reduction
3369 // Build a path to 'name' in buf. Actually only build if cnt is zero, so we
3507 // neither side is spillable, nor prevents cisc spilling
3511 // right side is spillable
3515 // left side is spillable
3597 // If cisc is still possible, check rest of tree
3750 // Don't swap if right operand is an immediate constant.
3859 // The MatchNode that is called first treats its
3913 // If this is ideal, then it is a base match, not a chain rule.
4121 // Some loads operate on what is effectively immutable memory so we
4181 // Make sure it is an integer constant: