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 match_assign(struct expression *expr)
  95 {
  96         call_modification_hooks(expr->left);
  97 }
  98
  99 static void unop_expr(struct expression *expr)
 100 {
 101         if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
 102                 return;
 103
 104         expr = strip_expr(expr->unop);
 105         call_modification_hooks(expr);
 106 }
 107
 108 static void match_call(struct expression *expr)
 109 {
 110         struct expression *arg, *tmp;
 111
 112         FOR_EACH_PTR(expr->args, arg) {
 113                 tmp = strip_expr(arg);
 114                 if (tmp->type == EXPR_PREOP && tmp->op == '&') {
 115                         tmp = strip_expr(tmp->unop);
 116                         call_modification_hooks(tmp);
 117                 } else {
 118                         call_modification_hooks(deref_expression(tmp));
 119                 }
 120         } END_FOR_EACH_PTR(arg);
 121 }
 122
 123 static void asm_expr(struct statement *stmt)
 124 {
 125
 126         struct expression *expr;
 127         int state = 0;
 128
 129         FOR_EACH_PTR(stmt->asm_outputs, expr) {
 130                 switch (state) {
 131                 case 0: /* identifier */
 132                 case 1: /* constraint */
 133                         state++;
 134                         continue;
 135                 case 2: /* expression */
 136                         state = 0;
 137                         call_modification_hooks(expr);
 138                         continue;
 139                 }
 140         } END_FOR_EACH_PTR(expr);
 141 }
 142
 143 void register_modification_hooks(int id)
 144 {
 145         hooks = malloc((num_checks + 1) * sizeof(*hooks));
 146         memset(hooks, 0, (num_checks + 1) * sizeof(*hooks));
 147         indirect_hooks = malloc((num_checks + 1) * sizeof(*hooks));
 148         memset(indirect_hooks, 0, (num_checks + 1) * sizeof(*hooks));
 149
 150         add_hook(&match_assign, ASSIGNMENT_HOOK);
 151         add_hook(&unop_expr, OP_HOOK);
 152         add_hook(&asm_expr, ASM_HOOK);
 153 }
 154
 155 void register_modification_hooks_late(int id)
 156 {
 157         add_hook(&match_call, FUNCTION_CALL_HOOK);
 158 }
 159