set the source position of an call expression

[cparser] / ast2firm.c

diff --git a/ast2firm.c b/ast2firm.c
index c8cf896..53e55c8 100644 (file)
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -1912,6 +1912,8 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
                        node = do_strict_conv(dbgi, node);
                        return node;
                } else {
+                       /* make sure firm type is constructed */
+                       (void) get_ir_type(type);
                        return value_node;
                }
        }
@@ -2097,10 +2099,11 @@ static ir_node *create_sub(const binary_expression_t *expression)
 
                ir_node *const elem_size = get_type_size(ptr_type->points_to);
                ir_mode *const mode      = get_ir_mode(type);
+               ir_node *const conv_size = new_d_Conv(dbgi, elem_size, mode);
                ir_node *const sub       = new_d_Sub(dbgi, left, right, mode);
                ir_node *const no_mem    = new_NoMem();
-               ir_node *const div       = new_d_Div(dbgi, no_mem, sub, elem_size, mode,
-                                                    op_pin_state_floats);
+               ir_node *const div       = new_d_DivRL(dbgi, no_mem, sub, conv_size, mode,
+                                                      op_pin_state_floats);
                return new_d_Proj(dbgi, div, mode, pn_Div_res);
        }
 
@@ -3061,8 +3064,9 @@ static void descend_into_subtype(type_path_t *path)
 
                top->compound_entry = entry;
                top->index          = 0;
-               path->top_type      = entry->type;
                len                 = get_compound_size(&top_type->compound);
+               if(entry != NULL)
+                       path->top_type = entry->type;
        } else {
                assert(is_type_array(top_type));
                assert(top_type->array.size > 0);
@@ -3263,6 +3267,8 @@ static ir_initializer_t *create_ir_initializer_list(
 static ir_initializer_t *create_ir_initializer_string(
                const initializer_string_t *initializer, type_t *type)
 {
+       type = skip_typeref(type);
+
        size_t            string_len    = initializer->string.size;
        assert(type->kind == TYPE_ARRAY && type->array.size_constant);
        size_t            len           = type->array.size;
@@ -3338,9 +3344,10 @@ static void create_dynamic_initializer_sub(ir_initializer_t *initializer,
 {
        switch(get_initializer_kind(initializer)) {
        case IR_INITIALIZER_NULL: {
-               ir_mode *mode = get_type_mode(type);
                /* TODO: implement this for compound types... */
                assert(type != NULL);
+
+               ir_mode *mode = get_type_mode(type);
                tarval  *zero = get_mode_null(mode);
                ir_node *cnst = new_d_Const(dbgi, mode, zero);
 
@@ -4284,6 +4291,10 @@ static void statement_to_firm(statement_t *statement)
        switch(statement->kind) {
        case STATEMENT_INVALID:
                panic("invalid statement found");
+               return;
+       case STATEMENT_EMPTY:
+               /* nothing */
+               return;
        case STATEMENT_COMPOUND:
                compound_statement_to_firm(&statement->compound);
                return;
@@ -4355,10 +4366,12 @@ static int count_local_declarations(const declaration_t *      decl,
 }
 
 static int count_decls_in_expression(const expression_t *expression) {
+       int count = 0;
+
        if(expression == NULL)
                return 0;
 
-       switch(expression->base.kind) {
+       switch((expression_kind_t) expression->base.kind) {
        case EXPR_STATEMENT:
                return count_decls_in_stmts(expression->statement.statement);
        EXPR_BINARY_CASES {
@@ -4369,7 +4382,6 @@ static int count_decls_in_expression(const expression_t *expression) {
        EXPR_UNARY_CASES
                return count_decls_in_expression(expression->unary.value);
        case EXPR_CALL: {
-               int count = 0;
                call_argument_t *argument = expression->call.arguments;
                for( ; argument != NULL; argument = argument->next) {
                        count += count_decls_in_expression(argument->expression);
@@ -4377,7 +4389,64 @@ static int count_decls_in_expression(const expression_t *expression) {
                return count;
        }
 
-       default:
+       case EXPR_UNKNOWN:
+       case EXPR_INVALID:
+               panic("unexpected expression kind");
+
+       case EXPR_COMPOUND_LITERAL:
+               /* TODO... */
+               break;
+
+       case EXPR_CONDITIONAL:
+               count += count_decls_in_expression(expression->conditional.condition);
+               count += count_decls_in_expression(expression->conditional.true_expression);
+               count += count_decls_in_expression(expression->conditional.false_expression);
+               return count;
+
+       case EXPR_BUILTIN_PREFETCH:
+               count += count_decls_in_expression(expression->builtin_prefetch.adr);
+               count += count_decls_in_expression(expression->builtin_prefetch.rw);
+               count += count_decls_in_expression(expression->builtin_prefetch.locality);
+               return count;
+
+       case EXPR_BUILTIN_CONSTANT_P:
+               count += count_decls_in_expression(expression->builtin_constant.value);
+               return count;
+
+       case EXPR_SELECT:
+               count += count_decls_in_expression(expression->select.compound);
+               return count;
+
+       case EXPR_ARRAY_ACCESS:
+               count += count_decls_in_expression(expression->array_access.array_ref);
+               count += count_decls_in_expression(expression->array_access.index);
+               return count;
+
+       case EXPR_CLASSIFY_TYPE:
+               count += count_decls_in_expression(expression->classify_type.type_expression);
+               return count;
+
+       case EXPR_SIZEOF:
+       case EXPR_ALIGNOF: {
+               expression_t *tp_expression = expression->typeprop.tp_expression;
+               if (tp_expression != NULL) {
+                       count += count_decls_in_expression(tp_expression);
+               }
+               return count;
+       }
+
+       case EXPR_OFFSETOF:
+       case EXPR_REFERENCE:
+       case EXPR_CONST:
+       case EXPR_CHARACTER_CONSTANT:
+       case EXPR_WIDE_CHARACTER_CONSTANT:
+       case EXPR_STRING_LITERAL:
+       case EXPR_WIDE_STRING_LITERAL:
+       case EXPR_FUNCTION:
+       case EXPR_PRETTY_FUNCTION:
+       case EXPR_BUILTIN_SYMBOL:
+       case EXPR_VA_START:
+       case EXPR_VA_ARG:
                break;
        }
 
@@ -4393,6 +4462,9 @@ static int count_decls_in_stmts(const statement_t *stmt)
        int count = 0;
        for (; stmt != NULL; stmt = stmt->base.next) {
                switch (stmt->kind) {
+                       case STATEMENT_EMPTY:
+                               break;
+
                        case STATEMENT_DECLARATION: {
                                const declaration_statement_t *const decl_stmt = &stmt->declaration;
                                count += count_local_declarations(decl_stmt->declarations_begin,