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
|