dist/gcc/genrecog.c

210 /* The position of an rtx relative to X0.  Each useful position is
212 struct position
214   /* The parent rtx.  This is the root position for POS_PEEP2_INSNs.  */
215   struct position *base;
217   /* A position with the same BASE and TYPE, but with the next value
219   struct position *next;
224   struct position *xexps;
229   struct position *xvecexp0s;
231   /* The type of position.  */
237   /* The instruction to which the position belongs.  */
240   /* The depth of this position relative to the instruction pattern.
245   /* A unique identifier for this position.  */
253 /* The root position (x0).  */
254 static struct position root_pos;
257    position id.  */
260 /* A list of all POS_PEEP2_INSNs.  The entry for insn 0 is the root position,
262 static struct position *peep2_insn_pos_list = &root_pos;
265 /* Return a position with the given BASE, TYPE and ARG.  NEXT_PTR
266    points to where the unique object that represents the position
270 static struct position *
271 next_position (struct position **next_ptr, struct position *base,
274   struct position *pos;
279       pos = XCNEW (struct position);
303 compare_positions (struct position *pos1, struct position *pos2)
327 /* Return the most deeply-nested position that is common to both
331 static struct position *
332 common_position (struct position *pos1, struct position *pos2)
1084   /* The deepest root position from which S can access all the rtxes it needs.
1087   position *pos;
1183   /* The position of rtx X in the above description, relative to the
1184      incoming instruction "insn".  The position is null if the test
1186   position *pos;
1218   static rtx_test code (position *);
1219   static rtx_test mode (position *);
1220   static rtx_test regno_field (position *);
1221   static rtx_test subreg_field (position *);
1222   static rtx_test int_field (position *, int);
1223   static rtx_test wide_int_field (position *, int);
1224   static rtx_test veclen (position *);
1226   static rtx_test veclen_ge (position *, int);
1227   static rtx_test predicate (position *, const pred_data *, machine_mode);
1228   static rtx_test duplicate (position *, int);
1229   static rtx_test pattern (position *, pattern_use *);
1232   static rtx_test set_op (position *, int);
1239   rtx_test (position *, kind_enum);
1244 rtx_test::rtx_test (position *pos_in, kind_enum kind_in)
1248 rtx_test::code (position *pos)
1254 rtx_test::mode (position *pos)
1260 rtx_test::regno_field (position *pos)
1267 rtx_test::subreg_field (position *pos)
1274 rtx_test::int_field (position *pos, int opno)
1282 rtx_test::wide_int_field (position *pos, int opno)
1290 rtx_test::veclen (position *pos)
1304 rtx_test::veclen_ge (position *pos, int min_len)
1312 rtx_test::predicate (position *pos, const struct pred_data *data,
1323 rtx_test::duplicate (position *pos, int opno)
1331 rtx_test::pattern (position *pos, pattern_use *pattern)
1353 rtx_test::set_op (position *pos, int opno)
1786   /* A mask of TESTED_ values for each position, indexed by the position's
1883    WITH_POSITION_P is true if only tests with position POS should be tried,
1891 		  position *pos, bool worthwhile_single_p,
1943    Also try to bunch tests for the same position together.  POS is the
1944    position of the rtx tested before reaching S.  KC are the conditions
1948 cse_tests (position *pos, state *s, known_conditions *kc)
1962 	    /* Try to find other conditions related to position POS
1963 	       before moving to the new position.  Again, this is
1965 	       since it means that fewer position variables are live
2091    If OPERAND_POS[ID] >= 0, the position with id ID is stored in
2352   merge_state_result (merge_pattern_info *, position *, merge_state_result *);
2358      the state should pass the rtx at position ROOT to the pattern's
2361   position *root;
2374 					position *root_in,
2582 merge_relative_positions (position **roota, position *a,
2583 			  position *rootb, position *b)
2679   /* If D2 tests a position, SINFO1's root relative to D1 is the same
2681   position *root1 = 0;
2682   position *root2 = res2->root;
2851      so each return value always refers to the same position within
3202       position *root2 = (d2->test.pos_operand < 0 ? d2->test.pos : 0);
3257 	       First update the root position so that it can reach
3424 	     change of position is required.  We'll output this chain as a
3880 /* Pairs a pattern that needs to be matched with the rtx position at
3885   pattern_pos (rtx, position *);
3888   position *pos;
3891 pattern_pos::pattern_pos (rtx pattern_in, position *pos_in)
3896    be two entries at the same position.  */
3906 /* Add new decisions to S that check whether the rtx at position POS
3911 match_pattern_2 (state *s, md_rtx_info *info, position *pos, rtx pattern)
3994 		position **subpos_ptr;
4011 		    position *subpos = next_position (subpos_ptr, pos,
4032 	    position **subpos_ptr = &pos->xexps;
4035 		position *subpos = next_position (subpos_ptr, pos,
4052 		      position **subpos2_ptr = &pos->xvecexp0s;
4055 			  position *subpos2 = next_position (subpos2_ptr, pos,
4205       position **subpos_ptr = &peep2_insn_pos_list;
4210 	  position *subpos = next_position (subpos_ptr, &root_pos,
4413   /* Maps position ids to xN variable numbers.  The entry is only valid if
4414      it is less than the length of VAR_TO_ID, but this holds for every position
4418   /* Maps xN variable numbers to position ids.  */
4487 change_state (output_state *os, position *pos, unsigned int indent)
5085 /* Make sure that OS has a position variable for POS.  ROOT_P is true if
5086    POS is the root position for the routine.  */
5089 assign_position_var (output_state *os, position *pos, bool root_p)
5100 /* Make sure that OS has the position variables required by S.  */
5119    so that every relevant position has an rtx variable xN and so that
5123 print_subroutine_start (output_state *os, state *s, position *root)
5131       /* Create a fake entry for position 0 so that an id_to_var of 0