gcc/gcc/genrecog.c

127 /* A single test.  The two accept types aren't tests per-se, but
133   /* A linked list through the tests attached to a node.  */
172   struct decision *prev;	/* Node whose failure tests us.  */
178   struct decision_test *tests;	/* The tests for this node.  */
721   place = &this_decision->tests;
897   /* Do tests against the current node first.  */
982       place = &this_decision->tests;
989       place = &this_decision->tests;
994   /* If we didn't insert any tests or accept nodes, hork.  */
995   gcc_assert (this_decision->tests);
1050       /* If D2 tests a mode, see if it matches D1.  */
1071 	  /* If D2 tests a code, see if it is in the list of valid
1107 /* A subroutine of maybe_both_true; examines all the tests for a given node.
1120   /* Eliminate pairs of tests while they can exactly match.  */
1188   cmp = maybe_both_true_1 (d1->tests, d2->tests);
1209 /* A subroutine of nodes_identical.  Examine two tests for equivalence.  */
1259    consider different orderings on the tests.  */
1266   for (t1 = d1->tests, t2 = d2->tests; t1 && t2; t1 = t1->next, t2 = t2->next)
1302   for (old = oldd->tests; old; old = old->next)
1308   for (add = addd->tests; add; add = add->next)
1362       /* The semantics of pattern matching state that the tests are
1367 	 identical tests and group all similar modes and codes together.
1373 	 last node that tests the same code and mode and the last one
1374 	 that tests just the same mode.
1391 	     how expensive/important the test is.  Given that the tests
1394 	  if ((int) add->tests->type < (int) old->tests->type)
1420 /* Walk the tree looking for sub-nodes that perform common tests.
1434       type = first->tests->type;
1438       if (next->tests->type != type)
1453       if (first->tests->next != NULL)
1456 	  new_dec->tests = first->tests->next;
1457 	  first->tests->next = NULL;
1471 	  if (next->tests->next != NULL)
1474 	      new_dec->tests = next->tests->next;
1475 	      next->tests->next = NULL;
1484       while (next && next->tests->type == type);
1486       /* After we run out of compatible tests, graft the remaining nodes
1501 /* After factoring, try to simplify the tests on any one node.
1504    nodes with multiple tests:
1506    If we have mode tests or code tests that are redundant with
1518       a = tree->tests;
1528 	  /* Due to how these tests are constructed, we don't even need
1533 	  tree->tests = a;
1691   enum decision_type type = p->tests->type;
1698       || p->tests->next
1699       || p->next->tests->type != type
1700       || p->next->tests->next
1701       || nodes_identical_1 (p->tests, p->next->tests))
1715       code = p->tests->u.code;
1730 	     && ! p->tests->next
1731 	     && p->tests->type == DT_code
1732 	     && ! codemap[code = p->tests->u.code]);
1737 	 Since we are already in a switch, these redundant tests are very
1743 	 we only processed the CODE tests.  */
1749       while (p && p->tests->type == DT_pred && p->tests->u.pred.data)
1751 	  const struct pred_data *data = p->tests->u.pred.data;
1840 	    if (nodes_identical_1 (p->tests, q->tests))
1850 	      printf ("%smode", GET_MODE_NAME (p->tests->u.mode));
1853 	      printf ("%d", p->tests->u.veclen);
1859 	      print_host_wide_int (p->tests->u.intval);
1869       while (p && p->tests->type == type && !p->tests->next);
1879       /* None of the other tests are amenable.  */
1956 /* Emit code for one action.  The previous tests have succeeded;
1958    perform a state change.  For the `accept' tests we must do more work.  */
1991   /* Sanity check that we're now at the end of the list of tests.  */
2083   /* Scan the tests and simplify comparisons against small
2085   for (test = p->tests; test; test = test->next)
2100   last_test = test = p->tests;
2430   for (test = last->tests; test->next; test = test->next)
2441 	  place = &last->tests;
2497 	      for (test = last->tests; test->next; test = test->next)
2506 		  place = &last->tests;
2560 	 the redundant DT_mode tests on predicates to determine whether
2561 	 two tests can both be true or not.  */
2713   test = d->tests;