X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=c30463cc7690e3654355d9ef37cd362efabd01f0;hb=ed1ed2b5fb813fd8de24b2eaa6fffce033246a8c;hp=cb165824ff67abef1cae3d0aa1b4ce20b72d556a;hpb=50f3b6c78da4dbfab627adf5b9eb52aaffc3cebd;p=cparser

diff --git a/ast2firm.c b/ast2firm.c
index cb16582..c30463c 100644
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -201,7 +201,7 @@ static void init_atomic_modes(void)
 	mode_uint = atomic_modes[ATOMIC_TYPE_UINT];
 
 	/* there's no real void type in firm */
-	atomic_modes[ATOMIC_TYPE_VOID] = mode_int;
+	atomic_modes[ATOMIC_TYPE_VOID] = atomic_modes[ATOMIC_TYPE_CHAR];
 
 	/* initialize pointer modes */
 	char            name[64];
@@ -279,17 +279,22 @@ static unsigned get_type_size_const(type_t *type)
 	panic("Trying to determine size of invalid type");
 }
 
+static ir_node *get_vla_size(array_type_t *const type)
+{
+	ir_node *size_node = type->size_node;
+	if (size_node == NULL) {
+		size_node = expression_to_firm(type->size_expression);
+		type->size_node = size_node;
+	}
+	return size_node;
+}
+
 static ir_node *get_type_size(type_t *type)
 {
 	type = skip_typeref(type);
 
 	if (is_type_array(type) && type->array.is_vla) {
-		ir_node *size_node = type->array.size_node;
-		if (size_node == NULL) {
-			size_node = expression_to_firm(type->array.size_expression);
-			type->array.size_node = size_node;
-		}
-
+		ir_node *size_node = get_vla_size(&type->array);
 		ir_node *elem_size = get_type_size(type->array.element_type);
 		ir_mode *mode      = get_irn_mode(size_node);
 		ir_node *real_size = new_d_Mul(NULL, size_node, elem_size, mode);
@@ -1596,9 +1601,11 @@ static ir_node *process_builtin_call(const call_expression_t *call)
 		return _expression_to_firm(argument);
 	}
 	case T___builtin_va_end:
+		/* evaluate the argument of va_end for its side effects */
+		_expression_to_firm(call->arguments->expression);
 		return NULL;
 	default:
-		panic("Unsupported builtin found\n");
+		panic("unsupported builtin found");
 	}
 }
 
