smatch_modification_hooks.c

   1 /*
   2  * sparse/smatch_modification_hooks.c
   3  *
   4  * Copyright (C) 2009 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_extra.h"
  14 #include "smatch_slist.h"
  15
  16 enum {
  17         match_none = 0,
  18         match_exact,
  19         match_indirect
  20 };
  21
  22 static modification_hook **hooks;
  23 static modification_hook **indirect_hooks;  /* parent struct modified etc */
  24
  25 void add_modification_hook(int owner, modification_hook *call_back)
  26 {
  27         hooks[owner] = call_back;
  28 }
  29
  30 void add_indirect_modification_hook(int owner, modification_hook *call_back)
  31 {
  32         indirect_hooks[owner] = call_back;
  33 }
  34
  35 static int matches(char *name, struct symbol *sym, struct sm_state *sm)
  36 {
  37         int len;
  38
  39         if (sym != sm->sym)
  40                 return match_none;
  41
  42         len = strlen(name);
  43         if (strncmp(sm->name, name, len) == 0) {
  44                 if (sm->name[len] == '\0')
  45                         return match_exact;
  46                 if (sm->name[len] == '-' || sm->name[len] == '.')
  47                         return match_indirect;
  48         }
  49         if (sm->name[0] != '*')
  50                 return match_none;
  51         if (strncmp(sm->name + 1, name, len) == 0) {
  52                 if (sm->name[len + 1] == '\0')
  53                         return match_indirect;
  54                 if (sm->name[len + 1] == '-' || sm->name[len + 1] == '.')
  55                         return match_indirect;
  56         }
  57         return match_none;
  58 }
  59
  60 static void call_modification_hooks_name_sym(char *name, struct symbol *sym)
  61 {
  62         struct state_list *slist;
  63         struct sm_state *sm;
  64         int match;
  65
  66         slist = __get_cur_slist();
  67
  68         FOR_EACH_PTR(slist, sm) {
  69                 if (sm->owner > num_checks)
  70                         continue;
  71                 match = matches(name, sym, sm);
  72
  73                 if (match && hooks[sm->owner])
  74                         (hooks[sm->owner])(sm);
  75
  76                 if (match == match_indirect && indirect_hooks[sm->owner])
  77                         (indirect_hooks[sm->owner])(sm);
  78         } END_FOR_EACH_PTR(sm);
  79 }
  80
  81 static void call_modification_hooks(struct expression *expr)
  82 {
  83         char *name;
  84         struct symbol *sym;
  85
  86         name = expr_to_var_sym(expr, &sym);
  87         if (!name || !sym)
  88                 goto free;
  89         call_modification_hooks_name_sym(name, sym);
  90 free:
  91         free_string(name);
  92 }
  93
  94 static void db_param_add(struct expression *expr, int param, char *key, char *value)
  95 {
  96         struct expression *arg;
  97         char *name;
  98         struct symbol *sym;
  99
 100         while (expr->type == EXPR_ASSIGNMENT)
 101                 expr = strip_expr(expr->right);
 102         if (expr->type != EXPR_CALL)
 103                 return;
 104
 105         arg = get_argument_from_call_expr(expr->args, param);
 106         if (!arg)
 107                 return;
 108
 109         name = get_variable_from_key(arg, key, &sym);
 110         if (!name || !sym)
 111                 goto free;
 112
 113         call_modification_hooks_name_sym(name, sym);
 114 free:
 115         free_string(name);
 116 }
 117
 118 static void match_assign(struct expression *expr)
 119 {
 120         call_modification_hooks(expr->left);
 121 }
 122
 123 static void unop_expr(struct expression *expr)
 124 {
 125         if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
 126                 return;
 127
 128         expr = strip_expr(expr->unop);
 129         call_modification_hooks(expr);
 130 }
 131
 132 static void match_call(struct expression *expr)
 133 {
 134         struct expression *arg, *tmp;
 135
 136         FOR_EACH_PTR(expr->args, arg) {
 137                 tmp = strip_expr(arg);
 138                 if (tmp->type == EXPR_PREOP && tmp->op == '&') {
 139                         tmp = strip_expr(tmp->unop);
 140                         call_modification_hooks(tmp);
 141                 } else {
 142                         call_modification_hooks(deref_expression(tmp));
 143                 }
 144         } END_FOR_EACH_PTR(arg);
 145 }
 146
 147 static void asm_expr(struct statement *stmt)
 148 {
 149
 150         struct expression *expr;
 151         int state = 0;
 152
 153         FOR_EACH_PTR(stmt->asm_outputs, expr) {
 154                 switch (state) {
 155                 case 0: /* identifier */
 156                 case 1: /* constraint */
 157                         state++;
 158                         continue;
 159                 case 2: /* expression */
 160                         state = 0;
 161                         call_modification_hooks(expr);
 162                         continue;
 163                 }
 164         } END_FOR_EACH_PTR(expr);
 165 }
 166
 167 void register_modification_hooks(int id)
 168 {
 169         hooks = malloc((num_checks + 1) * sizeof(*hooks));
 170         memset(hooks, 0, (num_checks + 1) * sizeof(*hooks));
 171         indirect_hooks = malloc((num_checks + 1) * sizeof(*hooks));
 172         memset(indirect_hooks, 0, (num_checks + 1) * sizeof(*hooks));
 173
 174         add_hook(&match_assign, ASSIGNMENT_HOOK);
 175         add_hook(&unop_expr, OP_HOOK);
 176         add_hook(&asm_expr, ASM_HOOK);
 177 }
 178
 179 void register_modification_hooks_late(int id)
 180 {
 181         add_hook(&match_call, FUNCTION_CALL_HOOK);
 182         add_db_return_states_callback(ADDED_VALUE, &db_param_add);
 183 }
 184