1 /* 2 * Copyright (C) 2006 Dan Carpenter. 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 * Miscellaneous helper functions. 20 */ 21 22 #include <stdlib.h> 23 #include <stdio.h> 24 #include "allocate.h" 25 #include "smatch.h" 26 #include "smatch_extra.h" 27 #include "smatch_slist.h" 28 29 #define VAR_LEN 512 30 31 char *alloc_string(const char *str) 32 { 33 char *tmp; 34 35 if (!str) 36 return NULL; 37 tmp = malloc(strlen(str) + 1); 38 strcpy(tmp, str); 39 return tmp; 40 } 41 42 char *alloc_string_newline(const char *str) 43 { 44 char *tmp; 45 int len; 46 47 if (!str) 48 return NULL; 49 len = strlen(str); 50 tmp = malloc(len + 2); 51 snprintf(tmp, len + 2, "%s\n", str); 52 return tmp; 53 } 54 55 void free_string(char *str) 56 { 57 free(str); 58 } 59 60 void remove_parens(char *str) 61 { 62 char *src, *dst; 63 64 dst = src = str; 65 while (*src != '\0') { 66 if (*src == '(' || *src == ')') { 67 src++; 68 continue; 69 } 70 *dst++ = *src++; 71 } 72 *dst = *src; 73 } 74 75 struct smatch_state *alloc_state_num(int num) 76 { 77 struct smatch_state *state; 78 static char buff[256]; 79 80 state = __alloc_smatch_state(0); 81 snprintf(buff, 255, "%d", num); 82 buff[255] = '\0'; 83 state->name = alloc_string(buff); 84 state->data = INT_PTR(num); 85 return state; 86 } 87 88 struct smatch_state *alloc_state_str(const char *name) 89 { 90 struct smatch_state *state; 91 92 state = __alloc_smatch_state(0); 93 state->name = alloc_string(name); 94 return state; 95 } 96 97 struct smatch_state *merge_str_state(struct smatch_state *s1, struct smatch_state *s2) 98 { 99 if (!s1->name || !s2->name) 100 return &merged; 101 if (strcmp(s1->name, s2->name) == 0) 102 return s1; 103 return &merged; 104 } 105 106 struct smatch_state *alloc_state_expr(struct expression *expr) 107 { 108 struct smatch_state *state; 109 char *name; 110 111 expr = strip_expr(expr); 112 name = expr_to_str(expr); 113 if (!name) 114 return NULL; 115 116 state = __alloc_smatch_state(0); 117 state->name = alloc_sname(name); 118 free_string(name); 119 state->data = expr; 120 return state; 121 } 122 123 void append(char *dest, const char *data, int buff_len) 124 { 125 strncat(dest, data, buff_len - strlen(dest) - 1); 126 } 127 128 /* 129 * If you have "foo(a, b, 1);" then use 130 * get_argument_from_call_expr(expr, 0) to return the expression for 131 * a. Yes, it does start counting from 0. 132 */ 133 struct expression *get_argument_from_call_expr(struct expression_list *args, 134 int num) 135 { 136 struct expression *expr; 137 int i = 0; 138 139 if (!args) 140 return NULL; 141 142 FOR_EACH_PTR(args, expr) { 143 if (i == num) 144 return expr; 145 i++; 146 } END_FOR_EACH_PTR(expr); 147 return NULL; 148 } 149 150 struct expression *get_array_expr(struct expression *expr) 151 { 152 struct expression *parent; 153 struct symbol *type; 154 155 if (expr->type != EXPR_BINOP || expr->op != '+') 156 return NULL; 157 158 type = get_type(expr->left); 159 if (!type) 160 return NULL; 161 if (type->type == SYM_ARRAY) 162 return expr->left; 163 if (type->type != SYM_PTR) 164 return NULL; 165 166 parent = expr_get_parent_expr(expr); 167 if (!parent) /* Sometimes we haven't set up the ->parent yet. FIXME!! */ 168 return expr->left; 169 if (parent->type == EXPR_PREOP && parent->op == '*') 170 return expr->left; 171 172 return NULL; 173 } 174 175 static void __get_variable_from_expr(struct symbol **sym_ptr, char *buf, 176 struct expression *expr, int len, 177 int *complicated) 178 { 179 if (!expr) { 180 /* can't happen on valid code */ 181 *complicated = 1; 182 return; 183 } 184 185 switch (expr->type) { 186 case EXPR_DEREF: { 187 struct expression *deref; 188 int op; 189 190 deref = expr->deref; 191 op = deref->op; 192 if (deref->type == EXPR_PREOP && op == '*') { 193 struct expression *unop = strip_expr(deref->unop); 194 195 if (unop->type == EXPR_PREOP && unop->op == '&') { 196 deref = unop->unop; 197 op = '.'; 198 } else { 199 if (!is_pointer(deref) && !is_pointer(deref->unop)) 200 op = '.'; 201 deref = deref->unop; 202 } 203 } 204 205 __get_variable_from_expr(sym_ptr, buf, deref, len, complicated); 206 207 if (op == '*') 208 append(buf, "->", len); 209 else 210 append(buf, ".", len); 211 212 if (expr->member) 213 append(buf, expr->member->name, len); 214 else 215 append(buf, "unknown_member", len); 216 217 return; 218 } 219 case EXPR_SYMBOL: 220 if (expr->symbol_name) 221 append(buf, expr->symbol_name->name, len); 222 if (sym_ptr) { 223 if (*sym_ptr) 224 *complicated = 1; 225 *sym_ptr = expr->symbol; 226 } 227 return; 228 case EXPR_PREOP: { 229 const char *tmp; 230 231 if (get_expression_statement(expr)) { 232 *complicated = 2; 233 return; 234 } 235 236 if (expr->op == '(') { 237 if (expr->unop->type != EXPR_SYMBOL) 238 append(buf, "(", len); 239 } else if (expr->op != '*' || !get_array_expr(expr->unop)) { 240 tmp = show_special(expr->op); 241 append(buf, tmp, len); 242 } 243 __get_variable_from_expr(sym_ptr, buf, expr->unop, 244 len, complicated); 245 246 if (expr->op == '(' && expr->unop->type != EXPR_SYMBOL) 247 append(buf, ")", len); 248 249 if (expr->op == SPECIAL_DECREMENT || 250 expr->op == SPECIAL_INCREMENT) 251 *complicated = 1; 252 253 return; 254 } 255 case EXPR_POSTOP: { 256 const char *tmp; 257 258 __get_variable_from_expr(sym_ptr, buf, expr->unop, 259 len, complicated); 260 tmp = show_special(expr->op); 261 append(buf, tmp, len); 262 263 if (expr->op == SPECIAL_DECREMENT || expr->op == SPECIAL_INCREMENT) 264 *complicated = 1; 265 return; 266 } 267 case EXPR_ASSIGNMENT: 268 case EXPR_COMPARE: 269 case EXPR_LOGICAL: 270 case EXPR_BINOP: { 271 char tmp[10]; 272 struct expression *array_expr; 273 274 *complicated = 1; 275 array_expr = get_array_expr(expr); 276 if (array_expr) { 277 __get_variable_from_expr(sym_ptr, buf, array_expr, len, complicated); 278 append(buf, "[", len); 279 } else { 280 __get_variable_from_expr(sym_ptr, buf, expr->left, len, complicated); 281 snprintf(tmp, sizeof(tmp), " %s ", show_special(expr->op)); 282 append(buf, tmp, len); 283 } 284 __get_variable_from_expr(NULL, buf, expr->right, len, complicated); 285 if (array_expr) 286 append(buf, "]", len); 287 return; 288 } 289 case EXPR_VALUE: { 290 sval_t sval = {}; 291 char tmp[25]; 292 293 *complicated = 1; 294 if (!get_value(expr, &sval)) 295 return; 296 snprintf(tmp, 25, "%s", sval_to_numstr(sval)); 297 append(buf, tmp, len); 298 return; 299 } 300 case EXPR_FVALUE: { 301 sval_t sval = {}; 302 char tmp[25]; 303 304 *complicated = 1; 305 if (!get_value(expr, &sval)) 306 return; 307 snprintf(tmp, 25, "%s", sval_to_numstr(sval)); 308 append(buf, tmp, len); 309 return; 310 } 311 case EXPR_STRING: 312 append(buf, "\"", len); 313 if (expr->string) 314 append(buf, expr->string->data, len); 315 append(buf, "\"", len); 316 return; 317 case EXPR_CALL: { 318 struct expression *tmp; 319 int i; 320 321 *complicated = 1; 322 __get_variable_from_expr(NULL, buf, expr->fn, len, complicated); 323 append(buf, "(", len); 324 i = 0; 325 FOR_EACH_PTR(expr->args, tmp) { 326 if (i++) 327 append(buf, ", ", len); 328 __get_variable_from_expr(NULL, buf, tmp, len, complicated); 329 } END_FOR_EACH_PTR(tmp); 330 append(buf, ")", len); 331 return; 332 } 333 case EXPR_CAST: 334 case EXPR_FORCE_CAST: 335 __get_variable_from_expr(sym_ptr, buf, 336 expr->cast_expression, len, 337 complicated); 338 return; 339 case EXPR_SIZEOF: { 340 sval_t sval; 341 int size; 342 char tmp[25]; 343 344 if (expr->cast_type && get_base_type(expr->cast_type)) { 345 size = type_bytes(get_base_type(expr->cast_type)); 346 snprintf(tmp, 25, "%d", size); 347 append(buf, tmp, len); 348 } else if (get_value(expr, &sval)) { 349 snprintf(tmp, 25, "%s", sval_to_str(sval)); 350 append(buf, tmp, len); 351 } 352 return; 353 } 354 case EXPR_IDENTIFIER: 355 *complicated = 1; 356 if (expr->expr_ident) 357 append(buf, expr->expr_ident->name, len); 358 return; 359 case EXPR_SELECT: 360 case EXPR_CONDITIONAL: 361 *complicated = 1; 362 append(buf, "(", len); 363 __get_variable_from_expr(NULL, buf, expr->conditional, len, complicated); 364 append(buf, ") ?", len); 365 if (expr->cond_true) 366 __get_variable_from_expr(NULL, buf, expr->cond_true, len, complicated); 367 append(buf, ":", len); 368 __get_variable_from_expr(NULL, buf, expr->cond_false, len, complicated); 369 return; 370 default: { 371 char tmp[64]; 372 373 snprintf(tmp, sizeof(tmp), "$expr_%p(%d)", expr, expr->type); 374 append(buf, tmp, len); 375 *complicated = 1; 376 } 377 return; 378 } 379 } 380 381 struct expr_str_cache_results { 382 struct expression *expr; 383 char str[VAR_LEN]; 384 struct symbol *sym; 385 int complicated; 386 }; 387 388 static void get_variable_from_expr(struct symbol **sym_ptr, char *buf, 389 struct expression *expr, int len, 390 int *complicated) 391 { 392 static struct expr_str_cache_results cached[8]; 393 struct symbol *tmp_sym = NULL; 394 static int idx; 395 int i; 396 397 for (i = 0; i < ARRAY_SIZE(cached); i++) { 398 if (expr == cached[i].expr) { 399 strncpy(buf, cached[i].str, len); 400 if (sym_ptr) 401 *sym_ptr = cached[i].sym; 402 *complicated = cached[i].complicated; 403 return; 404 } 405 } 406 407 __get_variable_from_expr(&tmp_sym, buf, expr, len, complicated); 408 if (sym_ptr) 409 *sym_ptr = tmp_sym; 410 411 if (expr->smatch_flags & Tmp) 412 return; 413 414 cached[idx].expr = expr; 415 strncpy(cached[idx].str, buf, VAR_LEN); 416 cached[idx].sym = tmp_sym; 417 cached[idx].complicated = *complicated; 418 419 idx = (idx + 1) % ARRAY_SIZE(cached); 420 } 421 422 /* 423 * This is returns a stylized "c looking" representation of the 424 * variable name. 425 * 426 * It uses the same buffer every time so you have to save the result 427 * yourself if you want to keep it. 428 * 429 */ 430 431 char *expr_to_str_sym(struct expression *expr, struct symbol **sym_ptr) 432 { 433 static char var_name[VAR_LEN]; 434 int complicated = 0; 435 436 if (sym_ptr) 437 *sym_ptr = NULL; 438 var_name[0] = '\0'; 439 440 if (!expr) 441 return NULL; 442 get_variable_from_expr(sym_ptr, var_name, expr, sizeof(var_name), 443 &complicated); 444 if (complicated < 2) 445 return alloc_string(var_name); 446 else 447 return NULL; 448 } 449 450 char *expr_to_str(struct expression *expr) 451 { 452 return expr_to_str_sym(expr, NULL); 453 } 454 455 /* 456 * get_variable_from_expr_simple() only returns simple variables. 457 * If it's a complicated variable like a->foo[x] instead of just 'a->foo' 458 * then it returns NULL. 459 */ 460 char *expr_to_var_sym(struct expression *expr, 461 struct symbol **sym_ptr) 462 { 463 static char var_name[VAR_LEN]; 464 int complicated = 0; 465 466 if (sym_ptr) 467 *sym_ptr = NULL; 468 var_name[0] = '\0'; 469 470 if (!expr) 471 return NULL; 472 expr = strip_expr(expr); 473 get_variable_from_expr(sym_ptr, var_name, expr, sizeof(var_name), 474 &complicated); 475 476 if (complicated) { 477 if (sym_ptr) 478 *sym_ptr = NULL; 479 return NULL; 480 } 481 return alloc_string(var_name); 482 } 483 484 char *expr_to_var(struct expression *expr) 485 { 486 return expr_to_var_sym(expr, NULL); 487 } 488 489 struct symbol *expr_to_sym(struct expression *expr) 490 { 491 struct symbol *sym; 492 char *name; 493 494 name = expr_to_var_sym(expr, &sym); 495 free_string(name); 496 return sym; 497 } 498 499 int get_complication_score(struct expression *expr) 500 { 501 expr = strip_expr(expr); 502 503 /* 504 * Don't forget to keep get_complication_score() and store_all_links() 505 * in sync. 506 * 507 */ 508 509 if (!expr) 510 return 990; 511 512 switch (expr->type) { 513 case EXPR_CALL: 514 return 991; 515 case EXPR_COMPARE: 516 case EXPR_BINOP: 517 return get_complication_score(expr->left) + 518 get_complication_score(expr->right); 519 case EXPR_SYMBOL: 520 return 1; 521 case EXPR_PREOP: 522 if (expr->op == '*' || expr->op == '(') 523 return get_complication_score(expr->unop); 524 return 993; 525 case EXPR_DEREF: 526 return get_complication_score(expr->deref); 527 case EXPR_VALUE: 528 case EXPR_SIZEOF: 529 return 0; 530 default: 531 return 994; 532 } 533 } 534 535 struct expression *reorder_expr_alphabetically(struct expression *expr) 536 { 537 struct expression *ret; 538 char *left, *right; 539 540 if (expr->type != EXPR_BINOP) 541 return expr; 542 if (expr->op != '+' && expr->op != '*') 543 return expr; 544 545 left = expr_to_var(expr->left); 546 right = expr_to_var(expr->right); 547 ret = expr; 548 if (!left || !right) 549 goto free; 550 if (strcmp(left, right) <= 0) 551 goto free; 552 553 ret = binop_expression(expr->right, expr->op, expr->left); 554 free: 555 free_string(left); 556 free_string(right); 557 558 return ret; 559 } 560 561 char *expr_to_chunk_helper(struct expression *expr, struct symbol **sym, struct var_sym_list **vsl) 562 { 563 struct var_sym_list *tmp_vsl; 564 char *name; 565 struct symbol *tmp; 566 int score; 567 568 if (vsl) 569 *vsl = NULL; 570 if (sym) 571 *sym = NULL; 572 573 expr = strip_parens(expr); 574 if (!expr) 575 return NULL; 576 577 name = expr_to_var_sym(expr, &tmp); 578 if (name && tmp) { 579 if (sym) 580 *sym = tmp; 581 if (vsl) 582 add_var_sym(vsl, name, tmp); 583 return name; 584 } 585 free_string(name); 586 587 score = get_complication_score(expr); 588 if (score <= 0 || score > 2) 589 return NULL; 590 591 tmp_vsl = expr_to_vsl(expr); 592 if (vsl) { 593 *vsl = tmp_vsl; 594 if (!*vsl) 595 return NULL; 596 } 597 if (sym) { 598 if (ptr_list_size((struct ptr_list *)tmp_vsl) == 1) { 599 struct var_sym *vs; 600 601 vs = first_ptr_list((struct ptr_list *)tmp_vsl); 602 *sym = vs->sym; 603 } 604 } 605 606 expr = reorder_expr_alphabetically(expr); 607 608 return expr_to_str(expr); 609 } 610 611 char *expr_to_known_chunk_sym(struct expression *expr, struct symbol **sym) 612 { 613 return expr_to_chunk_helper(expr, sym, NULL); 614 } 615 616 char *expr_to_chunk_sym_vsl(struct expression *expr, struct symbol **sym, struct var_sym_list **vsl) 617 { 618 return expr_to_chunk_helper(expr, sym, vsl); 619 } 620 621 int sym_name_is(const char *name, struct expression *expr) 622 { 623 if (!expr) 624 return 0; 625 if (expr->type != EXPR_SYMBOL) 626 return 0; 627 if (!strcmp(expr->symbol_name->name, name)) 628 return 1; 629 return 0; 630 } 631 632 int expr_is_zero(struct expression *expr) 633 { 634 sval_t sval; 635 636 if (get_value(expr, &sval) && sval.value == 0) 637 return 1; 638 return 0; 639 } 640 641 int is_array(struct expression *expr) 642 { 643 struct symbol *type; 644 645 expr = strip_expr(expr); 646 if (!expr) 647 return 0; 648 649 if (expr->type == EXPR_PREOP && expr->op == '*') { 650 expr = strip_expr(expr->unop); 651 if (!expr) 652 return 0; 653 if (expr->type == EXPR_BINOP && expr->op == '+') 654 return 1; 655 } 656 657 if (expr->type != EXPR_BINOP || expr->op != '+') 658 return 0; 659 660 type = get_type(expr->left); 661 if (!type || type->type != SYM_ARRAY) 662 return 0; 663 664 return 1; 665 } 666 667 struct expression *get_array_base(struct expression *expr) 668 { 669 if (!is_array(expr)) 670 return NULL; 671 expr = strip_expr(expr); 672 if (expr->type == EXPR_PREOP && expr->op == '*') 673 expr = strip_expr(expr->unop); 674 if (expr->type != EXPR_BINOP || expr->op != '+') 675 return NULL; 676 return strip_parens(expr->left); 677 } 678 679 struct expression *get_array_offset(struct expression *expr) 680 { 681 if (!is_array(expr)) 682 return NULL; 683 expr = strip_expr(expr); 684 if (expr->type == EXPR_PREOP && expr->op == '*') 685 expr = strip_expr(expr->unop); 686 if (expr->type != EXPR_BINOP || expr->op != '+') 687 return NULL; 688 return strip_parens(expr->right); 689 } 690 691 const char *show_state(struct smatch_state *state) 692 { 693 if (!state) 694 return NULL; 695 return state->name; 696 } 697 698 struct statement *get_expression_statement(struct expression *expr) 699 { 700 /* What are those things called? if (({....; ret;})) { ...*/ 701 702 if (expr->type != EXPR_PREOP) 703 return NULL; 704 if (expr->op != '(') 705 return NULL; 706 if (!expr->unop) 707 return NULL; 708 if (expr->unop->type != EXPR_STATEMENT) 709 return NULL; 710 if (expr->unop->statement->type != STMT_COMPOUND) 711 return NULL; 712 return expr->unop->statement; 713 } 714 715 struct expression *strip_parens(struct expression *expr) 716 { 717 if (!expr) 718 return NULL; 719 720 if (expr->type == EXPR_PREOP) { 721 if (!expr->unop) 722 return expr; /* parsing invalid code */ 723 724 if (expr->op == '(' && expr->unop->type == EXPR_STATEMENT && 725 expr->unop->statement->type == STMT_COMPOUND) 726 return expr; 727 if (expr->op == '(') 728 return strip_parens(expr->unop); 729 } 730 return expr; 731 } 732 733 static struct expression *strip_expr_helper(struct expression *expr, bool set_parent) 734 { 735 if (!expr) 736 return NULL; 737 738 switch (expr->type) { 739 case EXPR_FORCE_CAST: 740 case EXPR_CAST: 741 if (set_parent) 742 expr_set_parent_expr(expr->cast_expression, expr); 743 744 if (!expr->cast_expression) 745 return expr; 746 return strip_expr_helper(expr->cast_expression, set_parent); 747 case EXPR_PREOP: { 748 struct expression *unop; 749 750 if (!expr->unop) /* parsing invalid code */ 751 return expr; 752 if (set_parent) 753 expr_set_parent_expr(expr->unop, expr); 754 755 756 if (expr->op == '(' && expr->unop->type == EXPR_STATEMENT && 757 expr->unop->statement->type == STMT_COMPOUND) 758 return expr; 759 760 unop = strip_expr_helper(expr->unop, set_parent); 761 762 if (expr->op == '*' && unop && 763 unop->type == EXPR_PREOP && unop->op == '&') { 764 struct symbol *type = get_type(unop->unop); 765 766 if (type && type->type == SYM_ARRAY) 767 return expr; 768 return strip_expr_helper(unop->unop, set_parent); 769 } 770 771 if (expr->op == '(') 772 return unop; 773 774 return expr; 775 } 776 case EXPR_CONDITIONAL: 777 if (known_condition_true(expr->conditional)) { 778 if (expr->cond_true) { 779 if (set_parent) 780 expr_set_parent_expr(expr->cond_true, expr); 781 return strip_expr_helper(expr->cond_true, set_parent); 782 } 783 if (set_parent) 784 expr_set_parent_expr(expr->conditional, expr); 785 return strip_expr_helper(expr->conditional, set_parent); 786 } 787 if (known_condition_false(expr->conditional)) { 788 if (set_parent) 789 expr_set_parent_expr(expr->cond_false, expr); 790 return strip_expr_helper(expr->cond_false, set_parent); 791 } 792 return expr; 793 case EXPR_CALL: 794 if (sym_name_is("__builtin_expect", expr->fn) || 795 sym_name_is("__builtin_bswap16", expr->fn) || 796 sym_name_is("__builtin_bswap32", expr->fn) || 797 sym_name_is("__builtin_bswap64", expr->fn)) { 798 expr = get_argument_from_call_expr(expr->args, 0); 799 return strip_expr_helper(expr, set_parent); 800 } 801 return expr; 802 } 803 return expr; 804 } 805 806 struct expression *strip_expr(struct expression *expr) 807 { 808 return strip_expr_helper(expr, false); 809 } 810 811 struct expression *strip_expr_set_parent(struct expression *expr) 812 { 813 return strip_expr_helper(expr, true); 814 } 815 816 static void delete_state_tracker(struct tracker *t) 817 { 818 delete_state(t->owner, t->name, t->sym); 819 __free_tracker(t); 820 } 821 822 void scoped_state(int my_id, const char *name, struct symbol *sym) 823 { 824 struct tracker *t; 825 826 t = alloc_tracker(my_id, name, sym); 827 add_scope_hook((scope_hook *)&delete_state_tracker, t); 828 } 829 830 int is_error_return(struct expression *expr) 831 { 832 struct symbol *cur_func = cur_func_sym; 833 struct range_list *rl; 834 sval_t sval; 835 836 if (!expr) 837 return 0; 838 if (cur_func->type != SYM_NODE) 839 return 0; 840 cur_func = get_base_type(cur_func); 841 if (cur_func->type != SYM_FN) 842 return 0; 843 cur_func = get_base_type(cur_func); 844 if (cur_func == &void_ctype) 845 return 0; 846 if (option_project == PROJ_KERNEL && 847 get_implied_rl(expr, &rl) && 848 rl_type(rl) == &int_ctype && 849 sval_is_negative(rl_min(rl)) && 850 rl_max(rl).value == -1) 851 return 1; 852 if (!get_implied_value(expr, &sval)) 853 return 0; 854 if (sval.value < 0) 855 return 1; 856 if (cur_func->type == SYM_PTR && sval.value == 0) 857 return 1; 858 return 0; 859 } 860 861 int getting_address(struct expression *expr) 862 { 863 int deref_count = 0; 864 865 while ((expr = expr_get_parent_expr(expr))) { 866 if (expr->type == EXPR_PREOP && expr->op == '*') { 867 /* &foo->bar->baz dereferences "foo->bar" */ 868 if (deref_count == 0) 869 deref_count++; 870 return false; 871 } 872 if (expr->type == EXPR_PREOP && expr->op == '&') 873 return true; 874 } 875 return false; 876 } 877 878 int get_struct_and_member(struct expression *expr, const char **type, const char **member) 879 { 880 struct symbol *sym; 881 882 expr = strip_expr(expr); 883 if (expr->type != EXPR_DEREF) 884 return 0; 885 if (!expr->member) 886 return 0; 887 888 sym = get_type(expr->deref); 889 if (!sym) 890 return 0; 891 if (sym->type == SYM_UNION) 892 return 0; 893 if (!sym->ident) 894 return 0; 895 896 *type = sym->ident->name; 897 *member = expr->member->name; 898 return 1; 899 } 900 901 char *get_member_name(struct expression *expr) 902 { 903 char buf[256]; 904 struct symbol *sym; 905 906 expr = strip_expr(expr); 907 if (!expr || expr->type != EXPR_DEREF) 908 return NULL; 909 if (!expr->member) 910 return NULL; 911 912 sym = get_type(expr->deref); 913 if (!sym) 914 return NULL; 915 if (sym->type == SYM_UNION) { 916 snprintf(buf, sizeof(buf), "(union %s)->%s", 917 sym->ident ? sym->ident->name : "anonymous", 918 expr->member->name); 919 return alloc_string(buf); 920 } 921 if (!sym->ident) { 922 struct expression *deref; 923 char *full, *outer; 924 int len; 925 926 /* 927 * If we're in an anonymous struct then maybe we can find an 928 * outer struct name to use as a name. This code should be 929 * recursive and cleaner. I am not very proud of it. 930 * 931 */ 932 933 deref = expr->deref; 934 if (deref->type != EXPR_DEREF || !deref->member) 935 return NULL; 936 sym = get_type(deref->deref); 937 if (!sym || sym->type != SYM_STRUCT || !sym->ident) 938 return NULL; 939 940 full = expr_to_str(expr); 941 if (!full) 942 return NULL; 943 deref = deref->deref; 944 if (deref->type == EXPR_PREOP && deref->op == '*') 945 deref = deref->unop; 946 outer = expr_to_str(deref); 947 if (!outer) { 948 free_string(full); 949 return NULL; 950 } 951 len = strlen(outer); 952 if (strncmp(outer, full, len) != 0) { 953 free_string(full); 954 free_string(outer); 955 return NULL; 956 } 957 if (full[len] == '-' && full[len + 1] == '>') 958 len += 2; 959 if (full[len] == '.') 960 len++; 961 snprintf(buf, sizeof(buf), "(struct %s)->%s", sym->ident->name, full + len); 962 free_string(outer); 963 free_string(full); 964 965 return alloc_string(buf); 966 } 967 snprintf(buf, sizeof(buf), "(struct %s)->%s", sym->ident->name, expr->member->name); 968 return alloc_string(buf); 969 } 970 971 int cmp_pos(struct position pos1, struct position pos2) 972 { 973 /* the stream position is ... */ 974 if (pos1.stream > pos2.stream) 975 return -1; 976 if (pos1.stream < pos2.stream) 977 return 1; 978 979 if (pos1.line < pos2.line) 980 return -1; 981 if (pos1.line > pos2.line) 982 return 1; 983 984 if (pos1.pos < pos2.pos) 985 return -1; 986 if (pos1.pos > pos2.pos) 987 return 1; 988 989 return 0; 990 } 991 992 int positions_eq(struct position pos1, struct position pos2) 993 { 994 if (pos1.line != pos2.line) 995 return 0; 996 if (pos1.pos != pos2.pos) 997 return 0; 998 if (pos1.stream != pos2.stream) 999 return 0; 1000 return 1; 1001 } 1002 1003 struct statement *get_current_statement(void) 1004 { 1005 struct statement *prev, *tmp; 1006 1007 prev = last_ptr_list((struct ptr_list *)big_statement_stack); 1008 1009 if (!prev || !get_macro_name(prev->pos)) 1010 return prev; 1011 1012 FOR_EACH_PTR_REVERSE(big_statement_stack, tmp) { 1013 if (positions_eq(tmp->pos, prev->pos)) 1014 continue; 1015 if (prev->pos.line > tmp->pos.line) 1016 return prev; 1017 return tmp; 1018 } END_FOR_EACH_PTR_REVERSE(tmp); 1019 return prev; 1020 } 1021 1022 struct statement *get_prev_statement(void) 1023 { 1024 struct statement *tmp; 1025 int i; 1026 1027 i = 0; 1028 FOR_EACH_PTR_REVERSE(big_statement_stack, tmp) { 1029 if (i++ == 1) 1030 return tmp; 1031 } END_FOR_EACH_PTR_REVERSE(tmp); 1032 return NULL; 1033 } 1034 1035 struct expression *get_last_expr_from_expression_stmt(struct expression *expr) 1036 { 1037 struct statement *stmt; 1038 struct statement *last_stmt; 1039 1040 while (expr->type == EXPR_PREOP && expr->op == '(') 1041 expr = expr->unop; 1042 if (expr->type != EXPR_STATEMENT) 1043 return NULL; 1044 stmt = expr->statement; 1045 if (!stmt) 1046 return NULL; 1047 if (stmt->type == STMT_COMPOUND) { 1048 last_stmt = last_ptr_list((struct ptr_list *)stmt->stmts); 1049 if (!last_stmt) 1050 return NULL; 1051 if (last_stmt->type == STMT_LABEL) 1052 last_stmt = last_stmt->label_statement; 1053 if (last_stmt->type != STMT_EXPRESSION) 1054 return NULL; 1055 return last_stmt->expression; 1056 } 1057 if (stmt->type == STMT_EXPRESSION) 1058 return stmt->expression; 1059 return NULL; 1060 } 1061 1062 int get_param_num_from_sym(struct symbol *sym) 1063 { 1064 struct symbol *tmp; 1065 int i; 1066 1067 if (!sym) 1068 return UNKNOWN_SCOPE; 1069 1070 if (sym->ctype.modifiers & MOD_TOPLEVEL) { 1071 if (sym->ctype.modifiers & MOD_STATIC) 1072 return FILE_SCOPE; 1073 return GLOBAL_SCOPE; 1074 } 1075 1076 if (!cur_func_sym) { 1077 if (!parse_error) { 1078 sm_msg("warn: internal. problem with scope: %s", 1079 sym->ident ? sym->ident->name : "<anon var>"); 1080 } 1081 return GLOBAL_SCOPE; 1082 } 1083 1084 1085 i = 0; 1086 FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, tmp) { 1087 if (tmp == sym) 1088 return i; 1089 i++; 1090 } END_FOR_EACH_PTR(tmp); 1091 return LOCAL_SCOPE; 1092 } 1093 1094 int get_param_num(struct expression *expr) 1095 { 1096 struct symbol *sym; 1097 char *name; 1098 1099 if (!cur_func_sym) 1100 return UNKNOWN_SCOPE; 1101 name = expr_to_var_sym(expr, &sym); 1102 free_string(name); 1103 if (!sym) 1104 return UNKNOWN_SCOPE; 1105 return get_param_num_from_sym(sym); 1106 } 1107 1108 struct symbol *get_param_sym_from_num(int num) 1109 { 1110 struct symbol *sym; 1111 int i; 1112 1113 if (!cur_func_sym) 1114 return NULL; 1115 1116 i = 0; 1117 FOR_EACH_PTR(cur_func_sym->ctype.base_type->arguments, sym) { 1118 if (i++ == num) 1119 return sym; 1120 } END_FOR_EACH_PTR(sym); 1121 return NULL; 1122 } 1123 1124 int ms_since(struct timeval *start) 1125 { 1126 struct timeval end; 1127 double diff; 1128 1129 gettimeofday(&end, NULL); 1130 diff = (end.tv_sec - start->tv_sec) * 1000.0; 1131 diff += (end.tv_usec - start->tv_usec) / 1000.0; 1132 return (int)diff; 1133 } 1134 1135 int parent_is_gone_var_sym(const char *name, struct symbol *sym) 1136 { 1137 if (!name || !sym) 1138 return 0; 1139 1140 if (parent_is_null_var_sym(name, sym) || 1141 parent_is_free_var_sym(name, sym)) 1142 return 1; 1143 return 0; 1144 } 1145 1146 int parent_is_gone(struct expression *expr) 1147 { 1148 struct symbol *sym; 1149 char *var; 1150 int ret = 0; 1151 1152 expr = strip_expr(expr); 1153 var = expr_to_var_sym(expr, &sym); 1154 if (!var || !sym) 1155 goto free; 1156 ret = parent_is_gone_var_sym(var, sym); 1157 free: 1158 free_string(var); 1159 return ret; 1160 } 1161 1162 int invert_op(int op) 1163 { 1164 switch (op) { 1165 case '*': 1166 return '/'; 1167 case '/': 1168 return '*'; 1169 case '+': 1170 return '-'; 1171 case '-': 1172 return '+'; 1173 case SPECIAL_LEFTSHIFT: 1174 return SPECIAL_RIGHTSHIFT; 1175 case SPECIAL_RIGHTSHIFT: 1176 return SPECIAL_LEFTSHIFT; 1177 } 1178 return 0; 1179 } 1180 1181 int op_remove_assign(int op) 1182 { 1183 switch (op) { 1184 case SPECIAL_ADD_ASSIGN: 1185 return '+'; 1186 case SPECIAL_SUB_ASSIGN: 1187 return '-'; 1188 case SPECIAL_MUL_ASSIGN: 1189 return '*'; 1190 case SPECIAL_DIV_ASSIGN: 1191 return '/'; 1192 case SPECIAL_MOD_ASSIGN: 1193 return '%'; 1194 case SPECIAL_AND_ASSIGN: 1195 return '&'; 1196 case SPECIAL_OR_ASSIGN: 1197 return '|'; 1198 case SPECIAL_XOR_ASSIGN: 1199 return '^'; 1200 case SPECIAL_SHL_ASSIGN: 1201 return SPECIAL_LEFTSHIFT; 1202 case SPECIAL_SHR_ASSIGN: 1203 return SPECIAL_RIGHTSHIFT; 1204 default: 1205 return op; 1206 } 1207 } 1208 1209 int expr_equiv(struct expression *one, struct expression *two) 1210 { 1211 struct symbol *one_sym = NULL; 1212 struct symbol *two_sym = NULL; 1213 char *one_name = NULL; 1214 char *two_name = NULL; 1215 int ret = 0; 1216 1217 if (!one || !two) 1218 return 0; 1219 if (one->type != two->type) 1220 return 0; 1221 if (is_fake_call(one) || is_fake_call(two)) 1222 return 0; 1223 1224 one_name = expr_to_str_sym(one, &one_sym); 1225 if (!one_name) 1226 goto free; 1227 two_name = expr_to_str_sym(two, &two_sym); 1228 if (!two_name) 1229 goto free; 1230 if (one_sym != two_sym) 1231 goto free; 1232 /* 1233 * This is a terrible hack because expr_to_str() sometimes gives up in 1234 * the middle and just returns what it has. If you see a () you know 1235 * the string is bogus. 1236 */ 1237 if (strstr(one_name, "()")) 1238 goto free; 1239 if (strcmp(one_name, two_name) == 0) 1240 ret = 1; 1241 free: 1242 free_string(one_name); 1243 free_string(two_name); 1244 return ret; 1245 } 1246 1247 void push_int(struct int_stack **stack, int num) 1248 { 1249 int *munged; 1250 1251 /* 1252 * Just put the int on directly instead of a pointer to the int. 1253 * Shift it to the left because Sparse uses the last two bits. 1254 * This is sort of a dirty hack, yes. 1255 */ 1256 1257 munged = INT_PTR(num << 2); 1258 1259 add_ptr_list(stack, munged); 1260 } 1261 1262 int pop_int(struct int_stack **stack) 1263 { 1264 int *num; 1265 1266 num = last_ptr_list((struct ptr_list *)*stack); 1267 delete_ptr_list_last((struct ptr_list **)stack); 1268 1269 return PTR_INT(num) >> 2; 1270 } 1271