@@ -2218,10 +2225,12 @@ static ir_node *produce_condition_result(const expression_t *expression,
 	ir_node *cur_block = get_cur_block();
 
 	ir_node *one_block = new_immBlock();
+	set_cur_block(one_block);
 	ir_node *one       = new_Const(get_mode_one(mode));
 	ir_node *jmp_one   = new_d_Jmp(dbgi);
 
 	ir_node *zero_block = new_immBlock();
+	set_cur_block(zero_block);
 	ir_node *zero       = new_Const(get_mode_null(mode));
 	ir_node *jmp_zero   = new_d_Jmp(dbgi);
 
@@ -2392,12 +2401,24 @@ static ir_node *create_lazy_op(const binary_expression_t *expression)
 		long val = fold_constant(expression->left);
 		expression_kind_t ekind = expression->base.kind;
 		assert(ekind == EXPR_BINARY_LOGICAL_AND || ekind == EXPR_BINARY_LOGICAL_OR);
-		if ((ekind == EXPR_BINARY_LOGICAL_AND && val != 0) ||
-		    (ekind == EXPR_BINARY_LOGICAL_OR  && val == 0)) {
-			return produce_condition_result(expression->right, mode, dbgi);
+		if (ekind == EXPR_BINARY_LOGICAL_AND) {
+			if (val == 0) {
+				return new_Const(get_mode_null(mode));
+			}
 		} else {
-			return new_Const(get_mode_one(mode));
+			if (val != 0) {
+				return new_Const(get_mode_one(mode));
+			}
+		}
+
+		if (is_constant_expression(expression->right)) {
+			long const valr = fold_constant(expression->left);
+			return valr != 0 ?
+				new_Const(get_mode_one(mode)) :
+				new_Const(get_mode_null(mode));
 		}
+
+		return produce_condition_result(expression->right, mode, dbgi);
 	}
 
 	return produce_condition_result((const expression_t*) expression, mode,
@@ -2676,12 +2697,12 @@ long fold_constant(const expression_t *expression)
 	current_ir_graph = old_current_ir_graph;
 
 	if (!is_Const(cnst)) {
-		panic("couldn't fold constant\n");
+		panic("couldn't fold constant");
 	}
 
 	tarval *tv = get_Const_tarval(cnst);
 	if (!tarval_is_long(tv)) {
-		panic("result of constant folding is not integer\n");
+		panic("result of constant folding is not integer");
 	}
 
 	constant_folding = constant_folding_old;
@@ -2710,6 +2731,7 @@ static ir_node *conditional_to_firm(const conditional_expression_t *expression)
 
 	/* create the true block */
 	ir_node *true_block  = new_immBlock();
+	set_cur_block(true_block);
 
 	ir_node *true_val = expression->true_expression != NULL ?
 		expression_to_firm(expression->true_expression) : NULL;
@@ -2717,6 +2739,7 @@ static ir_node *conditional_to_firm(const conditional_expression_t *expression)
 
 	/* create the false block */
 	ir_node *false_block = new_immBlock();
+	set_cur_block(false_block);
 
 	ir_node *false_val = expression_to_firm(expression->false_expression);
 	ir_node *false_jmp = new_Jmp();
@@ -2987,17 +3010,18 @@ static ir_node *dereference_addr(const unary_expression_t *const expression)
 static ir_node *expression_to_addr(const expression_t *expression)
 {
 	switch(expression->kind) {
-	case EXPR_REFERENCE:
-		return reference_addr(&expression->reference);
 	case EXPR_ARRAY_ACCESS:
 		return array_access_addr(&expression->array_access);
-	case EXPR_SELECT:
-		return select_addr(&expression->select);
 	case EXPR_CALL:
 		return call_expression_to_firm(&expression->call);
-	case EXPR_UNARY_DEREFERENCE: {
+	case EXPR_COMPOUND_LITERAL:
+		return compound_literal_to_firm(&expression->compound_literal);
+	case EXPR_REFERENCE:
+		return reference_addr(&expression->reference);
+	case EXPR_SELECT:
+		return select_addr(&expression->select);
+	case EXPR_UNARY_DEREFERENCE:
 		return dereference_addr(&expression->unary);
-	}
 	default:
 		break;
 	}
@@ -3037,9 +3061,7 @@ static ir_node *get_label_block(label_t *label)
 	ir_graph *rem    = current_ir_graph;
 	current_ir_graph = current_function;
 
-	ir_node *old_cur_block = get_cur_block();
-	ir_node *block         = new_immBlock();
-	set_cur_block(old_cur_block);
+	ir_node *block = new_immBlock();
 
 	label->block = block;
 
@@ -3249,9 +3271,7 @@ static ir_node *create_condition_evaluation(const expression_t *expression,
 	case EXPR_BINARY_LOGICAL_AND: {
 		const binary_expression_t *binary_expression = &expression->binary;
 
-		ir_node *cur_block   = get_cur_block();
 		ir_node *extra_block = new_immBlock();
-		set_cur_block(cur_block);
 		create_condition_evaluation(binary_expression->left, extra_block,
 		                            false_block);
 		mature_immBlock(extra_block);
@@ -3263,9 +3283,7 @@ static ir_node *create_condition_evaluation(const expression_t *expression,
 	case EXPR_BINARY_LOGICAL_OR: {
 		const binary_expression_t *binary_expression = &expression->binary;
 
-		ir_node *cur_block   = get_cur_block();
 		ir_node *extra_block = new_immBlock();
-		set_cur_block(cur_block);
 		create_condition_evaluation(binary_expression->left, true_block,
 		                            extra_block);
 		mature_immBlock(extra_block);
@@ -3302,9 +3320,7 @@ static ir_node *create_condition_evaluation(const expression_t *expression,
 	}
 
 	add_immBlock_pred(true_block, true_proj);
-	if (false_block != NULL) {
-		add_immBlock_pred(false_block, false_proj);
-	}
+	add_immBlock_pred(false_block, false_proj);
 
 	set_cur_block(NULL);
 	return cond_expr;
@@ -4309,8 +4325,13 @@ static void declaration_statement_to_firm(declaration_statement_t *statement)
 	entity_t *const last   = statement->declarations_end;
 	if (entity != NULL) {
 		for ( ;; entity = entity->base.next) {
-			if (is_declaration(entity))
+			if (is_declaration(entity)) {
 				initialize_local_declaration(entity);
+			} else if (entity->kind == ENTITY_TYPEDEF) {
+				type_t *const type = entity->typedefe.type;
+				if (is_type_array(type) && type->array.is_vla)
+					get_vla_size(&type->array);
+			}
 			if (entity == last)
 				break;
 		}
@@ -4327,6 +4348,7 @@ static void if_statement_to_firm(if_statement_t *statement)
 	ir_node *true_block = NULL;
 	if (statement->true_statement != NULL) {
 		true_block = new_immBlock();
+		set_cur_block(true_block);
 		statement_to_firm(statement->true_statement);
 		if (get_cur_block() != NULL) {
 			ir_node *jmp = new_Jmp();
@@ -4340,6 +4362,7 @@ static void if_statement_to_firm(if_statement_t *statement)
 	ir_node *false_block = NULL;
 	if (statement->false_statement != NULL) {
 		false_block = new_immBlock();
+		set_cur_block(false_block);
 
 		statement_to_firm(statement->false_statement);
 		if (get_cur_block() != NULL) {
@@ -4397,6 +4420,7 @@ static void while_statement_to_firm(while_statement_t *statement)
 	break_label                 = NULL;
 
 	ir_node *body_block = new_immBlock();
+	set_cur_block(body_block);
 	statement_to_firm(statement->body);
 	ir_node *false_block = break_label;
 
@@ -4461,6 +4485,7 @@ static void do_while_statement_to_firm(do_while_statement_t *statement)
 	continue_label              = header_block;
 	break_label                 = NULL;
 
+	set_cur_block(body_block);
 	statement_to_firm(statement->body);
 	ir_node *false_block = break_label;
 
@@ -4484,9 +4509,7 @@ static void do_while_statement_to_firm(do_while_statement_t *statement)
 	create_condition_evaluation(statement->condition, body_block, false_block);
 	mature_immBlock(body_block);
 	mature_immBlock(header_block);
-	if (false_block != NULL) {
-		mature_immBlock(false_block);
-	}
+	mature_immBlock(false_block);
 
 	set_cur_block(false_block);
 }
@@ -4523,6 +4546,7 @@ static void for_statement_to_firm(for_statement_t *statement)
 
 	/* create the step block */
 	ir_node *const step_block = new_immBlock();
+	set_cur_block(step_block);
 	if (statement->step != NULL) {
 		expression_to_firm(statement->step);
 	}
@@ -4530,6 +4554,7 @@ static void for_statement_to_firm(for_statement_t *statement)
 
 	/* create the header block */
 	ir_node *const header_block = new_immBlock();
+	set_cur_block(header_block);
 	if (jmp != NULL) {
 		add_immBlock_pred(header_block, jmp);
 	}
@@ -4539,7 +4564,7 @@ static void for_statement_to_firm(for_statement_t *statement)
 	ir_node *const false_block = new_immBlock();
 
 	/* the loop body */
-	ir_node * body_block;
+	ir_node *body_block;
 	if (statement->body != NULL) {
 		ir_node *const old_continue_label = continue_label;
 		ir_node *const old_break_label    = break_label;
@@ -4547,6 +4572,7 @@ static void for_statement_to_firm(for_statement_t *statement)
 		break_label    = false_block;
 
 		body_block = new_immBlock();
+		set_cur_block(body_block);
 		statement_to_firm(statement->body);
 
 		assert(continue_label == step_block);
@@ -4599,9 +4625,7 @@ static void create_jump_statement(const statement_t *statement,
 static ir_node *get_break_label(void)
 {
 	if (break_label == NULL) {
-		ir_node *cur_block = get_cur_block();
 		break_label = new_immBlock();
-		set_cur_block(cur_block);
 	}
 	return break_label;
 }
@@ -4715,10 +4739,9 @@ static void case_label_to_firm(const case_label_statement_t *statement)
 	ir_node *const fallthrough = (get_cur_block() == NULL ? NULL : new_Jmp());
 
 	ir_node *proj;
-	ir_node *old_block = get_nodes_block(current_switch_cond);
 	ir_node *block     = new_immBlock();
 
-	set_cur_block(old_block);
+	set_cur_block(get_nodes_block(current_switch_cond));
 	if (statement->expression != NULL) {
 		long pn     = statement->first_case;
 		long end_pn = statement->last_case;
@@ -5092,10 +5115,6 @@ static void statement_to_firm(statement_t *statement)
 	case STATEMENT_LABEL:
 		label_to_firm(&statement->label);
 		return;
-	case STATEMENT_LOCAL_LABEL:
-		/* local labels transform the semantics of labels while parsing
-		 * they don't need any special treatment here */
-		return;
 	case STATEMENT_GOTO:
 		goto_to_firm(&statement->gotos);
 		return;
@@ -5109,7 +5128,7 @@ static void statement_to_firm(statement_t *statement)
 		leave_statement_to_firm(&statement->leave);
 		return;
 	}
-	panic("Statement not implemented\n");
+	panic("statement not implemented");
 }
 
 static int count_local_variables(const entity_t *entity,
@@ -5233,6 +5252,10 @@ static void initialize_function_parameters(entity_t *entity)
  */
 static void handle_decl_modifier_irg(ir_graph_ptr irg, decl_modifiers_t decl_modifiers)
 {
+	if (decl_modifiers & DM_RETURNS_TWICE) {
+		/* TRUE if the declaration includes __attribute__((returns_twice)) */
+		set_irg_additional_property(irg, mtp_property_returns_twice);
+	}
 	if (decl_modifiers & DM_NORETURN) {
 		/* TRUE if the declaration includes the Microsoft
 		   __declspec(noreturn) specifier. */