12166 resync smatch to 0.6.1-rc1-il-3

@@ -140,14 +140,17 @@
             rl_equiv(orig_rl, true_rl) || rl_equiv(orig_rl, false_rl) ||
             rl_equiv(estate_rl(sm->state), true_rl) || rl_equiv(estate_rl(sm->state), false_rl))
                 return 0;
 
         if (rl_intersection(true_rl, false_rl)) {
-                sm_perror("parsing (%s (%s) %s %s)",
-                        sm->name, sm->state->name, show_special(comparison), show_rl(rl));
-                sm_msg("true_rl = %s false_rl = %s intersection = %s",
-                       show_rl(true_rl), show_rl(false_rl), show_rl(rl_intersection(true_rl, false_rl)));
+                /*
+                 * Normally these won't intersect, but one exception is when
+                 * we're dealing with mtags.  We have a long list of mtags and
+                 * then negate the list.  Now it's over the limit for mtag list
+                 * length and we squash it down to 4096-ptr_max.  So then it's
+                 * possible for the true and false rl to overlap.
+                 */
                 return 0;
         }
 
         if (implied_debug)
                 sm_msg("fake_history: %s vs %s.  %s %s %s. --> T: %s F: %s",

@@ -805,10 +808,35 @@
                 return handle_comparison(expr, implied_true, implied_false);
         else
                 return handle_zero_comparison(expr, implied_true, implied_false);
 }
 
+static int handled_by_parsed_conditions(struct expression *expr,
+                                        struct stree **implied_true,
+                                        struct stree **implied_false)
+{
+        struct state_list *true_stack = NULL;
+        struct state_list *false_stack = NULL;
+        struct stree *pre_stree;
+        struct sm_state *sm;
+
+        sm = parsed_condition_implication_hook(expr, &true_stack, &false_stack);
+        if (!sm)
+                return 0;
+
+        pre_stree = clone_stree(__get_cur_stree());
+
+        *implied_true = filter_stack(sm, pre_stree, false_stack, true_stack);
+        *implied_false = filter_stack(sm, pre_stree, true_stack, false_stack);
+
+        free_stree(&pre_stree);
+        free_slist(&true_stack);
+        free_slist(&false_stack);
+
+        return 1;
+}
+
 static int handled_by_stored_conditions(struct expression *expr,
                                         struct stree **implied_true,
                                         struct stree **implied_false)
 {
         struct state_list *true_stack = NULL;

@@ -835,26 +863,27 @@
 static struct stree *saved_implied_true;
 static struct stree *saved_implied_false;
 static struct stree *extra_saved_implied_true;
 static struct stree *extra_saved_implied_false;
 
-static void separate_extra_states(struct stree **implied_true,
-                                  struct stree **implied_false)
+static void separate_implication_states(struct stree **implied_true,
+                                         struct stree **implied_false,
+                                         int owner)
 {
         struct sm_state *sm;
 
-        /* We process extra states later to preserve the implications. */
+        /* We process these states later to preserve the implications. */
         FOR_EACH_SM(*implied_true, sm) {
-                if (sm->owner == SMATCH_EXTRA)
+                if (sm->owner == owner)
                         overwrite_sm_state_stree(&extra_saved_implied_true, sm);
         } END_FOR_EACH_SM(sm);
         FOR_EACH_SM(extra_saved_implied_true, sm) {
                 delete_state_stree(implied_true, sm->owner, sm->name, sm->sym);
         } END_FOR_EACH_SM(sm);
 
         FOR_EACH_SM(*implied_false, sm) {
-                if (sm->owner == SMATCH_EXTRA)
+                if (sm->owner == owner)
                         overwrite_sm_state_stree(&extra_saved_implied_false, sm);
         } END_FOR_EACH_SM(sm);
         FOR_EACH_SM(extra_saved_implied_false, sm) {
                 delete_state_stree(implied_false, sm->owner, sm->name, sm->sym);
         } END_FOR_EACH_SM(sm);

@@ -862,15 +891,20 @@
 
 static void get_tf_states(struct expression *expr,
                           struct stree **implied_true,
                           struct stree **implied_false)
 {
-        if (handled_by_comparison_hook(expr, implied_true, implied_false))
+        if (handled_by_parsed_conditions(expr, implied_true, implied_false))
                 return;
 
+        if (handled_by_comparison_hook(expr, implied_true, implied_false)) {
+                separate_implication_states(implied_true, implied_false, comparison_id);
+                return;
+        }
+
         if (handled_by_extra_states(expr, implied_true, implied_false)) {
-                separate_extra_states(implied_true, implied_false);
+                separate_implication_states(implied_true, implied_false, SMATCH_EXTRA);
                 return;
         }
 
         if (handled_by_stored_conditions(expr, implied_true, implied_false))
                 return;

@@ -1136,10 +1170,10 @@
 void register_implications(int id)
 {
         add_hook(&save_implications_hook, CONDITION_HOOK);
         add_hook(&set_implied_states, CONDITION_HOOK);
         add_hook(&__extra_match_condition, CONDITION_HOOK);
-        add_hook(&set_extra_implied_states, CONDITION_HOOK);
         add_hook(&__comparison_match_condition, CONDITION_HOOK);
+        add_hook(&set_extra_implied_states, CONDITION_HOOK);
         add_hook(&__stored_condition, CONDITION_HOOK);
         add_hook(&match_end_func, END_FUNC_HOOK);
 }