X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firio.c;h=471b06bd96408279e3393345288fadae8db9412b;hb=3db23eee84cbabb3f399f1ca820948114a9c837c;hp=a0dd0363a491e5873878427fcc078717289530eb;hpb=6bb28287b0f135a4dda410e2caa974997a5c6a21;p=libfirm diff --git a/ir/ir/irio.c b/ir/ir/irio.c index a0dd0363a..471b06bd9 100644 --- a/ir/ir/irio.c +++ b/ir/ir/irio.c @@ -91,7 +91,6 @@ typedef enum typetag_t { tt_builtin_kind, tt_cond_jmp_predicate, tt_initializer, - tt_irg_inline_property, tt_keyword, tt_linkage, tt_mode_arithmetic, @@ -177,7 +176,7 @@ parse_error(read_env_t *env, const char *fmt, ...) env->read_errors = true; /* let's hope firm doesn't die on further errors */ - do_node_verification(0); + do_node_verification(FIRM_VERIFICATION_OFF); va_start(ap, fmt); vfprintf(stderr, fmt, ap); @@ -199,7 +198,7 @@ static void symtbl_init(void) key.str = (s); \ key.typetag = (tt); \ key.code = (cod); \ - set_insert(symtbl, &key, sizeof(key), hash_str(s) + tt * 17) + (void)set_insert(symbol_t, symtbl, &key, sizeof(key), hash_str(s) + tt * 17) #define INSERTENUM(tt, e) INSERT(tt, #e, e) #define INSERTKEYWORD(k) INSERT(tt_keyword, #k, kw_##k) @@ -226,7 +225,6 @@ static void symtbl_init(void) INSERT(tt_visibility, "local", ir_visibility_local); INSERT(tt_visibility, "external", ir_visibility_external); - INSERT(tt_visibility, "default", ir_visibility_default); INSERT(tt_visibility, "private", ir_visibility_private); INSERT(tt_throws, "throw", true); @@ -277,18 +275,11 @@ static void symtbl_init(void) INSERTENUM(tt_initializer, IR_INITIALIZER_NULL); INSERTENUM(tt_initializer, IR_INITIALIZER_COMPOUND); - INSERT(tt_mode_arithmetic, "uninitialized", irma_uninitialized); INSERT(tt_mode_arithmetic, "none", irma_none); INSERT(tt_mode_arithmetic, "twos_complement", irma_twos_complement); INSERT(tt_mode_arithmetic, "ieee754", irma_ieee754); INSERT(tt_mode_arithmetic, "x86_extended_float", irma_x86_extended_float); - INSERT(tt_irg_inline_property, "any", irg_inline_any); - INSERT(tt_irg_inline_property, "recommended", irg_inline_recomended); - INSERT(tt_irg_inline_property, "forbidden", irg_inline_forbidden); - INSERT(tt_irg_inline_property, "forced", irg_inline_forced); - INSERT(tt_irg_inline_property, "forced_no_body", irg_inline_forced_no_body); - INSERTENUM(tt_pin_state, op_pin_state_floats); INSERTENUM(tt_pin_state, op_pin_state_pinned); INSERTENUM(tt_pin_state, op_pin_state_exc_pinned); @@ -324,7 +315,6 @@ static const char *get_visibility_name(ir_visibility visibility) switch (visibility) { case ir_visibility_local: return "local"; case ir_visibility_external: return "external"; - case ir_visibility_default: return "default"; case ir_visibility_private: return "private"; } panic("INVALID_VISIBILITY"); @@ -333,7 +323,6 @@ static const char *get_visibility_name(ir_visibility visibility) static const char *get_mode_arithmetic_name(ir_mode_arithmetic arithmetic) { switch (arithmetic) { - case irma_uninitialized: return "uninitialized"; case irma_none: return "none"; case irma_twos_complement: return "twos_complement"; case irma_ieee754: return "ieee754"; @@ -342,18 +331,6 @@ static const char *get_mode_arithmetic_name(ir_mode_arithmetic arithmetic) panic("invalid mode_arithmetic"); } -static const char *get_irg_inline_property_name(irg_inline_property prop) -{ - switch (prop) { - case irg_inline_any: return "any"; - case irg_inline_recomended: return "recommended"; - case irg_inline_forbidden: return "forbidden"; - case irg_inline_forced: return "forced"; - case irg_inline_forced_no_body: return "forced_no_body"; - } - panic("invalid irg_inline_property"); -} - /** Returns the according symbol value for the given string and tag, or SYMERROR if none was found. */ static unsigned symbol(const char *str, typetag_t typetag) { @@ -362,7 +339,7 @@ static unsigned symbol(const char *str, typetag_t typetag) key.str = str; key.typetag = typetag; - entry = (symbol_t*)set_find(symtbl, &key, sizeof(key), hash_str(str) + typetag * 17); + entry = set_find(symbol_t, symtbl, &key, sizeof(key), hash_str(str) + typetag * 17); return entry ? entry->code : SYMERROR; } @@ -575,12 +552,6 @@ static void write_volatility(write_env_t *env, ir_volatility vol) fputc(' ', env->file); } -static void write_inline_property(write_env_t *env, irg_inline_property prop) -{ - fputs(get_irg_inline_property_name(prop), env->file); - fputc(' ', env->file); -} - static void write_type_state(write_env_t *env, ir_type_state state) { fputs(get_type_state_name(state), env->file); @@ -635,9 +606,8 @@ static void write_type_compound(write_env_t *env, ir_type *tp) size_t i; if (is_Class_type(tp)) { - if (get_class_n_subtypes(tp) > 0 || get_class_n_supertypes(tp) > 0 - || get_class_type_info(tp) != NULL || get_class_vtable_size(tp) > 0) { - /* sub/superclass export not implemented yet, it's unclear wether + if (get_class_n_subtypes(tp) > 0 || get_class_n_supertypes(tp) > 0 || get_class_vtable_size(tp) > 0) { + /* sub/superclass export not implemented yet, it's unclear whether * class types will stay in libfirm anyway */ panic("can't export class types yet"); } @@ -821,9 +791,6 @@ static void write_entity(write_env_t *env, ir_entity *ent) if (ent->initializer != NULL) { write_symbol(env, "initializer"); write_initializer(env, get_entity_initializer(ent)); - } else if (entity_has_compound_ent_values(ent)) { - /* compound graph API is deprecated */ - panic("exporting compound_graph initializers not supported"); } else { write_symbol(env, "none"); } @@ -886,21 +853,16 @@ static void write_node_nr(write_env_t *env, const ir_node *node) static void write_ASM(write_env_t *env, const 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); - size_t n_input_constraints = get_ASM_n_input_constraints(node); - size_t n_output_constraints = get_ASM_n_output_constraints(node); - size_t n_clobbers = get_ASM_n_clobbers(node); - size_t i; - write_symbol(env, "ASM"); write_node_nr(env, node); write_node_nr(env, get_nodes_block(node)); + write_node_nr(env, get_ASM_mem(node)); write_ident(env, get_ASM_text(node)); write_list_begin(env); - for (i = 0; i < n_input_constraints; ++i) { + ir_asm_constraint *input_constraints = get_ASM_input_constraints(node); + int n_inputs = get_ASM_n_inputs(node); + for (int i = 0; i < n_inputs; ++i) { const ir_asm_constraint *constraint = &input_constraints[i]; write_unsigned(env, constraint->pos); write_ident(env, constraint->constraint); @@ -909,7 +871,9 @@ static void write_ASM(write_env_t *env, const ir_node *node) write_list_end(env); write_list_begin(env); - for (i = 0; i < n_output_constraints; ++i) { + ir_asm_constraint *output_constraints = get_ASM_output_constraints(node); + size_t n_output_constraints = get_ASM_n_output_constraints(node); + for (size_t 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); @@ -918,14 +882,16 @@ static void write_ASM(write_env_t *env, const ir_node *node) write_list_end(env); write_list_begin(env); - for (i = 0; i < n_clobbers; ++i) { + ident **clobbers = get_ASM_clobbers(node); + size_t n_clobbers = get_ASM_n_clobbers(node); + for (size_t i = 0; i < n_clobbers; ++i) { ident *clobber = clobbers[i]; write_ident(env, clobber); } write_list_end(env); write_pin_state(env, get_irn_pinned(node)); - write_pred_refs(env, node, 0); + write_pred_refs(env, node, n_ASM_max+1); } static void write_Phi(write_env_t *env, const ir_node *node) @@ -971,11 +937,11 @@ static void write_SymConst(write_env_t *env, const ir_node *node) write_entity_ref(env, get_SymConst_entity(node)); } -typedef void (*write_node_func)(write_env_t *env, const ir_node *node); +typedef void write_node_func(write_env_t *env, ir_node const *node); -static void register_node_writer(ir_op *op, write_node_func func) +static void register_node_writer(ir_op *op, write_node_func *func) { - set_generic_function_ptr(op, (op_func)func); + set_generic_function_ptr(op, func); } static void writers_init(void) @@ -991,8 +957,8 @@ static void writers_init(void) static void write_node(const ir_node *node, write_env_t *env) { - ir_op *op = get_irn_op(node); - write_node_func func = (write_node_func) get_generic_function_ptr(op); + ir_op *const op = get_irn_op(node); + write_node_func *const func = get_generic_function_ptr(write_node_func, op); fputc('\t', env->file); if (func == NULL) @@ -1074,13 +1040,14 @@ static void write_mode(write_env_t *env, ir_mode *mode) static void write_modes(write_env_t *env) { - size_t i, n_modes = get_irp_n_modes(); + size_t n_modes = ir_get_n_modes(); + size_t i; write_symbol(env, "modes"); fputs("{\n", env->file); for (i = 0; i < n_modes; i++) { - ir_mode *mode = get_irp_mode(i); + ir_mode *mode = ir_get_mode(i); if (!mode_is_int(mode) && !mode_is_reference(mode) && !mode_is_float(mode)) { /* skip internal modes */ @@ -1175,8 +1142,6 @@ static void write_irg(write_env_t *env, ir_graph *irg) write_symbol(env, "irg"); write_entity_ref(env, get_irg_entity(irg)); write_type_ref(env, get_irg_frame_type(irg)); - write_inline_property(env, get_irg_inline_property(irg)); - write_unsigned(env, get_irg_additional_properties(irg)); write_scope_begin(env); ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED); inc_irg_visited(irg); @@ -1458,7 +1423,7 @@ static void *get_id(read_env_t *env, long id) id_entry key, *entry; key.id = id; - entry = (id_entry*)set_find(env->idset, &key, sizeof(key), (unsigned) id); + entry = set_find(id_entry, env->idset, &key, sizeof(key), (unsigned) id); return entry ? entry->elem : NULL; } @@ -1467,7 +1432,7 @@ static void set_id(read_env_t *env, long id, void *elem) id_entry key; key.id = id; key.elem = elem; - set_insert(env->idset, &key, sizeof(key), (unsigned) id); + (void)set_insert(id_entry, env->idset, &key, sizeof(key), (unsigned) id); } static ir_node *get_node_or_null(read_env_t *env, long nodenr) @@ -1548,11 +1513,11 @@ static ir_entity *read_entity_ref(read_env_t *env) static ir_mode *read_mode_ref(read_env_t *env) { char *str = read_string(env); - size_t n = get_irp_n_modes(); + size_t n = ir_get_n_modes(); size_t i; for (i = 0; i < n; i++) { - ir_mode *mode = get_irp_mode(i); + ir_mode *mode = ir_get_mode(i); if (strcmp(str, get_mode_name(mode)) == 0) { obstack_free(&env->obst, str); return mode; @@ -1570,7 +1535,6 @@ static const char *get_typetag_name(typetag_t typetag) case tt_builtin_kind: return "builtin kind"; case tt_cond_jmp_predicate: return "cond_jmp_predicate"; case tt_initializer: return "initializer kind"; - case tt_irg_inline_property: return "irg_inline_property"; case tt_keyword: return "keyword"; case tt_linkage: return "linkage"; case tt_mode_arithmetic: return "mode_arithmetic"; @@ -1668,11 +1632,6 @@ static keyword_t read_keyword(read_env_t *env) return (keyword_t)read_enum(env, tt_keyword); } -static irg_inline_property read_inline_property(read_env_t *env) -{ - return (irg_inline_property)read_enum(env, tt_irg_inline_property); -} - static ir_relation read_relation(read_env_t *env) { return (ir_relation)read_long(env); @@ -1808,7 +1767,7 @@ static void read_type(read_env_t *env) size_t nparams = read_size_t(env); size_t nresults = read_size_t(env); size_t i; - int variadicity; + ir_variadicity variadicity; type = new_type_method(nparams, nresults); @@ -1825,7 +1784,7 @@ static void read_type(read_env_t *env) set_method_res_type(type, i, restype); } - variadicity = (int) read_long(env); + variadicity = (ir_variadicity) read_long(env); set_method_variadicity(type, variadicity); set_method_calling_convention(type, callingconv); @@ -1900,7 +1859,7 @@ static void read_entity(read_env_t *env, ir_entity_kind kind) long entnr = read_long(env); ident *name = NULL; ident *ld_name = NULL; - ir_visibility visibility = ir_visibility_default; + ir_visibility visibility = ir_visibility_external; ir_linkage linkage = IR_LINKAGE_DEFAULT; ir_type *owner = NULL; ir_entity *entity = NULL; @@ -1971,10 +1930,10 @@ static void read_entity(read_env_t *env, ir_entity_kind kind) ir_label_t nr = get_irp_next_label_nr(); entity = new_label_entity(nr); break; + } case IR_ENTITY_UNKNOWN: panic("read_entity with IR_ENTITY_UNKNOWN?"); } - } set_entity_compiler_generated(entity, compiler_generated); set_entity_volatility(entity, volatility); @@ -2097,6 +2056,7 @@ static ir_node *read_ASM(read_env_t *env) ir_asm_constraint *output_constraints = NEW_ARR_F(ir_asm_constraint, 0); ident **clobbers = NEW_ARR_F(ident*, 0); ir_node *block = read_node_ref(env); + ir_node *mem = read_node_ref(env); op_pin_state pin_state; ident *asm_text = read_ident(env); @@ -2128,14 +2088,14 @@ static ir_node *read_ASM(read_env_t *env) pin_state = read_pin_state(env); n_in = read_preds(env); - in = obstack_finish(&env->preds_obst); + in = (ir_node**)obstack_finish(&env->preds_obst); if (ARR_LEN(input_constraints) != (size_t)n_in) { parse_error(env, "input_constraints != n_in in ir file"); return new_r_Bad(env->irg, mode_T); } - newnode = new_r_ASM(block, n_in, in, + newnode = new_r_ASM(block, mem, n_in, in, input_constraints, ARR_LEN(output_constraints), output_constraints, ARR_LEN(clobbers), clobbers, asm_text); @@ -2191,20 +2151,20 @@ static ir_node *read_Anchor(read_env_t *env) return res; } -typedef ir_node* (*read_node_func)(read_env_t *env); +typedef ir_node* read_node_func(read_env_t *env); static pmap *node_readers; -static void register_node_reader(ident *ident, read_node_func func) +static void register_node_reader(ident *ident, read_node_func* func) { - pmap_insert(node_readers, ident, func); + pmap_insert(node_readers, ident, (void*)func); } static ir_node *read_node(read_env_t *env) { - ident *id = read_symbol(env); - read_node_func func = pmap_get(node_readers, id); - long nr = read_long(env); - ir_node *res; + ident *id = read_symbol(env); + read_node_func *func = pmap_get(read_node_func, node_readers, id); + long nr = read_long(env); + ir_node *res; if (func == NULL) { parse_error(env, "Unknown nodetype '%s'", get_id_str(id)); skip_to(env, '\n'); @@ -2281,15 +2241,12 @@ next_delayed_pred: ; static ir_graph *read_irg(read_env_t *env) { - ir_entity *irgent = get_entity(env, read_long(env)); - ir_graph *irg = new_ir_graph(irgent, 0); - ir_type *frame = read_type_ref(env); - irg_inline_property prop = read_inline_property(env); - unsigned props = read_unsigned(env); + ir_entity *irgent = get_entity(env, read_long(env)); + ir_graph *irg = new_ir_graph(irgent, 0); + ir_type *frame = read_type_ref(env); set_irg_frame_type(irg, frame); - set_irg_inline_property(irg, prop); - set_irg_additional_properties(irg, (mtp_additional_properties)props); read_graph(env, irg); + irg_finalize_cons(irg); return irg; } @@ -2421,6 +2378,10 @@ int ir_import_file(FILE *input, const char *inputname) /* read first character */ read_c(env); + /* if the first line starts with '#', it contains a comment. */ + if (env->c == '#') + skip_to(env, '\n'); + set_optimize(0); while (true) {