22 {
  23         struct expression *arg;
  24         sval_t val;
  25         int i;
  26 
  27         i = -1;
  28         FOR_EACH_PTR(expr->args, arg) {
  29                 i++;
  30                 if (!get_implied_value(arg, &val))
  31                         continue;
  32                 if (val.value == size)
  33                         return i;
  34         } END_FOR_EACH_PTR(arg);
  35 
  36         return -1;
  37 }
  38 
  39 static void match_call(struct expression *expr)
  40 {
  41         struct expression *arg;
  42         struct symbol *type;
  43         int size, bytes;
  44         int i, nr;
  45         char buf[16];


  46 


  47 
  48         i = -1;
  49         FOR_EACH_PTR(expr->args, arg) {
  50                 i++;
  51                 type = get_type(arg);
  52                 if (!type || (type->type != SYM_PTR && type->type != SYM_ARRAY))
  53                         continue;




  54                 size = get_array_size(arg);
  55                 if (size > 0) {
  56                         nr = find_param_eq(expr, size);
  57                         if (nr >= 0) {
  58                                 snprintf(buf, sizeof(buf), "%d", nr);
  59                                 sql_insert_caller_info(expr, ARRAYSIZE_ARG, i, buf, "");
  60                                 continue;
  61                         }
  62                 }
  63                 bytes = get_array_size_bytes(arg);
  64                 if (bytes > 0) {
  65                         nr = find_param_eq(expr, bytes);
  66                         if (nr >= 0) {
  67                                 snprintf(buf, sizeof(buf), "%d", nr);
  68                                 sql_insert_caller_info(expr, SIZEOF_ARG, i, buf, "");
  69                                 continue;
  70                         }
  71                 }
  72         } END_FOR_EACH_PTR(arg);
  73 }
  74 
  75 void register_passes_array_size(int id)
  76 {
  77         add_hook(&match_call, FUNCTION_CALL_HOOK);
  78 }
  79 

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