check_nospec.c

   1 /*
   2  * Copyright (C) 2018 Oracle.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16  */
  17
  18 #include <stdlib.h>
  19 #include "parse.h"
  20 #include "smatch.h"
  21 #include "smatch_slist.h"
  22 #include "smatch_extra.h"
  23
  24 static int my_id;
  25
  26 STATE(nospec);
  27
  28 static bool in_nospec_stmt;
  29
  30 static struct smatch_state *unmatched_state(struct sm_state *sm)
  31 {
  32         struct range_list *rl;
  33
  34         if (__in_function_def && !get_user_rl_var_sym(sm->name, sm->sym, &rl))
  35                 return &nospec;
  36         return &undefined;
  37 }
  38
  39 bool is_nospec(struct expression *expr)
  40 {
  41         char *macro;
  42
  43         if (in_nospec_stmt)
  44                 return true;
  45         if (!expr)
  46                 return false;
  47         if (get_state_expr(my_id, expr) == &nospec)
  48                 return true;
  49         macro = get_macro_name(expr->pos);
  50         if (macro && strcmp(macro, "array_index_nospec") == 0)
  51                 return true;
  52         return false;
  53 }
  54
  55 static void nospec_assign(struct expression *expr)
  56 {
  57         if (is_nospec(expr->right))
  58                 set_state_expr(my_id, expr->left, &nospec);
  59 }
  60
  61 static void set_param_nospec(const char *name, struct symbol *sym, char *key, char *value)
  62 {
  63         char fullname[256];
  64
  65         if (strcmp(key, "*$") == 0)
  66                 snprintf(fullname, sizeof(fullname), "*%s", name);
  67         else if (strncmp(key, "$", 1) == 0)
  68                 snprintf(fullname, 256, "%s%s", name, key + 1);
  69         else
  70                 return;
  71
  72         set_state(my_id, fullname, sym, &nospec);
  73 }
  74
  75 static void match_call_info(struct expression *expr)
  76 {
  77         struct expression *arg;
  78         int i = 0;
  79
  80         FOR_EACH_PTR(expr->args, arg) {
  81                 if (get_state_expr(my_id, arg) == &nospec)
  82                         sql_insert_caller_info(expr, NOSPEC, i, "$", "");
  83                 i++;
  84         } END_FOR_EACH_PTR(arg);
  85 }
  86
  87 static void struct_member_callback(struct expression *call, int param, char *printed_name, struct sm_state *sm)
  88 {
  89         struct range_list *rl;
  90
  91         if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
  92                 return;
  93         sql_insert_caller_info(call, NOSPEC, param, printed_name, "");
  94 }
  95
  96 static void returned_struct_members(int return_id, char *return_ranges, struct expression *expr)
  97 {
  98         struct symbol *returned_sym;
  99         struct sm_state *sm;
 100         const char *param_name;
 101         struct range_list *rl;
 102         int param;
 103
 104         returned_sym = expr_to_sym(expr);
 105
 106         FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
 107                 param = get_param_num_from_sym(sm->sym);
 108                 if (param < 0) {
 109                         if (!returned_sym || returned_sym != sm->sym)
 110                                 continue;
 111                         param = -1;
 112                 }
 113
 114                 param_name = get_param_name(sm);
 115                 if (!param_name)
 116                         continue;
 117                 if (param != -1 && strcmp(param_name, "$") == 0)
 118                         continue;
 119
 120                 if (!get_user_rl_var_sym(sm->name, sm->sym, &rl))
 121                         continue;
 122
 123                 sql_insert_return_states(return_id, return_ranges, NOSPEC, param, param_name, "");
 124         } END_FOR_EACH_SM(sm);
 125
 126         if (is_nospec(expr) && get_user_rl(expr, &rl))
 127                 sql_insert_return_states(return_id, return_ranges, NOSPEC, -1, "$", "");
 128 }
 129
 130 static int is_return_statement(void)
 131 {
 132         if (__cur_stmt && __cur_stmt->type == STMT_RETURN)
 133                 return 1;
 134         return 0;
 135 }
 136
 137 static void db_returns_nospec(struct expression *expr, int param, char *key, char *value)
 138 {
 139         struct expression *call;
 140         struct expression *arg;
 141         char *name;
 142         struct symbol *sym;
 143
 144         call = expr;
 145         while (call->type == EXPR_ASSIGNMENT)
 146                 call = strip_expr(call->right);
 147         if (call->type != EXPR_CALL)
 148                 return;
 149
 150         if (param == -1 && expr->type == EXPR_ASSIGNMENT) {
 151                 name = get_variable_from_key(expr->left, key, &sym);
 152         } else if (param == -1 && is_return_statement()) {
 153                 in_nospec_stmt = true;
 154                 return;
 155         } else {
 156                 arg = get_argument_from_call_expr(call->args, param);
 157                 if (!arg)
 158                         return;
 159                 name = get_variable_from_key(arg, key, &sym);
 160         }
 161         if (!name || !sym)
 162                 goto free;
 163
 164         set_state(my_id, name, sym, &nospec);
 165 free:
 166         free_string(name);
 167 }
 168
 169 static int is_nospec_asm(struct statement *stmt)
 170 {
 171         char *macro;
 172
 173         if (!stmt || stmt->type != STMT_ASM)
 174                 return 0;
 175         macro = get_macro_name(stmt->asm_string->pos);
 176         if (!macro || strcmp(macro, "CALL_NOSPEC") != 0)
 177                 return 0;
 178         return 1;
 179 }
 180
 181 static void match_asm(struct statement *stmt)
 182 {
 183         if (is_nospec_asm(stmt))
 184                 in_nospec_stmt = true;
 185 }
 186
 187 static void match_after_nospec_asm(struct statement *stmt)
 188 {
 189         in_nospec_stmt = false;
 190 }
 191
 192 static void match_barrier(struct statement *stmt)
 193 {
 194         struct stree *stree;
 195         struct symbol *type;
 196         struct sm_state *sm;
 197         char *macro;
 198
 199         macro = get_macro_name(stmt->pos);
 200         if (!macro)
 201                 return;
 202         if (strcmp(macro, "rmb") != 0 &&
 203             strcmp(macro, "smp_rmb") != 0 &&
 204             strcmp(macro, "barrier_nospec") != 0)
 205                 return;
 206
 207         stree = get_user_stree();
 208         FOR_EACH_SM(stree, sm) {
 209                 if (is_whole_rl(estate_rl(sm->state)))
 210                         continue;
 211                 type = estate_type(sm->state);
 212                 if (!type || type->type != SYM_BASETYPE)
 213                         continue;
 214                 if (!is_capped_var_sym(sm->name, sm->sym))
 215                         continue;
 216                 set_state(my_id, sm->name, sm->sym, &nospec);
 217         } END_FOR_EACH_SM(sm);
 218         free_stree(&stree);
 219 }
 220
 221 void check_nospec(int id)
 222 {
 223         my_id = id;
 224
 225         add_hook(&nospec_assign, ASSIGNMENT_HOOK);
 226
 227         select_caller_info_hook(set_param_nospec, NOSPEC);
 228         add_unmatched_state_hook(my_id, &unmatched_state);
 229
 230         add_hook(&match_call_info, FUNCTION_CALL_HOOK);
 231         add_member_info_callback(my_id, struct_member_callback);
 232         add_split_return_callback(&returned_struct_members);
 233         select_return_states_hook(NOSPEC, &db_returns_nospec);
 234
 235         add_hook(&match_asm, ASM_HOOK);
 236         add_hook(&match_after_nospec_asm, STMT_HOOK_AFTER);
 237         add_hook(&match_barrier, ASM_HOOK);
 238 }