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