check_missing_break.c

   1 /*
   2  * sparse/check_missing_break.c
   3  *
   4  * Copyright (C) 2013 Oracle.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * The way I'm detecting missing breaks is if there is an assignment inside a
  12  * switch statement which is over written.
  13  *
  14  */
  15
  16 #include "smatch.h"
  17 #include "smatch_slist.h"
  18
  19 static int my_id;
  20 static struct expression *skip_this;
  21
  22 /*
  23  * It goes like this:
  24  * - Allocate a state which stores the switch expression.  I wanted to
  25  *   just have a state &assigned but we need to know the switch statement where
  26  *   it was assigned.
  27  * - If it gets used then we change it to &used.
  28  * - For unmatched states we use &used (because of cleanness, not because we need
  29  *   to).
  30  * - If we merge inside a case statement and one of the states is &assigned (or
  31  *   if it is &nobreak) then &nobreak is used.
  32  *
  33  * We print an error when we assign something to a &no_break symbol.
  34  *
  35  */
  36
  37 STATE(used);
  38 STATE(no_break);
  39
  40 static struct smatch_state *alloc_my_state(struct expression *expr)
  41 {
  42         struct smatch_state *state;
  43         char *name;
  44
  45         state = __alloc_smatch_state(0);
  46         expr = strip_expr(expr);
  47         name = get_variable_from_expr_complex(expr, NULL);
  48         if (!name)
  49                 name = alloc_string("");
  50         state->name = alloc_sname(name);
  51         free_string(name);
  52         state->data = expr;
  53         return state;
  54 }
  55
  56 static void match_assign(struct expression *expr)
  57 {
  58         struct expression *left;
  59
  60         if (expr->op != '=')
  61                 return;
  62         if (!get_switch_expr())
  63                 return;
  64         left = strip_expr(expr->left);
  65         if (get_state_expr(my_id, left) == &no_break) {
  66                 char *name;
  67
  68                 name = get_variable_from_expr(left, NULL);
  69                 sm_msg("warn: missing break? reassigning '%s'", name);
  70                 free_string(name);
  71         }
  72
  73         set_state_expr(my_id, left, alloc_my_state(get_switch_expr()));
  74         skip_this = left;
  75 }
  76
  77 static void match_symbol(struct expression *expr)
  78 {
  79         expr = strip_expr(expr);
  80         if (expr == skip_this)
  81                 return;
  82         set_state_expr(my_id, expr, &used);
  83 }
  84
  85 static struct smatch_state *unmatched_state(struct sm_state *sm)
  86 {
  87         return &used;
  88 }
  89
  90 static int in_case;
  91 struct smatch_state *merge_hook(struct smatch_state *s1, struct smatch_state *s2)
  92 {
  93         struct expression *switch_expr;
  94
  95         if (s1 == &no_break || s2 == &no_break)
  96                 return &no_break;
  97         if (!in_case)
  98                 return &used;
  99         switch_expr = get_switch_expr();
 100         if (s1->data == switch_expr || s2->data == switch_expr)
 101                 return &no_break;
 102         return &used;
 103 }
 104
 105 static void match_stmt(struct statement *stmt)
 106 {
 107         if (stmt->type == STMT_CASE)
 108                 in_case = 1;
 109         else
 110                 in_case = 0;
 111 }
 112
 113 void check_missing_break(int id)
 114 {
 115         my_id = id;
 116
 117         add_unmatched_state_hook(my_id, &unmatched_state);
 118         add_merge_hook(my_id, &merge_hook);
 119
 120         add_hook(&match_assign, ASSIGNMENT_HOOK);
 121         add_hook(&match_symbol, SYM_HOOK);
 122         add_hook(&match_stmt, STMT_HOOK);
 123 }