smatch_comparison.c

   1 /*
   2  * Copyright (C) 2012 Oracle.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16  */
  17
  18 /*
  19  * The point here is to store the relationships between two variables.
  20  * Ie:  y > x.
  21  * To do that we create a state with the two variables in alphabetical order:
  22  * ->name = "x vs y" and the state would be "<".  On the false path the state
  23  * would be ">=".
  24  *
  25  * Part of the trick of it is that if x or y is modified then we need to reset
  26  * the state.  We need to keep a list of all the states which depend on x and
  27  * all the states which depend on y.  The link_id code handles this.
  28  *
  29  */
  30
  31 #include "smatch.h"
  32 #include "smatch_extra.h"
  33 #include "smatch_slist.h"
  34
  35 static int compare_id;
  36 static int link_id;
  37
  38 ALLOCATOR(compare_data, "compare data");
  39
  40 static struct symbol *vsl_to_sym(struct var_sym_list *vsl)
  41 {
  42         struct var_sym *vs;
  43
  44         if (!vsl)
  45                 return NULL;
  46         if (ptr_list_size((struct ptr_list *)vsl) != 1)
  47                 return NULL;
  48         vs = first_ptr_list((struct ptr_list *)vsl);
  49         return vs->sym;
  50 }
  51
  52 static struct smatch_state *alloc_compare_state(
  53                 const char *var1, struct var_sym_list *vsl1,
  54                 int comparison,
  55                 const char *var2, struct var_sym_list *vsl2)
  56 {
  57         struct smatch_state *state;
  58         struct compare_data *data;
  59
  60         state = __alloc_smatch_state(0);
  61         state->name = alloc_sname(show_special(comparison));
  62         data = __alloc_compare_data(0);
  63         data->var1 = alloc_sname(var1);
  64         data->vsl1 = clone_var_sym_list(vsl1);
  65         data->comparison = comparison;
  66         data->var2 = alloc_sname(var2);
  67         data->vsl2 = clone_var_sym_list(vsl2);
  68         state->data = data;
  69         return state;
  70 }
  71
  72 static int state_to_comparison(struct smatch_state *state)
  73 {
  74         if (!state || !state->data)
  75                 return 0;
  76         return ((struct compare_data *)state->data)->comparison;
  77 }
  78
  79 /*
  80  * flip_comparison() reverses the op left and right.  So "x >= y" becomes "y <= x".
  81  */
  82 int flip_comparison(int op)
  83 {
  84         switch (op) {
  85         case 0:
  86                 return 0;
  87         case '<':
  88                 return '>';
  89         case SPECIAL_UNSIGNED_LT:
  90                 return SPECIAL_UNSIGNED_GT;
  91         case SPECIAL_LTE:
  92                 return SPECIAL_GTE;
  93         case SPECIAL_UNSIGNED_LTE:
  94                 return SPECIAL_UNSIGNED_GTE;
  95         case SPECIAL_EQUAL:
  96                 return SPECIAL_EQUAL;
  97         case SPECIAL_NOTEQUAL:
  98                 return SPECIAL_NOTEQUAL;
  99         case SPECIAL_GTE:
 100                 return SPECIAL_LTE;
 101         case SPECIAL_UNSIGNED_GTE:
 102                 return SPECIAL_UNSIGNED_LTE;
 103         case '>':
 104                 return '<';
 105         case SPECIAL_UNSIGNED_GT:
 106                 return SPECIAL_UNSIGNED_LT;
 107         default:
 108                 sm_msg("internal smatch bug.  unhandled comparison %d", op);
 109                 return op;
 110         }
 111 }
 112
 113 int negate_comparison(int op)
 114 {
 115         switch (op) {
 116         case 0:
 117                 return 0;
 118         case '<':
 119                 return SPECIAL_GTE;
 120         case SPECIAL_UNSIGNED_LT:
 121                 return SPECIAL_UNSIGNED_GTE;
 122         case SPECIAL_LTE:
 123                 return '>';
 124         case SPECIAL_UNSIGNED_LTE:
 125                 return SPECIAL_UNSIGNED_GT;
 126         case SPECIAL_EQUAL:
 127                 return SPECIAL_NOTEQUAL;
 128         case SPECIAL_NOTEQUAL:
 129                 return SPECIAL_EQUAL;
 130         case SPECIAL_GTE:
 131                 return '<';
 132         case SPECIAL_UNSIGNED_GTE:
 133                 return SPECIAL_UNSIGNED_LT;
 134         case '>':
 135                 return SPECIAL_LTE;
 136         case SPECIAL_UNSIGNED_GT:
 137                 return SPECIAL_UNSIGNED_LTE;
 138         default:
 139                 sm_msg("internal smatch bug.  unhandled comparison %d", op);
 140                 return op;
 141         }
 142 }
 143
 144 static int rl_comparison(struct range_list *left_rl, struct range_list *right_rl)
 145 {
 146         sval_t left_min, left_max, right_min, right_max;
 147
 148         if (!left_rl || !right_rl)
 149                 return 0;
 150
 151         left_min = rl_min(left_rl);
 152         left_max = rl_max(left_rl);
 153         right_min = rl_min(right_rl);
 154         right_max = rl_max(right_rl);
 155
 156         if (left_min.value == left_max.value &&
 157             right_min.value == right_max.value &&
 158             left_min.value == right_min.value)
 159                 return SPECIAL_EQUAL;
 160
 161         if (sval_cmp(left_max, right_min) < 0)
 162                 return '<';
 163         if (sval_cmp(left_max, right_min) == 0)
 164                 return SPECIAL_LTE;
 165         if (sval_cmp(left_min, right_max) > 0)
 166                 return '>';
 167         if (sval_cmp(left_min, right_max) == 0)
 168                 return SPECIAL_GTE;
 169
 170         return 0;
 171 }
 172
 173 static struct range_list *get_orig_rl(struct var_sym_list *vsl)
 174 {
 175         struct symbol *sym;
 176         struct smatch_state *state;
 177
 178         if (!vsl)
 179                 return NULL;
 180         sym = vsl_to_sym(vsl);
 181         if (!sym || !sym->ident)
 182                 return NULL;
 183         state = get_orig_estate(sym->ident->name, sym);
 184         return estate_rl(state);
 185 }
 186
 187 static struct smatch_state *unmatched_comparison(struct sm_state *sm)
 188 {
 189         struct compare_data *data = sm->state->data;
 190         struct range_list *left_rl, *right_rl;
 191         int op;
 192
 193         if (!data)
 194                 return &undefined;
 195
 196         if (strstr(data->var1, " orig"))
 197                 left_rl = get_orig_rl(data->vsl1);
 198         else if (!get_implied_rl_var_sym(data->var1, vsl_to_sym(data->vsl1), &left_rl))
 199                 return &undefined;
 200         if (strstr(data->var2, " orig"))
 201                 right_rl = get_orig_rl(data->vsl2);
 202         else if (!get_implied_rl_var_sym(data->var2, vsl_to_sym(data->vsl2), &right_rl))
 203                 return &undefined;
 204
 205
 206         op = rl_comparison(left_rl, right_rl);
 207         if (op)
 208                 return alloc_compare_state(data->var1, data->vsl1, op, data->var2, data->vsl2);
 209
 210         return &undefined;
 211 }
 212
 213 /* remove_unsigned_from_comparison() is obviously a hack. */
 214 static int remove_unsigned_from_comparison(int op)
 215 {
 216         switch (op) {
 217         case SPECIAL_UNSIGNED_LT:
 218                 return '<';
 219         case SPECIAL_UNSIGNED_LTE:
 220                 return SPECIAL_LTE;
 221         case SPECIAL_UNSIGNED_GTE:
 222                 return SPECIAL_GTE;
 223         case SPECIAL_UNSIGNED_GT:
 224                 return '>';
 225         default:
 226                 return op;
 227         }
 228 }
 229
 230 /*
 231  * This is for when you merge states "a < b" and "a == b", the result is that
 232  * we can say for sure, "a <= b" after the merge.
 233  */
 234 static int merge_comparisons(int one, int two)
 235 {
 236         int LT, EQ, GT;
 237
 238         one = remove_unsigned_from_comparison(one);
 239         two = remove_unsigned_from_comparison(two);
 240
 241         LT = EQ = GT = 0;
 242
 243         switch (one) {
 244         case '<':
 245                 LT = 1;
 246                 break;
 247         case SPECIAL_LTE:
 248                 LT = 1;
 249                 EQ = 1;
 250                 break;
 251         case SPECIAL_EQUAL:
 252                 EQ = 1;
 253                 break;
 254         case SPECIAL_GTE:
 255                 GT = 1;
 256                 EQ = 1;
 257                 break;
 258         case '>':
 259                 GT = 1;
 260         }
 261
 262         switch (two) {
 263         case '<':
 264                 LT = 1;
 265                 break;
 266         case SPECIAL_LTE:
 267                 LT = 1;
 268                 EQ = 1;
 269                 break;
 270         case SPECIAL_EQUAL:
 271                 EQ = 1;
 272                 break;
 273         case SPECIAL_GTE:
 274                 GT = 1;
 275                 EQ = 1;
 276                 break;
 277         case '>':
 278                 GT = 1;
 279         }
 280
 281         if (LT && EQ && GT)
 282                 return 0;
 283         if (LT && EQ)
 284                 return SPECIAL_LTE;
 285         if (LT && GT)
 286                 return SPECIAL_NOTEQUAL;
 287         if (LT)
 288                 return '<';
 289         if (EQ && GT)
 290                 return SPECIAL_GTE;
 291         if (GT)
 292                 return '>';
 293         return 0;
 294 }
 295
 296 /*
 297  * This is for if you have "a < b" and "b <= c".  Or in other words,
 298  * "a < b <= c".  You would call this like get_combined_comparison('<', '<=').
 299  * The return comparison would be '<'.
 300  *
 301  * This function is different from merge_comparisons(), for example:
 302  * merge_comparison('<', '==') returns '<='
 303  * get_combined_comparison('<', '==') returns '<'
 304  */
 305 static int combine_comparisons(int left_compare, int right_compare)
 306 {
 307         int LT, EQ, GT;
 308
 309         left_compare = remove_unsigned_from_comparison(left_compare);
 310         right_compare = remove_unsigned_from_comparison(right_compare);
 311
 312         LT = EQ = GT = 0;
 313
 314         switch (left_compare) {
 315         case '<':
 316                 LT++;
 317                 break;
 318         case SPECIAL_LTE:
 319                 LT++;
 320                 EQ++;
 321                 break;
 322         case SPECIAL_EQUAL:
 323                 return right_compare;
 324         case SPECIAL_GTE:
 325                 GT++;
 326                 EQ++;
 327                 break;
 328         case '>':
 329                 GT++;
 330         }
 331
 332         switch (right_compare) {
 333         case '<':
 334                 LT++;
 335                 break;
 336         case SPECIAL_LTE:
 337                 LT++;
 338                 EQ++;
 339                 break;
 340         case SPECIAL_EQUAL:
 341                 return left_compare;
 342         case SPECIAL_GTE:
 343                 GT++;
 344                 EQ++;
 345                 break;
 346         case '>':
 347                 GT++;
 348         }
 349
 350         if (LT == 2) {
 351                 if (EQ == 2)
 352                         return SPECIAL_LTE;
 353                 return '<';
 354         }
 355
 356         if (GT == 2) {
 357                 if (EQ == 2)
 358                         return SPECIAL_GTE;
 359                 return '>';
 360         }
 361         return 0;
 362 }
 363
 364 static int filter_comparison(int orig, int op)
 365 {
 366         if (orig == op)
 367                 return orig;
 368
 369         switch (orig) {
 370         case 0:
 371                 return op;
 372         case '<':
 373                 switch (op) {
 374                 case '<':
 375                 case SPECIAL_LTE:
 376                 case SPECIAL_NOTEQUAL:
 377                         return '<';
 378                 }
 379                 return 0;
 380         case SPECIAL_LTE:
 381                 switch (op) {
 382                 case '<':
 383                 case SPECIAL_LTE:
 384                 case SPECIAL_EQUAL:
 385                         return op;
 386                 case SPECIAL_NOTEQUAL:
 387                         return '<';
 388                 }
 389                 return 0;
 390         case SPECIAL_EQUAL:
 391                 switch (op) {
 392                 case SPECIAL_LTE:
 393                 case SPECIAL_EQUAL:
 394                 case SPECIAL_GTE:
 395                 case SPECIAL_UNSIGNED_LTE:
 396                 case SPECIAL_UNSIGNED_GTE:
 397                         return SPECIAL_EQUAL;
 398                 }
 399                 return 0;
 400         case SPECIAL_NOTEQUAL:
 401                 switch (op) {
 402                 case '<':
 403                 case SPECIAL_LTE:
 404                         return '<';
 405                 case SPECIAL_UNSIGNED_LT:
 406                 case SPECIAL_UNSIGNED_LTE:
 407                         return SPECIAL_UNSIGNED_LT;
 408                 case SPECIAL_NOTEQUAL:
 409                         return op;
 410                 case '>':
 411                 case SPECIAL_GTE:
 412                         return '>';
 413                 case SPECIAL_UNSIGNED_GT:
 414                 case SPECIAL_UNSIGNED_GTE:
 415                         return SPECIAL_UNSIGNED_GT;
 416                 }
 417                 return 0;
 418         case SPECIAL_GTE:
 419                 switch (op) {
 420                 case SPECIAL_LTE:
 421                         return SPECIAL_EQUAL;
 422                 case '>':
 423                 case SPECIAL_GTE:
 424                 case SPECIAL_EQUAL:
 425                         return op;
 426                 case SPECIAL_NOTEQUAL:
 427                         return '>';
 428                 }
 429                 return 0;
 430         case '>':
 431                 switch (op) {
 432                 case '>':
 433                 case SPECIAL_GTE:
 434                 case SPECIAL_NOTEQUAL:
 435                         return '>';
 436                 }
 437                 return 0;
 438         case SPECIAL_UNSIGNED_LT:
 439                 switch (op) {
 440                 case SPECIAL_UNSIGNED_LT:
 441                 case SPECIAL_UNSIGNED_LTE:
 442                 case SPECIAL_NOTEQUAL:
 443                         return SPECIAL_UNSIGNED_LT;
 444                 }
 445                 return 0;
 446         case SPECIAL_UNSIGNED_LTE:
 447                 switch (op) {
 448                 case SPECIAL_UNSIGNED_LT:
 449                 case SPECIAL_UNSIGNED_LTE:
 450                 case SPECIAL_EQUAL:
 451                         return op;
 452                 case SPECIAL_NOTEQUAL:
 453                         return SPECIAL_UNSIGNED_LT;
 454                 case SPECIAL_UNSIGNED_GTE:
 455                         return SPECIAL_EQUAL;
 456                 }
 457                 return 0;
 458         case SPECIAL_UNSIGNED_GTE:
 459                 switch (op) {
 460                 case SPECIAL_UNSIGNED_LTE:
 461                         return SPECIAL_EQUAL;
 462                 case SPECIAL_NOTEQUAL:
 463                         return SPECIAL_UNSIGNED_GT;
 464                 case SPECIAL_EQUAL:
 465                 case SPECIAL_UNSIGNED_GTE:
 466                 case SPECIAL_UNSIGNED_GT:
 467                         return op;
 468                 }
 469                 return 0;
 470         case SPECIAL_UNSIGNED_GT:
 471                 switch (op) {
 472                 case SPECIAL_UNSIGNED_GT:
 473                 case SPECIAL_UNSIGNED_GTE:
 474                 case SPECIAL_NOTEQUAL:
 475                         return SPECIAL_UNSIGNED_GT;
 476                 }
 477                 return 0;
 478         }
 479         return 0;
 480 }
 481
 482 static struct smatch_state *merge_compare_states(struct smatch_state *s1, struct smatch_state *s2)
 483 {
 484         struct compare_data *data = s1->data;
 485         int op;
 486
 487         op = merge_comparisons(state_to_comparison(s1), state_to_comparison(s2));
 488         if (op)
 489                 return alloc_compare_state(data->var1, data->vsl1, op, data->var2, data->vsl2);
 490         return &undefined;
 491 }
 492
 493 static struct smatch_state *alloc_link_state(struct string_list *links)
 494 {
 495         struct smatch_state *state;
 496         static char buf[256];
 497         char *tmp;
 498         int i;
 499
 500         state = __alloc_smatch_state(0);
 501
 502         i = 0;
 503         FOR_EACH_PTR(links, tmp) {
 504                 if (!i++) {
 505                         snprintf(buf, sizeof(buf), "%s", tmp);
 506                 } else {
 507                         append(buf, ", ", sizeof(buf));
 508                         append(buf, tmp, sizeof(buf));
 509                 }
 510         } END_FOR_EACH_PTR(tmp);
 511
 512         state->name = alloc_sname(buf);
 513         state->data = links;
 514         return state;
 515 }
 516
 517 static void save_start_states(struct statement *stmt)
 518 {
 519         struct symbol *param;
 520         char orig[64];
 521         char state_name[128];
 522         struct smatch_state *state;
 523         struct string_list *links;
 524         char *link;
 525
 526         FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
 527                 struct var_sym_list *vsl1 = NULL;
 528                 struct var_sym_list *vsl2 = NULL;
 529
 530                 if (!param->ident)
 531                         continue;
 532                 snprintf(orig, sizeof(orig), "%s orig", param->ident->name);
 533                 snprintf(state_name, sizeof(state_name), "%s vs %s", param->ident->name, orig);
 534                 add_var_sym(&vsl1, param->ident->name, param);
 535                 add_var_sym(&vsl2, orig, param);
 536                 state = alloc_compare_state(param->ident->name, vsl1, SPECIAL_EQUAL, alloc_sname(orig), vsl2);
 537                 set_state(compare_id, state_name, NULL, state);
 538
 539                 link = alloc_sname(state_name);
 540                 links = NULL;
 541                 insert_string(&links, link);
 542                 state = alloc_link_state(links);
 543                 set_state(link_id, param->ident->name, param, state);
 544         } END_FOR_EACH_PTR(param);
 545 }
 546
 547 static struct smatch_state *merge_links(struct smatch_state *s1, struct smatch_state *s2)
 548 {
 549         struct smatch_state *ret;
 550         struct string_list *links;
 551
 552         links = combine_string_lists(s1->data, s2->data);
 553         ret = alloc_link_state(links);
 554         return ret;
 555 }
 556
 557 static void save_link_var_sym(const char *var, struct symbol *sym, const char *link)
 558 {
 559         struct smatch_state *old_state, *new_state;
 560         struct string_list *links;
 561         char *new;
 562
 563         old_state = get_state(link_id, var, sym);
 564         if (old_state)
 565                 links = clone_str_list(old_state->data);
 566         else
 567                 links = NULL;
 568
 569         new = alloc_sname(link);
 570         insert_string(&links, new);
 571
 572         new_state = alloc_link_state(links);
 573         set_state(link_id, var, sym, new_state);
 574 }
 575
 576 static void match_inc(struct sm_state *sm)
 577 {
 578         struct string_list *links;
 579         struct smatch_state *state;
 580         char *tmp;
 581
 582         links = sm->state->data;
 583
 584         FOR_EACH_PTR(links, tmp) {
 585                 state = get_state(compare_id, tmp, NULL);
 586
 587                 switch (state_to_comparison(state)) {
 588                 case SPECIAL_EQUAL:
 589                 case SPECIAL_GTE:
 590                 case SPECIAL_UNSIGNED_GTE:
 591                 case '>':
 592                 case SPECIAL_UNSIGNED_GT: {
 593                         struct compare_data *data = state->data;
 594                         struct smatch_state *new;
 595
 596                         new = alloc_compare_state(data->var1, data->vsl1, '>', data->var2, data->vsl2);
 597                         set_state(compare_id, tmp, NULL, new);
 598                         break;
 599                         }
 600                 default:
 601                         set_state(compare_id, tmp, NULL, &undefined);
 602                 }
 603         } END_FOR_EACH_PTR(tmp);
 604 }
 605
 606 static void match_dec(struct sm_state *sm)
 607 {
 608         struct string_list *links;
 609         struct smatch_state *state;
 610         char *tmp;
 611
 612         links = sm->state->data;
 613
 614         FOR_EACH_PTR(links, tmp) {
 615                 state = get_state(compare_id, tmp, NULL);
 616
 617                 switch (state_to_comparison(state)) {
 618                 case SPECIAL_EQUAL:
 619                 case SPECIAL_LTE:
 620                 case SPECIAL_UNSIGNED_LTE:
 621                 case '<':
 622                 case SPECIAL_UNSIGNED_LT: {
 623                         struct compare_data *data = state->data;
 624                         struct smatch_state *new;
 625
 626                         new = alloc_compare_state(data->var1, data->vsl1, '<', data->var2, data->vsl2);
 627                         set_state(compare_id, tmp, NULL, new);
 628                         break;
 629                         }
 630                 default:
 631                         set_state(compare_id, tmp, NULL, &undefined);
 632                 }
 633         } END_FOR_EACH_PTR(tmp);
 634 }
 635
 636 static int match_inc_dec(struct sm_state *sm, struct expression *mod_expr)
 637 {
 638         if (!mod_expr)
 639                 return 0;
 640         if (mod_expr->type != EXPR_PREOP && mod_expr->type != EXPR_POSTOP)
 641                 return 0;
 642
 643         if (mod_expr->op == SPECIAL_INCREMENT) {
 644                 match_inc(sm);
 645                 return 1;
 646         }
 647         if (mod_expr->op == SPECIAL_DECREMENT) {
 648                 match_dec(sm);
 649                 return 1;
 650         }
 651         return 0;
 652 }
 653
 654 static void match_modify(struct sm_state *sm, struct expression *mod_expr)
 655 {
 656         struct string_list *links;
 657         char *tmp;
 658
 659         /* Huh???  This needs a comment!  */
 660         if (match_inc_dec(sm, mod_expr))
 661                 return;
 662
 663         links = sm->state->data;
 664
 665         FOR_EACH_PTR(links, tmp) {
 666                 set_state(compare_id, tmp, NULL, &undefined);
 667         } END_FOR_EACH_PTR(tmp);
 668         set_state(link_id, sm->name, sm->sym, &undefined);
 669 }
 670
 671 static char *chunk_to_var_sym(struct expression *expr, struct symbol **sym)
 672 {
 673         char *name, *left_name, *right_name;
 674         struct symbol *tmp;
 675         char buf[128];
 676
 677         expr = strip_expr(expr);
 678         if (!expr)
 679                 return NULL;
 680         if (sym)
 681                 *sym = NULL;
 682
 683         name = expr_to_var_sym(expr, &tmp);
 684         if (name && tmp) {
 685                 if (sym)
 686                         *sym = tmp;
 687                 return name;
 688         }
 689         if (name)
 690                 free_string(name);
 691
 692         if (expr->type != EXPR_BINOP)
 693                 return NULL;
 694         if (expr->op != '-' && expr->op != '+')
 695                 return NULL;
 696
 697         left_name = expr_to_var(expr->left);
 698         if (!left_name)
 699                 return NULL;
 700         right_name = expr_to_var(expr->right);
 701         if (!right_name) {
 702                 free_string(left_name);
 703                 return NULL;
 704         }
 705         snprintf(buf, sizeof(buf), "%s %s %s", left_name, show_special(expr->op), right_name);
 706         free_string(left_name);
 707         free_string(right_name);
 708         return alloc_string(buf);
 709 }
 710
 711 static char *chunk_to_var(struct expression *expr)
 712 {
 713         return chunk_to_var_sym(expr, NULL);
 714 }
 715
 716 static void save_link(struct expression *expr, char *link)
 717 {
 718         char *var;
 719         struct symbol *sym;
 720
 721         expr = strip_expr(expr);
 722         if (expr->type == EXPR_BINOP) {
 723                 char *chunk;
 724
 725                 chunk = chunk_to_var(expr);
 726                 if (!chunk)
 727                         return;
 728
 729                 save_link(expr->left, link);
 730                 save_link(expr->right, link);
 731                 save_link_var_sym(chunk, NULL, link);
 732                 return;
 733         }
 734
 735         var = expr_to_var_sym(expr, &sym);
 736         if (!var || !sym)
 737                 goto done;
 738
 739         save_link_var_sym(var, sym, link);
 740 done:
 741         free_string(var);
 742 }
 743
 744 static int get_orig_comparison(struct stree *pre_stree, const char *left, const char *right)
 745 {
 746         struct smatch_state *state;
 747         struct compare_data *data;
 748         int flip = 0;
 749         char state_name[256];
 750
 751         if (strcmp(left, right) > 0) {
 752                 const char *tmp = right;
 753
 754                 flip = 1;
 755                 right = left;
 756                 left = tmp;
 757         }
 758
 759         snprintf(state_name, sizeof(state_name), "%s vs %s", left, right);
 760         state = get_state_stree(pre_stree, compare_id, state_name, NULL);
 761         if (!state || !state->data)
 762                 return 0;
 763         data = state->data;
 764         if (flip)
 765                 return flip_comparison(data->comparison);
 766         return data->comparison;
 767
 768 }
 769
 770 /*
 771  * The idea here is that we take a comparison "a < b" and then we look at all
 772  * the things which "b" is compared against "b < c" and we say that that implies
 773  * a relationship "a < c".
 774  *
 775  * The names here about because the comparisons are organized like this
 776  * "a < b < c".
 777  *
 778  */
 779 static void update_tf_links(struct stree *pre_stree,
 780                             const char *left_var, struct var_sym_list *left_vsl,
 781                             int left_comparison, int left_false_comparison,
 782                             const char *mid_var, struct var_sym_list *mid_vsl,
 783                             struct string_list *links)
 784 {
 785         struct smatch_state *state;
 786         struct smatch_state *true_state, *false_state;
 787         struct compare_data *data;
 788         const char *right_var;
 789         struct var_sym_list *right_vsl;
 790         int orig_comparison;
 791         int right_comparison;
 792         int true_comparison;
 793         int false_comparison;
 794         char *tmp;
 795         char state_name[256];
 796         struct var_sym *vs;
 797
 798         FOR_EACH_PTR(links, tmp) {
 799                 state = get_state_stree(pre_stree, compare_id, tmp, NULL);
 800                 if (!state || !state->data)
 801                         continue;
 802                 data = state->data;
 803                 right_comparison = data->comparison;
 804                 right_var = data->var2;
 805                 right_vsl = data->vsl2;
 806                 if (strcmp(mid_var, right_var) == 0) {
 807                         right_var = data->var1;
 808                         right_vsl = data->vsl1;
 809                         right_comparison = flip_comparison(right_comparison);
 810                 }
 811                 if (strcmp(left_var, right_var) == 0)
 812                         continue;
 813
 814                 orig_comparison = get_orig_comparison(pre_stree, left_var, right_var);
 815
 816                 true_comparison = combine_comparisons(left_comparison, right_comparison);
 817                 false_comparison = combine_comparisons(left_false_comparison, right_comparison);
 818
 819                 true_comparison = filter_comparison(orig_comparison, true_comparison);
 820                 false_comparison = filter_comparison(orig_comparison, false_comparison);
 821
 822                 if (strcmp(left_var, right_var) > 0) {
 823                         const char *tmp_var = left_var;
 824                         struct var_sym_list *tmp_vsl = left_vsl;
 825
 826                         left_var = right_var;
 827                         left_vsl = right_vsl;
 828                         right_var = tmp_var;
 829                         right_vsl = tmp_vsl;
 830                         true_comparison = flip_comparison(true_comparison);
 831                         false_comparison = flip_comparison(false_comparison);
 832                 }
 833
 834                 if (!true_comparison && !false_comparison)
 835                         continue;
 836
 837                 if (true_comparison)
 838                         true_state = alloc_compare_state(left_var, left_vsl, true_comparison, right_var, right_vsl);
 839                 else
 840                         true_state = NULL;
 841                 if (false_comparison)
 842                         false_state = alloc_compare_state(left_var, left_vsl, false_comparison, right_var, right_vsl);
 843                 else
 844                         false_state = NULL;
 845
 846                 snprintf(state_name, sizeof(state_name), "%s vs %s", left_var, right_var);
 847                 set_true_false_states(compare_id, state_name, NULL, true_state, false_state);
 848                 FOR_EACH_PTR(left_vsl, vs) {
 849                         save_link_var_sym(vs->var, vs->sym, state_name);
 850                 } END_FOR_EACH_PTR(vs);
 851                 FOR_EACH_PTR(right_vsl, vs) {
 852                         save_link_var_sym(vs->var, vs->sym, state_name);
 853                 } END_FOR_EACH_PTR(vs);
 854                 if (!vsl_to_sym(left_vsl))
 855                         save_link_var_sym(left_var, NULL, state_name);
 856                 if (!vsl_to_sym(right_vsl))
 857                         save_link_var_sym(right_var, NULL, state_name);
 858         } END_FOR_EACH_PTR(tmp);
 859 }
 860
 861 static void update_tf_data(struct stree *pre_stree,
 862                 const char *left_name, struct var_sym_list *left_vsl,
 863                 const char *right_name, struct var_sym_list *right_vsl,
 864                 int true_comparison, int false_comparison)
 865 {
 866         struct smatch_state *state;
 867
 868         state = get_state_stree(pre_stree, link_id, right_name, vsl_to_sym(right_vsl));
 869         if (state)
 870                 update_tf_links(pre_stree, left_name, left_vsl, true_comparison, false_comparison, right_name, right_vsl, state->data);
 871
 872         state = get_state_stree(pre_stree, link_id, left_name, vsl_to_sym(left_vsl));
 873         if (state)
 874                 update_tf_links(pre_stree, right_name, right_vsl, flip_comparison(true_comparison), flip_comparison(false_comparison), left_name, left_vsl, state->data);
 875 }
 876
 877 static void match_compare(struct expression *expr)
 878 {
 879         char *left = NULL;
 880         char *right = NULL;
 881         struct symbol *left_sym, *right_sym;
 882         struct var_sym_list *left_vsl, *right_vsl;
 883         int op, false_op;
 884         int orig_comparison;
 885         struct smatch_state *true_state, *false_state;
 886         char state_name[256];
 887         struct stree *pre_stree;
 888
 889         if (expr->type != EXPR_COMPARE)
 890                 return;
 891         left = chunk_to_var_sym(expr->left, &left_sym);
 892         if (!left)
 893                 goto free;
 894         left_vsl = expr_to_vsl(expr->left);
 895         right = chunk_to_var_sym(expr->right, &right_sym);
 896         if (!right)
 897                 goto free;
 898         right_vsl = expr_to_vsl(expr->right);
 899
 900         if (strcmp(left, right) > 0) {
 901                 struct symbol *tmp_sym = left_sym;
 902                 char *tmp_name = left;
 903                 struct var_sym_list *tmp_vsl = left_vsl;
 904
 905                 left = right;
 906                 left_sym = right_sym;
 907                 left_vsl = right_vsl;
 908                 right = tmp_name;
 909                 right_sym = tmp_sym;
 910                 right_vsl = tmp_vsl;
 911                 op = flip_comparison(expr->op);
 912         } else {
 913                 op = expr->op;
 914         }
 915         false_op = negate_comparison(op);
 916
 917         orig_comparison = get_comparison_strings(left, right);
 918         op = filter_comparison(orig_comparison, op);
 919         false_op = filter_comparison(orig_comparison, false_op);
 920
 921         snprintf(state_name, sizeof(state_name), "%s vs %s", left, right);
 922         true_state = alloc_compare_state(left, left_vsl, op, right, right_vsl);
 923         false_state = alloc_compare_state(left, left_vsl, false_op, right, right_vsl);
 924
 925         pre_stree = clone_stree(__get_cur_stree());
 926         update_tf_data(pre_stree, left, left_vsl, right, right_vsl, op, false_op);
 927         free_stree(&pre_stree);
 928
 929         set_true_false_states(compare_id, state_name, NULL, true_state, false_state);
 930         save_link(expr->left, state_name);
 931         save_link(expr->right, state_name);
 932 free:
 933         free_string(left);
 934         free_string(right);
 935 }
 936
 937 static void add_comparison_var_sym(const char *left_name,
 938                 struct var_sym_list *left_vsl,
 939                 int comparison,
 940                 const char *right_name, struct var_sym_list *right_vsl)
 941 {
 942         struct smatch_state *state;
 943         struct var_sym *vs;
 944         char state_name[256];
 945
 946         if (strcmp(left_name, right_name) > 0) {
 947                 const char *tmp_name = left_name;
 948                 struct var_sym_list *tmp_vsl = left_vsl;
 949
 950                 left_name = right_name;
 951                 left_vsl = right_vsl;
 952                 right_name = tmp_name;
 953                 right_vsl = tmp_vsl;
 954                 comparison = flip_comparison(comparison);
 955         }
 956         snprintf(state_name, sizeof(state_name), "%s vs %s", left_name, right_name);
 957         state = alloc_compare_state(left_name, left_vsl, comparison, right_name, right_vsl);
 958
 959         set_state(compare_id, state_name, NULL, state);
 960
 961         FOR_EACH_PTR(left_vsl, vs) {
 962                 save_link_var_sym(vs->var, vs->sym, state_name);
 963         } END_FOR_EACH_PTR(vs);
 964         FOR_EACH_PTR(right_vsl, vs) {
 965                 save_link_var_sym(vs->var, vs->sym, state_name);
 966         } END_FOR_EACH_PTR(vs);
 967 }
 968
 969 static void add_comparison(struct expression *left, int comparison, struct expression *right)
 970 {
 971         char *left_name = NULL;
 972         char *right_name = NULL;
 973         struct symbol *left_sym, *right_sym;
 974         struct var_sym_list *left_vsl, *right_vsl;
 975         struct smatch_state *state;
 976         char state_name[256];
 977
 978         left_name = chunk_to_var_sym(left, &left_sym);
 979         if (!left_name)
 980                 goto free;
 981         left_vsl = expr_to_vsl(left);
 982         right_name = chunk_to_var_sym(right, &right_sym);
 983         if (!right_name)
 984                 goto free;
 985         right_vsl = expr_to_vsl(right);
 986
 987         if (strcmp(left_name, right_name) > 0) {
 988                 struct symbol *tmp_sym = left_sym;
 989                 char *tmp_name = left_name;
 990                 struct var_sym_list *tmp_vsl = left_vsl;
 991
 992                 left_name = right_name;
 993                 left_sym = right_sym;
 994                 left_vsl = right_vsl;
 995                 right_name = tmp_name;
 996                 right_sym = tmp_sym;
 997                 right_vsl = tmp_vsl;
 998                 comparison = flip_comparison(comparison);
 999         }
1000         snprintf(state_name, sizeof(state_name), "%s vs %s", left_name, right_name);
1001         state = alloc_compare_state(left_name, left_vsl, comparison, right_name, right_vsl);
1002
1003         set_state(compare_id, state_name, NULL, state);
1004         save_link(left, state_name);
1005         save_link(right, state_name);
1006
1007 free:
1008         free_string(left_name);
1009         free_string(right_name);
1010 }
1011
1012 static void match_assign_add(struct expression *expr)
1013 {
1014         struct expression *right;
1015         struct expression *r_left, *r_right;
1016         sval_t left_tmp, right_tmp;
1017
1018         right = strip_expr(expr->right);
1019         r_left = strip_expr(right->left);
1020         r_right = strip_expr(right->right);
1021
1022         get_absolute_min(r_left, &left_tmp);
1023         get_absolute_min(r_right, &right_tmp);
1024
1025         if (left_tmp.value > 0)
1026                 add_comparison(expr->left, '>', r_right);
1027         else if (left_tmp.value == 0)
1028                 add_comparison(expr->left, SPECIAL_GTE, r_right);
1029
1030         if (right_tmp.value > 0)
1031                 add_comparison(expr->left, '>', r_left);
1032         else if (right_tmp.value == 0)
1033                 add_comparison(expr->left, SPECIAL_GTE, r_left);
1034 }
1035
1036 static void match_assign_sub(struct expression *expr)
1037 {
1038         struct expression *right;
1039         struct expression *r_left, *r_right;
1040         int comparison;
1041         sval_t min;
1042
1043         right = strip_expr(expr->right);
1044         r_left = strip_expr(right->left);
1045         r_right = strip_expr(right->right);
1046
1047         if (get_absolute_min(r_right, &min) && sval_is_negative(min))
1048                 return;
1049
1050         comparison = get_comparison(r_left, r_right);
1051
1052         switch (comparison) {
1053         case '>':
1054         case SPECIAL_GTE:
1055                 if (implied_not_equal(r_right, 0))
1056                         add_comparison(expr->left, '>', r_left);
1057                 else
1058                         add_comparison(expr->left, SPECIAL_GTE, r_left);
1059                 return;
1060         }
1061 }
1062
1063 static void match_assign_divide(struct expression *expr)
1064 {
1065         struct expression *right;
1066         struct expression *r_left, *r_right;
1067         sval_t min;
1068
1069         right = strip_expr(expr->right);
1070         r_left = strip_expr(right->left);
1071         r_right = strip_expr(right->right);
1072         if (!get_implied_min(r_right, &min) || min.value <= 1)
1073                 return;
1074
1075         add_comparison(expr->left, '<', r_left);
1076 }
1077
1078 static void match_binop_assign(struct expression *expr)
1079 {
1080         struct expression *right;
1081
1082         right = strip_expr(expr->right);
1083         if (right->op == '+')
1084                 match_assign_add(expr);
1085         if (right->op == '-')
1086                 match_assign_sub(expr);
1087         if (right->op == '/')
1088                 match_assign_divide(expr);
1089 }
1090
1091 static void copy_comparisons(struct expression *left, struct expression *right)
1092 {
1093         struct string_list *links;
1094         struct smatch_state *state;
1095         struct compare_data *data;
1096         struct symbol *left_sym, *right_sym;
1097         char *left_var = NULL;
1098         char *right_var = NULL;
1099         struct var_sym_list *left_vsl;
1100         const char *var;
1101         struct var_sym_list *vsl;
1102         int comparison;
1103         char *tmp;
1104
1105         left_var = chunk_to_var_sym(left, &left_sym);
1106         if (!left_var)
1107                 goto done;
1108         left_vsl = expr_to_vsl(left);
1109         right_var = chunk_to_var_sym(right, &right_sym);
1110         if (!right_var)
1111                 goto done;
1112
1113         state = get_state(link_id, right_var, right_sym);
1114         if (!state)
1115                 return;
1116         links = state->data;
1117
1118         FOR_EACH_PTR(links, tmp) {
1119                 state = get_state(compare_id, tmp, NULL);
1120                 if (!state || !state->data)
1121                         continue;
1122                 data = state->data;
1123                 comparison = data->comparison;
1124                 var = data->var2;
1125                 vsl = data->vsl2;
1126                 if (strcmp(var, right_var) == 0) {
1127                         var = data->var1;
1128                         vsl = data->vsl1;
1129                         comparison = flip_comparison(comparison);
1130                 }
1131                 add_comparison_var_sym(left_var, left_vsl, comparison, var, vsl);
1132         } END_FOR_EACH_PTR(tmp);
1133
1134 done:
1135         free_string(right_var);
1136 }
1137
1138 static void match_assign(struct expression *expr)
1139 {
1140         struct expression *right;
1141
1142         if (expr->op != '=')
1143                 return;
1144
1145         if (is_struct(expr->left))
1146                 return;
1147
1148         copy_comparisons(expr->left, expr->right);
1149         add_comparison(expr->left, SPECIAL_EQUAL, expr->right);
1150
1151         right = strip_expr(expr->right);
1152         if (right->type == EXPR_BINOP)
1153                 match_binop_assign(expr);
1154 }
1155
1156 int get_comparison_strings(const char *one, const char *two)
1157 {
1158         char buf[256];
1159         struct smatch_state *state;
1160         int invert = 0;
1161         int ret = 0;
1162
1163         if (strcmp(one, two) == 0)
1164                 return SPECIAL_EQUAL;
1165
1166         if (strcmp(one, two) > 0) {
1167                 const char *tmp = one;
1168
1169                 one = two;
1170                 two = tmp;
1171                 invert = 1;
1172         }
1173
1174         snprintf(buf, sizeof(buf), "%s vs %s", one, two);
1175         state = get_state(compare_id, buf, NULL);
1176         if (state)
1177                 ret = state_to_comparison(state);
1178
1179         if (invert)
1180                 ret = flip_comparison(ret);
1181
1182         return ret;
1183 }
1184
1185 int get_comparison(struct expression *a, struct expression *b)
1186 {
1187         char *one = NULL;
1188         char *two = NULL;
1189         int ret = 0;
1190
1191         one = chunk_to_var(a);
1192         if (!one)
1193                 goto free;
1194         two = chunk_to_var(b);
1195         if (!two)
1196                 goto free;
1197
1198         ret = get_comparison_strings(one, two);
1199 free:
1200         free_string(one);
1201         free_string(two);
1202         return ret;
1203 }
1204
1205 int possible_comparison(struct expression *a, int comparison, struct expression *b)
1206 {
1207         char *one = NULL;
1208         char *two = NULL;
1209         int ret = 0;
1210         char buf[256];
1211         struct sm_state *sm;
1212         int saved;
1213
1214         one = chunk_to_var(a);
1215         if (!one)
1216                 goto free;
1217         two = chunk_to_var(b);
1218         if (!two)
1219                 goto free;
1220
1221
1222         if (strcmp(one, two) == 0 && comparison == SPECIAL_EQUAL) {
1223                 ret = 1;
1224                 goto free;
1225         }
1226
1227         if (strcmp(one, two) > 0) {
1228                 char *tmp = one;
1229
1230                 one = two;
1231                 two = tmp;
1232                 comparison = flip_comparison(comparison);
1233         }
1234
1235         snprintf(buf, sizeof(buf), "%s vs %s", one, two);
1236         sm = get_sm_state(compare_id, buf, NULL);
1237         if (!sm)
1238                 goto free;
1239
1240         FOR_EACH_PTR(sm->possible, sm) {
1241                 if (!sm->state->data)
1242                         continue;
1243                 saved = ((struct compare_data *)sm->state->data)->comparison;
1244                 if (saved == comparison)
1245                         ret = 1;
1246                 if (comparison == SPECIAL_EQUAL &&
1247                     (saved == SPECIAL_LTE ||
1248                      saved == SPECIAL_GTE ||
1249                      saved == SPECIAL_UNSIGNED_LTE ||
1250                      saved == SPECIAL_UNSIGNED_GTE))
1251                         ret = 1;
1252                 if (ret == 1)
1253                         goto free;
1254         } END_FOR_EACH_PTR(sm);
1255
1256         return ret;
1257 free:
1258         free_string(one);
1259         free_string(two);
1260         return ret;
1261 }
1262
1263 struct state_list *get_all_comparisons(struct expression *expr)
1264 {
1265         struct smatch_state *state;
1266         struct string_list *links;
1267         struct state_list *ret = NULL;
1268         struct sm_state *sm;
1269         char *tmp;
1270
1271         state = get_state_expr(link_id, expr);
1272         if (!state)
1273                 return NULL;
1274         links = state->data;
1275
1276         FOR_EACH_PTR(links, tmp) {
1277                 sm = get_sm_state(compare_id, tmp, NULL);
1278                 if (!sm)
1279                         continue;
1280                 // FIXME have to compare name with vsl
1281                 add_ptr_list(&ret, sm);
1282         } END_FOR_EACH_PTR(tmp);
1283
1284         return ret;
1285 }
1286
1287 struct state_list *get_all_possible_equal_comparisons(struct expression *expr)
1288 {
1289         struct smatch_state *state;
1290         struct string_list *links;
1291         struct state_list *ret = NULL;
1292         struct sm_state *sm;
1293         char *tmp;
1294
1295         state = get_state_expr(link_id, expr);
1296         if (!state)
1297                 return NULL;
1298         links = state->data;
1299
1300         FOR_EACH_PTR(links, tmp) {
1301                 sm = get_sm_state(compare_id, tmp, NULL);
1302                 if (!sm)
1303                         continue;
1304                 if (!strchr(sm->state->name, '='))
1305                         continue;
1306                 if (strcmp(sm->state->name, "!=") == 0)
1307                         continue;
1308                 add_ptr_list(&ret, sm);
1309         } END_FOR_EACH_PTR(tmp);
1310
1311         return ret;
1312 }
1313
1314 static void update_links_from_call(struct expression *left,
1315                                    int left_compare,
1316                                    struct expression *right)
1317 {
1318         struct string_list *links;
1319         struct smatch_state *state;
1320         struct compare_data *data;
1321         struct symbol *left_sym, *right_sym;
1322         char *left_var = NULL;
1323         char *right_var = NULL;
1324         struct var_sym_list *left_vsl;
1325         const char *var;
1326         struct var_sym_list *vsl;
1327         int comparison;
1328         char *tmp;
1329
1330         left_var = chunk_to_var_sym(left, &left_sym);
1331         if (!left_var)
1332                 goto done;
1333         left_vsl = expr_to_vsl(left);
1334         right_var = chunk_to_var_sym(right, &right_sym);
1335         if (!right_var)
1336                 goto done;
1337
1338         state = get_state(link_id, right_var, right_sym);
1339         if (!state)
1340                 return;
1341         links = state->data;
1342
1343         FOR_EACH_PTR(links, tmp) {
1344                 state = get_state(compare_id, tmp, NULL);
1345                 if (!state || !state->data)
1346                         continue;
1347                 data = state->data;
1348                 comparison = data->comparison;
1349                 var = data->var2;
1350                 vsl = data->vsl2;
1351                 if (strcmp(var, right_var) == 0) {
1352                         var = data->var1;
1353                         vsl = data->vsl1;
1354                         comparison = flip_comparison(comparison);
1355                 }
1356                 comparison = combine_comparisons(left_compare, comparison);
1357                 if (!comparison)
1358                         continue;
1359                 add_comparison_var_sym(left_var, left_vsl, comparison, var, vsl);
1360         } END_FOR_EACH_PTR(tmp);
1361
1362 done:
1363         free_string(right_var);
1364 }
1365
1366 void __add_comparison_info(struct expression *expr, struct expression *call, const char *range)
1367 {
1368         struct expression *arg;
1369         int comparison;
1370         const char *c = range;
1371
1372         if (!str_to_comparison_arg(c, call, &comparison, &arg))
1373                 return;
1374         update_links_from_call(expr, comparison, arg);
1375         add_comparison(expr, comparison, arg);
1376 }
1377
1378 static char *range_comparison_to_param_helper(struct expression *expr, char starts_with, int ignore)
1379 {
1380         struct symbol *param;
1381         char *var = NULL;
1382         char buf[256];
1383         char *ret_str = NULL;
1384         int compare;
1385         int i;
1386
1387         var = chunk_to_var(expr);
1388         if (!var)
1389                 goto free;
1390
1391         i = -1;
1392         FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
1393                 i++;
1394                 if (i == ignore)
1395                         continue;
1396                 if (!param->ident)
1397                         continue;
1398                 snprintf(buf, sizeof(buf), "%s orig", param->ident->name);
1399                 compare = get_comparison_strings(var, buf);
1400                 if (!compare)
1401                         continue;
1402                 if (show_special(compare)[0] != starts_with)
1403                         continue;
1404                 snprintf(buf, sizeof(buf), "[%s$%d]", show_special(compare), i);
1405                 ret_str = alloc_sname(buf);
1406                 break;
1407         } END_FOR_EACH_PTR(param);
1408
1409 free:
1410         free_string(var);
1411         return ret_str;
1412 }
1413
1414 char *expr_equal_to_param(struct expression *expr, int ignore)
1415 {
1416         return range_comparison_to_param_helper(expr, '=', ignore);
1417 }
1418
1419 char *expr_lte_to_param(struct expression *expr, int ignore)
1420 {
1421         return range_comparison_to_param_helper(expr, '<', ignore);
1422 }
1423
1424 char *expr_param_comparison(struct expression *expr, int ignore)
1425 {
1426         struct symbol *param;
1427         char *var = NULL;
1428         char buf[256];
1429         char *ret_str = NULL;
1430         int compare;
1431         int i;
1432
1433         var = chunk_to_var(expr);
1434         if (!var)
1435                 goto free;
1436
1437         i = -1;
1438         FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, param) {
1439                 i++;
1440                 if (i == ignore)
1441                         continue;
1442                 if (!param->ident)
1443                         continue;
1444                 snprintf(buf, sizeof(buf), "%s orig", param->ident->name);
1445                 compare = get_comparison_strings(var, buf);
1446                 if (!compare)
1447                         continue;
1448                 snprintf(buf, sizeof(buf), "[%s$%d]", show_special(compare), i);
1449                 ret_str = alloc_sname(buf);
1450                 break;
1451         } END_FOR_EACH_PTR(param);
1452
1453 free:
1454         free_string(var);
1455         return ret_str;
1456 }
1457
1458 static void free_data(struct symbol *sym)
1459 {
1460         if (__inline_fn)
1461                 return;
1462         clear_compare_data_alloc();
1463 }
1464
1465 void register_comparison(int id)
1466 {
1467         compare_id = id;
1468         add_hook(&match_compare, CONDITION_HOOK);
1469         add_hook(&match_assign, ASSIGNMENT_HOOK);
1470         add_hook(&save_start_states, AFTER_DEF_HOOK);
1471         add_unmatched_state_hook(compare_id, unmatched_comparison);
1472         add_merge_hook(compare_id, &merge_compare_states);
1473         add_hook(&free_data, AFTER_FUNC_HOOK);
1474 }
1475
1476 void register_comparison_links(int id)
1477 {
1478         link_id = id;
1479         add_merge_hook(link_id, &merge_links);
1480         add_modification_hook(link_id, &match_modify);
1481 }