int line;
ir_type **fixedtypes;
struct obstack obst;
+ ir_graph *irg;
} io_env_t;
typedef enum typetag_t
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);
INSERTKEYWORD(constirg);
INSERTKEYWORD(entity);
return "INVALID_SEGMENT";
}
+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";
+ }
+ return "INVALID_VISIBILITY";
+}
+
/** 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)
{
fputc(' ', env->file);
}
-static void write_tarval(io_env_t *env, tarval *tv)
+static void write_tarval(io_env_t *env, ir_tarval *tv)
{
char buf[1024];
write_mode(env, get_tarval_mode(tv));
case IR_INITIALIZER_COMPOUND: {
unsigned i, n = get_initializer_compound_n_entries(ini);
- fprintf(f, "%d ", n);
+ fprintf(f, "%u ", n);
for (i = 0; i < n; i++)
write_initializer(env, get_initializer_compound_value(ini, i));
break;
static void export_type_common(io_env_t *env, ir_type *tp)
{
- fprintf(env->file, "\ttype %ld %s %u %u %s %d ",
+ fprintf(env->file, "\ttype %ld %s %u %u %s %u ",
get_type_nr(tp),
get_type_tpop_name(tp),
get_type_size_bytes(tp),
static void export_entity(io_env_t *env, ir_entity *ent)
{
- ir_type *owner = get_entity_owner(ent);
+ FILE *file = env->file;
+ ir_type *owner = get_entity_owner(ent);
+ ir_visibility visibility = get_entity_visibility(ent);
+ ir_linkage linkage = get_entity_linkage(ent);
/* we don't dump array_element_ent entities. They're a strange concept
* and lead to cycles in type_graph.
fprintf(env->file, "NULL ");
}
- fprintf(env->file, "%ld %ld %d %u %d %s ",
+ /* visibility + linkage */
+ if (visibility != ir_visibility_default) {
+ fprintf(file, "%s ", get_visibility_name(visibility));
+ }
+ if (linkage & IR_LINKAGE_CONSTANT)
+ fputs("constant ", file);
+ if (linkage & IR_LINKAGE_WEAK)
+ fputs("weak ", file);
+ if (linkage & IR_LINKAGE_GARBAGE_COLLECT)
+ fputs("garbage_collect ", file);
+ if (linkage & IR_LINKAGE_MERGE)
+ fputs("merge ", file);
+ if (linkage & IR_LINKAGE_HIDDEN_USER)
+ fputs("hidden_user ", file);
+
+ fprintf(file, "%ld %ld %d %u %d %s ",
get_type_nr(get_entity_type(ent)),
get_type_nr(owner),
get_entity_offset(ent),
fprintf(env->file, "] { ");
- switch (opcode) {
- #include "gen_irio_export.inl"
+ switch (opcode) {
+#include "gen_irio_export.inl"
}
fputs("}\n", env->file);
}
break;
}
- fprintf(env->file, "\tmode \"%s\" %s %d %d %s %d %d ",
+ fprintf(env->file, "\tmode \"%s\" %s %u %d %s %u %u ",
get_mode_name(mode), get_mode_sort_name(get_mode_sort(mode)),
get_mode_size_bits(mode), get_mode_sign(mode),
get_mode_arithmetic_name(get_mode_arithmetic(mode)),
do {
obstack_1grow(&env->obst, env->c);
read_c(env);
- } while(isdigit(env->c));
+ } while (isdigit(env->c));
obstack_1grow(&env->obst, 0);
str = obstack_finish(&env->obst);
{
ir_node *node = get_node_or_null(env, nodenr);
if (node == NULL) {
- node = new_Dummy(mode_X);
+ node = new_r_Dummy(env->irg, mode_X);
set_id(env, nodenr, node);
}
return node;
return flags;
}
-static tarval *read_tv(io_env_t *env)
+static ir_tarval *read_tv(io_env_t *env)
{
- ir_mode *tvmode = read_mode(env);
- char *str = read_word(env);
- tarval *tv = new_tarval_from_str(str, strlen(str), tvmode);
+ ir_mode *tvmode = read_mode(env);
+ char *str = read_word(env);
+ ir_tarval *tv = new_tarval_from_str(str, strlen(str), tvmode);
obstack_free(&env->obst, str);
return tv;
const char *name = read_quoted_string_null(env);
ident *id = name != NULL ? new_id_from_str(name) : NULL;
- if(typenr == (long) IR_SEGMENT_GLOBAL)
+ if (typenr == (long) IR_SEGMENT_GLOBAL)
type = get_glob_type();
else
type = new_type_class(id);
/** Reads an entity description and remembers it by its id. */
static void import_entity(io_env_t *env)
{
- long entnr = read_long(env);
- ident *name = read_ident(env);
- ident *ld_name = read_ident_null(env);
- long typenr = read_long(env);
- long ownertypenr = read_long(env);
- const char *str;
+ long entnr = read_long(env);
+ ident *name = read_ident(env);
+ ident *ld_name = read_ident_null(env);
+ ir_visibility visibility = ir_visibility_default;
+ ir_linkage linkage = IR_LINKAGE_DEFAULT;
+ long typenr;
+ long ownertypenr;
+ const char *str;
+ ir_type *type;
+ ir_type *ownertype;
+ ir_entity *entity;
+
+ skip_ws(env);
+ while (!isdigit(env->c)) {
+ char *str = read_word(env);
+ unsigned v;
+
+ skip_ws(env);
+
+ v = symbol(str, tt_visibility);
+ if (v != SYMERROR) {
+ visibility = v;
+ continue;
+ }
+ v = symbol(str, tt_linkage);
+ if (v != SYMERROR) {
+ linkage |= v;
+ continue;
+ }
+ printf("Parser error, expected visibility or linkage, got '%s'\n",
+ str);
+ break;
+ }
+
+ typenr = read_long(env);
+ ownertypenr = read_long(env);
- ir_type *type = get_type(env, typenr);
- ir_type *ownertype = !ownertypenr ? get_glob_type() : get_type(env, ownertypenr);
- ir_entity *entity = new_entity(ownertype, name, type);
+ type = get_type(env, typenr);
+ ownertype = !ownertypenr ? get_glob_type() : get_type(env, ownertypenr);
+ entity = new_entity(ownertype, name, type);
if (ld_name != NULL)
set_entity_ld_ident(entity, ld_name);
- set_entity_offset (entity, (int) read_long(env));
+ set_entity_offset(entity, (int) read_long(env));
set_entity_offset_bits_remainder(entity, (unsigned char) read_long(env));
set_entity_compiler_generated(entity, (int) read_long(env));
- set_entity_volatility (entity, read_volatility(env));
- /* TODO: read/write linkage */
+ set_entity_volatility(entity, read_volatility(env));
+ set_entity_visibility(entity, visibility);
+ set_entity_linkage(entity, linkage);
str = read_word(env);
if (strcmp(str, "initializer") == 0) {
/** Parses the whole type graph. */
static int parse_typegraph(io_env_t *env)
{
+ ir_graph *old_irg = env->irg;
keyword_t kwkind;
EXPECT('{');
- current_ir_graph = get_const_code_irg();
+ env->irg = get_const_code_irg();
/* parse all types first */
while (true) {
break;
}
}
+ env->irg = old_irg;
return 1;
}
*nodename = read_word(env);
*nodenr = read_long(env);
- ARR_RESIZE(ir_node *, *preds, 0);
+ ARR_RESIZE(long, *preds, 0);
EXPECT('[');
for (numpreds = 0; !feof(env->file); numpreds++) {
const char *nodename;
ir_node *node, *newnode;
- current_ir_graph = irg;
+ env->irg = irg;
EXPECT('{');
case iro_End:
{
ir_node *newendblock = get_node(env, preds[0]);
- newnode = get_irg_end(current_ir_graph);
+ newnode = get_irg_end(irg);
exchange(get_nodes_block(newnode), newendblock);
for (i = 0; i < numpreds - 1; i++)
add_irn_n(newnode, prednodes[i]);
case iro_Start:
{
ir_node *newstartblock = get_node(env, preds[0]);
- newnode = get_irg_start(current_ir_graph);
+ newnode = get_irg_start(irg);
exchange(get_nodes_block(newnode), newstartblock);
break;
}
goto endloop;
}
- newnode = new_Block(numpreds - 1, prednodes);
+ newnode = new_r_Block(irg, numpreds - 1, prednodes);
break;
}
case iro_Anchor:
- newnode = current_ir_graph->anchor;
+ newnode = irg->anchor;
for (i = 0; i < numpreds - 1; i++)
set_irn_n(newnode, i, prednodes[i]);
set_irn_n(newnode, -1, get_node(env, preds[0]));
long entnr = read_long(env);
union symconst_symbol sym;
sym.entity_p = get_entity(env, entnr);
- newnode = new_SymConst(mode_P, sym, symconst_addr_ent);
+ newnode = new_r_SymConst(irg, mode_P, sym, symconst_addr_ent);
break;
}