smatch_extra.c

   1 /*
   2  * sparse/smatch_extra.c
   3  *
   4  * Copyright (C) 2008 Dan Carpenter.
   5  *
   6  *  Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include <stdlib.h>
  11 #include "parse.h"
  12 #include "smatch.h"
  13
  14 static int my_id;
  15
  16 static int _zero = 0;
  17 static int _one = 1;
  18
  19 static struct smatch_state zero = {
  20         .name = "zero",
  21         .data = &_zero,
  22 };
  23
  24 static struct smatch_state one = {
  25         .name = "one",
  26         .data = &_one,
  27 };
  28
  29 static struct smatch_state *alloc_state(int val)
  30 {
  31         struct smatch_state *state;
  32
  33         if (val == 0)
  34                 return &zero;
  35         if (val == 1)
  36                 return &one;
  37         if (val == UNDEFINED)
  38                 return &undefined;
  39
  40         state = malloc(sizeof(*state));
  41         state->name = "value";
  42         state->data = malloc(sizeof(int));
  43         *(int *)state->data = val;
  44         return state;
  45 }
  46
  47 static struct smatch_state *merge_func(const char *name, struct symbol *sym,
  48                                        struct smatch_state *s1,
  49                                        struct smatch_state *s2)
  50 {
  51         return &undefined;
  52 }
  53
  54 static void match_function_call_after(struct expression *expr)
  55 {
  56         struct expression *tmp;
  57         struct symbol *sym;
  58         char *name;
  59         int i = 0;
  60
  61         FOR_EACH_PTR(expr->args, tmp) {
  62                 if (tmp->op == '&') {
  63                         name = get_variable_from_expr(tmp->unop, &sym);
  64                         if (name) {
  65                                 set_state(name, my_id, sym, &undefined);
  66                         }
  67                 }
  68                 i++;
  69         } END_FOR_EACH_PTR(tmp);
  70 }
  71
  72 static void match_assign(struct expression *expr)
  73 {
  74         struct expression *left;
  75         struct symbol *sym;
  76         char *name;
  77
  78         left = strip_expr(expr->left);
  79         name = get_variable_from_expr(left, &sym);
  80         if (!name)
  81                 return;
  82         set_state(name, my_id, sym, alloc_state(get_value(expr->right)));
  83 }
  84
  85 static void undef_expr(struct expression *expr)
  86 {
  87         struct symbol *sym;
  88         char *name;
  89
  90         name = get_variable_from_expr(expr->unop, &sym);
  91         if (!name)
  92                 return;
  93         if (!get_state(name, my_id, sym)) {
  94                 free_string(name);
  95                 return;
  96         }
  97         set_state(name, my_id, sym, &undefined);
  98 }
  99
 100 static void match_declarations(struct symbol *sym)
 101 {
 102         const char *name;
 103
 104         if (sym->ident) {
 105                 name = sym->ident->name;
 106                 if (sym->initializer) {
 107                         set_state(name, my_id, sym, alloc_state(get_value(sym->initializer)));
 108                 }
 109         }
 110 }
 111
 112 void register_smatch_extra(int id)
 113 {
 114         my_id = id;
 115         add_merge_hook(my_id, &merge_func);
 116         add_hook(&undef_expr, OP_HOOK);
 117         add_hook(&match_function_call_after, FUNCTION_CALL_AFTER_HOOK);
 118         add_hook(&match_assign, ASSIGNMENT_AFTER_HOOK);
 119         add_hook(&match_declarations, DECLARATION_HOOK);
 120         add_hook(&__implied_states_hook, WHOLE_CONDITION_HOOK);
 121 }
 122
 123 static int expr_to_val(struct expression *expr)
 124 {
 125         struct smatch_state *state;
 126         int val;
 127         struct symbol *sym;
 128         char *name;
 129
 130         val = get_value(expr);
 131         if (val != UNDEFINED)
 132                 return val;
 133
 134         name = get_variable_from_expr(expr, &sym);
 135         if (!name)
 136                 return UNDEFINED;
 137         state = get_state(name, my_id, sym);
 138         free_string(name);
 139         if (!state || !state->data)
 140                 return UNDEFINED;
 141         return *(int *)state->data;
 142 }
 143
 144 static int true_comparison(int left, int comparison, int right)
 145 {
 146         switch(comparison){
 147         case '<':
 148         case SPECIAL_UNSIGNED_LT:
 149                 if (left < right)
 150                         return 1;
 151                 return 0;
 152         case SPECIAL_UNSIGNED_LTE:
 153         case SPECIAL_LTE:
 154                 if (left < right)
 155                         return 1;
 156         case SPECIAL_EQUAL:
 157                 if (left == right)
 158                         return 1;
 159                 return 0;
 160         case SPECIAL_UNSIGNED_GTE:
 161         case SPECIAL_GTE:
 162                 if (left == right)
 163                         return 1;
 164         case '>':
 165         case SPECIAL_UNSIGNED_GT:
 166                 if (left > right)
 167                         return 1;
 168                 return 0;
 169         case SPECIAL_NOTEQUAL:
 170                 if (left != right)
 171                         return 1;
 172                 return 0;
 173         default:
 174                 smatch_msg("unhandled comparison %d\n", comparison);
 175         }
 176         return 0;
 177 }
 178
 179 int known_condition_true(struct expression *expr)
 180 {
 181         int left, right, ret;
 182
 183         if (!expr || expr->type != EXPR_COMPARE)
 184                 return 0;
 185
 186         if ((left = expr_to_val(expr->left)) == UNDEFINED)
 187                 return 0;
 188
 189         if ((right = expr_to_val(expr->right)) == UNDEFINED)
 190                 return 0;
 191
 192         ret = true_comparison(left, expr->op, right);
 193         if (ret)
 194                 SM_DEBUG("%d known condition: %d %s %d => true", get_lineno(),
 195                          left, show_special(expr->op), right);
 196         else
 197                 smatch_msg("known condition: %d %s %d => false", left,
 198                            show_special(expr->op), right);
 199
 200         return ret;
 201 }