Print this page
11506 smatch resync
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/tools/smatch/src/smatch_assigned_expr.c
+++ new/usr/src/tools/smatch/src/smatch_assigned_expr.c
1 1 /*
2 2 * Copyright (C) 2009 Dan Carpenter.
3 3 *
4 4 * This program is free software; you can redistribute it and/or
5 5 * modify it under the terms of the GNU General Public License
6 6 * as published by the Free Software Foundation; either version 2
7 7 * of the License, or (at your option) any later version.
8 8 *
9 9 * This program is distributed in the hope that it will be useful,
10 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 * GNU General Public License for more details.
13 13 *
14 14 * You should have received a copy of the GNU General Public License
15 15 * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
16 16 */
17 17
18 18 /*
19 19 * This is not a check. It just saves an struct expression pointer
20 20 * whenever something is assigned. This can be used later on by other scripts.
|
↓ open down ↓ |
20 lines elided |
↑ open up ↑ |
21 21 */
22 22
23 23 #include "smatch.h"
24 24 #include "smatch_slist.h"
25 25 #include "smatch_extra.h"
26 26
27 27 int check_assigned_expr_id;
28 28 static int my_id;
29 29 static int link_id;
30 30
31 +static struct expression *skip_mod;
32 +
31 33 static void undef(struct sm_state *sm, struct expression *mod_expr)
32 34 {
35 + if (mod_expr == skip_mod)
36 + return;
33 37 set_state(my_id, sm->name, sm->sym, &undefined);
34 38 }
35 39
36 40 struct expression *get_assigned_expr(struct expression *expr)
37 41 {
38 42 struct smatch_state *state;
39 43
40 44 state = get_state_expr(my_id, expr);
41 45 if (!state)
42 46 return NULL;
43 47 return (struct expression *)state->data;
44 48 }
45 49
46 50 struct expression *get_assigned_expr_name_sym(const char *name, struct symbol *sym)
47 51 {
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
48 52 struct smatch_state *state;
49 53
50 54 state = get_state(my_id, name, sym);
51 55 if (!state)
52 56 return NULL;
53 57 return (struct expression *)state->data;
54 58 }
55 59
56 60 static void match_assignment(struct expression *expr)
57 61 {
62 + static struct expression *ignored_expr;
58 63 struct symbol *left_sym, *right_sym;
59 64 char *left_name = NULL;
60 65 char *right_name = NULL;
61 66
62 67 if (expr->op != '=')
63 68 return;
64 69 if (is_fake_call(expr->right))
65 70 return;
66 71 if (__in_fake_struct_assign) {
67 72 struct range_list *rl;
68 73
69 74 if (!get_implied_rl(expr->right, &rl))
70 75 return;
71 76 if (is_whole_rl(rl))
72 77 return;
73 78 }
74 79
80 + if (expr->left == ignored_expr)
81 + return;
82 + ignored_expr = NULL;
83 + if (__in_fake_parameter_assign)
84 + ignored_expr = expr->left;
85 +
75 86 left_name = expr_to_var_sym(expr->left, &left_sym);
76 87 if (!left_name || !left_sym)
77 88 goto free;
78 89 set_state(my_id, left_name, left_sym, alloc_state_expr(strip_expr(expr->right)));
79 90
80 91 right_name = expr_to_var_sym(expr->right, &right_sym);
81 92 if (!right_name || !right_sym)
82 93 goto free;
83 94
84 95 store_link(link_id, right_name, right_sym, left_name, left_sym);
85 96
86 97 free:
87 98 free_string(left_name);
88 99 free_string(right_name);
89 100 }
90 101
91 102 static void record_param_assignment(struct expression *expr, int param, char *key, char *value)
92 103 {
93 104 struct expression *arg, *right;
94 105 struct symbol *sym;
95 106 char *name;
96 107 char *p;
97 108 int right_param;
98 109
99 110 while (expr->type == EXPR_ASSIGNMENT)
100 111 expr = strip_expr(expr->right);
101 112 if (!expr || expr->type != EXPR_CALL)
102 113 return;
103 114
104 115 p = strstr(value, "[$");
105 116 if (!p)
106 117 return;
107 118
108 119 p += 2;
109 120 right_param = strtol(p, &p, 10);
110 121 if (*p != ']')
|
↓ open down ↓ |
26 lines elided |
↑ open up ↑ |
111 122 return;
112 123
113 124 arg = get_argument_from_call_expr(expr->args, param);
114 125 right = get_argument_from_call_expr(expr->args, right_param);
115 126 if (!right || !arg)
116 127 return;
117 128 name = get_variable_from_key(arg, key, &sym);
118 129 if (!name || !sym)
119 130 goto free;
120 131
132 + skip_mod = expr;
121 133 set_state(my_id, name, sym, alloc_state_expr(right));
122 134 free:
123 135 free_string(name);
124 136 }
125 137
126 138 void register_assigned_expr(int id)
127 139 {
128 140 my_id = check_assigned_expr_id = id;
141 + set_dynamic_states(check_assigned_expr_id);
129 142 add_hook(&match_assignment, ASSIGNMENT_HOOK_AFTER);
130 143 add_modification_hook(my_id, &undef);
131 144 select_return_states_hook(PARAM_SET, &record_param_assignment);
132 145 }
133 146
134 147 void register_assigned_expr_links(int id)
135 148 {
136 149 link_id = id;
150 + set_dynamic_states(link_id);
137 151 db_ignore_states(link_id);
138 152 set_up_link_functions(my_id, link_id);
139 153 }
140 154
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX