X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ast2firm.c;h=cdf317424e4473a09a3682d4004339e766c3339c;hb=09964a9e87be1ddf585aef762a0042feff30ce87;hp=9ca18d760f0a954aeeab80c6c91fe1dc968c0b1e;hpb=daf8c3b8a9b664a13963a1337b785f8c64df98e5;p=cparser

diff --git a/ast2firm.c b/ast2firm.c
index 9ca18d7..cdf3174 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);
@@ -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.
  *
@@ -2439,12 +2425,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);
@@ -3008,7 +2994,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;
@@ -3019,8 +3005,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();
 
@@ -3041,16 +3025,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");
@@ -3061,8 +3041,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);
 }
@@ -3449,12 +3427,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
@@ -3521,7 +3493,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");
 }
@@ -5104,18 +5076,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;
@@ -5373,73 +5333,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");
 }