Lines Matching refs:routine
54 1. Build up a decision tree for each routine, using the following
78 In the latter case the users of the pattern routine pass the
91 then we can consider using the same matching routine for both
144 a pattern routine to be shared between a plain SET and a PARALLEL
163 /* Whether to require each parameter passed to a pattern routine to be
171 routine or subroutine should have. This limit is about keeping the
186 routine. */
189 /* The maximum number of arguments that a pattern routine can have.
192 routine instead. */
958 /* Describes a possible successful return from a routine. */
961 /* The type of routine we're returning from. */
981 value belongs to an ad-hoc routine-specific enum. For the
1015 /* Represents a parameter to a pattern routine. */
1074 /* Represents a routine that matches a partial rtx pattern, returning
1075 an ad-hoc enum value on success and -1 on failure. The routine can
1089 /* A unique identifier for the routine. */
1092 /* True if the routine takes pnum_clobbers as argument. */
1095 /* True if the routine takes the enclosing instruction as argument. */
1098 /* The types of the other parameters to the routine, if any. */
1105 /* Represents one use of a pattern routine. */
1109 /* The pattern routine to use. */
1110 pattern_routine *routine;
1207 to the routine rather than a constant machine_mode. If true,
1419 return (a.u.pattern->routine == b.u.pattern->routine
2111 /* Statistics about a matching routine. */
2117 /* The total number of decisions in the routine, excluding trivial
2122 the routine, and the return value that contributes most to that
2127 /* The maximum number of times that a single call to the routine
2328 /* The routine associated with the pattern, or null if we haven't generated
2330 pattern_routine *routine;
2342 routine (0)
2396 pattern routine. */
2424 into PAT1's C routine. */
2518 to a pattern routine. It is still incomplete; index I has a kind of
2843 routine. */
2846 /* The routine itself. */
2847 pattern_routine *routine;
2860 /* SINFO matches a pattern for which we've decided to create a C routine.
2861 Return a decision that performs a call to the pattern routine,
2863 for this purpose. Also create a definition for the pattern routine,
2875 cpi->routine = pat->routine;
2876 if (!cpi->routine)
2878 /* We haven't defined the pattern routine yet, so create
2880 pattern_routine *routine = new pattern_routine;
2881 pat->routine = routine;
2882 cpi->routine = routine;
2883 routine->s = new state;
2884 routine->insn_p = false;
2885 routine->pnum_clobbers_p = false;
2888 Also record the C type of each parameter to the routine. */
2893 routine->param_types.quick_push (pat->params[i].type);
2897 create the routine definition. We might as well use SINFO
2900 routine->pos = res->root;
2902 populate_pattern_routine (cpi, sinfo, routine->s, def_params);
2905 /* Add the routine to the global list, after the subroutines
2907 routine->pattern_id = patterns.length ();
2908 patterns.safe_push (routine);
2911 /* Create a decision to call the routine, passing PARAMS to it. */
2913 use->routine = pat->routine;
2926 /* Make S return the next unclaimed pattern routine result for CPI. */
2940 (here referred to as "P"). P may be the top level of a pattern routine
2941 or a subpattern that should be inlined into its parent pattern's routine
2958 pattern_routine *routine = cpi->routine;
2960 /* Create a copy of D's test for the pattern routine and generalize it
2966 routine->pos) == routine->pos);
2988 routine->insn_p = true;
2990 routine->pnum_clobbers_p = true;
3020 /* TO_PAT is part of the current routine, so just recurse. */
3024 /* TO_PAT should be matched by calling a separate routine. */
3027 routine->insn_p |= sub_cpi.routine->insn_p;
3028 routine->pnum_clobbers_p |= sub_cpi.routine->pnum_clobbers_p;
3030 /* Add the pattern routine call to the new target state. */
3060 /* USE is a decision that calls a pattern routine and SINFO is part of the
3083 pattern routine. */
3092 routine. Make the change, creating a definition of the pattern routine
3448 /* Keeping the target state in the same routine would lead
3458 Keep it in the same routine as S. */
3462 same routine as S, but record it as a subroutine candidate
4373 peephole2 routine. */
4379 /* Return the C failure value for a routine of type TYPE. */
4410 /* The type of routine that we're generating. */
4425 /* Return true if D is a call to a pattern routine and if there is some X
4638 pattern_routine *routine = test.u.pattern->routine;
4639 printf ("pattern%d (", routine->pattern_id);
4646 if (routine->insn_p)
4651 if (routine->pnum_clobbers_p)
4785 if the state fails then the entire routine fails. */
4911 /* Look for cases where a pattern routine P1 calls another pattern routine
5086 POS is the root position for the routine. */
5116 /* Print the open brace and variable definitions for a routine that
5164 /* Output the definition of pattern routine ROUTINE. */
5167 print_pattern (output_state *os, pattern_routine *routine)
5169 printf ("\nstatic int\npattern%d (", routine->pattern_id);
5172 if (routine->pos)
5178 if (routine->insn_p)
5185 if (routine->pnum_clobbers_p)
5191 for (unsigned int i = 0; i < routine->param_types.length (); ++i)
5194 parameter_type_string (routine->param_types[i]), i + 1);
5199 print_subroutine_start (os, routine->s, routine->pos);
5200 print_state (os, routine->s, 2, true);
5204 /* Output a routine of type TYPE that implements S. PROC_ID is the
5206 routine. */
5254 /* Print out a routine of type TYPE that performs ROOT. */
5273 /* Output the main routine. */
5394 /* Declare the gen_split routine that we'll call if the
5406 /* Declare the gen_peephole2 routine that we'll call if the
5422 /* Optimize each routine in turn. */
5441 pattern_routine *routine;
5442 FOR_EACH_VEC_ELT (patterns, i, routine)
5443 print_pattern (&os, routine);