smatch_struct_assignment.c

   1 /*
   2  * sparse/smatch_struct_assignment.c
   3  *
   4  * Copyright (C) 2014 Oracle.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "scope.h"
  11 #include "smatch.h"
  12 #include "smatch_slist.h"
  13 #include "smatch_extra.h"
  14
  15 static struct symbol *get_struct_type(struct expression *expr)
  16 {
  17         struct symbol *type;
  18
  19         type = get_type(expr);
  20         if (!type)
  21                 return NULL;
  22         if (type->type == SYM_PTR)
  23                 type = get_real_base_type(type);
  24         if (type && type->type == SYM_STRUCT)
  25                 return type;
  26         return NULL;
  27 }
  28
  29 static int known_struct_member_states(struct expression *expr)
  30 {
  31         struct state_list *slist = __get_cur_slist();
  32         struct sm_state *sm;
  33         char *name;
  34         int ret = 0;
  35         int cmp;
  36         int len;
  37
  38         if (expr->type == EXPR_PREOP && expr->op == '&')
  39                 expr = strip_expr(expr->unop);
  40
  41         name = expr_to_var(expr);
  42         if (!name)
  43                 return 0;
  44         len = strlen(name);
  45
  46         FOR_EACH_PTR(slist, sm) {
  47                 if (sm->owner != SMATCH_EXTRA)
  48                         continue;
  49                 cmp = strncmp(sm->name, name, len);
  50                 if (cmp < 0)
  51                         continue;
  52                 if (cmp == 0) {
  53                         if (sm->name[len] == '.' ||
  54                             sm->name[len] == '-' ||
  55                             sm->name[len] == '.') {
  56                                 ret = 1;
  57                                 goto out;
  58                         }
  59                         continue;
  60                 }
  61                 goto out;
  62         } END_FOR_EACH_PTR(sm);
  63
  64 out:
  65         return ret;
  66 }
  67
  68 static struct expression *get_matching_member_expr(struct symbol *left_type, struct expression *right, struct symbol *left_member)
  69 {
  70         struct symbol *struct_type;
  71         int op = '.';
  72
  73         if (!left_member->ident)
  74                 return NULL;
  75
  76         struct_type = get_struct_type(right);
  77         if (!struct_type)
  78                 return NULL;
  79         if (struct_type != left_type)
  80                 return NULL;
  81
  82         if (right->type == EXPR_PREOP && right->op == '&')
  83                 right = strip_expr(right->unop);
  84
  85         if (is_pointer(right)) {
  86                 right = deref_expression(right);
  87                 op = '*';
  88         }
  89
  90         return member_expression(right, op, left_member->ident);
  91 }
  92
  93 void __struct_members_copy(int mode, struct expression *left, struct expression *right)
  94 {
  95         struct symbol *struct_type, *tmp, *type;
  96         struct expression *left_member, *right_member, *assign;
  97         int op = '.';
  98
  99
 100         if (__in_fake_assign)
 101                 return;
 102
 103         left = strip_expr(left);
 104         right = strip_expr(right);
 105
 106         struct_type = get_struct_type(left);
 107         if (!struct_type)
 108                 return;
 109
 110         if (is_pointer(left)) {
 111                 left = deref_expression(left);
 112                 op = '*';
 113         }
 114
 115         FOR_EACH_PTR(struct_type->symbol_list, tmp) {
 116                 type = get_real_base_type(tmp);
 117                 if (type && type->type == SYM_ARRAY)
 118                         continue;
 119
 120                 left_member = member_expression(left, op, tmp->ident);
 121
 122                 switch (mode) {
 123                 case COPY_NORMAL:
 124                 case COPY_MEMCPY:
 125                         right_member = get_matching_member_expr(struct_type, right, tmp);
 126                         break;
 127                 case COPY_MEMSET:
 128                         right_member = right;
 129                         break;
 130                 }
 131                 if (!right_member)
 132                         right_member = unknown_value_expression(left_member);
 133                 assign = assign_expression(left_member, right_member);
 134                 __in_fake_assign++;
 135                 __split_expr(assign);
 136                 __in_fake_assign--;
 137         } END_FOR_EACH_PTR(tmp);
 138 }
 139
 140 void __fake_struct_member_assignments(struct expression *expr)
 141 {
 142         __struct_members_copy(COPY_NORMAL, expr->left, expr->right);
 143 }
 144
 145 static struct expression *remove_addr(struct expression *expr)
 146 {
 147         expr = strip_expr(expr);
 148
 149         if (expr->type == EXPR_PREOP && expr->op == '&')
 150                 return strip_expr(expr->unop);
 151         return expr;
 152 }
 153
 154 static void match_memset(const char *fn, struct expression *expr, void *_size_arg)
 155 {
 156         struct expression *buf;
 157         struct expression *val;
 158
 159         buf = get_argument_from_call_expr(expr->args, 0);
 160         val = get_argument_from_call_expr(expr->args, 1);
 161
 162         buf = strip_expr(buf);
 163         __struct_members_copy(COPY_MEMSET, remove_addr(buf), val);
 164 }
 165
 166 static void match_memcpy(const char *fn, struct expression *expr, void *_arg)
 167 {
 168         struct expression *dest;
 169         struct expression *src;
 170
 171         dest = get_argument_from_call_expr(expr->args, 0);
 172         src = get_argument_from_call_expr(expr->args, 1);
 173
 174         __struct_members_copy(COPY_MEMCPY, remove_addr(dest), remove_addr(src));
 175 }
 176
 177 static void match_memcpy_unknown(const char *fn, struct expression *expr, void *_arg)
 178 {
 179         struct expression *dest;
 180
 181         dest = get_argument_from_call_expr(expr->args, 0);
 182         __struct_members_copy(COPY_MEMCPY, remove_addr(dest), NULL);
 183 }
 184
 185 static void register_clears_param(void)
 186 {
 187         struct token *token;
 188         char name[256];
 189         const char *function;
 190         int param;
 191
 192         if (option_project == PROJ_NONE)
 193                 return;
 194
 195         snprintf(name, 256, "%s.clears_argument", option_project_str);
 196
 197         token = get_tokens_file(name);
 198         if (!token)
 199                 return;
 200         if (token_type(token) != TOKEN_STREAMBEGIN)
 201                 return;
 202         token = token->next;
 203         while (token_type(token) != TOKEN_STREAMEND) {
 204                 if (token_type(token) != TOKEN_IDENT)
 205                         return;
 206                 function = show_ident(token->ident);
 207                 token = token->next;
 208                 if (token_type(token) != TOKEN_NUMBER)
 209                         return;
 210                 param = atoi(token->number);
 211                 add_function_hook(function, &match_memcpy_unknown, INT_PTR(param));
 212                 token = token->next;
 213         }
 214         clear_token_alloc();
 215 }
 216
 217 void register_struct_assignment(int id)
 218 {
 219         add_function_hook("memset", &match_memset, NULL);
 220
 221         add_function_hook("memcpy", &match_memcpy, INT_PTR(0));
 222         add_function_hook("memmove", &match_memcpy, INT_PTR(0));
 223
 224         register_clears_param();
 225 }