11506 smatch resync

*** 40,50 ****
  
  static struct smatch_state *unmatched_state(struct sm_state *sm)
  {
          struct smatch_state *state;
  
!         state = get_state(SMATCH_EXTRA, sm->name, sm->sym);
          if (state && !estate_is_whole(state))
                  return &capped;
          return &uncapped;
  }
  
--- 40,50 ----
  
  static struct smatch_state *unmatched_state(struct sm_state *sm)
  {
          struct smatch_state *state;
  
!         state = __get_state(SMATCH_EXTRA, sm->name, sm->sym);
          if (state && !estate_is_whole(state))
                  return &capped;
          return &uncapped;
  }
  
*** 66,84 ****
--- 66,93 ----
          return 0;
  }
  
  int is_capped(struct expression *expr)
  {
+         struct symbol *type;
          sval_t dummy;
  
          expr = strip_expr(expr);
          while (expr && expr->type == EXPR_POSTOP) {
                  expr = strip_expr(expr->unop);
          }
          if (!expr)
                  return 0;
  
+         type = get_type(expr);
+         if (is_ptr_type(type))
+                 return 0;
+         if (type == &bool_ctype)
+                 return 0;
+         if (type_bits(type) >= 0 && type_bits(type) <= 2)
+                 return 0;
+ 
          if (get_hard_max(expr, &dummy))
                  return 1;
  
          if (is_capped_macro(expr))
                  return 1;
*** 88,99 ****
  
                  if (expr->op == '&')
                          return 1;
                  if (expr->op == SPECIAL_RIGHTSHIFT)
                          return 1;
!                 if (expr->op == '%')
!                         return is_capped(expr->right);
                  if (!is_capped(expr->left))
                          return 0;
                  if (expr->op == '/')
                          return 1;
                  if (!is_capped(expr->right))
--- 97,108 ----
  
                  if (expr->op == '&')
                          return 1;
                  if (expr->op == SPECIAL_RIGHTSHIFT)
                          return 1;
!                 if (expr->op == '%' && is_capped(expr->right))
!                         return 1;
                  if (!is_capped(expr->left))
                          return 0;
                  if (expr->op == '/')
                          return 1;
                  if (!is_capped(expr->right))
*** 129,147 ****
--- 138,169 ----
          set_state(my_id, fullname, sym, &capped);
  }
  
  static void match_condition(struct expression *expr)
  {
+         struct expression *left, *right;
          struct smatch_state *left_true = NULL;
          struct smatch_state *left_false = NULL;
          struct smatch_state *right_true = NULL;
          struct smatch_state *right_false = NULL;
+         sval_t sval;
  
  
          if (expr->type != EXPR_COMPARE)
                  return;
  
+         left = strip_expr(expr->left);
+         right = strip_expr(expr->right);
+ 
+         while (left->type == EXPR_ASSIGNMENT)
+                 left = strip_expr(left->left);
+ 
+         /* If we're dealing with known expressions, that's for smatch_extra.c */
+         if (get_implied_value(left, &sval) ||
+             get_implied_value(right, &sval))
+                 return;
+ 
          switch (expr->op) {
          case '<':
          case SPECIAL_LTE:
          case SPECIAL_UNSIGNED_LT:
          case SPECIAL_UNSIGNED_LTE:
*** 166,181 ****
  
          default:
                  return;
          }
  
!         set_true_false_states_expr(my_id, expr->left, left_true, left_false);
!         set_true_false_states_expr(my_id, expr->right, right_true, right_false);
  }
  
  static void match_assign(struct expression *expr)
  {
          if (is_capped(expr->right)) {
                  set_state_expr(my_id, expr->left, &capped);
          } else {
                  if (get_state_expr(my_id, expr->left))
                          set_state_expr(my_id, expr->left, &uncapped);
--- 188,213 ----
  
          default:
                  return;
          }
  
!         set_true_false_states_expr(my_id, left, left_true, left_false);
!         set_true_false_states_expr(my_id, right, right_true, right_false);
  }
  
  static void match_assign(struct expression *expr)
  {
+         struct symbol *type;
+ 
+         type = get_type(expr);
+         if (is_ptr_type(type))
+                 return;
+         if (type == &bool_ctype)
+                 return;
+         if (type_bits(type) >= 0 && type_bits(type) <= 2)
+                 return;
+ 
          if (is_capped(expr->right)) {
                  set_state_expr(my_id, expr->left, &capped);
          } else {
                  if (get_state_expr(my_id, expr->left))
                          set_state_expr(my_id, expr->left, &uncapped);
*** 204,214 ****
          struct smatch_state *estate;
          sval_t sval;
  
          if (sm->state != &capped)
                  return;
!         estate = get_state(SMATCH_EXTRA, sm->name, sm->sym);
          if (estate_get_single_value(estate, &sval))
                  return;
          sql_insert_caller_info(call, CAPPED_DATA, param, printed_name, "1");
  }
  
--- 236,246 ----
          struct smatch_state *estate;
          sval_t sval;
  
          if (sm->state != &capped)
                  return;
!         estate = __get_state(SMATCH_EXTRA, sm->name, sm->sym);
          if (estate_get_single_value(estate, &sval))
                  return;
          sql_insert_caller_info(call, CAPPED_DATA, param, printed_name, "1");
  }
  
*** 233,248 ****
  
                  param = get_param_num_from_sym(sm->sym);
                  if (param < 0)
                          continue;
  
!                 estate = get_state(SMATCH_EXTRA, sm->name, sm->sym);
                  if (estate_get_single_value(estate, &sval))
                          continue;
  
                  orig = get_state_stree(get_start_states(), my_id, sm->name, sm->sym);
!                 if (orig == &capped)
                          continue;
  
                  param_name = get_param_name(sm);
                  if (!param_name)
                          continue;
--- 265,280 ----
  
                  param = get_param_num_from_sym(sm->sym);
                  if (param < 0)
                          continue;
  
!                 estate = __get_state(SMATCH_EXTRA, sm->name, sm->sym);
                  if (estate_get_single_value(estate, &sval))
                          continue;
  
                  orig = get_state_stree(get_start_states(), my_id, sm->name, sm->sym);
!                 if (orig == &capped && !param_was_set_var_sym(sm->name, sm->sym))
                          continue;
  
                  param_name = get_param_name(sm);
                  if (!param_name)
                          continue;
*** 252,264 ****
--- 284,302 ----
          } END_FOR_EACH_SM(sm);
  
          FOR_EACH_MY_SM(my_id, __get_cur_stree(), sm) {
                  if (!ret_sym)
                          break;
+                 if (sm->state != &capped)
+                         continue;
                  if (ret_sym != sm->sym)
                          continue;
  
+                 estate = __get_state(SMATCH_EXTRA, sm->name, sm->sym);
+                 if (estate_get_single_value(estate, &sval))
+                         continue;
+ 
                  param_name = state_name_to_param_name(sm->name, return_str);
                  if (!param_name)
                          continue;
                  if (strcmp(param_name, "$") == 0)
                          return_found = true;