kw_segment_type,
kw_type,
kw_typegraph,
+ kw_unknown,
} keyword_t;
typedef struct symbol_t {
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);
INSERTKEYWORD(segment_type);
INSERTKEYWORD(type);
INSERTKEYWORD(typegraph);
+ INSERTKEYWORD(unknown);
INSERTENUM(tt_align, align_non_aligned);
INSERTENUM(tt_align, align_is_aligned);
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;
}
static void write_type_ref(write_env_t *env, ir_type *type)
{
- if (type == firm_unknown_type) {
+ switch (get_type_tpop_code(type)) {
+ case tpo_unknown:
write_symbol(env, "unknown");
- } else if (type == firm_none_type) {
+ return;
+ case tpo_none:
write_symbol(env, "none");
- } else if (type == firm_code_type) {
+ return;
+ case tpo_code:
write_symbol(env, "code");
- } else {
- write_long(env, get_type_nr(type));
+ return;
+ default:
+ break;
}
+ write_long(env, get_type_nr(type));
}
static void write_string(write_env_t *env, const char *string)
write_type_common(env, tp);
write_mode_ref(env, get_type_mode(tp));
if (base_type == NULL)
- base_type = firm_none_type;
+ base_type = get_none_type();
write_type_ref(env, base_type);
fputc('\n', env->file);
}
case IR_ENTITY_LABEL: write_symbol(env, "label"); break;
case IR_ENTITY_COMPOUND_MEMBER: write_symbol(env, "compound_member"); break;
case IR_ENTITY_PARAMETER: write_symbol(env, "parameter"); break;
+ case IR_ENTITY_UNKNOWN:
+ write_symbol(env, "unknown");
+ write_long(env, get_entity_nr(ent));
+ return;
}
write_long(env, get_entity_nr(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");
}
}
break;
}
+ case IR_ENTITY_UNKNOWN:
case IR_ENTITY_LABEL:
case IR_ENTITY_METHOD:
break;
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)
ir_type *type = (ir_type *) get_id(env, typenr);
if (type == NULL) {
parse_error(env, "Type %ld not defined (yet?)\n", typenr);
- return firm_unknown_type;
+ return get_unknown_type();
}
if (type->kind != k_type) {
parse_error(env, "Object %ld is not a type (but should be)\n", typenr);
- return firm_unknown_type;
+ return get_unknown_type();
}
return type;
}
char *str = read_word(env);
if (strcmp(str, "none") == 0) {
obstack_free(&env->obst, str);
- return firm_none_type;
+ return get_none_type();
}
if (strcmp(str, "unknown") == 0) {
obstack_free(&env->obst, str);
- return firm_unknown_type;
+ return get_unknown_type();
}
if (strcmp(str, "code") == 0) {
obstack_free(&env->obst, str);
- return firm_code_type;
+ return get_code_type();
}
long nr = atol(str);
obstack_free(&env->obst, str);
static ir_entity *create_error_entity(void)
{
ir_entity *res = new_entity(get_glob_type(), new_id_from_str("error"),
- firm_unknown_type);
+ get_unknown_type());
return res;
}
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);
ir_mode *mode = read_mode_ref(env);
ir_type *base_type = read_type_ref(env);
type = new_type_primitive(mode);
- if (base_type != firm_none_type) {
+ if (base_type != get_none_type()) {
set_primitive_base_type(type, base_type);
}
goto finish_type;
set_id(env, typenr, type);
}
+static void read_unknown_entity(read_env_t *env)
+{
+ long entnr = read_long(env);
+ ir_entity *entity = get_unknown_entity();
+ set_id(env, entnr, entity);
+}
+
/** Reads an entity description and remembers it by its id. */
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;
entity = new_label_entity(nr);
break;
}
+ case IR_ENTITY_UNKNOWN:
+ panic("read_entity with IR_ENTITY_UNKNOWN?");
}
set_entity_compiler_generated(entity, compiler_generated);
case kw_parameter:
read_entity(env, IR_ENTITY_PARAMETER);
break;
+ case kw_unknown:
+ read_unknown_entity(env);
+ break;
default:
parse_error(env, "type graph element not supported yet: %d\n", kwkind);
skip_to(env, '\n');
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;
}
projects / libfirm / blobdiff