1 #include "smatch.h"
   2 #include "smatch_extra.h"
   3 
   4 DECLARE_ALLOCATOR(sname);
   5 __ALLOCATOR(struct expression, "temporary expr", tmp_expression);
   6 
   7 static struct position get_cur_pos(void)
   8 {
   9         static struct position pos;
  10         static struct position none;
  11         struct expression *expr;
  12         struct statement *stmt;
  13 
  14         expr = last_ptr_list((struct ptr_list *)big_expression_stack);
  15         stmt = last_ptr_list((struct ptr_list *)big_statement_stack);
  16         if (expr)
  17                 pos = expr->pos;
  18         else if (stmt)
  19                 pos = stmt->pos;
  20         else
  21                 pos = none;
  22         return pos;
  23 }
  24 
  25 struct expression *alloc_tmp_expression(struct position pos, int type)
  26 {
  27         struct expression *expr;
  28 
  29         expr = __alloc_tmp_expression(0);
  30         expr->smatch_flags |= Fake;
  31         expr->type = type;
  32         expr->pos = pos;
  33         return expr;
  34 }
  35 
  36 void free_tmp_expressions(void)
  37 {
  38         clear_tmp_expression_alloc();
  39 }
  40 
  41 struct expression *zero_expr(void)
  42 {
  43         struct expression *zero;
  44 
  45         zero = alloc_tmp_expression(get_cur_pos(), EXPR_VALUE);
  46         zero->value = 0;
  47         zero->ctype = &int_ctype;
  48         return zero;
  49 }
  50 
  51 struct expression *value_expr(long long val)
  52 {
  53         struct expression *expr;
  54 
  55         if (!val)
  56                 return zero_expr();
  57 
  58         expr = alloc_tmp_expression(get_cur_pos(), EXPR_VALUE);
  59         expr->value = val;
  60         expr->ctype = &llong_ctype;
  61         return expr;
  62 }
  63 
  64 struct expression *member_expression(struct expression *deref, int op, struct ident *member)
  65 {
  66         struct expression *expr;
  67 
  68         expr = alloc_tmp_expression(deref->pos, EXPR_DEREF);
  69         expr->op = op;
  70         expr->deref = deref;
  71         expr->member = member;
  72         expr->member_offset = -1;
  73         return expr;
  74 }
  75 
  76 struct expression *preop_expression(struct expression *expr, int op)
  77 {
  78         struct expression *preop;
  79 
  80         preop = alloc_tmp_expression(expr->pos, EXPR_PREOP);
  81         preop->unop = expr;
  82         preop->op = op;
  83         return preop;
  84 }
  85 
  86 struct expression *deref_expression(struct expression *expr)
  87 {
  88         return preop_expression(expr, '*');
  89 }
  90 
  91 struct expression *assign_expression(struct expression *left, int op, struct expression *right)
  92 {
  93         struct expression *expr;
  94 
  95         if (!right)
  96                 return NULL;
  97 
  98         /* FIXME: make this a tmp expression. */
  99         expr = alloc_expression(right->pos, EXPR_ASSIGNMENT);
 100         expr->op = op;
 101         expr->left = left;
 102         expr->right = right;
 103         return expr;
 104 }
 105 
 106 struct expression *binop_expression(struct expression *left, int op, struct expression *right)
 107 {
 108         struct expression *expr;
 109 
 110         expr = alloc_tmp_expression(right->pos, EXPR_BINOP);
 111         expr->op = op;
 112         expr->left = left;
 113         expr->right = right;
 114         return expr;
 115 }
 116 
 117 struct expression *array_element_expression(struct expression *array, struct expression *offset)
 118 {
 119         struct expression *expr;
 120 
 121         expr = binop_expression(array, '+', offset);
 122         return deref_expression(expr);
 123 }
 124 
 125 struct expression *symbol_expression(struct symbol *sym)
 126 {
 127         struct expression *expr;
 128 
 129         expr = alloc_tmp_expression(sym->pos, EXPR_SYMBOL);
 130         expr->symbol = sym;
 131         expr->symbol_name = sym->ident;
 132         return expr;
 133 }
 134 
 135 struct expression *compare_expression(struct expression *left, int op, struct expression *right)
 136 {
 137         struct expression *expr;
 138 
 139         expr = alloc_tmp_expression(get_cur_pos(), EXPR_COMPARE);
 140         expr->op = op;
 141         expr->left = left;
 142         expr->right = right;
 143         return expr;
 144 }
 145 
 146 struct expression *string_expression(char *str)
 147 {
 148         struct expression *ret;
 149         struct string *string;
 150         int len;
 151 
 152         len = strlen(str) + 1;
 153         string = (void *)__alloc_sname(4 + len);
 154         string->length = len;
 155         string->immutable = 0;
 156         memcpy(string->data, str, len);
 157 
 158         ret = alloc_tmp_expression(get_cur_pos(), EXPR_STRING);
 159         ret->wide = 0;
 160         ret->string = string;
 161 
 162         return ret;
 163 }
 164 
 165 static struct expression *get_expression_from_base_and_str(struct expression *base, const char *addition)
 166 {
 167         struct expression *ret = NULL;
 168         struct token *token, *prev, *end;
 169         char *alloc;
 170 
 171         if (addition[0] == '\0')
 172                 return base;
 173 
 174         alloc = alloc_string_newline(addition);
 175 
 176         token = tokenize_buffer(alloc, strlen(alloc), &end);
 177         if (!token)
 178                 goto free;
 179         if (token_type(token) != TOKEN_STREAMBEGIN)
 180                 goto free;
 181         token = token->next;
 182 
 183         ret = base;
 184         while (token_type(token) == TOKEN_SPECIAL &&
 185                (token->special == SPECIAL_DEREFERENCE || token->special == '.')) {
 186                 prev = token;
 187                 token = token->next;
 188                 if (token_type(token) != TOKEN_IDENT)
 189                         goto free;
 190                 switch (prev->special) {
 191                 case SPECIAL_DEREFERENCE:
 192                         ret = deref_expression(ret);
 193                         ret = member_expression(ret, '*', token->ident);
 194                         break;
 195                 case '.':
 196                         ret = member_expression(ret, '.', token->ident);
 197                         break;
 198                 default:
 199                         goto free;
 200                 }
 201                 token = token->next;
 202         }
 203 
 204         if (token_type(token) != TOKEN_STREAMEND)
 205                 goto free;
 206 
 207 free:
 208         free_string(alloc);
 209 
 210         return ret;
 211 }
 212 
 213 struct expression *gen_expression_from_name_sym(const char *name, struct symbol *sym)
 214 {
 215         struct expression *base;
 216         int skip = 0;
 217         struct expression *ret;
 218 
 219         if (!name || !sym)
 220                 return NULL;
 221 
 222         base = symbol_expression(sym);
 223         while (name[skip] != '\0' && name[skip] != '.' && name[skip] != '-')
 224                 skip++;
 225 
 226         ret = get_expression_from_base_and_str(base, name + skip);
 227         if (ret) {
 228                 char *new = expr_to_str(ret);
 229 
 230                 /*
 231                  * FIXME: this sometimes changes "foo->bar.a.b->c" into
 232                  * "foo->bar.a.b.c".  I don't know why...  :(
 233                  *
 234                  */
 235                 if (!new || strcmp(name, new) != 0)
 236                         return NULL;
 237         }
 238         return ret;
 239 }
 240 
 241 struct expression *gen_expression_from_key(struct expression *arg, const char *key)
 242 {
 243         struct expression *ret;
 244         struct token *token, *prev, *end;
 245         const char *p = key;
 246         char buf[4095];
 247         char *alloc;
 248         size_t len;
 249 
 250         /* The idea is that we can parse either $0->foo or $->foo */
 251         if (key[0] != '$')
 252                 return NULL;
 253         p++;
 254         while (*p >= '0' && *p <= '9')
 255                 p++;
 256         len = snprintf(buf, sizeof(buf), "%s\n", p);
 257         alloc = alloc_string(buf);
 258 
 259         token = tokenize_buffer(alloc, len, &end);
 260         if (!token)
 261                 return NULL;
 262         if (token_type(token) != TOKEN_STREAMBEGIN)
 263                 return NULL;
 264         token = token->next;
 265 
 266         ret = arg;
 267         while (token_type(token) == TOKEN_SPECIAL &&
 268                (token->special == SPECIAL_DEREFERENCE || token->special == '.')) {
 269                 prev = token;
 270                 token = token->next;
 271                 if (token_type(token) != TOKEN_IDENT)
 272                         return NULL;
 273                 ret = deref_expression(ret);
 274                 ret = member_expression(ret,
 275                                         (prev->special == SPECIAL_DEREFERENCE) ? '*' : '.',
 276                                         token->ident);
 277                 token = token->next;
 278         }
 279 
 280         if (token_type(token) != TOKEN_STREAMEND)
 281                 return NULL;
 282 
 283         return ret;
 284 }
 285 
 286 void expr_set_parent_expr(struct expression *expr, struct expression *parent)
 287 {
 288         if (!expr)
 289                 return;
 290         if (parent->smatch_flags & Fake)
 291                 return;
 292 
 293         expr->parent = (unsigned long)parent | 0x1UL;
 294 }
 295 
 296 void expr_set_parent_stmt(struct expression *expr, struct statement *parent)
 297 {
 298         if (!expr)
 299                 return;
 300         expr->parent = (unsigned long)parent;
 301 }
 302 
 303 struct expression *expr_get_parent_expr(struct expression *expr)
 304 {
 305         if (!expr)
 306                 return NULL;
 307         if (!(expr->parent & 0x1UL))
 308                 return NULL;
 309         return (struct expression *)(expr->parent & ~0x1UL);
 310 }
 311 
 312 struct statement *expr_get_parent_stmt(struct expression *expr)
 313 {
 314         if (!expr)
 315                 return NULL;
 316         if (expr->parent & 0x1UL)
 317                 return NULL;
 318         return (struct statement *)expr->parent;
 319 }
 320