Print this page
new smatch

Split Close
Expand all
Collapse all
          --- old/usr/src/tools/smatch/src/smatch_param_set.c
          +++ new/usr/src/tools/smatch/src/smatch_param_set.c
↓ open down ↓ 122 lines elided ↑ open up ↑
 123  123                  goto free;
 124  124          get_absolute_rl(expr->right, &rl);
 125  125          rl = cast_rl(get_type(expr->left), rl);
 126  126  
 127  127          snprintf(buf, sizeof(buf), "*%s", name);
 128  128          set_state(my_id, buf, sym, alloc_estate_rl(rl));
 129  129  free:
 130  130          free_string(name);
 131  131  }
 132  132  
      133 +static char *get_two_dots(const char *name)
      134 +{
      135 +        static char buf[80];
      136 +        int i, cnt = 0;
      137 +
      138 +        for (i = 0; i < sizeof(buf); i++) {
      139 +                if (name[i] == '.') {
      140 +                        cnt++;
      141 +                        if (cnt >= 2) {
      142 +                                buf[i] = '\0';
      143 +                                return buf;
      144 +                        }
      145 +                }
      146 +                buf[i] = name[i];
      147 +        }
      148 +        return NULL;
      149 +}
      150 +
 133  151  /*
 134  152   * This relies on the fact that these states are stored so that
 135  153   * foo->bar is before foo->bar->baz.
 136  154   */
 137  155  static int parent_set(struct string_list *list, const char *name)
 138  156  {
 139  157          char *tmp;
 140  158          int len;
 141  159          int ret;
 142  160  
↓ open down ↓ 4 lines elided ↑ open up ↑
 147  165                          continue;
 148  166                  if (ret > 0)
 149  167                          return 0;
 150  168                  if (name[len] == '-')
 151  169                          return 1;
 152  170          } END_FOR_EACH_PTR(tmp);
 153  171  
 154  172          return 0;
 155  173  }
 156  174  
 157      -static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
      175 +static void print_return_value_param_helper(int return_id, char *return_ranges, struct expression *expr, int limit)
 158  176  {
 159  177          struct sm_state *sm;
 160  178          struct smatch_state *extra;
 161  179          int param;
 162  180          struct range_list *rl;
 163  181          const char *param_name;
 164  182          struct string_list *set_list = NULL;
 165  183          char *math_str;
 166  184          char buf[256];
      185 +        char two_dot[80] = "";
      186 +        int count = 0;
 167  187  
 168  188          FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 169  189                  if (!estate_rl(sm->state))
 170  190                          continue;
 171      -                extra = get_state(SMATCH_EXTRA, sm->name, sm->sym);
      191 +                extra = __get_state(SMATCH_EXTRA, sm->name, sm->sym);
 172  192                  if (extra) {
 173  193                          rl = rl_intersection(estate_rl(sm->state), estate_rl(extra));
 174  194                          if (!rl)
 175  195                                  continue;
 176  196                  } else {
 177  197                          rl = estate_rl(sm->state);
 178  198                  }
 179  199  
 180  200                  param = get_param_num_from_sym(sm->sym);
 181  201                  if (param < 0)
↓ open down ↓ 7 lines elided ↑ open up ↑
 189  209                  }
 190  210                  if (is_recursive_member(param_name)) {
 191  211                          insert_string(&set_list, (char *)sm->name);
 192  212                          continue;
 193  213                  }
 194  214  
 195  215                  if (is_ignored_kernel_data(param_name)) {
 196  216                          insert_string(&set_list, (char *)sm->name);
 197  217                          continue;
 198  218                  }
      219 +                if (limit) {
      220 +                        char *new = get_two_dots(param_name);
 199  221  
      222 +                        if (new) {
      223 +                                if (strcmp(new, two_dot) == 0)
      224 +                                        continue;
      225 +                                strncpy(two_dot, new, sizeof(two_dot));
      226 +                                sql_insert_return_states(return_id, return_ranges,
      227 +                                         PARAM_SET, param, new, "s64min-s64max");
      228 +                                continue;
      229 +                        }
      230 +                }
      231 +
 200  232                  math_str = get_value_in_terms_of_parameter_math_var_sym(sm->name, sm->sym);
 201  233                  if (math_str) {
 202  234                          snprintf(buf, sizeof(buf), "%s[%s]", show_rl(rl), math_str);
 203  235                          insert_string(&set_list, (char *)sm->name);
 204  236                          sql_insert_return_states(return_id, return_ranges,
 205  237                                          param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
 206  238                                          param, param_name, buf);
 207  239                          continue;
 208  240                  }
 209  241  
 210  242                  /* no useful information here. */
 211  243                  if (is_whole_rl(rl) && parent_set(set_list, sm->name))
 212  244                          continue;
 213  245                  insert_string(&set_list, (char *)sm->name);
 214  246  
 215  247                  sql_insert_return_states(return_id, return_ranges,
 216  248                                           param_has_filter_data(sm) ? PARAM_ADD : PARAM_SET,
 217  249                                           param, param_name, show_rl(rl));
      250 +                if (limit && ++count > limit)
      251 +                        break;
 218  252  
 219  253          } END_FOR_EACH_SM(sm);
 220  254  
 221  255          free_ptr_list((struct ptr_list **)&set_list);
 222  256  }
 223  257  
      258 +static void print_return_value_param(int return_id, char *return_ranges, struct expression *expr)
      259 +{
      260 +        print_return_value_param_helper(return_id, return_ranges, expr, 0);
      261 +}
      262 +
      263 +void print_limited_param_set(int return_id, char *return_ranges, struct expression *expr)
      264 +{
      265 +        print_return_value_param_helper(return_id, return_ranges, expr, 1000);
      266 +}
      267 +
      268 +static int possibly_empty(struct sm_state *sm)
      269 +{
      270 +        struct sm_state *tmp;
      271 +
      272 +        FOR_EACH_PTR(sm->possible, tmp) {
      273 +                if (strcmp(tmp->name, "") == 0)
      274 +                        return 1;
      275 +        } END_FOR_EACH_PTR(tmp);
      276 +        return 0;
      277 +}
      278 +
 224  279  int param_was_set_var_sym(const char *name, struct symbol *sym)
 225  280  {
 226  281          struct sm_state *sm;
 227      -        int len;
      282 +        char buf[80];
      283 +        int len, i;
 228  284  
 229      -        FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 230      -                if (sm->sym != sym)
      285 +        if (!name)
      286 +                return 0;
      287 +
      288 +        len = strlen(name);
      289 +        if (len >= sizeof(buf))
      290 +                len = sizeof(buf) - 1;
      291 +
      292 +        for (i = 0; i <= len; i++) {
      293 +                if (name[i] != '-' && name[i] != '\0')
 231  294                          continue;
 232      -                len = strlen(sm->name);
 233      -                if (strncmp(sm->name, name, len) != 0)
      295 +
      296 +                memcpy(buf, name, i);
      297 +                buf[i] = '\0';
      298 +
      299 +                sm = get_sm_state(my_id, buf, sym);
      300 +                if (!sm)
 234  301                          continue;
 235      -                if (name[len] == '\0' ||
 236      -                    name[len] == '-')
 237      -                        return 1;
 238      -        } END_FOR_EACH_SM(sm);
      302 +                if (possibly_empty(sm))
      303 +                        continue;
      304 +                return 1;
      305 +        }
 239  306  
      307 +        if (name[0] == '*')
      308 +                return param_was_set_var_sym(name + 1, sym);
      309 +
 240  310          return 0;
 241  311  }
 242  312  
 243  313  int param_was_set(struct expression *expr)
 244  314  {
 245  315          char *name;
 246  316          struct symbol *sym;
 247  317          int ret = 0;
 248  318  
 249  319          name = expr_to_var_sym(expr, &sym);
↓ open down ↓ 21 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX