irio.c

/*
 * This file is part of libFirm.
 * Copyright (C) 2012 University of Karlsruhe.
 */

/**
 * @file
 * @brief   Write textual representation of firm to file.
 * @author  Moritz Kroll, Matthias Braun
 */
#include "config.h"

#include <string.h>
#include <ctype.h>
#include <stdbool.h>
#include <stdarg.h>

#include "irio.h"

#include "irnode_t.h"
#include "irprog.h"
#include "irgraph_t.h"
#include "irprintf.h"
#include "ircons_t.h"
#include "irgmod.h"
#include "irflag_t.h"
#include "irgwalk.h"
#include "tv.h"
#include "array.h"
#include "error.h"
#include "typerep.h"
#include "set.h"
#include "obst.h"
#include "pmap.h"
#include "pdeq.h"

#define SYMERROR ((unsigned) ~0)

static void register_generated_node_readers(void);
static void register_generated_node_writers(void);

typedef struct delayed_initializer_t {
	ir_initializer_t *initializer;
	long              node_nr;
} delayed_initializer_t;

typedef struct delayed_pred_t {
	ir_node *node;
	int      n_preds;
	long     preds[];
} delayed_pred_t;

typedef struct read_env_t {
	int            c;           /**< currently read char */
	FILE          *file;
	const char    *inputname;
	unsigned       line;

	ir_graph      *irg;
	set           *idset;       /**< id_entry set, which maps from file ids to
	                                 new Firm elements */
	ir_type      **fixedtypes;
	bool           read_errors;
	struct obstack obst;
	struct obstack preds_obst;
	delayed_initializer_t *delayed_initializers;
	const delayed_pred_t **delayed_preds;
} read_env_t;

typedef struct write_env_t {
	FILE *file;
	pdeq *write_queue;
	pdeq *entity_queue;
} write_env_t;

typedef enum typetag_t {
	tt_align,
	tt_builtin_kind,
	tt_cond_jmp_predicate,
	tt_initializer,
	tt_keyword,
	tt_linkage,
	tt_mode_arithmetic,
	tt_pin_state,
	tt_segment,
	tt_throws,
	tt_tpo,
	tt_type_state,
	tt_visibility,
	tt_volatility,
	tt_where_alloc,
} typetag_t;

typedef enum keyword_t {
	kw_asm,
	kw_compound_member,
	kw_constirg,
	kw_entity,
	kw_float_mode,
	kw_int_mode,
	kw_irg,
	kw_label,
	kw_method,
	kw_modes,
	kw_parameter,
	kw_program,
	kw_reference_mode,
	kw_segment_type,
	kw_type,
	kw_typegraph,
	kw_unknown,
} keyword_t;

typedef struct symbol_t {
	const char *str;      /**< The name of this symbol. */
	typetag_t   typetag;  /**< The type tag of this symbol. */
	unsigned    code;     /**< The value of this symbol. */
} symbol_t;

typedef struct id_entry {
	long id;
	void *elem;
} id_entry;

/** The symbol table, a set of symbol_t elements. */
static set *symtbl;

/**
 * Compare two symbol table entries.
 */
static int symbol_cmp(const void *elt, const void *key, size_t size)
{
	int res;
	const symbol_t *entry = (const symbol_t *) elt;
	const symbol_t *keyentry = (const symbol_t *) key;
	(void) size;
	res = entry->typetag - keyentry->typetag;
	if (res) return res;
	return strcmp(entry->str, keyentry->str);
}

static int id_cmp(const void *elt, const void *key, size_t size)
{
	const id_entry *entry = (const id_entry *) elt;
	const id_entry *keyentry = (const id_entry *) key;
	(void) size;
	return entry->id - keyentry->id;
}

static void __attribute__((format(printf, 2, 3)))
parse_error(read_env_t *env, const char *fmt, ...)
{
	va_list  ap;
	unsigned line = env->line;

	/* workaround read_c "feature" that a '\n' triggers the line++
	 * instead of the character after the '\n' */
	if (env->c == '\n') {
		line--;
	}

	fprintf(stderr, "%s:%u: error ", env->inputname, line);
	env->read_errors = true;

	/* let's hope firm doesn't die on further errors */
	do_node_verification(FIRM_VERIFICATION_OFF);

	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
}

/** Initializes the symbol table. May be called more than once without problems. */
static void symtbl_init(void)
{
	symbol_t key;

	/* Only initialize once */
	if (symtbl != NULL)
		return;

	symtbl = new_set(symbol_cmp, 256);

#define INSERT(tt, s, cod)                                       \
	key.str = (s);                                               \
	key.typetag = (tt);                                          \
	key.code = (cod);                                            \
	(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_tpo, "array", tpo_array);
	INSERT(tt_tpo, "class", tpo_class);
	INSERT(tt_tpo, "method", tpo_method);
	INSERT(tt_tpo, "pointer", tpo_pointer);
	INSERT(tt_tpo, "primitive", tpo_primitive);
	INSERT(tt_tpo, "struct", tpo_struct);
	INSERT(tt_tpo, "union", tpo_union);
	INSERT(tt_tpo, "Unknown", tpo_unknown);

	INSERT(tt_segment, "global", IR_SEGMENT_GLOBAL);
	INSERT(tt_segment, "thread_local", IR_SEGMENT_THREAD_LOCAL);
	INSERT(tt_segment, "constructors", IR_SEGMENT_CONSTRUCTORS);
	INSERT(tt_segment, "destructors", IR_SEGMENT_DESTRUCTORS);

	INSERT(tt_linkage, "constant", IR_LINKAGE_CONSTANT);
	INSERT(tt_linkage, "weak", IR_LINKAGE_WEAK);
	INSERT(tt_linkage, "garbage_collect", IR_LINKAGE_GARBAGE_COLLECT);
	INSERT(tt_linkage, "merge", IR_LINKAGE_MERGE);
	INSERT(tt_linkage, "hidden_user", IR_LINKAGE_HIDDEN_USER);

	INSERT(tt_visibility, "local", ir_visibility_local);
	INSERT(tt_visibility, "external", ir_visibility_external);
	INSERT(tt_visibility, "private", ir_visibility_private);

	INSERT(tt_throws, "throw",   true);
	INSERT(tt_throws, "nothrow", false);

	INSERTKEYWORD(asm);
	INSERTKEYWORD(compound_member);
	INSERTKEYWORD(constirg);
	INSERTKEYWORD(entity);
	INSERTKEYWORD(float_mode);
	INSERTKEYWORD(int_mode);
	INSERTKEYWORD(irg);
	INSERTKEYWORD(label);
	INSERTKEYWORD(method);
	INSERTKEYWORD(modes);
	INSERTKEYWORD(parameter);
	INSERTKEYWORD(program);
	INSERTKEYWORD(reference_mode);
	INSERTKEYWORD(segment_type);
	INSERTKEYWORD(type);
	INSERTKEYWORD(typegraph);
	INSERTKEYWORD(unknown);

	INSERTENUM(tt_align, align_non_aligned);
	INSERTENUM(tt_align, align_is_aligned);

	INSERTENUM(tt_builtin_kind, ir_bk_trap);
	INSERTENUM(tt_builtin_kind, ir_bk_debugbreak);
	INSERTENUM(tt_builtin_kind, ir_bk_return_address);
	INSERTENUM(tt_builtin_kind, ir_bk_frame_address);
	INSERTENUM(tt_builtin_kind, ir_bk_prefetch);
	INSERTENUM(tt_builtin_kind, ir_bk_ffs);
	INSERTENUM(tt_builtin_kind, ir_bk_clz);
	INSERTENUM(tt_builtin_kind, ir_bk_ctz);
	INSERTENUM(tt_builtin_kind, ir_bk_popcount);
	INSERTENUM(tt_builtin_kind, ir_bk_parity);
	INSERTENUM(tt_builtin_kind, ir_bk_bswap);
	INSERTENUM(tt_builtin_kind, ir_bk_inport);
	INSERTENUM(tt_builtin_kind, ir_bk_outport);
	INSERTENUM(tt_builtin_kind, ir_bk_inner_trampoline);

	INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_NONE);
	INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_TRUE);
	INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_FALSE);

	INSERTENUM(tt_initializer, IR_INITIALIZER_CONST);
	INSERTENUM(tt_initializer, IR_INITIALIZER_TARVAL);
	INSERTENUM(tt_initializer, IR_INITIALIZER_NULL);
	INSERTENUM(tt_initializer, IR_INITIALIZER_COMPOUND);

	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);

	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);
	INSERTENUM(tt_pin_state, op_pin_state_mem_pinned);

	INSERTENUM(tt_type_state, layout_undefined);
	INSERTENUM(tt_type_state, layout_fixed);

	INSERTENUM(tt_volatility, volatility_non_volatile);
	INSERTENUM(tt_volatility, volatility_is_volatile);

	INSERTENUM(tt_where_alloc, stack_alloc);
	INSERTENUM(tt_where_alloc, heap_alloc);

#undef INSERTKEYWORD
#undef INSERTENUM
#undef INSERT
}

static const char *get_segment_name(ir_segment_t segment)
{
	switch (segment) {
	case IR_SEGMENT_GLOBAL:       return "global";
	case IR_SEGMENT_THREAD_LOCAL: return "thread_local";
	case IR_SEGMENT_CONSTRUCTORS: return "constructors";
	case IR_SEGMENT_DESTRUCTORS:  return "destructors";
	}
	panic("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_private:  return "private";
	}
	panic("INVALID_VISIBILITY");
}

static const char *get_mode_arithmetic_name(ir_mode_arithmetic arithmetic)
{
	switch (arithmetic) {
	case irma_none:               return "none";
	case irma_twos_complement:    return "twos_complement";
	case irma_ieee754:            return "ieee754";
	case irma_x86_extended_float: return "x86_extended_float";
	}
	panic("invalid mode_arithmetic");
}

/** 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)
{
	symbol_t key, *entry;

	key.str = str;
	key.typetag = typetag;

	entry = set_find(symbol_t, symtbl, &key, sizeof(key), hash_str(str) + typetag * 17);
	return entry ? entry->code : SYMERROR;
}

static void write_long(write_env_t *env, long value)
{
	fprintf(env->file, "%ld ", value);
}

static void write_int(write_env_t *env, int value)
{
	fprintf(env->file, "%d ", value);
}

static void write_unsigned(write_env_t *env, unsigned value)
{
	fprintf(env->file, "%u ", value);
}

static void write_size_t(write_env_t *env, size_t value)
{
	ir_fprintf(env->file, "%zu ", value);
}

static void write_symbol(write_env_t *env, const char *symbol)
{
	fputs(symbol, env->file);
	fputc(' ', env->file);
}

static void write_entity_ref(write_env_t *env, ir_entity *entity)
{
	write_long(env, get_entity_nr(entity));
}

static void write_type_ref(write_env_t *env, ir_type *type)
{
	switch (get_type_tpop_code(type)) {
	case tpo_unknown:
		write_symbol(env, "unknown");
		return;
	case tpo_none:
		write_symbol(env, "none");
		return;
	case tpo_code:
		write_symbol(env, "code");
		return;
	default:
		break;
	}
	write_long(env, get_type_nr(type));
}

static void write_string(write_env_t *env, const char *string)
{
	const char *c;
	fputc('"', env->file);
	for (c = string; *c != '\0'; ++c) {
		switch (*c) {
		case '\n':
			fputc('\\', env->file);
			fputc('n', env->file);
			break;
		case '"':
		case '\\':
			fputc('\\', env->file);
			/* FALLTHROUGH */
		default:
			fputc(*c, env->file);
			break;
		}
	}
	fputc('"', env->file);
	fputc(' ', env->file);
}

static void write_ident(write_env_t *env, ident *id)
{
	write_string(env, get_id_str(id));
}

static void write_ident_null(write_env_t *env, ident *id)
{
	if (id == NULL) {
		fputs("NULL ", env->file);
	} else {
		write_ident(env, id);
	}
}

static void write_mode_ref(write_env_t *env, ir_mode *mode)
{
	write_string(env, get_mode_name(mode));
}

static void write_tarval(write_env_t *env, ir_tarval *tv)
{
	write_mode_ref(env, get_tarval_mode(tv));
	if (tv == tarval_bad) {
		write_symbol(env, "bad");
	} else {
		char buf[1024];
		tarval_snprintf(buf, sizeof(buf), tv);
		fputs(buf, env->file);
		fputc(' ', env->file);
	}
}

static void write_align(write_env_t *env, ir_align align)
{
	fputs(get_align_name(align), env->file);
	fputc(' ', env->file);
}

static void write_builtin_kind(write_env_t *env, const ir_node *node)
{
	fputs(get_builtin_kind_name(get_Builtin_kind(node)), env->file);
	fputc(' ', env->file);
}

static void write_cond_jmp_predicate(write_env_t *env, const ir_node *node)
{
	fputs(get_cond_jmp_predicate_name(get_Cond_jmp_pred(node)), env->file);
	fputc(' ', env->file);
}

static void write_relation(write_env_t *env, ir_relation relation)
{
	write_long(env, (long)relation);
}

static void write_where_alloc(write_env_t *env, ir_where_alloc where_alloc)
{
	switch (where_alloc) {
	case stack_alloc: write_symbol(env, "stack_alloc"); return;
	case heap_alloc:  write_symbol(env, "heap_alloc");  return;
	}
	panic("invalid where_alloc value");
}

static void write_throws(write_env_t *env, bool throws)
{
	write_symbol(env, throws ? "throw" : "nothrow");
}

static void write_list_begin(write_env_t *env)
{
	fputs("[", env->file);
}

static void write_list_end(write_env_t *env)
{
	fputs("] ", env->file);
}

static void write_scope_begin(write_env_t *env)
{
	fputs("{\n", env->file);
}

static void write_scope_end(write_env_t *env)
{
	fputs("}\n\n", env->file);
}

static void write_node_ref(write_env_t *env, const ir_node *node)
{
	write_long(env, get_irn_node_nr(node));
}

static void write_initializer(write_env_t *env, ir_initializer_t *ini)
{
	FILE *f = env->file;
	ir_initializer_kind_t ini_kind = get_initializer_kind(ini);

	fputs(get_initializer_kind_name(ini_kind), f);
	fputc(' ', f);

	switch (ini_kind) {
	case IR_INITIALIZER_CONST:
		write_node_ref(env, get_initializer_const_value(ini));
		return;

	case IR_INITIALIZER_TARVAL:
		write_tarval(env, get_initializer_tarval_value(ini));
		return;

	case IR_INITIALIZER_NULL:
		return;

	case IR_INITIALIZER_COMPOUND: {
		size_t i, n = get_initializer_compound_n_entries(ini);
		write_size_t(env, n);
		for (i = 0; i < n; ++i)
			write_initializer(env, get_initializer_compound_value(ini, i));
		return;
	}
	}
	panic("Unknown initializer kind");
}

static void write_pin_state(write_env_t *env, op_pin_state state)
{
	fputs(get_op_pin_state_name(state), env->file);
	fputc(' ', env->file);
}

static void write_volatility(write_env_t *env, ir_volatility vol)
{
	fputs(get_volatility_name(vol), 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);
	fputc(' ', env->file);
}

static void write_visibility(write_env_t *env, ir_visibility visibility)
{
	fputs(get_visibility_name(visibility), env->file);
	fputc(' ', env->file);
}

static void write_mode_arithmetic(write_env_t *env, ir_mode_arithmetic arithmetic)
{
	fputs(get_mode_arithmetic_name(arithmetic), env->file);
	fputc(' ', env->file);
}

static void write_type_common(write_env_t *env, ir_type *tp)
{
	fputc('\t', env->file);
	write_symbol(env, "type");
	write_long(env, get_type_nr(tp));
	write_symbol(env, get_type_tpop_name(tp));
	write_unsigned(env, get_type_size_bytes(tp));
	write_unsigned(env, get_type_alignment_bytes(tp));
	write_type_state(env, get_type_state(tp));
	write_unsigned(env, tp->flags);
}

static void write_type(write_env_t *env, ir_type *tp);

static void write_type_primitive(write_env_t *env, ir_type *tp)
{
	ir_type *base_type = get_primitive_base_type(tp);

	if (base_type != NULL)
		write_type(env, base_type);

	write_type_common(env, tp);
	write_mode_ref(env, get_type_mode(tp));
	if (base_type == NULL)
		base_type = get_none_type();
	write_type_ref(env, base_type);
	fputc('\n', env->file);
}

static void write_type_compound(write_env_t *env, ir_type *tp)
{
	size_t n_members = get_compound_n_members(tp);
	size_t i;

	if (is_Class_type(tp)) {
		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");
		}
	}
	write_type_common(env, tp);
	write_ident_null(env, get_compound_ident(tp));
	fputc('\n', env->file);

	for (i = 0; i < n_members; ++i) {
		ir_entity *member = get_compound_member(tp, i);
		pdeq_putr(env->entity_queue, member);
	}
}

static void write_type_array(write_env_t *env, ir_type *tp)
{
	size_t     n_dimensions   = get_array_n_dimensions(tp);
	ir_type   *element_type   = get_array_element_type(tp);
	ir_entity *element_entity = get_array_element_entity(tp);
	size_t   i;

	write_type(env, element_type);

	write_type_common(env, tp);
	write_size_t(env, n_dimensions);
	write_type_ref(env, get_array_element_type(tp));
	for (i = 0; i < n_dimensions; i++) {
		ir_node *lower = get_array_lower_bound(tp, i);
		ir_node *upper = get_array_upper_bound(tp, i);

		if (is_Const(lower))
			write_long(env, get_tarval_long(get_Const_tarval(lower)));
		else
			panic("Lower array bound is not constant");

		if (is_Const(upper))
			write_long(env, get_tarval_long(get_Const_tarval(upper)));
		else if (is_Unknown(upper))
			write_symbol(env, "unknown");
		else
			panic("Upper array bound is not constant");
	}
	/* note that we just write a reference to the element entity
	 * but never the entity itself */
	write_entity_ref(env, element_entity);
	fputc('\n', env->file);
}

static void write_type_method(write_env_t *env, ir_type *tp)
{
	size_t nparams  = get_method_n_params(tp);
	size_t nresults = get_method_n_ress(tp);
	size_t i;

	for (i = 0; i < nparams; i++)
		write_type(env, get_method_param_type(tp, i));
	for (i = 0; i < nresults; i++)
		write_type(env, get_method_res_type(tp, i));

	write_type_common(env, tp);
	write_unsigned(env, get_method_calling_convention(tp));
	write_unsigned(env, get_method_additional_properties(tp));
	write_size_t(env, nparams);
	write_size_t(env, nresults);
	for (i = 0; i < nparams; i++)
		write_type_ref(env, get_method_param_type(tp, i));
	for (i = 0; i < nresults; i++)
		write_type_ref(env, get_method_res_type(tp, i));
	write_unsigned(env, get_method_variadicity(tp));
	fputc('\n', env->file);
}

static void write_type_pointer(write_env_t *env, ir_type *tp)
{
	ir_type *points_to = get_pointer_points_to_type(tp);

	write_type(env, points_to);

	write_type_common(env, tp);
	write_mode_ref(env, get_type_mode(tp));
	write_type_ref(env, points_to);
	fputc('\n', env->file);
}

static void write_type_enumeration(write_env_t *env, ir_type *tp)
{
	write_type_common(env, tp);
	write_ident_null(env, get_enumeration_ident(tp));
	fputc('\n', env->file);
}

static void write_type(write_env_t *env, ir_type *tp)
{
	if (type_visited(tp))
		return;
	mark_type_visited(tp);

	switch ((tp_opcode)get_type_tpop_code(tp)) {
	case tpo_none:
	case tpo_unknown:
	case tpo_code:
	case tpo_uninitialized:
		/* no need to write special builtin types */
		return;

	case tpo_union:
	case tpo_struct:
	case tpo_class:
		write_type_compound(env, tp);
		return;

	case tpo_primitive:    write_type_primitive(env, tp);   return;
	case tpo_enumeration:  write_type_enumeration(env, tp); return;
	case tpo_method:       write_type_method(env, tp);      return;
	case tpo_pointer:      write_type_pointer(env, tp);     return;
	case tpo_array:        write_type_array(env, tp);       return;
	}
	panic("can't write invalid type %+F\n", tp);
}

