11506 smatch resync

          --- old/usr/src/tools/smatch/src/smatch_passes_array_size.c
          +++ new/usr/src/tools/smatch/src/smatch_passes_array_size.c

   1    1  /*
   2    2   * Copyright (C) 2017 Oracle.
   3    3   *
   4    4   * This program is free software; you can redistribute it and/or
   5    5   * modify it under the terms of the GNU General Public License
   6    6   * as published by the Free Software Foundation; either version 2
   7    7   * of the License, or (at your option) any later version.
   8    8   *
   9    9   * This program is distributed in the hope that it will be useful,
  10   10   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   11   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   12   * GNU General Public License for more details.
  13   13   *
  14   14   * You should have received a copy of the GNU General Public License
  15   15   * along with this program; if not, see http://www.gnu.org/copyleft/gpl.txt
  16   16   */
  17   17  
  18   18  #include "smatch.h"
  19   19  #include "smatch_extra.h"
  20   20  
  21   21  static int find_param_eq(struct expression *expr, int size)
  22   22  {
  23   23          struct expression *arg;
  24   24          sval_t val;
  25   25          int i;
  26   26  
  27   27          i = -1;
  28   28          FOR_EACH_PTR(expr->args, arg) {
  29   29                  i++;
  30   30                  if (!get_implied_value(arg, &val))
  31   31                          continue;

  32   32                  if (val.value == size)
  33   33                          return i;
  34   34          } END_FOR_EACH_PTR(arg);
  35   35  
  36   36          return -1;
  37   37  }
  38   38  
  39   39  static void match_call(struct expression *expr)
  40   40  {
  41   41          struct expression *arg;
  42      -        struct symbol *type;
       42 +        struct symbol *type, *arg_type;
  43   43          int size, bytes;
  44   44          int i, nr;
  45   45          char buf[16];
       46 +        char elem_count[8];
       47 +        char byte_count[8];
  46   48  
       49 +        snprintf(elem_count, sizeof(elem_count), "%d", ELEM_COUNT);
       50 +        snprintf(byte_count, sizeof(byte_count), "%d", BYTE_COUNT);
  47   51  
  48   52          i = -1;
  49   53          FOR_EACH_PTR(expr->args, arg) {
  50   54                  i++;
  51   55                  type = get_type(arg);
  52   56                  if (!type || (type->type != SYM_PTR && type->type != SYM_ARRAY))
  53   57                          continue;
       58 +                arg_type = get_arg_type(expr->fn, i);
       59 +                if (arg_type != type)
       60 +                        continue;
       61 +
  54   62                  size = get_array_size(arg);
  55   63                  if (size > 0) {
  56   64                          nr = find_param_eq(expr, size);
  57   65                          if (nr >= 0) {
  58      -                                snprintf(buf, sizeof(buf), "%d", nr);
  59      -                                sql_insert_caller_info(expr, ARRAYSIZE_ARG, i, buf, "");
       66 +                                snprintf(buf, sizeof(buf), "==$%d", nr);
       67 +                                sql_insert_caller_info(expr, ELEM_COUNT, i, buf, elem_count);
  60   68                                  continue;
  61   69                          }
  62   70                  }
  63   71                  bytes = get_array_size_bytes(arg);
  64   72                  if (bytes > 0) {
  65   73                          nr = find_param_eq(expr, bytes);
  66   74                          if (nr >= 0) {
  67      -                                snprintf(buf, sizeof(buf), "%d", nr);
  68      -                                sql_insert_caller_info(expr, SIZEOF_ARG, i, buf, "");
       75 +                                snprintf(buf, sizeof(buf), "==$%d", nr);
       76 +                                sql_insert_caller_info(expr, BYTE_COUNT, i, buf, byte_count);
  69   77                                  continue;
  70   78                          }
  71   79                  }
  72   80          } END_FOR_EACH_PTR(arg);
  73   81  }
  74   82  
  75   83  void register_passes_array_size(int id)
  76   84  {
  77   85          add_hook(&match_call, FUNCTION_CALL_HOOK);
  78   86  }
  79   87  
    

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX