Lines Matching refs:expr
57 static int expand_symbol_expression(struct expression *expr)
59 struct symbol *sym = expr->symbol;
63 warning(expr->pos, "undefined preprocessor identifier '%s'", show_ident(expr->symbol_name));
64 expr->type = EXPR_VALUE;
65 expr->value = 0;
66 expr->taint = 0;
74 if (sym->initializer && !expr->symbol_name)
81 static long long get_longlong(struct expression *expr)
83 int no_expand = expr->ctype->ctype.modifiers & MOD_UNSIGNED;
84 long long mask = 1ULL << (expr->ctype->bit_size - 1);
85 long long value = expr->value;
97 void cast_value(struct expression *expr, struct symbol *newtype,
109 expr->type = EXPR_VALUE;
110 expr->taint = old->taint;
112 expr->value = old->value;
122 expr->value = !!value;
131 expr->value = value & mask;
154 expr->type = EXPR_VALUE;
155 expr->taint = 0;
160 expr->fvalue = (long double)get_longlong(old);
162 expr->fvalue = old->fvalue;
166 expr->fvalue = (double)expr->fvalue;
168 expr->fvalue = (float)expr->fvalue;
170 expr->type = EXPR_FVALUE;
174 static bool check_shift_count(struct expression *expr, struct expression *right)
176 struct symbol *ctype = expr->ctype;
191 static int simplify_int_binop(struct expression *expr, struct symbol *ctype)
193 struct expression *left = expr->left, *right = expr->right;
201 if (expr->op == SPECIAL_LEFTSHIFT || expr->op == SPECIAL_RIGHTSHIFT) {
202 if (!check_shift_count(expr, right))
216 switch (CONVERT(expr->op,is_signed)) {
293 expr->value = v & mask;
294 expr->type = EXPR_VALUE;
295 expr->taint = left->taint | right->taint;
299 warning(expr->pos, "division by zero");
303 warning(expr->pos, "constant integer operation overflow");
307 static int simplify_cmp_binop(struct expression *expr, struct symbol *ctype)
309 struct expression *left = expr->left, *right = expr->right;
322 switch (expr->op) {
323 case '<': expr->value = sl < sr; break;
324 case '>': expr->value = sl > sr; break;
325 case SPECIAL_LTE: expr->value = sl <= sr; break;
326 case SPECIAL_GTE: expr->value = sl >= sr; break;
327 case SPECIAL_EQUAL: expr->value = l == r; break;
328 case SPECIAL_NOTEQUAL: expr->value = l != r; break;
329 case SPECIAL_UNSIGNED_LT:expr->value = l < r; break;
330 case SPECIAL_UNSIGNED_GT:expr->value = l > r; break;
331 case SPECIAL_UNSIGNED_LTE:expr->value = l <= r; break;
332 case SPECIAL_UNSIGNED_GTE:expr->value = l >= r; break;
334 expr->type = EXPR_VALUE;
335 expr->taint = left->taint | right->taint;
339 static int simplify_float_binop(struct expression *expr)
341 struct expression *left = expr->left, *right = expr->right;
342 int rank = expr->ctype->rank;
352 switch (expr->op) {
361 switch (expr->op) {
370 switch (expr->op) {
379 expr->type = EXPR_FVALUE;
380 expr->fvalue = res;
384 warning(expr->pos, "division by zero");
388 static int simplify_float_cmp(struct expression *expr, struct symbol *ctype)
390 struct expression *left = expr->left, *right = expr->right;
398 switch (expr->op) {
399 case '<': expr->value = l < r; break;
400 case '>': expr->value = l > r; break;
401 case SPECIAL_LTE: expr->value = l <= r; break;
402 case SPECIAL_GTE: expr->value = l >= r; break;
403 case SPECIAL_EQUAL: expr->value = l == r; break;
404 case SPECIAL_NOTEQUAL: expr->value = l != r; break;
406 expr->type = EXPR_VALUE;
407 expr->taint = 0;
411 static int expand_binop(struct expression *expr)
415 cost = expand_expression(expr->left);
416 cost += expand_expression(expr->right);
417 if (simplify_int_binop(expr, expr->ctype))
419 if (simplify_float_binop(expr))
424 static int expand_logical(struct expression *expr)
426 struct expression *left = expr->left;
433 if (expr->op == SPECIAL_LOGICAL_AND) {
435 expr->type = EXPR_VALUE;
436 expr->value = 0;
437 expr->taint = left->taint;
442 expr->type = EXPR_VALUE;
443 expr->value = 1;
444 expr->taint = left->taint;
450 right = expr->right;
457 expr->type = EXPR_VALUE;
458 expr->value = right->value != 0;
459 expr->taint = left->taint | right->taint;
469 expr->type = EXPR_BINOP;
476 static int expand_comma(struct expression *expr)
480 cost = expand_expression(expr->left);
481 cost += expand_expression(expr->right);
482 if (expr->left->type == EXPR_VALUE || expr->left->type == EXPR_FVALUE) {
483 unsigned flags = expr->flags;
485 taint = expr->left->type == EXPR_VALUE ? expr->left->taint : 0;
486 *expr = *expr->right;
487 expr->flags = flags;
488 if (expr->type == EXPR_VALUE)
489 expr->taint |= Taint_comma | taint;
517 static int expand_compare(struct expression *expr)
519 struct expression *left = expr->left, *right = expr->right;
528 int op = expr->op;
529 expr->type = EXPR_VALUE;
530 expr->value = compare_types(op, left->symbol, right->symbol);
531 expr->taint = 0;
534 if (simplify_cmp_binop(expr, left->ctype))
536 if (simplify_float_cmp(expr, left->ctype))
542 static int expand_conditional(struct expression *expr)
544 struct expression *cond = expr->conditional;
545 struct expression *valt = expr->cond_true;
546 struct expression *valf = expr->cond_false;
551 unsigned flags = expr->flags;
557 *expr = *valt;
558 expr->flags = flags;
559 if (expr->type == EXPR_VALUE)
560 expr->taint |= cond->taint;
568 expr->type = EXPR_SELECT;
575 static void check_assignment(struct expression *expr)
579 switch (expr->op) {
582 right = expr->right;
585 check_shift_count(expr, right);
591 static int expand_assignment(struct expression *expr)
593 expand_expression(expr->left);
594 expand_expression(expr->right);
597 check_assignment(expr);
601 static int expand_addressof(struct expression *expr)
603 return expand_expression(expr->unop);
700 static int expand_dereference(struct expression *expr)
702 struct expression *unop = expr->unop;
715 if (expr->ctype->ctype.modifiers & MOD_NODEREF)
732 struct symbol *ctype = expr->ctype;
744 expr->type = EXPR_VALUE;
745 expr->value = value->value;
746 expr->taint = 0;
751 expr->type = EXPR_FVALUE;
752 expr->fvalue = value->fvalue;
764 static int simplify_preop(struct expression *expr)
766 struct expression *op = expr->unop;
772 mask = 1ULL << (expr->ctype->bit_size-1);
774 switch (expr->op) {
777 if (v == mask && !(expr->ctype->ctype.modifiers & MOD_UNSIGNED))
786 expr->value = v & mask;
787 expr->type = EXPR_VALUE;
788 expr->taint = op->taint;
793 warning(expr->pos, "constant integer operation overflow");
797 static int simplify_float_preop(struct expression *expr)
799 struct expression *op = expr->unop;
805 switch (expr->op) {
810 expr->fvalue = v;
811 expr->type = EXPR_FVALUE;
818 static int expand_postop(struct expression *expr)
820 expand_expression(expr->unop);
824 static int expand_preop(struct expression *expr)
828 switch (expr->op) {
830 return expand_dereference(expr);
833 return expand_addressof(expr);
841 return expand_postop(expr);
846 cost = expand_expression(expr->unop);
848 if (simplify_preop(expr))
850 if (simplify_float_preop(expr))
858 struct expression *expr;
860 FOR_EACH_PTR (head, expr) {
861 cost += expand_expression(expr);
862 } END_FOR_EACH_PTR(expr);
866 static int expand_cast(struct expression *expr)
869 struct expression *target = expr->cast_expression;
875 cast_value(expr, expr->ctype, target, target->ctype);
885 static int expand_symbol_call(struct expression *expr, int cost)
887 struct expression *fn = expr->fn;
899 if (inline_function(expr, def)) {
904 evaluate_statement(expr->statement);
908 cost = expand_expression(expr);
915 return ctype->op->expand(expr, cost);
923 static int expand_call(struct expression *expr)
927 struct expression *fn = expr->fn;
929 cost = expand_arguments(expr->args);
932 expression_error(expr, "function has no type");
936 return expand_symbol_call(expr, cost);
944 struct expression *expr;
946 FOR_EACH_PTR(list, expr) {
947 cost += expand_expression(expr);
948 } END_FOR_EACH_PTR(expr);
956 static int expand_pos_expression(struct expression *expr)
958 struct expression *nested = expr->init_expr;
959 unsigned long offset = expr->init_offset;
960 int nr = expr->init_nr;
966 *expr = *nested;
967 expr->init_offset = offset;
968 nested = expr;
973 *expr = *nested;
974 FOR_EACH_PTR(expr->expr_list, entry) {
995 nested = expr;
1006 static unsigned long bit_offset(const struct expression *expr)
1009 while (expr->type == EXPR_POS) {
1010 offset += bytes_to_bits(expr->init_offset);
1011 expr = expr->init_expr;
1013 if (expr && expr->ctype)
1014 offset += expr->ctype->bit_offset;
1018 static unsigned long bit_range(const struct expression *expr)
1022 while (expr->type == EXPR_POS) {
1023 unsigned long nr = expr->init_nr;
1024 size = expr->ctype->bit_size;
1026 expr = expr->init_expr;
1047 static void verify_nonoverlapping(struct expression_list **list, struct expression *expr)
1051 unsigned long whole = expr->ctype->bit_size;
1084 static int expand_expression(struct expression *expr)
1086 if (!expr)
1088 if (!expr->ctype || expr->ctype == &bad_ctype)
1091 switch (expr->type) {
1098 return expand_symbol_expression(expr);
1100 return expand_binop(expr);
1103 return expand_logical(expr);
1106 return expand_comma(expr);
1109 return expand_compare(expr);
1112 return expand_assignment(expr);
1115 return expand_preop(expr);
1118 return expand_postop(expr);
1123 return expand_cast(expr);
1126 return expand_call(expr);
1129 warning(expr->pos, "we should not have an EXPR_DEREF left at expansion time");
1134 return expand_conditional(expr);
1137 struct statement *stmt = expr->statement;
1141 *expr = *stmt->expression;
1149 sort_expression_list(&expr->expr_list);
1150 verify_nonoverlapping(&expr->expr_list, expr);
1151 return expand_expression_list(expr->expr_list);
1160 return expand_expression(expr->base) + 1;
1163 return expand_pos_expression(expr);
1170 expression_error(expr, "internal front-end error: sizeof in expansion?");
1176 static void expand_const_expression(struct expression *expr, const char *where)
1178 if (expr) {
1179 expand_expression(expr);
1180 if (expr->type != EXPR_VALUE) {
1181 expression_error(expr, "Expected constant expression in %s", where);
1182 expr->ctype = &int_ctype;
1183 expr->type = EXPR_VALUE;
1184 expr->value = 0;
1216 struct expression *expr = stmt->if_conditional;
1218 if (!expr || !expr->ctype || expr->ctype == &bad_ctype)
1221 expand_expression(expr);
1226 if (expr->type == EXPR_VALUE) {
1228 simple = expr->value ? stmt->if_true : stmt->if_false;
1251 cost += expand_expression(op->expr);
1255 cost += expand_expression(op->expr);
1365 static inline int bad_integer_constant_expression(struct expression *expr)
1367 if (!(expr->flags & CEF_ICE))
1369 if (expr->taint & Taint_comma)
1374 static long long __get_expression_value(struct expression *expr, int strict)
1379 if (!expr)
1381 ctype = evaluate_expression(expr);
1383 expression_error(expr, "bad constant expression type");
1386 expand_expression(expr);
1387 if (expr->type != EXPR_VALUE) {
1389 expression_error(expr, "bad constant expression");
1392 if ((strict == 1) && bad_integer_constant_expression(expr)) {
1393 expression_error(expr, "bad integer constant expression");
1397 value = expr->value;
1409 long long get_expression_value(struct expression *expr)
1411 return __get_expression_value(expr, 0);
1414 long long const_expression_value(struct expression *expr)
1416 return __get_expression_value(expr, 1);
1419 long long get_expression_value_silent(struct expression *expr)
1422 return __get_expression_value(expr, 2);
1425 int expr_truth_value(struct expression *expr)
1430 if (!expr)
1433 ctype = evaluate_expression(expr);
1438 expand_expression(expr);
1442 switch (expr->type) {
1444 expr = expr->right;
1447 return expr->value != 0;
1449 return expr->fvalue != 0;
1455 int is_zero_constant(struct expression *expr)
1459 expand_expression(expr);
1461 return expr->type == EXPR_VALUE && !expr->value;