static void write_entity(write_env_t *env, ir_entity *ent)
{
	ir_type       *type       = get_entity_type(ent);
	ir_type       *owner      = get_entity_owner(ent);
	ir_visibility  visibility = get_entity_visibility(ent);
	ir_linkage     linkage    = get_entity_linkage(ent);

	if (entity_visited(ent))
		return;
	mark_entity_visited(ent);

	write_type(env, type);
	write_type(env, owner);

	fputc('\t', env->file);
	switch ((ir_entity_kind)ent->entity_kind) {
	case IR_ENTITY_NORMAL:          write_symbol(env, "entity");          break;
	case IR_ENTITY_METHOD:          write_symbol(env, "method");          break;
	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->entity_kind != IR_ENTITY_LABEL
	    && ent->entity_kind != IR_ENTITY_PARAMETER) {
		write_ident_null(env, get_entity_ident(ent));
		if (!entity_has_ld_ident(ent)) {
			write_ident_null(env, NULL);
		} else {
			write_ident_null(env, get_entity_ld_ident(ent));
		}
	}

	write_visibility(env, visibility);
	write_list_begin(env);
	if (linkage & IR_LINKAGE_CONSTANT)
		write_symbol(env, "constant");
	if (linkage & IR_LINKAGE_WEAK)
		write_symbol(env, "weak");
	if (linkage & IR_LINKAGE_GARBAGE_COLLECT)
		write_symbol(env, "garbage_collect");
	if (linkage & IR_LINKAGE_MERGE)
		write_symbol(env, "merge");
	if (linkage & IR_LINKAGE_HIDDEN_USER)
		write_symbol(env, "hidden_user");
	write_list_end(env);

	write_type_ref(env, type);
	if (ent->entity_kind != IR_ENTITY_LABEL)
		write_type_ref(env, owner);
	write_long(env, is_entity_compiler_generated(ent));
	write_volatility(env, get_entity_volatility(ent));

	switch ((ir_entity_kind)ent->entity_kind) {
	case IR_ENTITY_NORMAL:
		if (ent->initializer != NULL) {
			write_symbol(env, "initializer");
			write_initializer(env, get_entity_initializer(ent));
		} else {
			write_symbol(env, "none");
		}
		break;
	case IR_ENTITY_COMPOUND_MEMBER:
		write_long(env, get_entity_offset(ent));
		write_unsigned(env, get_entity_offset_bits_remainder(ent));
		break;
	case IR_ENTITY_PARAMETER: {
		size_t num = get_entity_parameter_number(ent);
		if (num == IR_VA_START_PARAMETER_NUMBER) {
			write_symbol(env, "va_start");
		} else {
			write_size_t(env, num);
		}
		break;
	}
	case IR_ENTITY_UNKNOWN:
	case IR_ENTITY_LABEL:
	case IR_ENTITY_METHOD:
		break;
	}

	fputc('\n', env->file);
}

static void write_switch_table(write_env_t *env, const ir_switch_table *table)
{
	size_t n_entries = ir_switch_table_get_n_entries(table);
	size_t i;

	write_size_t(env, n_entries);
	for (i = 0; i < n_entries; ++i) {
		long       pn  = ir_switch_table_get_pn(table, i);
		ir_tarval *min = ir_switch_table_get_min(table, i);
		ir_tarval *max = ir_switch_table_get_max(table, i);
		write_long(env, pn);
		write_tarval(env, min);
		write_tarval(env, max);
	}
}

static void write_pred_refs(write_env_t *env, const ir_node *node, int from)
{
	int arity = get_irn_arity(node);
	int i;
	write_list_begin(env);
	assert(from <= arity);
	for (i = from; i < arity; ++i) {
		ir_node *pred = get_irn_n(node, i);
		write_node_ref(env, pred);
	}
	write_list_end(env);
}

static void write_node_nr(write_env_t *env, const ir_node *node)
{
	write_long(env, get_irn_node_nr(node));
}

static void write_ASM(write_env_t *env, const ir_node *node)
{
	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);
	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);
		write_mode_ref(env, constraint->mode);
	}
	write_list_end(env);

	write_list_begin(env);
	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);
		write_mode_ref(env, constraint->mode);
	}
	write_list_end(env);

	write_list_begin(env);
	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, n_ASM_max+1);
}

static void write_Phi(write_env_t *env, const ir_node *node)
{
	write_symbol(env, "Phi");
	write_node_nr(env, node);
	write_node_ref(env, get_nodes_block(node));
	write_mode_ref(env, get_irn_mode(node));
	write_pred_refs(env, node, 0);
}

static void write_Block(write_env_t *env, const ir_node *node)
{
	ir_entity *entity = get_Block_entity(node);

	if (entity != NULL) {
		write_symbol(env, "BlockL");
		write_node_nr(env, node);
		write_entity_ref(env, entity);
	} else {
		write_symbol(env, "Block");
		write_node_nr(env, node);
	}
	write_pred_refs(env, node, 0);
}

static void write_Anchor(write_env_t *env, const ir_node *node)
{
	write_symbol(env, "Anchor");
	write_node_nr(env, node);
	write_pred_refs(env, node, 0);
}

static void write_SymConst(write_env_t *env, const ir_node *node)
{
	/* TODO: only symconst_addr_ent implemented yet */
	if (get_SymConst_kind(node) != symconst_addr_ent)
		panic("Can't export %+F (only symconst_addr_ent supported)", node);

	write_symbol(env, "SymConst");
	write_node_nr(env, node);
	write_mode_ref(env, get_irn_mode(node));
	write_entity_ref(env, get_SymConst_entity(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)
{
	set_generic_function_ptr(op, func);
}

static void writers_init(void)
{
	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);
	register_node_writer(op_Phi,      write_Phi);
	register_node_writer(op_SymConst, write_SymConst);
	register_generated_node_writers();
}

static void write_node(const ir_node *node, write_env_t *env)
{
	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)
		panic("No write_node_func for %+F", node);
	func(env, node);
	fputc('\n', env->file);
}

static void write_node_recursive(ir_node *node, write_env_t *env);

static void write_preds(ir_node *node, write_env_t *env)
{
	int arity = get_irn_arity(node);
	int i;
	for (i = 0; i < arity; ++i) {
		ir_node *pred = get_irn_n(node, i);
		write_node_recursive(pred, env);
	}
}

/**
 * Recursively write nodes.
 * The reader expects nodes in a way that except for block/phi/anchor nodes
 * all predecessors are already defined when we reach them. So usually we
 * recurse to all our predecessors except for block/phi/anchor nodes where
 * we put the predecessors into a queue for later processing.
 */
static void write_node_recursive(ir_node *node, write_env_t *env)
{
	if (irn_visited_else_mark(node))
		return;

	if (!is_Block(node)) {
		write_node_recursive(get_nodes_block(node), env);
	}
	/* write predecessors */
	if (!is_Phi(node) && !is_Block(node) && !is_Anchor(node)) {
		write_preds(node, env);
	} else {
		int arity = get_irn_arity(node);
		int i;
		for (i = 0; i < arity; ++i) {
			ir_node *pred = get_irn_n(node, i);
			pdeq_putr(env->write_queue, pred);
		}
	}
	write_node(node, env);
}

static void write_mode(write_env_t *env, ir_mode *mode)
{
	if (mode_is_int(mode)) {
		write_symbol(env, "int_mode");
		write_string(env, get_mode_name(mode));
		write_mode_arithmetic(env, get_mode_arithmetic(mode));
		write_unsigned(env, get_mode_size_bits(mode));
		write_int(env, get_mode_sign(mode));
		write_unsigned(env, get_mode_modulo_shift(mode));
	} else if (mode_is_reference(mode)) {
		write_symbol(env, "reference_mode");
		write_string(env, get_mode_name(mode));
		write_mode_arithmetic(env, get_mode_arithmetic(mode));
		write_unsigned(env, get_mode_size_bits(mode));
		write_unsigned(env, get_mode_modulo_shift(mode));

		write_mode_ref(env, get_reference_mode_signed_eq(mode));
		write_mode_ref(env, get_reference_mode_unsigned_eq(mode));
		write_int(env, (mode == mode_P ? 1 : 0));
	} else if (mode_is_float(mode)) {
		write_symbol(env, "float_mode");
		write_string(env, get_mode_name(mode));
		write_mode_arithmetic(env, get_mode_arithmetic(mode));
		write_unsigned(env, get_mode_exponent_size(mode));
		write_unsigned(env, get_mode_mantissa_size(mode));
	} else {
		panic("Can't write internal modes");
	}
}

