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 void match_function_call_after(struct expression *expr)
  48 {
  49         struct expression *tmp;
  50         struct symbol *sym;
  51         char *name;
  52         int i = 0;
  53
  54         FOR_EACH_PTR(expr->args, tmp) {
  55                 if (tmp->op == '&') {
  56                         name = get_variable_from_expr(tmp->unop, &sym);
  57                         if (name) {
  58                                 set_state(name, my_id, sym, &undefined);
  59                         }
  60                 }
  61                 i++;
  62         } END_FOR_EACH_PTR(tmp);
  63 }
  64
  65 static void match_assign(struct expression *expr)
  66 {
  67         struct expression *left;
  68         struct symbol *sym;
  69         char *name;
  70
  71         left = strip_expr(expr->left);
  72         name = get_variable_from_expr(left, &sym);
  73         if (!name)
  74                 return;
  75         set_state(name, my_id, sym, alloc_state(get_value(expr->right)));
  76 }
  77
  78 static void undef_expr(struct expression *expr)
  79 {
  80         struct symbol *sym;
  81         char *name;
  82
  83         name = get_variable_from_expr(expr->unop, &sym);
  84         if (!name)
  85                 return;
  86         if (!get_state(name, my_id, sym)) {
  87                 free_string(name);
  88                 return;
  89         }
  90         set_state(name, my_id, sym, &undefined);
  91 }
  92
  93 static void match_declarations(struct symbol *sym)
  94 {
  95         const char *name;
  96
  97         if (sym->ident) {
  98                 name = sym->ident->name;
  99                 if (sym->initializer) {
 100                         set_state(name, my_id, sym, alloc_state(get_value(sym->initializer)));
 101                 }
 102         }
 103 }
 104
 105 static void match_unop(struct expression *expr)
 106 {
 107         struct symbol *sym;
 108         char *name;
 109         const char *tmp;
 110
 111
 112         name = get_variable_from_expr(expr->unop, &sym);
 113         if (!name)
 114                 return;
 115
 116         tmp = show_special(expr->op);
 117         if ((!strcmp(tmp, "--")) || (!strcmp(tmp, "++")))
 118                 set_state(name, my_id, sym, &undefined);
 119 }
 120
 121 void register_smatch_extra(int id)
 122 {
 123         my_id = id;
 124         add_hook(&undef_expr, OP_HOOK);
 125         add_hook(&match_function_call_after, FUNCTION_CALL_AFTER_HOOK);
 126         add_hook(&match_assign, ASSIGNMENT_AFTER_HOOK);
 127         add_hook(&match_declarations, DECLARATION_HOOK);
 128         add_hook(&match_unop, OP_HOOK);
 129         add_hook(&__implied_states_hook, CONDITION_HOOK);
 130 }
 131
 132 static int expr_to_val(struct expression *expr)
 133 {
 134         struct smatch_state *state;
 135         int val;
 136         struct symbol *sym;
 137         char *name;
 138
 139         val = get_value(expr);
 140         if (val != UNDEFINED)
 141                 return val;
 142
 143         name = get_variable_from_expr(expr, &sym);
 144         if (!name)
 145                 return UNDEFINED;
 146         state = get_state(name, my_id, sym);
 147         free_string(name);
 148         if (!state || !state->data)
 149                 return UNDEFINED;
 150         return *(int *)state->data;
 151 }
 152
 153 static int true_comparison(int left, int comparison, int right)
 154 {
 155         switch(comparison){
 156         case '<':
 157         case SPECIAL_UNSIGNED_LT:
 158                 if (left < right)
 159                         return 1;
 160                 return 0;
 161         case SPECIAL_UNSIGNED_LTE:
 162         case SPECIAL_LTE:
 163                 if (left < right)
 164                         return 1;
 165         case SPECIAL_EQUAL:
 166                 if (left == right)
 167                         return 1;
 168                 return 0;
 169         case SPECIAL_UNSIGNED_GTE:
 170         case SPECIAL_GTE:
 171                 if (left == right)
 172                         return 1;
 173         case '>':
 174         case SPECIAL_UNSIGNED_GT:
 175                 if (left > right)
 176                         return 1;
 177                 return 0;
 178         case SPECIAL_NOTEQUAL:
 179                 if (left != right)
 180                         return 1;
 181                 return 0;
 182         default:
 183                 smatch_msg("unhandled comparison %d\n", comparison);
 184         }
 185         return 0;
 186 }
 187
 188 int known_condition_true(struct expression *expr)
 189 {
 190         int left, right, ret;
 191
 192         if (!expr || expr->type != EXPR_COMPARE)
 193                 return 0;
 194
 195         if ((left = expr_to_val(expr->left)) == UNDEFINED)
 196                 return 0;
 197
 198         if ((right = expr_to_val(expr->right)) == UNDEFINED)
 199                 return 0;
 200
 201         ret = true_comparison(left, expr->op, right);
 202         if (ret)
 203                 SM_DEBUG("%d known condition: %d %s %d => true", get_lineno(),
 204                          left, show_special(expr->op), right);
 205         else
 206                 smatch_msg("known condition: %d %s %d => false", left,
 207                            show_special(expr->op), right);
 208
 209         return ret;
 210 }