smatch_extra.c

   1 /*
   2  * sparse/smatch_extra.c
   3  *
   4  * Copyright (C) 2008 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * smatch_extra.c is supposed to track the value of every variable.
  12  *
  13  */
  14
  15 #include <stdlib.h>
  16 #include <errno.h>
  17 #ifndef __USE_ISOC99
  18 #define __USE_ISOC99
  19 #endif
  20 #include <limits.h>
  21 #include "parse.h"
  22 #include "smatch.h"
  23 #include "smatch_slist.h"
  24 #include "smatch_extra.h"
  25
  26 static int my_id;
  27
  28 struct string_list *__ignored_macros = NULL;
  29 static int in_warn_on_macro()
  30 {
  31         struct statement *stmt;
  32         char *tmp;
  33         char *macro;
  34
  35         stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
  36         macro = get_macro_name(&stmt->pos);
  37         if (!macro)
  38                 return 0;
  39
  40         FOR_EACH_PTR(__ignored_macros, tmp) {
  41                 if (!strcmp(tmp, macro))
  42                         return 1;
  43         } END_FOR_EACH_PTR(tmp);
  44         return 0;
  45 }
  46
  47 struct sm_state *set_extra_mod(const char *name, struct symbol *sym, struct smatch_state *state)
  48 {
  49         if (in_warn_on_macro())
  50                 return NULL;
  51         remove_from_equiv(name, sym);
  52         return set_state(SMATCH_EXTRA, name, sym, state);
  53 }
  54
  55 struct sm_state *set_extra_expr_mod(struct expression *expr, struct smatch_state *state)
  56 {
  57         if (in_warn_on_macro())
  58                 return NULL;
  59         remove_from_equiv_expr(expr);
  60         return set_state_expr(SMATCH_EXTRA, expr, state);
  61 }
  62
  63 /*
  64  * This is for return_implies_state() hooks which modify a SMATCH_EXTRA state
  65  */
  66 void set_extra_expr_nomod(struct expression *expr, struct smatch_state *state)
  67 {
  68         struct relation *rel;
  69         struct smatch_state *orig_state;
  70
  71         orig_state = get_state_expr(SMATCH_EXTRA, expr);
  72
  73         if (!orig_state || !get_dinfo(orig_state)->related) {
  74                 set_state_expr(SMATCH_EXTRA, expr, state);
  75                 return;
  76         }
  77
  78         FOR_EACH_PTR(get_dinfo(orig_state)->related, rel) {
  79                 sm_msg("setting %s to %s", rel->name, state->name);
  80                 set_state(SMATCH_EXTRA, rel->name, rel->sym, state);
  81                 add_equiv(state, rel->name, rel->sym);
  82         } END_FOR_EACH_PTR(rel);
  83 }
  84
  85 static void set_extra_true_false(const char *name, struct symbol *sym,
  86                         struct smatch_state *true_state,
  87                         struct smatch_state *false_state)
  88 {
  89         struct relation *rel;
  90         struct smatch_state *orig_state;
  91
  92         if (in_warn_on_macro())
  93                 return;
  94
  95         orig_state = get_state(SMATCH_EXTRA, name, sym);
  96
  97         if (!orig_state || !get_dinfo(orig_state)->related) {
  98                 set_true_false_states(SMATCH_EXTRA, name, sym, true_state, false_state);
  99                 return;
 100         }
 101
 102         // FIXME!!!!  equiv => related
 103         FOR_EACH_PTR(get_dinfo(orig_state)->related, rel) {
 104                 set_true_false_states(SMATCH_EXTRA, rel->name, rel->sym,
 105                                 true_state, false_state);
 106                 if (true_state)
 107                         add_equiv(true_state, rel->name, rel->sym);
 108                 if (false_state)
 109                         add_equiv(false_state, rel->name, rel->sym);
 110         } END_FOR_EACH_PTR(rel);
 111 }
 112
 113 static void set_extra_expr_true_false(struct expression *expr,
 114                 struct smatch_state *true_state,
 115                 struct smatch_state *false_state)
 116 {
 117         char *name;
 118         struct symbol *sym;
 119
 120         expr = strip_expr(expr);
 121         name = get_variable_from_expr(expr, &sym);
 122         if (!name || !sym)
 123                 goto free;
 124         set_extra_true_false(name, sym, true_state, false_state);
 125 free:
 126         free_string(name);
 127 }
 128
 129 struct smatch_state *filter_range(struct smatch_state *orig,
 130                                  long long filter_min, long long filter_max)
 131 {
 132         struct smatch_state *ret;
 133         struct data_info *ret_info;
 134
 135         if (!orig)
 136                 orig = extra_undefined();
 137         ret = alloc_estate_empty();
 138         ret_info = get_dinfo(ret);
 139         ret_info->value_ranges = remove_range(estate_ranges(orig), filter_min, filter_max);
 140         ret->name = show_ranges(ret_info->value_ranges);
 141         return ret;
 142 }
 143
 144 struct smatch_state *add_filter(struct smatch_state *orig, long long num)
 145 {
 146         return filter_range(orig, num, num);
 147 }
 148
 149 static struct smatch_state *merge_func(const char *name, struct symbol *sym,
 150                                        struct smatch_state *s1,
 151                                        struct smatch_state *s2)
 152 {
 153         struct data_info *info1 = get_dinfo(s1);
 154         struct data_info *info2 = get_dinfo(s2);
 155         struct data_info *ret_info;
 156         struct smatch_state *tmp;
 157         struct range_list *value_ranges;
 158         struct relation *rel;
 159         struct relation *new;
 160
 161         value_ranges = range_list_union(estate_ranges(s1), estate_ranges(s2));
 162         tmp = alloc_estate_empty();
 163         ret_info = get_dinfo(tmp);
 164         ret_info->value_ranges = value_ranges;
 165         tmp->name = show_ranges(ret_info->value_ranges);
 166         FOR_EACH_PTR(info1->related, rel) {
 167                 new = get_common_relationship(info2, rel->op, rel->name, rel->sym);
 168                 if (new)
 169                         add_related(tmp, new->op, new->name, new->sym);
 170         } END_FOR_EACH_PTR(rel);
 171         return tmp;
 172 }
 173
 174 static struct sm_state *handle_canonical_while_count_down(struct statement *loop)
 175 {
 176         struct expression *iter_var;
 177         struct expression *condition;
 178         struct sm_state *sm;
 179         long long start;
 180
 181         condition = strip_expr(loop->iterator_pre_condition);
 182         if (!condition)
 183                 return NULL;
 184         if (condition->type != EXPR_PREOP && condition->type != EXPR_POSTOP)
 185                 return NULL;
 186         if (condition->op != SPECIAL_DECREMENT)
 187                 return NULL;
 188
 189         iter_var = condition->unop;
 190         sm = get_sm_state_expr(SMATCH_EXTRA, iter_var);
 191         if (!sm)
 192                 return NULL;
 193         if (get_dinfo_min(get_dinfo(sm->state)) < 0)
 194                 return NULL;
 195         start = get_dinfo_max(get_dinfo(sm->state));
 196         if  (start <= 0)
 197                 return NULL;
 198         if (start != whole_range.max)
 199                 start--;
 200
 201         if (condition->type == EXPR_PREOP)
 202                 set_extra_expr_mod(iter_var, alloc_estate_range(1, start));
 203         if (condition->type == EXPR_POSTOP)
 204                 set_extra_expr_mod(iter_var, alloc_estate_range(0, start));
 205         return get_sm_state_expr(SMATCH_EXTRA, iter_var);
 206 }
 207
 208 static struct sm_state *handle_canonical_for_inc(struct expression *iter_expr,
 209                                                 struct expression *condition)
 210 {
 211         struct expression *iter_var;
 212         struct sm_state *sm;
 213         long long start;
 214         long long end;
 215
 216         iter_var = iter_expr->unop;
 217         sm = get_sm_state_expr(SMATCH_EXTRA, iter_var);
 218         if (!sm)
 219                 return NULL;
 220         if (!get_single_value_from_dinfo(get_dinfo(sm->state), &start))
 221                 return NULL;
 222         if (!get_implied_value(condition->right, &end))
 223                 end = whole_range.max;
 224         if (get_sm_state_expr(SMATCH_EXTRA, condition->left) != sm)
 225                 return NULL;
 226
 227         switch (condition->op) {
 228         case SPECIAL_NOTEQUAL:
 229         case '<':
 230                 if (end != whole_range.max)
 231                         end--;
 232                 break;
 233         case SPECIAL_LTE:
 234                 break;
 235         default:
 236                 return NULL;
 237         }
 238         if (end < start)
 239                 return NULL;
 240         set_extra_expr_mod(iter_var, alloc_estate_range(start, end));
 241         return get_sm_state_expr(SMATCH_EXTRA, iter_var);
 242 }
 243
 244 static struct sm_state *handle_canonical_for_dec(struct expression *iter_expr,
 245                                                 struct expression *condition)
 246 {
 247         struct expression *iter_var;
 248         struct sm_state *sm;
 249         long long start;
 250         long long end;
 251
 252         iter_var = iter_expr->unop;
 253         sm = get_sm_state_expr(SMATCH_EXTRA, iter_var);
 254         if (!sm)
 255                 return NULL;
 256         if (!get_single_value_from_dinfo(get_dinfo(sm->state), &start))
 257                 return NULL;
 258         if (!get_implied_value(condition->right, &end))
 259                 end = whole_range.max;
 260         if (get_sm_state_expr(SMATCH_EXTRA, condition->left) != sm)
 261                 return NULL;
 262
 263         switch (condition->op) {
 264         case SPECIAL_NOTEQUAL:
 265         case '>':
 266                 if (end != whole_range.min)
 267                         end++;
 268                 break;
 269         case SPECIAL_GTE:
 270                 break;
 271         default:
 272                 return NULL;
 273         }
 274         if (end > start)
 275                 return NULL;
 276         set_extra_expr_mod(iter_var, alloc_estate_range(end, start));
 277         return get_sm_state_expr(SMATCH_EXTRA, iter_var);
 278 }
 279
 280 static struct sm_state *handle_canonical_for_loops(struct statement *loop)
 281 {
 282         struct expression *iter_expr;
 283         struct expression *condition;
 284
 285         if (!loop->iterator_post_statement)
 286                 return NULL;
 287         if (loop->iterator_post_statement->type != STMT_EXPRESSION)
 288                 return NULL;
 289         iter_expr = loop->iterator_post_statement->expression;
 290         if (!loop->iterator_pre_condition)
 291                 return NULL;
 292         if (loop->iterator_pre_condition->type != EXPR_COMPARE)
 293                 return NULL;
 294         condition = loop->iterator_pre_condition;
 295
 296         if (iter_expr->op == SPECIAL_INCREMENT)
 297                 return handle_canonical_for_inc(iter_expr, condition);
 298         if (iter_expr->op == SPECIAL_DECREMENT)
 299                 return handle_canonical_for_dec(iter_expr, condition);
 300         return NULL;
 301 }
 302
 303 struct sm_state *__extra_handle_canonical_loops(struct statement *loop, struct state_list **slist)
 304 {
 305         struct sm_state *ret;
 306
 307         __push_fake_cur_slist();
 308         if (!loop->iterator_post_statement)
 309                 ret = handle_canonical_while_count_down(loop);
 310         else
 311                 ret = handle_canonical_for_loops(loop);
 312         *slist = __pop_fake_cur_slist();
 313         return ret;
 314 }
 315
 316 int __iterator_unchanged(struct sm_state *sm)
 317 {
 318         if (!sm)
 319                 return 0;
 320         if (get_sm_state(my_id, sm->name, sm->sym) == sm)
 321                 return 1;
 322         return 0;
 323 }
 324
 325 static void while_count_down_after(struct sm_state *sm, struct expression *condition)
 326 {
 327         long long after_value;
 328
 329         /* paranoid checking.  prolly not needed */
 330         condition = strip_expr(condition);
 331         if (!condition)
 332                 return;
 333         if (condition->type != EXPR_PREOP && condition->type != EXPR_POSTOP)
 334                 return;
 335         if (condition->op != SPECIAL_DECREMENT)
 336                 return;
 337         after_value = get_dinfo_min(get_dinfo(sm->state));
 338         after_value--;
 339         set_extra_mod(sm->name, sm->sym, alloc_estate(after_value));
 340 }
 341
 342 void __extra_pre_loop_hook_after(struct sm_state *sm,
 343                                 struct statement *iterator,
 344                                 struct expression *condition)
 345 {
 346         struct expression *iter_expr;
 347         char *name;
 348         struct symbol *sym;
 349         long long value;
 350         int left = 0;
 351         struct smatch_state *state;
 352         struct data_info *dinfo;
 353         long long min, max;
 354
 355         if (!iterator) {
 356                 while_count_down_after(sm, condition);
 357                 return;
 358         }
 359
 360         iter_expr = iterator->expression;
 361
 362         if (condition->type != EXPR_COMPARE)
 363                 return;
 364         if (!get_value(condition->left, &value)) {
 365                 if (!get_value(condition->right, &value))
 366                         return;
 367                 left = 1;
 368         }
 369         if (left)
 370                 name = get_variable_from_expr(condition->left, &sym);
 371         else
 372                 name = get_variable_from_expr(condition->right, &sym);
 373         if (!name || !sym)
 374                 goto free;
 375         if (sym != sm->sym || strcmp(name, sm->name))
 376                 goto free;
 377         state = get_state(my_id, name, sym);
 378         dinfo = get_dinfo(state);
 379         min = get_dinfo_min(dinfo);
 380         max = get_dinfo_max(dinfo);
 381         if (iter_expr->op == SPECIAL_INCREMENT &&
 382                 min != whole_range.min &&
 383                 max == whole_range.max) {
 384                 set_extra_mod(name, sym, alloc_estate(min));
 385         } else if (min == whole_range.min && max != whole_range.max) {
 386                 set_extra_mod(name, sym, alloc_estate(max));
 387         }
 388 free:
 389         free_string(name);
 390         return;
 391 }
 392
 393 static struct smatch_state *unmatched_state(struct sm_state *sm)
 394 {
 395         return extra_undefined();
 396 }
 397
 398 static void match_function_call(struct expression *expr)
 399 {
 400         struct expression *tmp;
 401
 402         FOR_EACH_PTR(expr->args, tmp) {
 403                 if (tmp->type == EXPR_PREOP && tmp->op == '&') {
 404                         remove_from_equiv_expr(tmp->unop);
 405                         set_state_expr(SMATCH_EXTRA, tmp->unop, extra_undefined());
 406                 }
 407         } END_FOR_EACH_PTR(tmp);
 408 }
 409
 410 static void set_equiv(struct sm_state *right_sm, struct expression *left)
 411 {
 412         struct smatch_state *state;
 413         struct data_info *dinfo;
 414         struct relation *rel;
 415         char *name;
 416         struct symbol *sym;
 417
 418         name = get_variable_from_expr(left, &sym);
 419         if (!name || !sym)
 420                 goto free;
 421
 422         remove_from_equiv(name, sym);
 423
 424         state = clone_estate(right_sm->state);
 425         dinfo = get_dinfo(state);
 426         if (!dinfo->related)
 427                 add_equiv(state, right_sm->name, right_sm->sym);
 428         add_equiv(state, name, sym);
 429
 430         FOR_EACH_PTR(dinfo->related, rel) {
 431                 struct sm_state *new_sm;
 432
 433                 new_sm = clone_sm(right_sm);
 434                 new_sm->name = rel->name;
 435                 new_sm->sym = rel->sym;
 436                 new_sm->state = state;
 437                 __set_sm(new_sm);
 438         } END_FOR_EACH_PTR(rel);
 439 free:
 440         free_string(name);
 441 }
 442
 443 static void match_assign(struct expression *expr)
 444 {
 445         struct expression *left;
 446         struct expression *right;
 447         struct sm_state *right_sm;
 448         struct symbol *right_sym;
 449         char *right_name;
 450         struct symbol *sym;
 451         char *name;
 452         long long value;
 453         int known;
 454         long long min = whole_range.min;
 455         long long max = whole_range.max;
 456         long long tmp;
 457
 458         if (__is_condition_assign(expr))
 459                 return;
 460         left = strip_expr(expr->left);
 461         name = get_variable_from_expr(left, &sym);
 462         if (!name)
 463                 return;
 464         right = strip_parens(expr->right);
 465         while (right->type == EXPR_ASSIGNMENT && right->op == '=')
 466                 right = strip_parens(right->left);
 467
 468         if (expr->op == '=' && right->type == EXPR_CALL)
 469                 return;  /* these are handled in match_call_assign() */
 470
 471         right_name = get_variable_from_expr(right, &right_sym);
 472         if (expr->op == '=' && right_name && right_sym) {
 473                 right_sm = get_sm_state_expr(SMATCH_EXTRA, right);
 474                 if (!right_sm)
 475                         right_sm = set_state_expr(SMATCH_EXTRA, right, extra_undefined());
 476                 if (!right_sm)
 477                         goto free;
 478                 set_equiv(right_sm, left);
 479                 goto free;
 480         }
 481
 482         known = get_implied_value(right, &value);
 483         switch (expr->op) {
 484         case '=': {
 485                 struct range_list *rl = NULL;
 486
 487                 if (get_implied_range_list(right, &rl)) {
 488                         set_extra_mod(name, sym, alloc_estate_range_list(rl));
 489                         goto free;
 490                 }
 491
 492                 if (expr_unsigned(right))
 493                         min = 0;
 494                 break;
 495         }
 496         case SPECIAL_ADD_ASSIGN:
 497                 if (get_implied_min(left, &tmp)) {
 498                         if (known)
 499                                 min = tmp + value;
 500                         else
 501                                 min = tmp;
 502                 }
 503                 if (!inside_loop() && known && get_implied_max(left, &tmp))
 504                                 max = tmp + value;
 505                 break;
 506         case SPECIAL_SUB_ASSIGN:
 507                 if (get_implied_max(left, &tmp)) {
 508                         if (known)
 509                                 max = tmp - value;
 510                         else
 511                                 max = tmp;
 512                 }
 513                 if (!inside_loop() && known && get_implied_min(left, &tmp))
 514                                 min = tmp - value;
 515                 break;
 516         }
 517         set_extra_mod(name, sym, alloc_estate_range(min, max));
 518 free:
 519         free_string(right_name);
 520         free_string(name);
 521 }
 522
 523 static void reset_struct_members(const char *name, struct symbol *sym, struct expression *expr, void *unused)
 524 {
 525         struct state_list *slist;
 526         struct sm_state *tmp;
 527         int len;
 528
 529         len = strlen(name);
 530         slist = get_all_states(SMATCH_EXTRA);
 531         FOR_EACH_PTR(slist, tmp) {
 532                 if (sym != tmp->sym)
 533                         continue;
 534                 if (strncmp(name, tmp->name, len))
 535                         continue;
 536                 if (tmp->name[len] != '-' && tmp->name[len] != '.')
 537                         continue;
 538                 set_extra_mod(tmp->name, tmp->sym, extra_undefined());
 539         } END_FOR_EACH_PTR(tmp);
 540 }
 541
 542 static struct smatch_state *increment_state(struct smatch_state *state)
 543 {
 544         long long min;
 545         long long max;
 546
 547         min = get_dinfo_min(get_dinfo(state));
 548         max = get_dinfo_max(get_dinfo(state));
 549
 550         if (inside_loop())
 551                 max = whole_range.max;
 552
 553         if (min != whole_range.min)
 554                 min++;
 555         if (max != whole_range.max)
 556                 max++;
 557         return alloc_estate_range(min, max);
 558 }
 559
 560 static struct smatch_state *decrement_state(struct smatch_state *state)
 561 {
 562         long long min;
 563         long long max;
 564
 565         min = get_dinfo_min(get_dinfo(state));
 566         max = get_dinfo_max(get_dinfo(state));
 567
 568         if (inside_loop())
 569                 min = whole_range.min;
 570
 571         if (min != whole_range.min)
 572                 min--;
 573         if (max != whole_range.max)
 574                 max--;
 575         return alloc_estate_range(min, max);
 576 }
 577
 578 static void unop_expr(struct expression *expr)
 579 {
 580         struct smatch_state *state;
 581
 582         if (expr->smatch_flags & Handled)
 583                 return;
 584
 585         switch (expr->op) {
 586         case SPECIAL_INCREMENT:
 587                 state = get_state_expr(SMATCH_EXTRA, expr->unop);
 588                 state = increment_state(state);
 589                 set_extra_expr_mod(expr->unop, state);
 590                 break;
 591         case SPECIAL_DECREMENT:
 592                 state = get_state_expr(SMATCH_EXTRA, expr->unop);
 593                 state = decrement_state(state);
 594                 set_extra_expr_mod(expr->unop, state);
 595                 break;
 596         default:
 597                 return;
 598         }
 599 }
 600
 601 static void delete_state_tracker(struct tracker *t)
 602 {
 603         remove_from_equiv(t->name, t->sym);
 604         delete_state(t->owner, t->name, t->sym);
 605 }
 606
 607 static void scoped_state_extra(const char *name, struct symbol *sym)
 608 {
 609         struct tracker *t;
 610
 611         t = alloc_tracker(SMATCH_EXTRA, name, sym);
 612         add_scope_hook((scope_hook *)&delete_state_tracker, t);
 613 }
 614
 615 static void match_declarations(struct symbol *sym)
 616 {
 617         const char *name;
 618
 619         if (sym->ident) {
 620                 name = sym->ident->name;
 621                 if (!sym->initializer) {
 622                         set_state(SMATCH_EXTRA, name, sym, extra_undefined());
 623                         scoped_state_extra(name, sym);
 624                 }
 625         }
 626 }
 627
 628 static void match_function_def(struct symbol *sym)
 629 {
 630         struct symbol *arg;
 631
 632         FOR_EACH_PTR(sym->ctype.base_type->arguments, arg) {
 633                 if (!arg->ident)
 634                         continue;
 635                 set_state(my_id, arg->ident->name, arg, extra_undefined());
 636         } END_FOR_EACH_PTR(arg);
 637 }
 638
 639 static int last_stmt_val(struct statement *stmt, long long *val)
 640 {
 641         struct expression *expr;
 642
 643         if (!stmt)
 644                 return 0;
 645
 646         stmt = last_ptr_list((struct ptr_list *)stmt->stmts);
 647         if (stmt->type != STMT_EXPRESSION)
 648                 return 0;
 649         expr = stmt->expression;
 650         return get_value(expr, val);
 651 }
 652
 653 static int match_func_comparison(struct expression *expr)
 654 {
 655         struct expression *left = strip_expr(expr->left);
 656         struct expression *right = strip_expr(expr->right);
 657         long long val;
 658
 659         if (left->type == EXPR_CALL) {
 660                 if (!get_implied_value(right, &val))
 661                         return 1;
 662                 function_comparison(expr->op, left, val, 1);
 663                 return 1;
 664         }
 665
 666         if (right->type == EXPR_CALL) {
 667                 if (!get_implied_value(left, &val))
 668                         return 1;
 669                 function_comparison(expr->op, right, val, 0);
 670                 return 1;
 671         }
 672
 673         return 0;
 674 }
 675
 676 static void match_comparison(struct expression *expr)
 677 {
 678         struct expression *left = strip_expr(expr->left);
 679         struct expression *right = strip_expr(expr->right);
 680         struct range_list *left_orig;
 681         struct range_list *left_true;
 682         struct range_list *left_false;
 683         struct range_list *right_orig;
 684         struct range_list *right_true;
 685         struct range_list *right_false;
 686         struct smatch_state *left_true_state;
 687         struct smatch_state *left_false_state;
 688         struct smatch_state *right_true_state;
 689         struct smatch_state *right_false_state;
 690         int left_postop = 0;
 691         int right_postop = 0;
 692
 693         if (match_func_comparison(expr))
 694                 return;
 695
 696         if (left->op == SPECIAL_INCREMENT || left->op == SPECIAL_DECREMENT) {
 697                 if (left->type == EXPR_POSTOP) {
 698                         left->smatch_flags |= Handled;
 699                         left_postop = left->op;
 700                 }
 701                 left = strip_expr(left->unop);
 702         }
 703
 704         if (right->op == SPECIAL_INCREMENT || right->op == SPECIAL_DECREMENT) {
 705                 if (right->type == EXPR_POSTOP) {
 706                         right->smatch_flags |= Handled;
 707                         right_postop = right->op;
 708                 }
 709                 right = strip_expr(right->unop);
 710         }
 711
 712         if (!get_implied_range_list(left, &left_orig))
 713                 left_orig = alloc_range_list(whole_range.min, whole_range.max);
 714         if (!get_implied_range_list(right, &right_orig))
 715                 right_orig = alloc_range_list(whole_range.min, whole_range.max);
 716
 717         left_true = clone_range_list(left_orig);
 718         left_false = clone_range_list(left_orig);
 719         right_true = clone_range_list(right_orig);
 720         right_false = clone_range_list(right_orig);
 721
 722         switch (expr->op) {
 723         case '<':
 724         case SPECIAL_UNSIGNED_LT:
 725                 if (rl_max(right_orig) != whole_range.max)
 726                         left_true = remove_range(left_orig, rl_max(right_orig), whole_range.max);
 727                 if (rl_min(right_orig) != whole_range.min)
 728                         left_false = remove_range(left_orig, whole_range.min, rl_min(right_orig) - 1);
 729
 730                 if (rl_min(left_orig) != whole_range.min)
 731                         right_true = remove_range(right_orig, whole_range.min, rl_min(left_orig));
 732                 if (rl_max(left_orig) != whole_range.max)
 733                         right_false = remove_range(right_orig, rl_max(left_orig) + 1, whole_range.max);
 734                 break;
 735         case SPECIAL_UNSIGNED_LTE:
 736         case SPECIAL_LTE:
 737                 if (rl_max(right_orig) != whole_range.max)
 738                         left_true = remove_range(left_orig, rl_max(right_orig) + 1, whole_range.max);
 739                 if (rl_min(right_orig) != whole_range.min)
 740                         left_false = remove_range(left_orig, whole_range.min, rl_min(right_orig));
 741
 742                 if (rl_min(left_orig) != whole_range.min)
 743                         right_true = remove_range(right_orig, whole_range.min, rl_min(left_orig) - 1);
 744                 if (rl_max(left_orig) != whole_range.max)
 745                         right_false = remove_range(right_orig, rl_max(left_orig), whole_range.max);
 746                 break;
 747         case SPECIAL_EQUAL:
 748                 if (rl_max(right_orig) != whole_range.max)
 749                         left_true = remove_range(left_true, rl_max(right_orig) + 1, whole_range.max);
 750                 if (rl_min(right_orig) != whole_range.min)
 751                         left_true = remove_range(left_true, whole_range.min, rl_min(right_orig) - 1);
 752                 if (rl_min(right_orig) == rl_max(right_orig))
 753                         left_false = remove_range(left_orig, rl_min(right_orig), rl_min(right_orig));
 754
 755                 if (rl_max(left_orig) != whole_range.max)
 756                         right_true = remove_range(right_true, rl_max(left_orig) + 1, whole_range.max);
 757                 if (rl_min(left_orig) != whole_range.min)
 758                         right_true = remove_range(right_true, whole_range.min, rl_min(left_orig) - 1);
 759                 if (rl_min(left_orig) == rl_max(left_orig))
 760                         right_false = remove_range(right_orig, rl_min(left_orig), rl_min(left_orig));
 761                 break;
 762         case SPECIAL_UNSIGNED_GTE:
 763         case SPECIAL_GTE:
 764                 if (rl_min(right_orig) != whole_range.min)
 765                         left_true = remove_range(left_orig, whole_range.min, rl_min(right_orig) - 1);
 766                 if (rl_max(right_orig) != whole_range.max)
 767                         left_false = remove_range(left_orig, rl_max(right_orig), whole_range.max);
 768
 769                 if (rl_max(left_orig) != whole_range.max)
 770                         right_true = remove_range(right_orig, rl_max(left_orig) + 1, whole_range.max);
 771                 if (rl_min(left_orig) != whole_range.min)
 772                         right_false = remove_range(right_orig, whole_range.min, rl_min(left_orig));
 773                 break;
 774         case '>':
 775         case SPECIAL_UNSIGNED_GT:
 776                 if (rl_min(right_orig) != whole_range.min)
 777                         left_true = remove_range(left_orig, whole_range.min, rl_min(right_orig));
 778                 if (rl_max(right_orig) != whole_range.max)
 779                         left_false = remove_range(left_orig, rl_max(right_orig) + 1, whole_range.max);
 780
 781                 if (rl_max(left_orig) != whole_range.max)
 782                         right_true = remove_range(right_orig, rl_max(left_orig), whole_range.max);
 783                 if (rl_min(left_orig) != whole_range.min)
 784                         right_false = remove_range(right_orig, whole_range.min, rl_min(left_orig) - 1);
 785                 break;
 786         case SPECIAL_NOTEQUAL:
 787                 if (rl_max(right_orig) != whole_range.max)
 788                         left_false = remove_range(left_false, rl_max(right_orig) + 1, whole_range.max);
 789                 if (rl_min(right_orig) != whole_range.min)
 790                         left_false = remove_range(left_false, whole_range.min, rl_min(right_orig) - 1);
 791                 if (rl_min(right_orig) == rl_max(right_orig))
 792                         left_true = remove_range(left_orig, rl_min(right_orig), rl_min(right_orig));
 793
 794                 if (rl_max(left_orig) != whole_range.max)
 795                         right_false = remove_range(right_false, rl_max(left_orig) + 1, whole_range.max);
 796                 if (rl_min(left_orig) != whole_range.min)
 797                         right_false = remove_range(right_false, whole_range.min, rl_min(left_orig) - 1);
 798                 if (rl_min(left_orig) == rl_max(left_orig))
 799                         right_true = remove_range(right_orig, rl_min(left_orig), rl_min(left_orig));
 800                 break;
 801         default:
 802                 return;
 803         }
 804
 805         left_true_state = alloc_estate_range_list(left_true);
 806         left_false_state = alloc_estate_range_list(left_false);
 807         right_true_state = alloc_estate_range_list(right_true);
 808         right_false_state = alloc_estate_range_list(right_false);
 809
 810         if (left_postop == SPECIAL_INCREMENT) {
 811                 left_true_state = increment_state(left_true_state);
 812                 left_false_state = increment_state(left_false_state);
 813         }
 814         if (left_postop == SPECIAL_DECREMENT) {
 815                 left_true_state = decrement_state(left_true_state);
 816                 left_false_state = decrement_state(left_false_state);
 817         }
 818         if (right_postop == SPECIAL_INCREMENT) {
 819                 right_true_state = increment_state(right_true_state);
 820                 right_false_state = increment_state(right_false_state);
 821         }
 822         if (right_postop == SPECIAL_DECREMENT) {
 823                 right_true_state = decrement_state(right_true_state);
 824                 right_false_state = decrement_state(right_false_state);
 825         }
 826
 827         set_extra_expr_true_false(left, left_true_state, left_false_state);
 828         set_extra_expr_true_false(right, right_true_state, right_false_state);
 829 }
 830
 831 /* this is actually hooked from smatch_implied.c...  it's hacky, yes */
 832 void __extra_match_condition(struct expression *expr)
 833 {
 834         struct symbol *sym;
 835         char *name;
 836         struct smatch_state *pre_state;
 837         struct smatch_state *true_state;
 838         struct smatch_state *false_state;
 839
 840         expr = strip_expr(expr);
 841         switch (expr->type) {
 842         case EXPR_CALL:
 843                 function_comparison(SPECIAL_NOTEQUAL, expr, 0, 1);
 844                 return;
 845         case EXPR_PREOP:
 846         case EXPR_SYMBOL:
 847         case EXPR_DEREF:
 848                 name = get_variable_from_expr(expr, &sym);
 849                 if (!name)
 850                         return;
 851                 pre_state = get_state(my_id, name, sym);
 852                 true_state = add_filter(pre_state, 0);
 853                 if (possibly_true(SPECIAL_EQUAL, expr, 0, 0))
 854                         false_state = alloc_estate(0);
 855                 else
 856                         false_state = alloc_estate_empty();
 857                 set_extra_true_false(name, sym, true_state, false_state);
 858                 free_string(name);
 859                 return;
 860         case EXPR_COMPARE:
 861                 match_comparison(expr);
 862                 return;
 863         case EXPR_ASSIGNMENT:
 864                 __extra_match_condition(expr->left);
 865                 return;
 866         }
 867 }
 868
 869 /* returns 1 if it is not possible for expr to be value, otherwise returns 0 */
 870 int implied_not_equal(struct expression *expr, long long val)
 871 {
 872         return !possibly_false(SPECIAL_NOTEQUAL, expr, val, 1);
 873 }
 874
 875 int known_condition_true(struct expression *expr)
 876 {
 877         long long tmp;
 878         struct statement *stmt;
 879
 880         if (!expr)
 881                 return 0;
 882
 883         if (get_value(expr, &tmp) && tmp)
 884                 return 1;
 885
 886         expr = strip_expr(expr);
 887         switch (expr->type) {
 888         case EXPR_PREOP:
 889                 if (expr->op == '!') {
 890                         if (known_condition_false(expr->unop))
 891                                 return 1;
 892                         break;
 893                 }
 894                 stmt = get_expression_statement(expr);
 895                 if (last_stmt_val(stmt, &tmp) && tmp == 1)
 896                         return 1;
 897                 break;
 898         default:
 899                 break;
 900         }
 901         return 0;
 902 }
 903
 904 int known_condition_false(struct expression *expr)
 905 {
 906         long long tmp;
 907         struct statement *stmt;
 908
 909         if (!expr)
 910                 return 0;
 911
 912         if (is_zero(expr))
 913                 return 1;
 914
 915         switch (expr->type) {
 916         case EXPR_PREOP:
 917                 if (expr->op == '!') {
 918                         if (known_condition_true(expr->unop))
 919                                 return 1;
 920                         break;
 921                 }
 922                 stmt = get_expression_statement(expr);
 923                 if (last_stmt_val(stmt, &tmp) && tmp == 0)
 924                         return 1;
 925                 break;
 926         case EXPR_CALL:
 927                 if (sym_name_is("__builtin_constant_p", expr->fn))
 928                         return 1;
 929                 break;
 930         default:
 931                 break;
 932         }
 933         return 0;
 934 }
 935
 936 struct range_list *get_range_list(struct expression *expr)
 937 {
 938         long long min;
 939         long long max;
 940         struct range_list *ret = NULL;
 941         struct smatch_state *state;
 942
 943         state = get_state_expr(SMATCH_EXTRA, expr);
 944         if (state)
 945                 return clone_range_list(estate_ranges(state));
 946         if (!get_absolute_min(expr, &min))
 947                 return NULL;
 948         if (!get_absolute_max(expr, &max))
 949                 return NULL;
 950         add_range(&ret, min, max);
 951         return ret;
 952 }
 953
 954 static int do_comparison(struct expression *expr)
 955 {
 956         struct range_list *left_ranges;
 957         struct range_list *right_ranges;
 958         int poss_true, poss_false;
 959
 960         left_ranges = get_range_list(expr->left);
 961         right_ranges = get_range_list(expr->right);
 962
 963         poss_true = possibly_true_range_lists(left_ranges, expr->op, right_ranges);
 964         poss_false = possibly_false_range_lists(left_ranges, expr->op, right_ranges);
 965
 966         free_range_list(&left_ranges);
 967         free_range_list(&right_ranges);
 968
 969         if (!poss_true && !poss_false)
 970                 return 0;
 971         if (poss_true && !poss_false)
 972                 return 1;
 973         if (!poss_true && poss_false)
 974                 return 2;
 975         return 3;
 976 }
 977
 978 int implied_condition_true(struct expression *expr)
 979 {
 980         struct statement *stmt;
 981         long long tmp;
 982         long long val;
 983
 984         if (!expr)
 985                 return 0;
 986
 987         if (get_implied_value(expr, &tmp) && tmp)
 988                 return 1;
 989
 990         if (expr->type == EXPR_POSTOP)
 991                 return implied_condition_true(expr->unop);
 992
 993         if (expr->type == EXPR_PREOP && expr->op == SPECIAL_DECREMENT)
 994                 return implied_not_equal(expr->unop, 1);
 995         if (expr->type == EXPR_PREOP && expr->op == SPECIAL_INCREMENT)
 996                 return implied_not_equal(expr->unop, -1);
 997
 998         expr = strip_expr(expr);
 999         switch (expr->type) {
1000         case EXPR_COMPARE:
1001                 if (do_comparison(expr) == 1)
1002                         return 1;
1003                 break;
1004         case EXPR_PREOP:
1005                 if (expr->op == '!') {
1006                         if (implied_condition_false(expr->unop))
1007                                 return 1;
1008                         break;
1009                 }
1010                 stmt = get_expression_statement(expr);
1011                 if (last_stmt_val(stmt, &val) && val == 1)
1012                         return 1;
1013                 break;
1014         default:
1015                 if (implied_not_equal(expr, 0) == 1)
1016                         return 1;
1017                 break;
1018         }
1019         return 0;
1020 }
1021
1022 int implied_condition_false(struct expression *expr)
1023 {
1024         struct statement *stmt;
1025         struct expression *tmp;
1026         long long val;
1027
1028         if (!expr)
1029                 return 0;
1030
1031         if (is_zero(expr))
1032                 return 1;
1033
1034         switch (expr->type) {
1035         case EXPR_COMPARE:
1036                 if (do_comparison(expr) == 2)
1037                         return 1;
1038         case EXPR_PREOP:
1039                 if (expr->op == '!') {
1040                         if (implied_condition_true(expr->unop))
1041                                 return 1;
1042                         break;
1043                 }
1044                 stmt = get_expression_statement(expr);
1045                 if (last_stmt_val(stmt, &val) && val == 0)
1046                         return 1;
1047                 tmp = strip_expr(expr);
1048                 if (tmp != expr)
1049                         return implied_condition_false(tmp);
1050                 break;
1051         default:
1052                 if (get_implied_value(expr, &val) && val == 0)
1053                         return 1;
1054                 break;
1055         }
1056         return 0;
1057 }
1058
1059 int get_implied_range_list(struct expression *expr, struct range_list **rl)
1060 {
1061         long long val;
1062         struct smatch_state *state;
1063         long long min;
1064         long long max;
1065
1066         expr = strip_parens(expr);
1067         if (!expr)
1068                 return 0;
1069
1070         state = get_state_expr(my_id, expr);
1071         if (state) {
1072                 *rl = clone_range_list(estate_ranges(state));
1073                 return 1;
1074         }
1075
1076         if (get_implied_value(expr, &val)) {
1077                 *rl = NULL;
1078                 add_range(rl, val, val);
1079                 return 1;
1080         }
1081
1082         if (expr->type != EXPR_BINOP)
1083                 return 0;
1084
1085         if (expr->type == EXPR_CALL) {
1086                 *rl = db_return_vals(expr);
1087                 return !!*rl;
1088         }
1089
1090         if (expr->op == '%') {
1091                 if (!get_implied_value(expr->right, &val))
1092                         return 0;
1093                 *rl = NULL;
1094                 add_range(rl, 0, val - 1);
1095                 return 1;
1096         }
1097
1098         if (!get_implied_min(expr, &min))
1099                 return 0;
1100         if (!get_implied_max(expr, &max))
1101                 return 0;
1102
1103         *rl = alloc_range_list(min, max);
1104         return 1;
1105 }
1106
1107 int is_whole_range(struct smatch_state *state)
1108 {
1109         struct data_range *drange;
1110
1111         if (!estate_ranges(state))
1112                 return 1;
1113         drange = first_ptr_list((struct ptr_list *)estate_ranges(state));
1114         if (drange->min == whole_range.min && drange->max == whole_range.max)
1115                 return 1;
1116         return 0;
1117 }
1118
1119 static void struct_member_callback(char *fn, int param, char *printed_name, struct smatch_state *state)
1120 {
1121         if (is_whole_range(state))
1122                 return;
1123         sm_msg("info: passes param_value '%s' %d '%s' %s", fn, param, printed_name, state->name);
1124 }
1125
1126 static void match_call_info(struct expression *expr)
1127 {
1128         struct range_list *rl = NULL;
1129         struct expression *arg;
1130         char *name;
1131         int i = 0;
1132
1133         name = get_fnptr_name(expr->fn);
1134         if (!name)
1135                 return;
1136
1137         FOR_EACH_PTR(expr->args, arg) {
1138                 if (get_implied_range_list(arg, &rl) && !is_whole_range_rl(rl)) {
1139                         sm_msg("info: passes param_value '%s' %d '$$' %s",
1140                                name, i, show_ranges(rl));
1141                 }
1142                 i++;
1143         } END_FOR_EACH_PTR(arg);
1144
1145         free_string(name);
1146 }
1147
1148 void set_param_value(const char *name, struct symbol *sym, char *key, char *value)
1149 {
1150         struct range_list *rl = NULL;
1151         struct smatch_state *state;
1152         char fullname[256];
1153
1154         if (strncmp(key, "$$", 2))
1155                 return;
1156
1157         snprintf(fullname, 256, "%s%s", name, key + 2);
1158         get_value_ranges(value, &rl);
1159         char *tmp = show_ranges(rl);
1160         if (strcmp(tmp, value))
1161                 sm_msg("value = %s, ranges = %s", value, tmp);
1162         state = alloc_estate_range_list(rl);
1163         set_state(SMATCH_EXTRA, fullname, sym, state);
1164 }
1165
1166 static void match_call_assign(struct expression *expr)
1167 {
1168         struct expression *right;
1169         struct range_list *rl;
1170
1171         if (expr->op != '=')
1172                 return;
1173
1174         right = strip_parens(expr->right);
1175         while (right->type == EXPR_ASSIGNMENT && right->op == '=')
1176                 right = strip_parens(right->left);
1177
1178         rl = db_return_vals(right);
1179         if (rl)
1180                 set_extra_expr_mod(expr->left, alloc_estate_range_list(rl));
1181         else
1182                 set_extra_expr_mod(expr->left, extra_undefined());
1183 }
1184
1185 void register_smatch_extra(int id)
1186 {
1187         my_id = id;
1188         add_merge_hook(my_id, &merge_func);
1189         add_unmatched_state_hook(my_id, &unmatched_state);
1190         add_hook(&unop_expr, OP_HOOK);
1191         add_hook(&match_function_def, FUNC_DEF_HOOK);
1192         add_hook(&match_function_call, FUNCTION_CALL_HOOK);
1193         add_hook(&match_assign, ASSIGNMENT_HOOK);
1194         add_hook(&match_call_assign, CALL_ASSIGNMENT_HOOK);
1195         add_hook(&match_declarations, DECLARATION_HOOK);
1196         if (option_info) {
1197                 add_hook(&match_call_info, FUNCTION_CALL_HOOK);
1198                 add_member_info_callback(my_id, struct_member_callback);
1199         }
1200         add_definition_db_callback(set_param_value, PARAM_VALUE);
1201 }
1202
1203 void register_smatch_extra_late(int id)
1204 {
1205         set_default_modification_hook(SMATCH_EXTRA, reset_struct_members);
1206 }