Print this page
11972 resync smatch


  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 


 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);


 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;


 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 




  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 


 272         case EXPR_BINOP: {
 273                 char tmp[10];
 274                 struct expression *array_expr;
 275 
 276                 *complicated = 1;
 277                 array_expr = get_array_expr(expr);
 278                 if (array_expr) {
 279                         __get_variable_from_expr(sym_ptr, buf, array_expr, len, complicated, no_parens);
 280                         append(buf, "[", len);
 281                 } else {
 282                         __get_variable_from_expr(sym_ptr, buf, expr->left, len, complicated, no_parens);
 283                         snprintf(tmp, sizeof(tmp), " %s ", show_special(expr->op));
 284                         append(buf, tmp, len);
 285                 }
 286                 __get_variable_from_expr(NULL, buf, expr->right, len, complicated, no_parens);
 287                 if (array_expr)
 288                         append(buf, "]", len);
 289                 return;
 290         }
 291         case EXPR_VALUE: {
 292                 sval_t sval = {};
 293                 char tmp[25];
 294 
 295                 *complicated = 1;
 296                 if (!get_value(expr, &sval))
 297                         return;
 298                 snprintf(tmp, 25, "%s", sval_to_numstr(sval));
 299                 append(buf, tmp, len);
 300                 return;
 301         }
 302         case EXPR_STRING:
 303                 append(buf, "\"", len);
 304                 if (expr->string)
 305                         append(buf, expr->string->data, len);
 306                 append(buf, "\"", len);
 307                 return;
 308         case EXPR_CALL: {
 309                 struct expression *tmp;
 310                 int i;
 311 
 312                 *complicated = 1;
 313                 __get_variable_from_expr(NULL, buf, expr->fn, len, complicated, no_parens);
 314                 append(buf, "(", len);
 315                 i = 0;
 316                 FOR_EACH_PTR(expr->args, tmp) {
 317                         if (i++)
 318                                 append(buf, ", ", len);


 588 {
 589         return expr_to_chunk_helper(expr, sym, NULL);
 590 }
 591 
 592 char *expr_to_chunk_sym_vsl(struct expression *expr, struct symbol **sym, struct var_sym_list **vsl)
 593 {
 594         return expr_to_chunk_helper(expr, sym, vsl);
 595 }
 596 
 597 int sym_name_is(const char *name, struct expression *expr)
 598 {
 599         if (!expr)
 600                 return 0;
 601         if (expr->type != EXPR_SYMBOL)
 602                 return 0;
 603         if (!strcmp(expr->symbol_name->name, name))
 604                 return 1;
 605         return 0;
 606 }
 607 
 608 int expr_is_zero(struct expression *expr)
 609 {
 610         sval_t sval;
 611 
 612         if (get_value(expr, &sval) && sval.value == 0)
 613                 return 1;
 614         return 0;
 615 }
 616 
 617 int is_array(struct expression *expr)
 618 {
 619         struct symbol *type;
 620 
 621         expr = strip_expr(expr);
 622         if (!expr)
 623                 return 0;
 624 
 625         if (expr->type == EXPR_PREOP && expr->op == '*') {
 626                 expr = strip_expr(expr->unop);
 627                 if (!expr)
 628                         return 0;


 817         if (cur_func->type != SYM_FN)
 818                 return 0;
 819         cur_func = get_base_type(cur_func);
 820         if (cur_func == &void_ctype)
 821                 return 0;
 822         if (option_project == PROJ_KERNEL &&
 823             get_implied_rl(expr, &rl) &&
 824             rl_type(rl) == &int_ctype &&
 825             sval_is_negative(rl_min(rl)) &&
 826             rl_max(rl).value == -1)
 827                 return 1;
 828         if (!get_implied_value(expr, &sval))
 829                 return 0;
 830         if (sval.value < 0)
 831                 return 1;
 832         if (cur_func->type == SYM_PTR && sval.value == 0)
 833                 return 1;
 834         return 0;
 835 }
 836 
 837 int getting_address(struct expression *expr)
 838 {
 839         int deref_count = 0;


 840 
 841         while ((expr = expr_get_parent_expr(expr))) {
 842                 if (expr->type == EXPR_PREOP && expr->op == '*') {
 843                         /* &foo->bar->baz dereferences "foo->bar" */
 844                         if (deref_count == 0)
 845                                 deref_count++;
 846                         return false;
 847                 }
 848                 if (expr->type == EXPR_PREOP && expr->op == '&')
 849                         return true;
 850         }
 851         return false;

 852 }
 853 
 854 int get_struct_and_member(struct expression *expr, const char **type, const char **member)
 855 {
 856         struct symbol *sym;
 857 
 858         expr = strip_expr(expr);
 859         if (expr->type != EXPR_DEREF)
 860                 return 0;
 861         if (!expr->member)
 862                 return 0;
 863 
 864         sym = get_type(expr->deref);
 865         if (!sym)
 866                 return 0;
 867         if (sym->type == SYM_UNION)
 868                 return 0;
 869         if (!sym->ident)
 870                 return 0;
 871