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(struct expression *expr)
  61 {
  62         char *name;
  63         struct symbol *sym;
  64         struct state_list *slist;
  65         struct sm_state *sm;
  66         int match;
  67
  68         name = expr_to_var_sym(expr, &sym);
  69         if (!name || !sym)
  70                 goto free;
  71         slist = __get_cur_slist();
  72
  73         FOR_EACH_PTR(slist, sm) {
  74                 if (sm->owner > num_checks)
  75                         continue;
  76                 match = matches(name, sym, sm);
  77
  78                 if (match && hooks[sm->owner])
  79                         (hooks[sm->owner])(sm);
  80
  81                 if (match == match_indirect && indirect_hooks[sm->owner])
  82                         (indirect_hooks[sm->owner])(sm);
  83         } END_FOR_EACH_PTR(sm);
  84 free:
  85         free_string(name);
  86 }
  87
  88 static void match_assign(struct expression *expr)
  89 {
  90         call_modification_hooks(expr->left);
  91 }
  92
  93 static void unop_expr(struct expression *expr)
  94 {
  95         if (expr->op != SPECIAL_DECREMENT && expr->op != SPECIAL_INCREMENT)
  96                 return;
  97
  98         expr = strip_expr(expr->unop);
  99         call_modification_hooks(expr);
 100 }
 101
 102 static void match_call(struct expression *expr)
 103 {
 104         struct expression *arg, *tmp;
 105
 106         FOR_EACH_PTR(expr->args, arg) {
 107                 tmp = strip_expr(arg);
 108                 if (tmp->type == EXPR_PREOP && tmp->op == '&') {
 109                         tmp = strip_expr(tmp->unop);
 110                         call_modification_hooks(tmp);
 111                 } else {
 112                         call_modification_hooks(deref_expression(tmp));
 113                 }
 114         } END_FOR_EACH_PTR(arg);
 115 }
 116
 117 static void asm_expr(struct statement *stmt)
 118 {
 119
 120         struct expression *expr;
 121         int state = 0;
 122
 123         FOR_EACH_PTR(stmt->asm_outputs, expr) {
 124                 switch (state) {
 125                 case 0: /* identifier */
 126                 case 1: /* constraint */
 127                         state++;
 128                         continue;
 129                 case 2: /* expression */
 130                         state = 0;
 131                         call_modification_hooks(expr);
 132                         continue;
 133                 }
 134         } END_FOR_EACH_PTR(expr);
 135 }
 136
 137 void register_modification_hooks(int id)
 138 {
 139         hooks = malloc((num_checks + 1) * sizeof(*hooks));
 140         memset(hooks, 0, (num_checks + 1) * sizeof(*hooks));
 141         indirect_hooks = malloc((num_checks + 1) * sizeof(*hooks));
 142         memset(indirect_hooks, 0, (num_checks + 1) * sizeof(*hooks));
 143
 144         add_hook(&match_assign, ASSIGNMENT_HOOK);
 145         add_hook(&unop_expr, OP_HOOK);
 146         add_hook(&asm_expr, ASM_HOOK);
 147 }
 148
 149 void register_modification_hooks_late(int id)
 150 {
 151         add_hook(&match_call, FUNCTION_CALL_HOOK);
 152 }
 153