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 char *get_variable_from_key(struct expression *arg, char *key, struct symbol **sym)
  95 {
  96         char buf[256];
  97         char *tmp;
  98
  99         if (strcmp(key, "$$") == 0)
 100                 return expr_to_var_sym(arg, sym);
 101
 102         if (strcmp(key, "*$$") == 0) {
 103                 if (arg->type == EXPR_PREOP && arg->op == '&') {
 104                         arg = strip_expr(arg->unop);
 105                         return expr_to_var_sym(arg, sym);
 106                 } else {
 107                         tmp = expr_to_var_sym(arg, sym);
 108                         if (!tmp)
 109                                 return NULL;
 110                         snprintf(buf, sizeof(buf), "*%s", tmp);
 111                         free_string(tmp);
 112                         return alloc_string(buf);
 113                 }
 114         }
 115
 116         if (arg->type == EXPR_PREOP && arg->op == '&') {
 117                 arg = strip_expr(arg->unop);
 118                 tmp = expr_to_var_sym(arg, sym);
 119                 if (!tmp)
 120                         return NULL;
 121                 snprintf(buf, sizeof(buf), "%s.%s", tmp, key + 4);
 122                 return alloc_string(buf);
 123         }
 124
 125         tmp = expr_to_var_sym(arg, sym);
 126         if (!tmp)
 127                 return NULL;
 128         snprintf(buf, sizeof(buf), "%s%s", tmp, key + 2);
 129         free_string(tmp);
 130         return alloc_string(buf);
 131 }
 132
 133 static void db_param_add(struct expression *expr, int param, char *key, char *value)
 134 {
 135         struct expression *arg;
 136         char *name;
 137         struct symbol *sym;
 138
 139         while (expr->type == EXPR_ASSIGNMENT)
 140                 expr = strip_expr(expr->right);
 141         if (expr->type != EXPR_CALL)
 142                 return;
 143
 144         arg = get_argument_from_call_expr(expr->args, param);
 145         if (!arg)
 146                 return;
 147
 148         name = get_variable_from_key(arg, key, &sym);
 149         if (!name || !sym)
 150                 goto free;
 151
 152         call_modification_hooks_name_sym(name, sym);
 153 free:
 154         free_string(name);
 155 }
 156
 157 static void match_assign(struct expression *expr)
 158 {
 159         call_modification_hooks(expr->left);
 160 }
 161
 162 static void unop_expr(struct expression *expr)
 163 {
 164         if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
 165                 return;
 166
 167         expr = strip_expr(expr->unop);
 168         call_modification_hooks(expr);
 169 }
 170
 171 static void match_call(struct expression *expr)
 172 {
 173         struct expression *arg, *tmp;
 174
 175         FOR_EACH_PTR(expr->args, arg) {
 176                 tmp = strip_expr(arg);
 177                 if (tmp->type == EXPR_PREOP && tmp->op == '&') {
 178                         tmp = strip_expr(tmp->unop);
 179                         call_modification_hooks(tmp);
 180                 } else {
 181                         call_modification_hooks(deref_expression(tmp));
 182                 }
 183         } END_FOR_EACH_PTR(arg);
 184 }
 185
 186 static void asm_expr(struct statement *stmt)
 187 {
 188
 189         struct expression *expr;
 190         int state = 0;
 191
 192         FOR_EACH_PTR(stmt->asm_outputs, expr) {
 193                 switch (state) {
 194                 case 0: /* identifier */
 195                 case 1: /* constraint */
 196                         state++;
 197                         continue;
 198                 case 2: /* expression */
 199                         state = 0;
 200                         call_modification_hooks(expr);
 201                         continue;
 202                 }
 203         } END_FOR_EACH_PTR(expr);
 204 }
 205
 206 void register_modification_hooks(int id)
 207 {
 208         hooks = malloc((num_checks + 1) * sizeof(*hooks));
 209         memset(hooks, 0, (num_checks + 1) * sizeof(*hooks));
 210         indirect_hooks = malloc((num_checks + 1) * sizeof(*hooks));
 211         memset(indirect_hooks, 0, (num_checks + 1) * sizeof(*hooks));
 212
 213         add_hook(&match_assign, ASSIGNMENT_HOOK);
 214         add_hook(&unop_expr, OP_HOOK);
 215         add_hook(&asm_expr, ASM_HOOK);
 216 }
 217
 218 void register_modification_hooks_late(int id)
 219 {
 220         add_hook(&match_call, FUNCTION_CALL_HOOK);
 221         add_db_return_states_callback(ADDED_VALUE, &db_param_add);
 222 }
 223