X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firio.c;h=c1b6e9d98afcb0fa28083a0140026b240e0e2ced;hb=4f92e524762e0febc361676111b3b5b79addd03a;hp=f9e22836685493e62a57618b6419c812705cc805;hpb=553e70ca816ba0756fc1ecab7206b1319dd831c9;p=libfirm diff --git a/ir/ir/irio.c b/ir/ir/irio.c index f9e228366..c1b6e9d98 100644 --- a/ir/ir/irio.c +++ b/ir/ir/irio.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2009 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -35,6 +35,7 @@ #include "irnode_t.h" #include "irprog.h" #include "irgraph_t.h" +#include "irprintf.h" #include "ircons.h" #include "irgmod.h" #include "irflag_t.h" @@ -395,17 +396,8 @@ static void write_tarval(io_env_t *env, ir_tarval *tv) fputc(' ', env->file); } -static void write_align(io_env_t *env, ir_node *irn) +static void write_align(io_env_t *env, ir_align align) { - ir_align align; - - if (is_Load(irn)) - align = get_Load_align(irn); - else if (is_Store(irn)) - align = get_Store_align(irn); - else - panic("Invalid optype for write_align"); - fputs(get_align_name(align), env->file); fputc(' ', env->file); } @@ -453,9 +445,9 @@ static void write_initializer(io_env_t *env, ir_initializer_t *ini) break; case IR_INITIALIZER_COMPOUND: { - unsigned i, n = get_initializer_compound_n_entries(ini); - fprintf(f, "%u ", n); - for (i = 0; i < n; i++) + size_t i, n = get_initializer_compound_n_entries(ini); + ir_fprintf(f, "%zu ", n); + for (i = 0; i < n; ++i) write_initializer(env, get_initializer_compound_value(ini, i)); break; } @@ -471,17 +463,8 @@ static void write_pin_state(io_env_t *env, ir_node *irn) fputc(' ', env->file); } -static void write_volatility(io_env_t *env, ir_node *irn) +static void write_volatility(io_env_t *env, ir_volatility vol) { - ir_volatility vol; - - if (is_Load(irn)) - vol = get_Load_volatility(irn); - else if (is_Store(irn)) - vol = get_Store_volatility(irn); - else - panic("Invalid optype for write_volatility"); - fputs(get_volatility_name(vol), env->file); fputc(' ', env->file); } @@ -545,7 +528,7 @@ static void export_type_pre(io_env_t *env, ir_type *tp) static void export_type_post(io_env_t *env, ir_type *tp) { FILE *f = env->file; - int i; + size_t i; /* skip types already handled by pre walker */ switch (get_type_tpop_code(tp)) { @@ -569,8 +552,8 @@ static void export_type_post(io_env_t *env, ir_type *tp) switch (get_type_tpop_code(tp)) { case tpo_array: { - int n = get_array_n_dimensions(tp); - fprintf(f, "%d %ld ", n, get_type_nr(get_array_element_type(tp))); + size_t n = get_array_n_dimensions(tp); + ir_fprintf(f, "%zu %ld ", n, get_type_nr(get_array_element_type(tp))); for (i = 0; i < n; i++) { ir_node *lower = get_array_lower_bound(tp, i); ir_node *upper = get_array_upper_bound(tp, i); @@ -591,15 +574,15 @@ static void export_type_post(io_env_t *env, ir_type *tp) } case tpo_method: { - int nparams = get_method_n_params(tp); - int nresults = get_method_n_ress(tp); - fprintf(f, "%u %u %d %d ", get_method_calling_convention(tp), + size_t nparams = get_method_n_params(tp); + size_t nresults = get_method_n_ress(tp); + ir_fprintf(f, "%u %u %zu %zu ", get_method_calling_convention(tp), get_method_additional_properties(tp), nparams, nresults); for (i = 0; i < nparams; i++) write_long(env, get_type_nr(get_method_param_type(tp, i))); for (i = 0; i < nresults; i++) write_long(env, get_type_nr(get_method_res_type(tp, i))); - fprintf(f, "%d ", get_method_first_variadic_param_index(tp)); + ir_fprintf(f, "%u ", get_method_variadicity(tp)); break; } @@ -669,9 +652,9 @@ static void export_entity(io_env_t *env, ir_entity *ent) fputs("initializer ", env->file); write_initializer(env, get_entity_initializer(ent)); } else if (entity_has_compound_ent_values(ent)) { - int i, n = get_compound_ent_n_values(ent); + size_t i, n = get_compound_ent_n_values(ent); fputs("compoundgraph ", env->file); - fprintf(env->file, "%d ", n); + ir_fprintf(env->file, "%zu ", n); for (i = 0; i < n; i++) { ir_entity *member = get_compound_ent_value_member(ent, i); ir_node *irn = get_compound_ent_value(ent, i); @@ -710,6 +693,43 @@ static void export_type_or_ent_post(type_or_ent tore, void *ctx) } } +static void export_ASM(io_env_t *env, ir_node *node) +{ + ir_asm_constraint *input_constraints = get_ASM_input_constraints(node); + ir_asm_constraint *output_constraints = get_ASM_output_constraints(node); + ident **clobbers = get_ASM_clobbers(node); + int n_input_constraints = get_ASM_n_input_constraints(node); + int n_output_constraints = get_ASM_n_output_constraints(node); + int n_clobbers = get_ASM_n_clobbers(node); + int i; + + write_ident(env, get_ASM_text(node)); + write_list_begin(env); + for (i = 0; i < n_input_constraints; ++i) { + const ir_asm_constraint *constraint = &input_constraints[i]; + write_unsigned(env, constraint->pos); + write_ident(env, constraint->constraint); + write_mode(env, constraint->mode); + } + write_list_end(env); + + write_list_begin(env); + for (i = 0; i < n_output_constraints; ++i) { + const ir_asm_constraint *constraint = &output_constraints[i]; + write_unsigned(env, constraint->pos); + write_ident(env, constraint->constraint); + write_mode(env, constraint->mode); + } + write_list_end(env); + + write_list_begin(env); + for (i = 0; i < n_clobbers; ++i) { + ident *clobber = clobbers[i]; + write_ident(env, clobber); + } + write_list_end(env); +} + /** * Walker: exports every node. */ @@ -761,6 +781,9 @@ static void export_node(ir_node *irn, void *ctx) write_mode(env, get_irn_mode(irn)); fprintf(env->file, "%ld ", get_Proj_proj(irn)); break; + case iro_ASM: + export_ASM(env, irn); + break; #include "gen_irio_export.inl" default: panic("no export code for node %+F\n", irn); @@ -784,7 +807,7 @@ static const char *get_mode_sort_name(ir_mode_sort sort) static void export_modes(io_env_t *env) { - int i, n_modes = get_irp_n_modes(); + size_t i, n_modes = get_irp_n_modes(); fputs("modes {\n", env->file); @@ -860,7 +883,7 @@ void ir_export(const char *filename) void ir_export_file(FILE *file, const char *outputname) { io_env_t env; - int i, n_irgs = get_irp_n_irgs(); + size_t i, n_irgs = get_irp_n_irgs(); (void) outputname; env.file = file; @@ -1116,6 +1139,12 @@ static unsigned read_unsigned(io_env_t *env) return (unsigned) read_long(env); } +static size_t read_size_t(io_env_t *env) +{ + /* FIXME */ + return (size_t) read_unsigned(env); +} + static void expect_list_begin(io_env_t *env) { skip_ws(env); @@ -1199,7 +1228,7 @@ static ir_entity *read_entity(io_env_t *env) static ir_mode *read_mode(io_env_t *env) { char *str = read_word(env); - int i, n; + size_t i, n; n = get_irp_n_modes(); for (i = 0; i < n; i++) { @@ -1314,7 +1343,7 @@ static ir_initializer_t *read_initializer(io_env_t *env) return get_initializer_null(); case IR_INITIALIZER_COMPOUND: { - unsigned i, n = (unsigned) read_long(env); + size_t i, n = read_size_t(env); ir_initializer_t *ini = create_initializer_compound(n); for (i = 0; i < n; i++) { ir_initializer_t *curini = read_initializer(env); @@ -1383,7 +1412,7 @@ static void import_type(io_env_t *env) mtp_additional_properties addprops = (mtp_additional_properties) read_long(env); int nparams = (int) read_long(env); int nresults = (int) read_long(env); - int variaindex; + int variadicity; type = new_type_method(nparams, nresults); @@ -1400,12 +1429,8 @@ static void import_type(io_env_t *env) set_method_res_type(type, i, restype); } - variaindex = (int) read_long(env); - if (variaindex != -1) { - set_method_variadicity(type, variadicity_variadic); - if (variaindex != nparams) - set_method_first_variadic_param_index(type, variaindex); - } + variadicity = (int) read_long(env); + set_method_variadicity(type, variadicity); set_method_calling_convention(type, callingconv); set_method_additional_properties(type, addprops); @@ -1590,6 +1615,54 @@ static int read_node_header(io_env_t *env, long *nodenr, ir_node ***preds, return numpreds; } +static ir_node *read_ASM(io_env_t *env, int numpreds, ir_node **preds) +{ + ir_node *newnode; + ir_asm_constraint *input_constraints = NEW_ARR_F(ir_asm_constraint, 0); + ir_asm_constraint *output_constraints = NEW_ARR_F(ir_asm_constraint, 0); + ident **clobbers = NEW_ARR_F(ident*, 0); + + ident *asm_text = read_ident(env); + + expect_list_begin(env); + while (list_has_next(env)) { + ir_asm_constraint constraint; + constraint.pos = read_unsigned(env); + constraint.constraint = read_ident(env); + constraint.mode = read_mode(env); + ARR_APP1(ir_asm_constraint, input_constraints, constraint); + } + + expect_list_begin(env); + while (list_has_next(env)) { + ir_asm_constraint constraint; + constraint.pos = read_unsigned(env); + constraint.constraint = read_ident(env); + constraint.mode = read_mode(env); + ARR_APP1(ir_asm_constraint, output_constraints, constraint); + } + + expect_list_begin(env); + while (list_has_next(env)) { + ident *clobber = read_ident(env); + ARR_APP1(ident*, clobbers, clobber); + } + + assert(ARR_LEN(input_constraints) == (size_t)numpreds-1); + + newnode = new_r_ASM(preds[0], numpreds-1, preds+1, + input_constraints, + ARR_LEN(output_constraints), + output_constraints, + ARR_LEN(clobbers), + clobbers, + asm_text); + DEL_ARR_F(clobbers); + DEL_ARR_F(output_constraints); + DEL_ARR_F(input_constraints); + return newnode; +} + /** Parses an IRG. */ static int parse_graph(io_env_t *env, ir_graph *irg) { @@ -1663,6 +1736,10 @@ static int parse_graph(io_env_t *env, ir_graph *irg) break; } + case iro_ASM: + newnode = read_ASM(env, numpreds, preds); + break; + #include "gen_irio_import.inl" default: @@ -1781,7 +1858,7 @@ void ir_import_file(FILE *input, const char *inputname) firm_verification_t oldver = get_node_verification_mode(); io_env_t ioenv; io_env_t *env = &ioenv; - int i, n; + size_t i, n; symtbl_init();