+static complex_value complex_conditional_to_firm(
+ const conditional_expression_t *const expression)
+{
+ jump_target true_target;
+ jump_target false_target;
+ init_jump_target(&true_target, NULL);
+ init_jump_target(&false_target, NULL);
+ complex_value cond_val;
+ memset(&cond_val, 0, sizeof(cond_val));
+ if (expression->true_expression == NULL) {
+ assert(is_type_complex(skip_typeref(expression->condition->base.type)));
+ cond_val = complex_to_control_flow(expression->condition,
+ &true_target, &false_target);
+ } else {
+ expression_to_control_flow(expression->condition, &true_target, &false_target);
+ }
+
+ complex_value val;
+ memset(&val, 0, sizeof(val));
+ jump_target exit_target;
+ init_jump_target(&exit_target, NULL);
+ type_t *const type = skip_typeref(expression->base.type);
+ ir_mode *const mode = get_complex_mode_arithmetic(type);
+ dbg_info *const dbgi = get_dbg_info(&expression->base.pos);
+
+ if (enter_jump_target(&true_target)) {
+ if (expression->true_expression) {
+ val = expression_to_complex(expression->true_expression);
+ } else {
+ assert(cond_val.real != NULL);
+ val = cond_val;
+ }
+ val = complex_conv(dbgi, val, mode);
+ jump_to_target(&exit_target);
+ }
+
+ if (enter_jump_target(&false_target)) {
+ complex_value false_val
+ = expression_to_complex(expression->false_expression);
+ false_val = complex_conv(dbgi, false_val, mode);
+ jump_to_target(&exit_target);
+ if (val.real != NULL) {
+ ir_node *const inr[] = { val.real, false_val.real };
+ ir_node *const ini[] = { val.imag, false_val.imag };
+ ir_node *const block = exit_target.block;
+ val.real = new_rd_Phi(dbgi, block, lengthof(inr), inr, mode);
+ val.imag = new_rd_Phi(dbgi, block, lengthof(ini), ini, mode);
+ } else {
+ val = false_val;
+ }
+ }
+
+ if (!enter_jump_target(&exit_target)) {
+ set_cur_block(new_Block(0, NULL));
+ assert(!is_type_void(type));
+ val.real = val.imag = new_Bad(mode);
+ }
+ return val;
+}
+
+static void create_local_declarations(entity_t*);
+
+static complex_value compound_statement_to_firm_complex(
+ const compound_statement_t *compound)
+{
+ create_local_declarations(compound->scope.entities);
+
+ complex_value result = { NULL, NULL };
+ statement_t *statement = compound->statements;
+ statement_t *next;
+ for ( ; statement != NULL; statement = next) {
+ next = statement->base.next;
+ /* last statement is the return value */
+ if (next == NULL) {
+ /* it must be an expression, otherwise we wouldn't be in the
+ * complex variant of compound_statement_to_firm */
+ if (statement->kind != STATEMENT_EXPRESSION)
+ panic("last member of complex statement expression not an expression statement");
+ expression_t *expression = statement->expression.expression;
+ assert(is_type_complex(skip_typeref(expression->base.type)));
+ result = expression_to_complex(expression);
+ } else {
+ statement_to_firm(statement);
+ }
+ }
+
+ return result;
+}
+
+static complex_value complex_assign_to_firm(const binary_expression_t *expr)
+{
+ dbg_info *const dbgi = get_dbg_info(&expr->base.pos);
+ complex_value const value = expression_to_complex(expr->right);
+ ir_node *const addr = expression_to_addr(expr->left);
+ set_complex_value_for_expression(dbgi, expr->left, value, addr);
+ return value;
+}
+
+static complex_value complex_statement_expression_to_firm(
+ const statement_expression_t *const expr)
+{
+ const statement_t *const statement = expr->statement;
+ assert(statement->kind == STATEMENT_COMPOUND);
+
+ return compound_statement_to_firm_complex(&statement->compound);
+}
+
+static complex_value expression_to_complex(const expression_t *expression)
+{
+ switch (expression->kind) {
+ case EXPR_REFERENCE:
+ return complex_reference_to_firm(&expression->reference);
+ case EXPR_SELECT:
+ return complex_select_to_firm(&expression->select);
+ case EXPR_ARRAY_ACCESS:
+ return complex_array_access_to_firm(&expression->array_access);
+ case EXPR_UNARY_CAST:
+ return complex_cast_to_firm(&expression->unary);
+ case EXPR_BINARY_COMMA:
+ evaluate_expression_discard_result(expression->binary.left);
+ return expression_to_complex(expression->binary.right);
+ case EXPR_BINARY_ADD:
+ return create_complex_binop(&expression->binary, new_complex_add);
+ case EXPR_BINARY_ADD_ASSIGN:
+ return create_complex_assign_binop(&expression->binary, new_complex_add);
+ case EXPR_BINARY_SUB:
+ return create_complex_binop(&expression->binary, new_complex_sub);
+ case EXPR_BINARY_SUB_ASSIGN:
+ return create_complex_assign_binop(&expression->binary, new_complex_sub);
+ case EXPR_BINARY_MUL:
+ return create_complex_binop(&expression->binary, new_complex_mul);
+ case EXPR_BINARY_MUL_ASSIGN:
+ return create_complex_assign_binop(&expression->binary, new_complex_mul);
+ case EXPR_BINARY_DIV:
+ return create_complex_binop(&expression->binary, new_complex_div);
+ case EXPR_BINARY_DIV_ASSIGN:
+ return create_complex_assign_binop(&expression->binary, new_complex_div);
+ case EXPR_UNARY_PLUS:
+ return expression_to_complex(expression->unary.value);
+ case EXPR_UNARY_PREFIX_INCREMENT:
+ return create_complex_assign_unop(&expression->unary,
+ new_complex_increment, false);
+ case EXPR_UNARY_PREFIX_DECREMENT:
+ return create_complex_assign_unop(&expression->unary,
+ new_complex_decrement, false);
+ case EXPR_UNARY_POSTFIX_INCREMENT:
+ return create_complex_assign_unop(&expression->unary,
+ new_complex_increment, true);
+ case EXPR_UNARY_POSTFIX_DECREMENT:
+ return create_complex_assign_unop(&expression->unary,
+ new_complex_decrement, true);
+ case EXPR_UNARY_NEGATE:
+ return complex_negate_to_firm(&expression->unary);
+ case EXPR_UNARY_COMPLEMENT:
+ return complex_complement_to_firm(&expression->unary);
+ case EXPR_BINARY_ASSIGN:
+ return complex_assign_to_firm(&expression->binary);
+ case EXPR_LITERAL_CASES:
+ return complex_literal_to_firm(&expression->literal);
+ case EXPR_CALL:
+ return complex_call_to_firm(&expression->call);
+ case EXPR_CONDITIONAL:
+ return complex_conditional_to_firm(&expression->conditional);
+ case EXPR_STATEMENT:
+ return complex_statement_expression_to_firm(&expression->statement);
+ default:
+ panic("unexpected complex expression");
+ }
+}
+
+
+