check_redundant_null_check.c

   1 /*
   2  * sparse/check_redundant_null_check.c
   3  *
   4  * Copyright (C) 2009 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 /*
  11  * Some functions are designed to handle NULL values but people always
  12  * do stuff like:  if (foo) kfree(foo);
  13  * The if check is unneeded and a waste of precious CPU cycles.  Also a
  14  * little bit messy.
  15  *
  16  * List of wine functions taken from Michael Stefaniuc's
  17  * redundant_null_check.pl
  18  *
  19  * This test is not the prettiest.  Smatch has a feature where it
  20  * simplifies comparisons to zero and I wanted to take advantage of
  21  * that, but that also makes things a bit complicated.
  22  *
  23  * We work backwards.  When we hit a kfree() we ask was the last statement
  24  * an if statement, and was the last comparison checking the pointer we
  25  * are about to free?  If all three answers are yes, then print a message.
  26  *
  27  */
  28
  29 #include "smatch.h"
  30
  31 static int my_id;
  32
  33 static struct statement *this_statement = NULL;
  34 static struct statement *previous_statement = NULL;
  35 static struct expression *previous_condition = NULL;
  36
  37 static const char *wine_funcs[] = {
  38         "HeapFree",
  39         "RtlFreeHeap",
  40         "SysFreeString",
  41         "CryptMemFree",
  42         "DllFreeSplMem",
  43         "FreeEnvironmentStringsA",
  44         "Free",
  45         "GdipFree",
  46         "I_RpcFree",
  47         "ldap_memfreeA",
  48         "ldap_memfreeW",
  49         "LsaFreeMemory",
  50         "MyFree",
  51         "SetupTermDefaultQueueCallback",
  52 };
  53
  54 static void dont_check(const char *fn, struct expression *expr, void *unused)
  55 {
  56         struct expression *arg;
  57         char *name = NULL;
  58         char *condition_name = NULL;
  59
  60         if (!previous_statement || !previous_condition || previous_statement->type != STMT_IF)
  61                 return;
  62
  63         arg = get_argument_from_call_expr(expr->args, 0);
  64         name = expr_to_var(arg);
  65         if (!name)
  66                 goto free;
  67         condition_name = expr_to_var(previous_condition);
  68         if (!condition_name)
  69                 goto free;
  70         if (!strcmp(name, condition_name))
  71                 sm_msg("info: redundant null check on %s calling %s()", name, fn);
  72
  73 free:
  74         free_string(name);
  75         free_string(condition_name);
  76 }
  77
  78 static void match_statement(struct statement *stmt)
  79 {
  80         if (stmt->type == STMT_COMPOUND)
  81                 return;
  82         previous_statement = this_statement;
  83         this_statement = stmt;
  84 }
  85
  86 static void match_condition(struct expression *expr)
  87 {
  88         previous_condition = expr;
  89 }
  90
  91 void check_redundant_null_check(int id)
  92 {
  93         my_id = id;
  94         int i;
  95
  96         add_hook(&match_statement, STMT_HOOK);
  97         add_hook(&match_condition, CONDITION_HOOK);
  98         add_function_hook("free", &dont_check, NULL);
  99         if (option_project == PROJ_KERNEL) {
 100                 add_function_hook("kfree", &dont_check, NULL);
 101         } else if (option_project == PROJ_WINE) {
 102                 for (i = 0; i < ARRAY_SIZE(wine_funcs); i++) {
 103                         add_function_hook(wine_funcs[i], &dont_check, NULL);
 104                 }
 105         }
 106 }