439                 ret = state1;
 440         else if (__has_merge_function(owner))
 441                 ret = __client_merge_function(owner, state1, state2);
 442         else if (state1 == &ghost)
 443                 ret = state2;
 444         else if (state2 == &ghost)
 445                 ret = state1;
 446         else if (!state1 || !state2)
 447                 ret = &undefined;
 448         else
 449                 ret = &merged;
 450         return ret;
 451 }
 452 
 453 struct sm_state *merge_sm_states(struct sm_state *one, struct sm_state *two)
 454 {
 455         struct smatch_state *s;
 456         struct sm_state *result;
 457         static int warned;
 458 



 459         if (one == two)
 460                 return one;
 461         if (out_of_memory()) {
 462                 if (!warned)
 463                         sm_warning("Function too hairy.  No more merges.");
 464                 warned = 1;
 465                 return one;
 466         }
 467         warned = 0;
 468         s = merge_states(one->owner, one->name, one->sym, one->state, two->state);
 469         result = alloc_state_no_name(one->owner, one->name, one->sym, s);
 470         result->merged = 1;
 471         result->left = one;
 472         result->right = two;
 473 
 474         copy_possibles(result, one, two);
 475 
 476         /*
 477          * The ->line information is used by deref_check where we complain about
 478          * checking pointers that have already been dereferenced.  Let's say we

 439                 ret = state1;
 440         else if (__has_merge_function(owner))
 441                 ret = __client_merge_function(owner, state1, state2);
 442         else if (state1 == &ghost)
 443                 ret = state2;
 444         else if (state2 == &ghost)
 445                 ret = state1;
 446         else if (!state1 || !state2)
 447                 ret = &undefined;
 448         else
 449                 ret = &merged;
 450         return ret;
 451 }
 452 
 453 struct sm_state *merge_sm_states(struct sm_state *one, struct sm_state *two)
 454 {
 455         struct smatch_state *s;
 456         struct sm_state *result;
 457         static int warned;
 458 
 459         if (one->state->data && !has_dynamic_states(one->owner))
 460                 sm_msg("dynamic state: %s", show_sm(one));
 461 
 462         if (one == two)
 463                 return one;
 464         if (out_of_memory()) {
 465                 if (!warned)
 466                         sm_warning("Function too hairy.  No more merges.");
 467                 warned = 1;
 468                 return one;
 469         }
 470         warned = 0;
 471         s = merge_states(one->owner, one->name, one->sym, one->state, two->state);
 472         result = alloc_state_no_name(one->owner, one->name, one->sym, s);
 473         result->merged = 1;
 474         result->left = one;
 475         result->right = two;
 476 
 477         copy_possibles(result, one, two);
 478 
 479         /*
 480          * The ->line information is used by deref_check where we complain about
 481          * checking pointers that have already been dereferenced.  Let's say we