contrib/gcc/genrecog.c

74 /* A single test.  The two accept types aren't tests per-se, but
80   /* A linked list through the tests attached to a node.  */
128   struct decision *prev;	/* Node whose failure tests us.  */
134   struct decision_test *tests;	/* The tests for this node.  */
920   place = &this->tests;
1088   /* Do tests against the current node first.  */
1167       place = &this->tests;
1174       place = &this->tests;
1179   /* If we didn't insert any tests or accept nodes, hork.  */
1180   gcc_assert (this->tests);
1236       /* If D2 tests a mode, see if it matches D1.  */
1257 	  /* If D2 tests a code, see if it is in the list of valid
1293 /* A subroutine of maybe_both_true; examines all the tests for a given node.
1306   /* Eliminate pairs of tests while they can exactly match.  */
1374   cmp = maybe_both_true_1 (d1->tests, d2->tests);
1395 /* A subroutine of nodes_identical.  Examine two tests for equivalence.  */
1445    consider different orderings on the tests.  */
1452   for (t1 = d1->tests, t2 = d2->tests; t1 && t2; t1 = t1->next, t2 = t2->next)
1488   for (old = oldd->tests; old; old = old->next)
1494   for (add = addd->tests; add; add = add->next)
1549       /* The semantics of pattern matching state that the tests are
1554 	 identical tests and group all similar modes and codes together.
1560 	 last node that tests the same code and mode and the last one
1561 	 that tests just the same mode.
1578 	     how expensive/important the test is.  Given that the tests
1581 	  if ((int) add->tests->type < (int) old->tests->type)
1607 /* Walk the tree looking for sub-nodes that perform common tests.
1621       type = first->tests->type;
1625       if (next->tests->type != type)
1640       if (first->tests->next != NULL)
1643 	  new->tests = first->tests->next;
1644 	  first->tests->next = NULL;
1658 	  if (next->tests->next != NULL)
1661 	      new->tests = next->tests->next;
1662 	      next->tests->next = NULL;
1671       while (next && next->tests->type == type);
1673       /* After we run out of compatible tests, graft the remaining nodes
1688 /* After factoring, try to simplify the tests on any one node.
1691    nodes with multiple tests:
1693    If we have mode tests or code tests that are redundant with
1705       a = tree->tests;
1715 	  /* Due to how these tests are constructed, we don't even need
1720 	  tree->tests = a;
1889   enum decision_type type = p->tests->type;
1896       || p->tests->next
1897       || p->next->tests->type != type
1898       || p->next->tests->next
1899       || nodes_identical_1 (p->tests, p->next->tests))
1913       code = p->tests->u.code;
1928 	     && ! p->tests->next
1929 	     && p->tests->type == DT_code
1930 	     && ! codemap[code = p->tests->u.code]);
1935 	 Since we are already in a switch, these redundant tests are very
1941 	 we only processed the CODE tests.  */
1947       while (p && p->tests->type == DT_pred && p->tests->u.pred.data)
1949 	  const struct pred_data *data = p->tests->u.pred.data;
2036 	    if (nodes_identical_1 (p->tests, q->tests))
2046 	      printf ("%smode", GET_MODE_NAME (p->tests->u.mode));
2049 	      printf ("%d", p->tests->u.veclen);
2055 	      print_host_wide_int (p->tests->u.intval);
2065       while (p && p->tests->type == type && !p->tests->next);
2075       /* None of the other tests are amenable.  */
2152 /* Emit code for one action.  The previous tests have succeeded;
2154    perform a state change.  For the `accept' tests we must do more work.  */
2187   /* Sanity check that we're now at the end of the list of tests.  */
2278   /* Scan the tests and simplify comparisons against small
2280   for (test = p->tests; test; test = test->next)
2295   last_test = test = p->tests;
2602   for (test = last->tests; test->next; test = test->next)
2613 	  place = &last->tests;
2668 	      for (test = last->tests; test->next; test = test->next)
2677 		  place = &last->tests;
2731 	 the redundant DT_mode tests on predicates to determine whether
2732 	 two tests can both be true or not.  */
2889   test = d->tests;