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_slist.h"
  14
  15 enum {
  16         match_none = 0,
  17         match_exact,
  18         match_indirect
  19 };
  20
  21 static modification_hook **hooks;
  22 static modification_hook **indirect_hooks;  /* parent struct modified etc */
  23
  24 void add_modification_hook(int owner, modification_hook *call_back)
  25 {
  26         hooks[owner] = call_back;
  27 }
  28
  29 void add_indirect_modification_hook(int owner, modification_hook *call_back)
  30 {
  31         indirect_hooks[owner] = call_back;
  32 }
  33
  34 static int matches(char *name, struct symbol *sym, struct sm_state *sm)
  35 {
  36         int len;
  37
  38         if (sym != sm->sym)
  39                 return match_none;
  40
  41         len = strlen(name);
  42         if (strncmp(sm->name, name, len) == 0) {
  43                 if (sm->name[len] == '\0')
  44                         return match_exact;
  45                 if (sm->name[len] == '-' || sm->name[len] == '.')
  46                         return match_indirect;
  47         }
  48         if (sm->name[0] != '*')
  49                 return match_none;
  50         if (strncmp(sm->name + 1, name, len) == 0) {
  51                 if (sm->name[len + 1] == '\0')
  52                         return match_indirect;
  53                 if (sm->name[len + 1] == '-' || sm->name[len + 1] == '.')
  54                         return match_indirect;
  55         }
  56         return match_none;
  57 }
  58
  59 static void call_modification_hooks(struct expression *expr)
  60 {
  61         char *name;
  62         struct symbol *sym;
  63         struct state_list *slist;
  64         struct sm_state *sm;
  65         int match;
  66
  67         name = get_variable_from_expr(expr, &sym);
  68         if (!name || !sym)
  69                 goto free;
  70         slist = __get_cur_slist();
  71
  72         FOR_EACH_PTR(slist, sm) {
  73                 if (sm->owner > num_checks)
  74                         continue;
  75                 match = matches(name, sym, sm);
  76
  77                 if (match && hooks[sm->owner])
  78                         (hooks[sm->owner])(sm);
  79
  80                 if (match == match_indirect && indirect_hooks[sm->owner])
  81                         (indirect_hooks[sm->owner])(sm);
  82         } END_FOR_EACH_PTR(sm);
  83 free:
  84         free_string(name);
  85 }
  86
  87 static void match_assign(struct expression *expr)
  88 {
  89         call_modification_hooks(expr->left);
  90 }
  91
  92 static void unop_expr(struct expression *expr)
  93 {
  94         if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
  95                 return;
  96
  97         expr = strip_expr(expr->unop);
  98         call_modification_hooks(expr);
  99 }
 100
 101 static void match_call(struct expression *expr)
 102 {
 103         struct expression *arg, *tmp;
 104
 105         FOR_EACH_PTR(expr->args, arg) {
 106                 tmp = strip_expr(arg);
 107                 if (tmp->type != EXPR_PREOP || tmp->op != '&')
 108                         continue;
 109                 tmp = strip_expr(tmp->unop);
 110                 call_modification_hooks(tmp);
 111         } END_FOR_EACH_PTR(arg);
 112 }
 113
 114 static void asm_expr(struct statement *stmt)
 115 {
 116
 117         struct expression *expr;
 118         int state = 0;
 119
 120         FOR_EACH_PTR(stmt->asm_outputs, expr) {
 121                 switch (state) {
 122                 case 0: /* identifier */
 123                 case 1: /* constraint */
 124                         state++;
 125                         continue;
 126                 case 2: /* expression */
 127                         state = 0;
 128                         call_modification_hooks(expr);
 129                         continue;
 130                 }
 131         } END_FOR_EACH_PTR(expr);
 132 }
 133
 134 void register_modification_hooks(int id)
 135 {
 136         hooks = malloc((num_checks + 1) * sizeof(*hooks));
 137         memset(hooks, 0, (num_checks + 1) * sizeof(*hooks));
 138         indirect_hooks = malloc((num_checks + 1) * sizeof(*hooks));
 139         memset(indirect_hooks, 0, (num_checks + 1) * sizeof(*hooks));
 140
 141         add_hook(&match_assign, ASSIGNMENT_HOOK);
 142         add_hook(&unop_expr, OP_HOOK);
 143         add_hook(&asm_expr, ASM_HOOK);
 144 }
 145
 146 void register_modification_hooks_late(int id)
 147 {
 148         add_hook(&match_call, FUNCTION_CALL_HOOK);
 149 }
 150