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);
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)
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);
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");
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;
}
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");
}
static void writers_init(void)
{
- clear_irp_opcodes_generic_func();
+ ir_clear_opcodes_generic_func();
register_node_writer(op_Anchor, write_Anchor);
register_node_writer(op_ASM, write_ASM);
register_node_writer(op_Block, write_Block);
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 */
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;
}
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)
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;
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);
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);
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;
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);
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 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');
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;
}