Print this page
11506 smatch resync

Split Close
Expand all
Collapse all
          --- old/usr/src/tools/smatch/src/check_off_by_one_relative.c
          +++ new/usr/src/tools/smatch/src/check_off_by_one_relative.c
↓ open down ↓ 25 lines elided ↑ open up ↑
  26   26  #include "smatch_extra.h"
  27   27  
  28   28  static int my_id;
  29   29  
  30   30  static void array_check(struct expression *expr)
  31   31  {
  32   32          struct expression *array;
  33   33          struct expression *size;
  34   34          struct expression *offset;
  35   35          char *array_str, *offset_str;
       36 +        int limit_type;
  36   37  
  37   38          expr = strip_expr(expr);
  38   39          if (!is_array(expr))
  39   40                  return;
  40   41  
  41   42          array = get_array_base(expr);
  42      -        size = get_size_variable(array);
  43      -        if (!size)
       43 +        size = get_size_variable(array, &limit_type);
       44 +        if (!size || limit_type != ELEM_COUNT)
  44   45                  return;
  45   46          offset = get_array_offset(expr);
  46   47          if (!possible_comparison(size, SPECIAL_EQUAL, offset))
  47   48                  return;
  48   49  
       50 +        if (buf_comparison_index_ok(expr))
       51 +                return;
       52 +
  49   53          array_str = expr_to_str(array);
  50   54          offset_str = expr_to_str(offset);
  51   55          sm_warning("potentially one past the end of array '%s[%s]'", array_str, offset_str);
  52   56          free_string(array_str);
  53   57          free_string(offset_str);
  54   58  }
  55   59  
  56      -static int known_access_ok_comparison(struct expression *expr)
  57      -{
  58      -        struct expression *array;
  59      -        struct expression *size;
  60      -        struct expression *offset;
  61      -        int comparison;
  62      -
  63      -        array = get_array_base(expr);
  64      -        size = get_size_variable(array);
  65      -        if (!size)
  66      -                return 0;
  67      -        offset = get_array_offset(expr);
  68      -        comparison = get_comparison(size, offset);
  69      -        if (comparison == '>' || comparison == SPECIAL_UNSIGNED_GT)
  70      -                return 1;
  71      -
  72      -        return 0;
  73      -}
  74      -
  75   60  static int known_access_ok_numbers(struct expression *expr)
  76   61  {
  77   62          struct expression *array;
  78   63          struct expression *offset;
  79   64          sval_t max;
  80   65          int size;
  81   66  
  82   67          array = get_array_base(expr);
  83   68          offset = get_array_offset(expr);
  84   69  
↓ open down ↓ 16 lines elided ↑ open up ↑
 101   86          struct compare_data *comp;
 102   87          char *offset_name;
 103   88          const char *equal_name = NULL;
 104   89  
 105   90          expr = strip_expr(expr);
 106   91          if (!is_array(expr))
 107   92                  return;
 108   93  
 109   94          if (known_access_ok_numbers(expr))
 110   95                  return;
 111      -        if (known_access_ok_comparison(expr))
       96 +        if (buf_comparison_index_ok(expr))
 112   97                  return;
 113   98  
 114   99          array = get_array_base(expr);
 115  100          offset = get_array_offset(expr);
 116  101          offset_name = expr_to_var(offset);
 117  102          if (!offset_name)
 118  103                  return;
 119  104          slist = get_all_possible_equal_comparisons(offset);
 120  105          if (!slist)
 121  106                  goto free;
↓ open down ↓ 36 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX