X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=5f7f660b9bf0e2ffbfed221fbad92bd59dab3795;hb=57b2bd82de1bc4d81969d7d7446ed54d3bffdcd6;hp=875f1d9fbffa15dc549f35d6da7b85ba8e3f2163;hpb=c1766187fc2226da5e59558aa7d0510b61ea4cf3;p=cparser

diff --git a/ast2firm.c b/ast2firm.c
index 875f1d9..5f7f660 100644
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -618,15 +618,14 @@ static ir_type *create_compound_type(compound_type_t *type,
 	return irtype;
 }
 
+static ir_tarval *fold_constant_to_tarval(expression_t const *);
+
 static void determine_enum_values(enum_type_t *const type)
 {
 	ir_mode   *const mode    = atomic_modes[type->base.akind];
 	ir_tarval *const one     = get_mode_one(mode);
 	ir_tarval *      tv_next = get_mode_null(mode);
 
-	bool constant_folding_old = constant_folding;
-	constant_folding = true;
-
 	enum_t   *enume = type->enume;
 	entity_t *entry = enume->base.next;
 	for (; entry != NULL; entry = entry->base.next) {
@@ -635,18 +634,12 @@ static void determine_enum_values(enum_type_t *const type)
 
 		expression_t *const init = entry->enum_value.value;
 		if (init != NULL) {
-			ir_node *const cnst = expression_to_firm(init);
-			if (!is_Const(cnst)) {
-				panic("couldn't fold constant");
-			}
-			tv_next = get_Const_tarval(cnst);
+			tv_next = fold_constant_to_tarval(init);
 		}
 		assert(entry->enum_value.tv == NULL || entry->enum_value.tv == tv_next);
 		entry->enum_value.tv = tv_next;
 		tv_next = tarval_add(tv_next, one);
 	}
-
-	constant_folding = constant_folding_old;
 }
 
 static ir_type *create_enum_type(enum_type_t *const type)
@@ -687,10 +680,6 @@ ir_type *get_ir_type(type_t *type)
 
 	ir_type *firm_type = NULL;
 	switch (type->kind) {
-	case TYPE_ERROR:
-		/* Happens while constant folding, when there was an error */
-		return create_atomic_type(ATOMIC_TYPE_VOID, NULL);
-
 	case TYPE_ATOMIC:
 		firm_type = create_atomic_type(type->atomic.akind, type);
 		break;
@@ -722,6 +711,7 @@ ir_type *get_ir_type(type_t *type)
 		firm_type = create_enum_type(&type->enumt);
 		break;
 
+	case TYPE_ERROR:
 	case TYPE_TYPEOF:
 	case TYPE_TYPEDEF:
 		break;
@@ -1072,15 +1062,16 @@ static ir_node *create_symconst(dbg_info *dbgi, ir_entity *entity)
 	return new_d_SymConst(dbgi, mode_P, sym, symconst_addr_ent);
 }
 
+static ir_node *create_Const_from_bool(ir_mode *const mode, bool const v)
+{
+	return new_Const((v ? get_mode_one : get_mode_null)(mode));
+}
+
 static ir_node *create_conv_from_b(dbg_info *dbgi, ir_node *value,
                                    ir_mode *dest_mode)
 {
 	if (is_Const(value)) {
-		if (is_Const_null(value)) {
-			return new_Const(get_mode_null(dest_mode));
-		} else {
-			return new_Const(get_mode_one(dest_mode));
-		}
+		return create_Const_from_bool(dest_mode, !is_Const_null(value));
 	}
 
 	ir_node *cond       = new_d_Cond(dbgi, value);
@@ -1112,7 +1103,7 @@ static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode)
 
 	if (dest_mode == mode_b) {
 		ir_node *zero = new_Const(get_mode_null(value_mode));
-		ir_node *cmp  = new_d_Cmp(dbgi, value, zero, ir_relation_less_greater);
+		ir_node *cmp  = new_d_Cmp(dbgi, value, zero, ir_relation_unordered_less_greater);
 		return cmp;
 	} else if (value_mode == mode_b) {
 		return create_conv_from_b(dbgi, value, dest_mode);
@@ -1121,11 +1112,6 @@ static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode)
 	return new_d_Conv(dbgi, value, dest_mode);
 }
 
-static ir_node *create_Const_from_bool(ir_mode *const mode, bool const v)
-{
-	return new_Const((v ? get_mode_one : get_mode_null)(mode));
-}
-
 /**
  * Creates a SymConst node representing a wide string literal.
  *
@@ -1547,8 +1533,7 @@ static void keep_all_memory(ir_node *block)
 	set_cur_block(old);
 }
 
-static ir_node *reference_expression_enum_value_to_firm(
-		const reference_expression_t *ref)
+static ir_node *enum_constant_to_firm(reference_expression_t const *const ref)
 {
 	entity_t *entity = ref->entity;
 	if (entity->enum_value.tv == NULL) {
@@ -2439,12 +2424,12 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
 	dbg_info *dbgi = get_dbg_info(&expression->base.source_position);
 	type_t   *type = skip_typeref(expression->base.type);
 
-	if (expression->base.kind == EXPR_UNARY_TAKE_ADDRESS)
-		return expression_to_addr(expression->value);
-
 	const expression_t *value = expression->value;
 
 	switch(expression->base.kind) {
+	case EXPR_UNARY_TAKE_ADDRESS:
+		return expression_to_addr(value);
+
 	case EXPR_UNARY_NEGATE: {
 		ir_node *value_node = expression_to_firm(value);
 		ir_mode *mode       = get_ir_mode_arithmetic(type);
@@ -2893,8 +2878,7 @@ static ir_entity *create_initializer_entity(dbg_info *dbgi,
 	return entity;
 }
 
-static ir_node *compound_literal_to_firm(
-		const compound_literal_expression_t *expression)
+static ir_node *compound_literal_addr(compound_literal_expression_t const *const expression)
 {
 	dbg_info      *dbgi        = get_dbg_info(&expression->base.source_position);
 	type_t        *type        = expression->type;
@@ -2922,6 +2906,14 @@ static ir_node *compound_literal_to_firm(
 	}
 }
 
+static ir_node *compound_literal_to_firm(compound_literal_expression_t const* const expr)
+{
+	dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
+	type_t   *const type = expr->type;
+	ir_node  *const addr = compound_literal_addr(expr);
+	return deref_address(dbgi, type, addr);
+}
+
 /**
  * Transform a sizeof expression into Firm code.
  */
@@ -3001,7 +2993,7 @@ static void init_ir_types(void);
 
 static ir_tarval *fold_constant_to_tarval(const expression_t *expression)
 {
-	assert(is_type_valid(skip_typeref(expression->base.type)));
+	assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
 
 	bool constant_folding_old = constant_folding;
 	constant_folding = true;
@@ -3012,8 +3004,6 @@ static ir_tarval *fold_constant_to_tarval(const expression_t *expression)
 
 	init_ir_types();
 
-	assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
-
 	ir_graph *old_current_ir_graph = current_ir_graph;
 	current_ir_graph = get_const_code_irg();
 
@@ -3034,16 +3024,12 @@ static ir_tarval *fold_constant_to_tarval(const expression_t *expression)
 /* this function is only used in parser.c, but it relies on libfirm functionality */
 bool constant_is_negative(const expression_t *expression)
 {
-	assert(is_constant_expression(expression) == EXPR_CLASS_CONSTANT);
 	ir_tarval *tv = fold_constant_to_tarval(expression);
 	return tarval_is_negative(tv);
 }
 
 long fold_constant_to_int(const expression_t *expression)
 {
-	if (expression->kind == EXPR_ERROR)
-		return 0;
-
 	ir_tarval *tv = fold_constant_to_tarval(expression);
 	if (!tarval_is_long(tv)) {
 		panic("result of constant folding is not integer");
@@ -3054,8 +3040,6 @@ long fold_constant_to_int(const expression_t *expression)
 
 bool fold_constant_to_bool(const expression_t *expression)
 {
-	if (expression->kind == EXPR_ERROR)
-		return false;
 	ir_tarval *tv = fold_constant_to_tarval(expression);
 	return !tarval_is_null(tv);
 }
@@ -3376,7 +3360,7 @@ static ir_node *expression_to_addr(const expression_t *expression)
 	case EXPR_CALL:
 		return call_expression_to_firm(&expression->call);
 	case EXPR_COMPOUND_LITERAL:
-		return compound_literal_to_firm(&expression->compound_literal);
+		return compound_literal_addr(&expression->compound_literal);
 	case EXPR_REFERENCE:
 		return reference_addr(&expression->reference);
 	case EXPR_SELECT:
@@ -3442,12 +3426,6 @@ static ir_node *label_address_to_firm(const label_address_expression_t *label)
 	return new_d_SymConst(dbgi, mode_P_code, value, symconst_addr_ent);
 }
 
-static ir_node *error_to_firm(const expression_t *expression)
-{
-	ir_mode *mode = get_ir_mode_arithmetic(expression->base.type);
-	return new_Bad(mode);
-}
-
 /**
  * creates firm nodes for an expression. The difference between this function
  * and expression_to_firm is, that this version might produce mode_b nodes
@@ -3472,8 +3450,8 @@ static ir_node *_expression_to_firm(const expression_t *expression)
 		return wide_string_literal_to_firm(&expression->string_literal);
 	case EXPR_REFERENCE:
 		return reference_expression_to_firm(&expression->reference);
-	case EXPR_REFERENCE_ENUM_VALUE:
-		return reference_expression_enum_value_to_firm(&expression->reference);
+	case EXPR_ENUM_CONSTANT:
+		return enum_constant_to_firm(&expression->reference);
 	case EXPR_CALL:
 		return call_expression_to_firm(&expression->call);
 	case EXPR_UNARY_CASES:
@@ -3514,7 +3492,7 @@ static ir_node *_expression_to_firm(const expression_t *expression)
 		return label_address_to_firm(&expression->label_address);
 
 	case EXPR_ERROR:
-		return error_to_firm(expression);
+		break;
 	}
 	panic("invalid expression found");
 }
@@ -5097,18 +5075,6 @@ static void computed_goto_to_firm(computed_goto_statement_t const *const stateme
 	set_unreachable_now();
 }
 
-static void goto_to_firm(const goto_statement_t *statement)
-{
-	if (!currently_reachable())
-		return;
-
-	ir_node *block = get_label_block(statement->label);
-	ir_node *jmp   = new_Jmp();
-	add_immBlock_pred(block, jmp);
-
-	set_unreachable_now();
-}
-
 static void asm_statement_to_firm(const asm_statement_t *statement)
 {
 	bool needs_memory = false;
@@ -5366,73 +5332,36 @@ static void leave_statement_to_firm(leave_statement_t *statement)
 /**
  * Transform a statement.
  */
-static void statement_to_firm(statement_t *statement)
+static void statement_to_firm(statement_t *const stmt)
 {
 #ifndef NDEBUG
-	assert(!statement->base.transformed);
-	statement->base.transformed = true;
+	assert(!stmt->base.transformed);
+	stmt->base.transformed = true;
 #endif
 
-	switch (statement->kind) {
-	case STATEMENT_ERROR:
-		panic("error statement found");
-	case STATEMENT_EMPTY:
-		/* nothing */
-		return;
-	case STATEMENT_COMPOUND:
-		compound_statement_to_firm(&statement->compound);
-		return;
-	case STATEMENT_RETURN:
-		return_statement_to_firm(&statement->returns);
-		return;
-	case STATEMENT_EXPRESSION:
-		expression_statement_to_firm(&statement->expression);
-		return;
-	case STATEMENT_IF:
-		if_statement_to_firm(&statement->ifs);
-		return;
-	case STATEMENT_WHILE:
-		while_statement_to_firm(&statement->whiles);
-		return;
-	case STATEMENT_DO_WHILE:
-		do_while_statement_to_firm(&statement->do_while);
-		return;
-	case STATEMENT_DECLARATION:
-		declaration_statement_to_firm(&statement->declaration);
-		return;
-	case STATEMENT_BREAK:
-		create_jump_statement(statement, get_break_label());
-		return;
-	case STATEMENT_CONTINUE:
-		create_jump_statement(statement, continue_label);
-		return;
-	case STATEMENT_SWITCH:
-		switch_statement_to_firm(&statement->switchs);
-		return;
-	case STATEMENT_CASE_LABEL:
-		case_label_to_firm(&statement->case_label);
-		return;
-	case STATEMENT_FOR:
-		for_statement_to_firm(&statement->fors);
-		return;
-	case STATEMENT_LABEL:
-		label_to_firm(&statement->label);
-		return;
-	case STATEMENT_COMPUTED_GOTO:
-		computed_goto_to_firm(&statement->computed_goto);
-		return;
-	case STATEMENT_GOTO:
-		goto_to_firm(&statement->gotos);
-		return;
-	case STATEMENT_ASM:
-		asm_statement_to_firm(&statement->asms);
-		return;
-	case STATEMENT_MS_TRY:
-		ms_try_statement_to_firm(&statement->ms_try);
-		return;
-	case STATEMENT_LEAVE:
-		leave_statement_to_firm(&statement->leave);
-		return;
+	switch (stmt->kind) {
+	case STATEMENT_ASM:           asm_statement_to_firm(        &stmt->asms);          return;
+	case STATEMENT_CASE_LABEL:    case_label_to_firm(           &stmt->case_label);    return;
+	case STATEMENT_COMPOUND:      compound_statement_to_firm(   &stmt->compound);      return;
+	case STATEMENT_COMPUTED_GOTO: computed_goto_to_firm(        &stmt->computed_goto); return;
+	case STATEMENT_DECLARATION:   declaration_statement_to_firm(&stmt->declaration);   return;
+	case STATEMENT_DO_WHILE:      do_while_statement_to_firm(   &stmt->do_while);      return;
+	case STATEMENT_EMPTY:         /* nothing */                                        return;
+	case STATEMENT_EXPRESSION:    expression_statement_to_firm( &stmt->expression);    return;
+	case STATEMENT_FOR:           for_statement_to_firm(        &stmt->fors);          return;
+	case STATEMENT_IF:            if_statement_to_firm(         &stmt->ifs);           return;
+	case STATEMENT_LABEL:         label_to_firm(                &stmt->label);         return;
+	case STATEMENT_LEAVE:         leave_statement_to_firm(      &stmt->leave);         return;
+	case STATEMENT_MS_TRY:        ms_try_statement_to_firm(     &stmt->ms_try);        return;
+	case STATEMENT_RETURN:        return_statement_to_firm(     &stmt->returns);       return;
+	case STATEMENT_SWITCH:        switch_statement_to_firm(     &stmt->switchs);       return;
+	case STATEMENT_WHILE:         while_statement_to_firm(      &stmt->whiles);        return;
+
+	case STATEMENT_BREAK:         create_jump_statement(stmt, get_break_label());                  return;
+	case STATEMENT_CONTINUE:      create_jump_statement(stmt, continue_label);                     return;
+	case STATEMENT_GOTO:          create_jump_statement(stmt, get_label_block(stmt->gotos.label)); return;
+
+	case STATEMENT_ERROR: panic("error statement found");
 	}
 	panic("statement not implemented");
 }