fix mode of call-result proj

[libfirm] / ir / ir / irio.c

diff --git a/ir/ir/irio.c b/ir/ir/irio.c
index c1b6e9d..311e3bd 100644 (file)
--- a/ir/ir/irio.c
+++ b/ir/ir/irio.c
@@ -383,7 +383,7 @@ static void write_ident_null(io_env_t *env, ident *id)
 
 static void write_mode(io_env_t *env, ir_mode *mode)
 {
-       fputs(get_mode_name(mode), env->file);
+       write_string(env, get_mode_name(mode));
        fputc(' ', env->file);
 }
 
@@ -689,7 +689,6 @@ static void export_type_or_ent_post(type_or_ent tore, void *ctx)
 
        default:
                panic("export_type_or_ent_post: Unknown type or entity.");
-               break;
        }
 }
 
@@ -776,6 +775,7 @@ static void export_node(ir_node *irn, void *ctx)
                /* TODO: only symconst_addr_ent implemented yet */
                assert(get_SymConst_kind(irn) == symconst_addr_ent);
                fprintf(env->file, "%ld ", get_entity_nr(get_SymConst_entity(irn)));
+               write_mode(env, get_irn_mode(irn));
                break;
        case iro_Proj:
                write_mode(env, get_irn_mode(irn));
@@ -835,6 +835,7 @@ static void export_modes(io_env_t *env)
                if (mode_is_reference(mode)) {
                        write_mode(env, get_reference_mode_signed_eq(mode));
                        write_mode(env, get_reference_mode_unsigned_eq(mode));
+                       write_int(env, (mode == mode_P ? 1 : 0));
                }
                fputc('\n', env->file);
        }
@@ -896,12 +897,10 @@ void ir_export_file(FILE *file, const char *outputname)
 
        for (i = 0; i < n_irgs; i++) {
                ir_graph *irg       = get_irp_irg(i);
-               ir_type  *valuetype = get_irg_value_param_type(irg);
 
-               fprintf(env.file, "\nirg %ld %ld %ld {\n",
+               fprintf(env.file, "\nirg %ld %ld {\n",
                        get_entity_nr(get_irg_entity(irg)),
-                       get_type_nr(get_irg_frame_type(irg)),
-                       valuetype == NULL ? -1 : get_type_nr(valuetype));
+                       get_type_nr(get_irg_frame_type(irg)));
 
                env.ignoreblocks = 0;
                irg_block_walk_graph(irg, NULL, export_node, &env);
@@ -1051,7 +1050,6 @@ static char *read_string(io_env_t *env)
                        default:
                                parse_error(env, "Unknown escape sequence '\\%c'\n", env->c);
                                exit(1);
-                               break;
                        }
                } else {
                        obstack_1grow(&env->obst, env->c);
@@ -1227,7 +1225,7 @@ static ir_entity *read_entity(io_env_t *env)
 
 static ir_mode *read_mode(io_env_t *env)
 {
-       char *str = read_word(env);
+       char *str = read_string(env);
        size_t i, n;
 
        n = get_irp_n_modes();
@@ -1295,27 +1293,6 @@ static unsigned read_enum(io_env_t *env, typetag_t typetag)
 #define read_variability(env)        ((ir_variability)        read_enum(env, tt_variability))
 #define read_volatility(env)         ((ir_volatility)         read_enum(env, tt_volatility))
 
-static ir_cons_flags get_cons_flags(io_env_t *env)
-{
-       ir_cons_flags flags = cons_none;
-
-       op_pin_state pinstate = read_pin_state(env);
-       switch (pinstate) {
-       case op_pin_state_floats: flags |= cons_floats; break;
-       case op_pin_state_pinned: break;
-       default:
-               panic("Error in %d: Invalid pinstate: %s", env->line,
-                     get_op_pin_state_name(pinstate));
-       }
-
-       if (read_volatility(env) == volatility_is_volatile)
-               flags |= cons_volatile;
-       if (read_align(env) == align_non_aligned)
-               flags |= cons_unaligned;
-
-       return flags;
-}
-
 static ir_tarval *read_tv(io_env_t *env)
 {
        ir_mode   *tvmode = read_mode(env);
@@ -1417,14 +1394,14 @@ static void import_type(io_env_t *env)
                type = new_type_method(nparams, nresults);
 
                for (i = 0; i < nparams; i++) {
-                       long     typenr = read_long(env);
-                       ir_type *paramtype = get_type(env, typenr);
+                       long ptypenr = read_long(env);
+                       ir_type *paramtype = get_type(env, ptypenr);
 
                        set_method_param_type(type, i, paramtype);
                }
                for (i = 0; i < nresults; i++) {
-                       long typenr = read_long(env);
-                       ir_type *restype = get_type(env, typenr);
+                       long ptypenr = read_long(env);
+                       ir_type *restype = get_type(env, ptypenr);
 
                        set_method_res_type(type, i, restype);
                }
@@ -1500,23 +1477,23 @@ static void import_entity(io_env_t *env)
 
        skip_ws(env);
        while (!isdigit(env->c)) {
-               char     *str = read_word(env);
+               char     *vstr = read_word(env);
                unsigned  v;
 
                skip_ws(env);
 
-               v = symbol(str, tt_visibility);
+               v = symbol(vstr, tt_visibility);
                if (v != SYMERROR) {
                        visibility = (ir_visibility)v;
                        continue;
                }
-               v = symbol(str, tt_linkage);
+               v = symbol(vstr, tt_linkage);
                if (v != SYMERROR) {
                        linkage |= (ir_linkage)v;
                        continue;
                }
                printf("Parser error, expected visibility or linkage, got '%s'\n",
-                      str);
+                      vstr);
                break;
        }
 
@@ -1722,7 +1699,8 @@ static int parse_graph(io_env_t *env, ir_graph *irg)
                        long entnr = read_long(env);
                        union symconst_symbol sym;
                        sym.entity_p = get_entity(env, entnr);
-                       newnode = new_r_SymConst(irg, mode_P, sym, symconst_addr_ent);
+                       ir_mode *mode = read_mode(env);
+                       newnode = new_r_SymConst(irg, mode, sym, symconst_addr_ent);
                        break;
                }
 
@@ -1798,6 +1776,11 @@ static int parse_modes(io_env_t *env)
                        if (mode_is_reference(mode)) {
                                set_reference_mode_signed_eq(mode, read_mode(env));
                                set_reference_mode_unsigned_eq(mode, read_mode(env));
+                               int is_mode_P = read_int(env);
+                               if (is_mode_P) {
+                                       set_modeP_data(mode);
+                                       set_modeP_code(mode);
+                               }
                        }
                        break;
                }
@@ -1896,14 +1879,8 @@ void ir_import_file(FILE *input, const char *inputname)
                case kw_irg:
                {
                        ir_entity *irgent = get_entity(env, read_long(env));
-                       long valuetypeid;
                        ir_graph *irg = new_ir_graph(irgent, 0);
                        set_irg_frame_type(irg, get_type(env, read_long(env)));
-                       valuetypeid = read_long(env);
-                       if (valuetypeid != -1)
-                               set_method_value_param_type(get_entity_type(irgent),
-                                               get_type(env, valuetypeid));
-
                        if (!parse_graph(env, irg)) goto end;
                        break;
                }