static void write_modes(write_env_t *env)
{
	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 = ir_get_mode(i);
		if (!mode_is_int(mode) && !mode_is_reference(mode)
		    && !mode_is_float(mode)) {
		    /* skip internal modes */
		    continue;
		}
		fputc('\t', env->file);
		write_mode(env, mode);
		fputc('\n', env->file);
	}

	fputs("}\n\n", env->file);
}

static void write_program(write_env_t *env)
{
	ir_segment_t s;
	size_t n_asms = get_irp_n_asms();
	size_t i;

	write_symbol(env, "program");
	write_scope_begin(env);
	if (irp_prog_name_is_set()) {
		fputc('\t', env->file);
		write_symbol(env, "name");
		write_string(env, get_irp_name());
		fputc('\n', env->file);
	}

	for (s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
		ir_type *segment_type = get_segment_type(s);
		fputc('\t', env->file);
		write_symbol(env, "segment_type");
		write_symbol(env, get_segment_name(s));
		if (segment_type == NULL) {
			write_symbol(env, "NULL");
		} else {
			write_type_ref(env, segment_type);
		}
		fputc('\n', env->file);
	}

	for (i = 0; i < n_asms; ++i) {
		ident *asm_text = get_irp_asm(i);
		fputc('\t', env->file);
		write_symbol(env, "asm");
		write_ident(env, asm_text);
		fputc('\n', env->file);
	}
	write_scope_end(env);
}

int ir_export(const char *filename)
{
	FILE *file = fopen(filename, "wt");
	int   res  = 0;
	if (file == NULL) {
		perror(filename);
		return 1;
	}

	ir_export_file(file);
	res = ferror(file);
	fclose(file);
	return res;
}

static void write_node_cb(ir_node *node, void *ctx)
{
	write_env_t *env = (write_env_t*)ctx;
	write_node(node, env);
}

static void write_typegraph(write_env_t *env)
{
	size_t n_types = get_irp_n_types();
	size_t i;

	write_symbol(env, "typegraph");
	write_scope_begin(env);
	irp_reserve_resources(irp, IRP_RESOURCE_TYPE_VISITED);
	inc_master_type_visited();
	for (i = 0; i < n_types; ++i) {
		ir_type *type = get_irp_type(i);
		write_type(env, type);
	}

	while (!pdeq_empty(env->entity_queue)) {
		ir_entity *entity = pdeq_getl(env->entity_queue);
		write_entity(env, entity);
	}

	irp_free_resources(irp, IRP_RESOURCE_TYPE_VISITED);
	write_scope_end(env);
}

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_scope_begin(env);
	ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
	inc_irg_visited(irg);
	assert(pdeq_empty(env->write_queue));
	pdeq_putr(env->write_queue, irg->anchor);
	do {
		ir_node *node = (ir_node*) pdeq_getl(env->write_queue);
		write_node_recursive(node, env);
	} while (!pdeq_empty(env->write_queue));
	ir_free_resources(irg, IR_RESOURCE_IRN_VISITED);
	write_scope_end(env);
}

/* Exports the whole irp to the given file in a textual form. */
void ir_export_file(FILE *file)
{
	write_env_t my_env;
	write_env_t *env = &my_env;
	size_t i, n_irgs = get_irp_n_irgs();

	memset(env, 0, sizeof(*env));
	env->file         = file;
	env->write_queue  = new_pdeq();
	env->entity_queue = new_pdeq();

	writers_init();
	write_modes(env);

	write_typegraph(env);

	for (