smatch_states.c

   1 /*
   2  * sparse/smatch_states.c
   3  *
   4  * Copyright (C) 2006 Dan Carpenter.
   5  *
   6  *  Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include "smatch.h"
  13 #include "smatch_slist.h"
  14
  15 struct state_list *cur_slist; /* current states */
  16
  17 static struct state_list_stack *true_stack; /* states after a t/f branch */
  18 static struct state_list_stack *false_stack;
  19 static struct state_list_stack *pre_cond_stack; /* states before a t/f branch */
  20
  21 static struct state_list_stack *cond_true_stack; /* states affected by a branch */
  22 static struct state_list_stack *cond_false_stack;
  23
  24 static struct state_list_stack *break_stack;
  25 static struct state_list_stack *switch_stack;
  26 static struct state_list_stack *default_stack;
  27 static struct state_list_stack *continue_stack;
  28 static struct state_list_stack *false_only_stack;
  29
  30 struct slist_stack *goto_stack;
  31
  32 int debug_states;
  33
  34 void __print_cur_slist()
  35 {
  36         struct smatch_state *state;
  37
  38         printf("dumping slist at %d\n", get_lineno());
  39         FOR_EACH_PTR(cur_slist, state) {
  40                 printf("%s=%d\n", state->name, state->state);
  41         } END_FOR_EACH_PTR(state);
  42         printf("---\n");
  43 }
  44
  45
  46 void set_state(const char *name, int owner, struct symbol *sym, int state)
  47 {
  48         struct smatch_state *tmp;
  49
  50         if (!name)
  51                 return;
  52
  53         FOR_EACH_PTR(cur_slist, tmp) {
  54                 if (tmp->owner == owner && tmp->sym == sym
  55                     && !strcmp(tmp->name, name)){
  56                         SM_DEBUG("%d state change name='%s' owner=%d: %d => %d\n"
  57                                  , get_lineno(), name, owner, tmp->state, state);
  58                         add_history(tmp);
  59                         tmp->state = state;
  60                         return;
  61                 }
  62         } END_FOR_EACH_PTR(tmp);
  63         SM_DEBUG("%d new state. name='%s' owner=%d: %d\n", get_lineno(), name,
  64                  owner, state);
  65         tmp = alloc_state(name, owner, sym, state);
  66         add_state_slist(&cur_slist, tmp);
  67
  68 }
  69
  70 int get_state(const char *name, int owner, struct symbol *sym)
  71 {
  72         return get_state_slist(cur_slist, name, owner, sym);
  73 }
  74
  75 void delete_state(const char *name, int owner, struct symbol *sym)
  76 {
  77         delete_state_slist(&cur_slist, name, owner, sym);
  78 }
  79
  80 struct state_list *get_current_states(int owner)
  81 {
  82         struct state_list *slist;
  83         struct smatch_state *tmp;
  84
  85         FOR_EACH_PTR(cur_slist, tmp) {
  86                 if (tmp->owner == owner) {
  87                         add_ptr_list(&slist, tmp);
  88                 }
  89         } END_FOR_EACH_PTR(tmp);
  90
  91         return slist;
  92 }
  93
  94 void set_true_false_states(const char *name, int owner, struct symbol *sym,
  95                            int true_state, int false_state)
  96 {
  97
  98         /* fixme.  save history */
  99
 100         SM_DEBUG("%d set_true_false %s.  Was %d.  Now T:%d F:%d\n",
 101                  get_lineno(), name, get_state(name, owner, sym), true_state,
 102                  false_state);
 103
 104         if (!cond_false_stack || !cond_true_stack) {
 105                 printf("Error:  missing true/false stacks\n");
 106                 return;
 107         }
 108
 109         set_state_slist(&cur_slist, name, owner, sym, true_state);
 110         set_state_stack(&cond_true_stack, name, owner, sym, true_state);
 111         set_state_stack(&cond_false_stack, name, owner, sym, false_state);
 112
 113 }
 114
 115 void nullify_path()
 116 {
 117         del_slist(&cur_slist);
 118 }
 119
 120 void clear_all_states()
 121 {
 122         struct named_slist *named_slist;
 123
 124         nullify_path();
 125         del_slist_stack(&true_stack);
 126         del_slist_stack(&false_stack);
 127         del_slist_stack(&pre_cond_stack);
 128         del_slist_stack(&cond_true_stack);
 129         del_slist_stack(&cond_false_stack);
 130         del_slist_stack(&break_stack);
 131         del_slist_stack(&switch_stack);
 132         del_slist_stack(&continue_stack);
 133
 134         FOR_EACH_PTR(goto_stack, named_slist) {
 135                 del_slist(&named_slist->slist);
 136         } END_FOR_EACH_PTR(named_slist);
 137         __free_ptr_list((struct ptr_list **)&goto_stack);
 138 }
 139
 140
 141 void __push_cond_stacks()
 142 {
 143         push_slist(&cond_true_stack, NULL);
 144         push_slist(&cond_false_stack, NULL);
 145 }
 146
 147 static void __use_cond_stack(struct state_list_stack **stack)
 148 {
 149         struct state_list *slist;
 150         struct smatch_state *tmp;
 151
 152         nullify_path();
 153
 154         slist = pop_slist(&pre_cond_stack);
 155         merge_slist(slist);
 156         push_slist(&pre_cond_stack, slist);
 157
 158         slist = pop_slist(stack);
 159
 160         FOR_EACH_PTR(slist, tmp) {
 161                 set_state(tmp->name, tmp->owner, tmp->sym, tmp->state);
 162         } END_FOR_EACH_PTR(tmp);
 163
 164
 165         push_slist(stack, slist);
 166
 167 }
 168
 169
 170 void __use_cond_true_states()
 171 {
 172         __use_cond_stack(&cond_true_stack);
 173 }
 174
 175 void __use_cond_false_states()
 176 {
 177         __use_cond_stack(&cond_false_stack);
 178 }
 179
 180 void __negate_cond_stacks()
 181 {
 182         struct state_list *tmp;
 183
 184         tmp = pop_slist(&cond_false_stack);
 185         push_slist(&cond_false_stack, pop_slist(&cond_true_stack));
 186         push_slist(&cond_true_stack, tmp);
 187 }
 188
 189
 190 void __and_cond_states()
 191 {
 192         struct state_list *tmp_slist;
 193
 194         tmp_slist = pop_slist(&cond_true_stack);
 195         and_slist_stack(&cond_true_stack, tmp_slist);
 196         or_slist_stack(&cond_false_stack);
 197 }
 198
 199 void __or_cond_states()
 200 {
 201         struct state_list *tmp_slist;
 202
 203         or_slist_stack(&cond_true_stack);
 204         tmp_slist = pop_slist(&cond_false_stack);
 205         and_slist_stack(&cond_false_stack, tmp_slist);
 206 }
 207
 208
 209 void __save_pre_cond_states()
 210 {
 211         push_slist(&pre_cond_stack, clone_slist(cur_slist));
 212 }
 213
 214
 215 static int false_only_prepped = 0;
 216 void __prep_false_only_stack()
 217 {
 218         false_only_prepped = 1;
 219 }
 220
 221 static void overwrite_slist(struct state_list *from, struct state_list *to)
 222 {
 223         struct smatch_state *tmp;
 224
 225         FOR_EACH_PTR(from, tmp) {
 226                 set_state_slist(&to, tmp->name, tmp->owner, tmp->sym, tmp->state);
 227         } END_FOR_EACH_PTR(tmp);
 228 }
 229
 230 void __use_false_only_stack()
 231 {
 232         struct state_list *slist;
 233
 234         slist = pop_slist(&false_only_stack);
 235         overwrite_slist(slist, cur_slist);
 236         del_slist(&slist);
 237         false_only_prepped = 0;
 238 }
 239
 240 void __use_cond_states()
 241 {
 242         struct state_list *tmp, *tmp2, *tmp3;
 243
 244         if (false_only_prepped) {
 245                 tmp = pop_slist(&cond_false_stack);
 246                 push_slist(&false_only_stack, clone_slist(tmp));
 247                 push_slist(&cond_false_stack, tmp);
 248         }
 249
 250         /* Everyone calls __use_true_states so setting up
 251            the true stack is enough here */
 252         tmp = pop_slist(&pre_cond_stack);
 253         tmp3 = clone_slist(tmp);
 254         tmp2 = pop_slist(&cond_true_stack);
 255         overwrite_slist(tmp2, tmp3);
 256         push_slist(&true_stack, tmp3);
 257
 258         tmp2 = pop_slist(&cond_false_stack);
 259         overwrite_slist(tmp2, tmp);
 260         push_slist(&false_stack, tmp);
 261 }
 262
 263 void __use_true_states()
 264 {
 265         struct state_list *slist;
 266
 267         nullify_path();
 268         slist = pop_slist(&true_stack);
 269         merge_slist(slist);
 270         del_slist(&slist);
 271 }
 272
 273 void __use_false_states()
 274 {
 275         struct state_list *slist;
 276
 277         push_slist(&true_stack, clone_slist(cur_slist));
 278         nullify_path();
 279         slist = pop_slist(&false_stack);
 280         merge_slist(slist);
 281         del_slist(&slist);
 282 }
 283
 284 void __pop_false_states()
 285 {
 286         struct state_list *slist;
 287
 288         slist = pop_slist(&false_stack);
 289         del_slist(&slist);
 290 }
 291
 292 void __merge_false_states()
 293 {
 294         struct state_list *slist;
 295
 296         slist = pop_slist(&false_stack);
 297         merge_slist(slist);
 298         del_slist(&slist);
 299 }
 300
 301 void __merge_true_states()
 302 {
 303         struct state_list *slist;
 304
 305         slist = pop_slist(&true_stack);
 306         merge_slist(slist);
 307         del_slist(&slist);
 308 }
 309
 310 void __pop_true_states()
 311 {
 312         struct state_list *slist;
 313
 314         slist = pop_slist(&true_stack);
 315         del_slist(&slist);
 316 }
 317
 318 void __push_continues()
 319 {
 320         push_slist(&continue_stack, NULL);
 321 }
 322
 323 void __pop_continues()
 324 {
 325         struct state_list *slist;
 326
 327         slist = pop_slist(&continue_stack);
 328         del_slist(&slist);
 329 }
 330
 331 void __process_continues()
 332 {
 333         struct smatch_state *state;
 334
 335         FOR_EACH_PTR(cur_slist, state) {
 336                 merge_state_stack(&continue_stack, state->name, state->owner,
 337                                   state->sym, state->state);
 338         } END_FOR_EACH_PTR(state);
 339 }
 340
 341 void __merge_continues()
 342 {
 343         struct state_list *slist;
 344
 345         slist = pop_slist(&continue_stack);
 346         merge_slist(slist);
 347         del_slist(&slist);
 348 }
 349
 350 void __push_breaks()
 351 {
 352         push_slist(&break_stack, NULL);
 353 }
 354
 355 void __process_breaks()
 356 {
 357         struct smatch_state *state;
 358
 359         FOR_EACH_PTR(cur_slist, state) {
 360                 merge_state_stack(&break_stack, state->name, state->owner,
 361                                   state->sym, state->state);
 362         } END_FOR_EACH_PTR(state);
 363 }
 364
 365 void __merge_breaks()
 366 {
 367         struct state_list *slist;
 368
 369         slist = pop_slist(&break_stack);
 370         merge_slist(slist);
 371         del_slist(&slist);
 372 }
 373
 374 void __pop_breaks()
 375 {
 376         struct state_list *slist;
 377
 378         slist = pop_slist(&break_stack);
 379         del_slist(&slist);
 380 }
 381
 382 void __save_switch_states()
 383 {
 384         push_slist(&switch_stack, clone_slist(cur_slist));
 385 }
 386
 387 void __merge_switches()
 388 {
 389         struct state_list *slist;
 390
 391         slist = pop_slist(&switch_stack);
 392         merge_slist(slist);
 393         push_slist(&switch_stack, slist);
 394 }
 395
 396 void __pop_switches()
 397 {
 398         struct state_list *slist;
 399
 400         slist = pop_slist(&switch_stack);
 401         del_slist(&slist);
 402 }
 403
 404 void __push_default()
 405 {
 406         push_slist(&default_stack, NULL);
 407         set_state_stack(&default_stack, "has_default", 0, NULL, 0);
 408 }
 409
 410 void __set_default()
 411 {
 412         set_state_stack(&default_stack, "has_default", 0, NULL, 1);
 413 }
 414
 415 int __pop_default()
 416 {
 417         struct state_list *slist;
 418         struct smatch_state *state;
 419
 420         int ret = -1;
 421         slist = pop_slist(&default_stack);
 422         FOR_EACH_PTR(slist, state) {
 423                 if (!strcmp(state->name, "has_default"))
 424                         ret = state->state;
 425         } END_FOR_EACH_PTR(state);
 426         del_slist(&slist);
 427         return ret;
 428 }
 429
 430 static struct named_slist *alloc_named_slist(const char *name,
 431                                          struct state_list *slist)
 432 {
 433         struct named_slist *named_slist = __alloc_named_slist(0);
 434
 435         named_slist->name = (char *)name;
 436         named_slist->slist = slist;
 437         return named_slist;
 438 }
 439
 440 void __save_gotos(const char *name)
 441 {
 442         struct state_list *slist;
 443
 444         slist = get_slist_from_slist_stack(name);
 445         if (slist) {
 446                 struct smatch_state *state;
 447                 FOR_EACH_PTR(cur_slist, state) {
 448                         merge_state_slist(&slist, state->name, state->owner,
 449                                           state->sym, state->state);
 450                 } END_FOR_EACH_PTR(state);
 451                 return;
 452         } else {
 453                 struct state_list *slist;
 454                 struct named_slist *named_slist;
 455                 slist = clone_slist(cur_slist);
 456                 named_slist = alloc_named_slist(name, slist);
 457                 add_ptr_list(&goto_stack, named_slist);
 458         }
 459 }
 460
 461 void __merge_gotos(const char *name)
 462 {
 463         struct state_list *slist;
 464
 465         slist = get_slist_from_slist_stack(name);
 466         merge_slist(slist);
 467 }