/*
- * Copyright (C) 1995-2009 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
#include "irnode_t.h"
#include "irprog.h"
#include "irgraph_t.h"
+#include "irprintf.h"
#include "ircons.h"
#include "irgmod.h"
#include "irflag_t.h"
static void write_mode(io_env_t *env, ir_mode *mode)
{
- fputs(get_mode_name(mode), env->file);
+ write_string(env, get_mode_name(mode));
fputc(' ', env->file);
}
fputc(' ', env->file);
}
-static void write_align(io_env_t *env, ir_node *irn)
+static void write_align(io_env_t *env, ir_align align)
{
- ir_align align;
-
- if (is_Load(irn))
- align = get_Load_align(irn);
- else if (is_Store(irn))
- align = get_Store_align(irn);
- else
- panic("Invalid optype for write_align");
-
fputs(get_align_name(align), env->file);
fputc(' ', env->file);
}
break;
case IR_INITIALIZER_COMPOUND: {
- unsigned i, n = get_initializer_compound_n_entries(ini);
- fprintf(f, "%u ", n);
- for (i = 0; i < n; i++)
+ size_t i, n = get_initializer_compound_n_entries(ini);
+ ir_fprintf(f, "%zu ", n);
+ for (i = 0; i < n; ++i)
write_initializer(env, get_initializer_compound_value(ini, i));
break;
}
fputc(' ', env->file);
}
-static void write_volatility(io_env_t *env, ir_node *irn)
+static void write_volatility(io_env_t *env, ir_volatility vol)
{
- ir_volatility vol;
-
- if (is_Load(irn))
- vol = get_Load_volatility(irn);
- else if (is_Store(irn))
- vol = get_Store_volatility(irn);
- else
- panic("Invalid optype for write_volatility");
-
fputs(get_volatility_name(vol), env->file);
fputc(' ', env->file);
}
static void export_type_post(io_env_t *env, ir_type *tp)
{
FILE *f = env->file;
- int i;
+ size_t i;
/* skip types already handled by pre walker */
switch (get_type_tpop_code(tp)) {
switch (get_type_tpop_code(tp)) {
case tpo_array: {
- int n = get_array_n_dimensions(tp);
- fprintf(f, "%d %ld ", n, get_type_nr(get_array_element_type(tp)));
+ size_t n = get_array_n_dimensions(tp);
+ ir_fprintf(f, "%zu %ld ", n, get_type_nr(get_array_element_type(tp)));
for (i = 0; i < n; i++) {
ir_node *lower = get_array_lower_bound(tp, i);
ir_node *upper = get_array_upper_bound(tp, i);
}
case tpo_method: {
- int nparams = get_method_n_params(tp);
- int nresults = get_method_n_ress(tp);
- fprintf(f, "%u %u %d %d ", get_method_calling_convention(tp),
+ size_t nparams = get_method_n_params(tp);
+ size_t nresults = get_method_n_ress(tp);
+ ir_fprintf(f, "%u %u %zu %zu ", get_method_calling_convention(tp),
get_method_additional_properties(tp), nparams, nresults);
for (i = 0; i < nparams; i++)
write_long(env, get_type_nr(get_method_param_type(tp, i)));
for (i = 0; i < nresults; i++)
write_long(env, get_type_nr(get_method_res_type(tp, i)));
- fprintf(f, "%d ", get_method_first_variadic_param_index(tp));
+ ir_fprintf(f, "%u ", get_method_variadicity(tp));
break;
}
fputs("initializer ", env->file);
write_initializer(env, get_entity_initializer(ent));
} else if (entity_has_compound_ent_values(ent)) {
- int i, n = get_compound_ent_n_values(ent);
+ size_t i, n = get_compound_ent_n_values(ent);
fputs("compoundgraph ", env->file);
- fprintf(env->file, "%d ", n);
+ ir_fprintf(env->file, "%zu ", n);
for (i = 0; i < n; i++) {
ir_entity *member = get_compound_ent_value_member(ent, i);
ir_node *irn = get_compound_ent_value(ent, i);
default:
panic("export_type_or_ent_post: Unknown type or entity.");
- break;
}
}
+static void export_ASM(io_env_t *env, 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);
+ int n_input_constraints = get_ASM_n_input_constraints(node);
+ int n_output_constraints = get_ASM_n_output_constraints(node);
+ int n_clobbers = get_ASM_n_clobbers(node);
+ int i;
+
+ write_ident(env, get_ASM_text(node));
+ write_list_begin(env);
+ for (i = 0; i < n_input_constraints; ++i) {
+ const ir_asm_constraint *constraint = &input_constraints[i];
+ write_unsigned(env, constraint->pos);
+ write_ident(env, constraint->constraint);
+ write_mode(env, constraint->mode);
+ }
+ write_list_end(env);
+
+ write_list_begin(env);
+ for (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(env, constraint->mode);
+ }
+ write_list_end(env);
+
+ write_list_begin(env);
+ for (i = 0; i < n_clobbers; ++i) {
+ ident *clobber = clobbers[i];
+ write_ident(env, clobber);
+ }
+ write_list_end(env);
+}
+
/**
* Walker: exports every node.
*/
/* TODO: only symconst_addr_ent implemented yet */
assert(get_SymConst_kind(irn) == symconst_addr_ent);
fprintf(env->file, "%ld ", get_entity_nr(get_SymConst_entity(irn)));
+ write_mode(env, get_irn_mode(irn));
break;
case iro_Proj:
write_mode(env, get_irn_mode(irn));
fprintf(env->file, "%ld ", get_Proj_proj(irn));
break;
+ case iro_ASM:
+ export_ASM(env, irn);
+ break;
#include "gen_irio_export.inl"
default:
panic("no export code for node %+F\n", irn);
static void export_modes(io_env_t *env)
{
- int i, n_modes = get_irp_n_modes();
+ size_t i, n_modes = get_irp_n_modes();
fputs("modes {\n", env->file);
if (mode_is_reference(mode)) {
write_mode(env, get_reference_mode_signed_eq(mode));
write_mode(env, get_reference_mode_unsigned_eq(mode));
+ write_int(env, (mode == mode_P ? 1 : 0));
}
fputc('\n', env->file);
}
void ir_export_file(FILE *file, const char *outputname)
{
io_env_t env;
- int i, n_irgs = get_irp_n_irgs();
+ size_t i, n_irgs = get_irp_n_irgs();
(void) outputname;
env.file = file;
for (i = 0; i < n_irgs; i++) {
ir_graph *irg = get_irp_irg(i);
- ir_type *valuetype = get_irg_value_param_type(irg);
- fprintf(env.file, "\nirg %ld %ld %ld {\n",
+ fprintf(env.file, "\nirg %ld %ld {\n",
get_entity_nr(get_irg_entity(irg)),
- get_type_nr(get_irg_frame_type(irg)),
- valuetype == NULL ? -1 : get_type_nr(valuetype));
+ get_type_nr(get_irg_frame_type(irg)));
env.ignoreblocks = 0;
irg_block_walk_graph(irg, NULL, export_node, &env);
default:
parse_error(env, "Unknown escape sequence '\\%c'\n", env->c);
exit(1);
- break;
}
} else {
obstack_1grow(&env->obst, env->c);
return (unsigned) read_long(env);
}
+static size_t read_size_t(io_env_t *env)
+{
+ /* FIXME */
+ return (size_t) read_unsigned(env);
+}
+
static void expect_list_begin(io_env_t *env)
{
skip_ws(env);
static ir_mode *read_mode(io_env_t *env)
{
- char *str = read_word(env);
- int i, n;
+ char *str = read_string(env);
+ size_t i, n;
n = get_irp_n_modes();
for (i = 0; i < n; i++) {
#define read_variability(env) ((ir_variability) read_enum(env, tt_variability))
#define read_volatility(env) ((ir_volatility) read_enum(env, tt_volatility))
-static ir_cons_flags get_cons_flags(io_env_t *env)
-{
- ir_cons_flags flags = cons_none;
-
- op_pin_state pinstate = read_pin_state(env);
- switch (pinstate) {
- case op_pin_state_floats: flags |= cons_floats; break;
- case op_pin_state_pinned: break;
- default:
- panic("Error in %d: Invalid pinstate: %s", env->line,
- get_op_pin_state_name(pinstate));
- }
-
- if (read_volatility(env) == volatility_is_volatile)
- flags |= cons_volatile;
- if (read_align(env) == align_non_aligned)
- flags |= cons_unaligned;
-
- return flags;
-}
-
static ir_tarval *read_tv(io_env_t *env)
{
ir_mode *tvmode = read_mode(env);
return get_initializer_null();
case IR_INITIALIZER_COMPOUND: {
- unsigned i, n = (unsigned) read_long(env);
+ size_t i, n = read_size_t(env);
ir_initializer_t *ini = create_initializer_compound(n);
for (i = 0; i < n; i++) {
ir_initializer_t *curini = read_initializer(env);
mtp_additional_properties addprops = (mtp_additional_properties) read_long(env);
int nparams = (int) read_long(env);
int nresults = (int) read_long(env);
- int variaindex;
+ int variadicity;
type = new_type_method(nparams, nresults);
for (i = 0; i < nparams; i++) {
- long typenr = read_long(env);
- ir_type *paramtype = get_type(env, typenr);
+ long ptypenr = read_long(env);
+ ir_type *paramtype = get_type(env, ptypenr);
set_method_param_type(type, i, paramtype);
}
for (i = 0; i < nresults; i++) {
- long typenr = read_long(env);
- ir_type *restype = get_type(env, typenr);
+ long ptypenr = read_long(env);
+ ir_type *restype = get_type(env, ptypenr);
set_method_res_type(type, i, restype);
}
- variaindex = (int) read_long(env);
- if (variaindex != -1) {
- set_method_variadicity(type, variadicity_variadic);
- if (variaindex != nparams)
- set_method_first_variadic_param_index(type, variaindex);
- }
+ variadicity = (int) read_long(env);
+ set_method_variadicity(type, variadicity);
set_method_calling_convention(type, callingconv);
set_method_additional_properties(type, addprops);
skip_ws(env);
while (!isdigit(env->c)) {
- char *str = read_word(env);
+ char *vstr = read_word(env);
unsigned v;
skip_ws(env);
- v = symbol(str, tt_visibility);
+ v = symbol(vstr, tt_visibility);
if (v != SYMERROR) {
visibility = (ir_visibility)v;
continue;
}
- v = symbol(str, tt_linkage);
+ v = symbol(vstr, tt_linkage);
if (v != SYMERROR) {
linkage |= (ir_linkage)v;
continue;
}
printf("Parser error, expected visibility or linkage, got '%s'\n",
- str);
+ vstr);
break;
}
return numpreds;
}
+static ir_node *read_ASM(io_env_t *env, int numpreds, ir_node **preds)
+{
+ ir_node *newnode;
+ ir_asm_constraint *input_constraints = NEW_ARR_F(ir_asm_constraint, 0);
+ ir_asm_constraint *output_constraints = NEW_ARR_F(ir_asm_constraint, 0);
+ ident **clobbers = NEW_ARR_F(ident*, 0);
+
+ ident *asm_text = read_ident(env);
+
+ expect_list_begin(env);
+ while (list_has_next(env)) {
+ ir_asm_constraint constraint;
+ constraint.pos = read_unsigned(env);
+ constraint.constraint = read_ident(env);
+ constraint.mode = read_mode(env);
+ ARR_APP1(ir_asm_constraint, input_constraints, constraint);
+ }
+
+ expect_list_begin(env);
+ while (list_has_next(env)) {
+ ir_asm_constraint constraint;
+ constraint.pos = read_unsigned(env);
+ constraint.constraint = read_ident(env);
+ constraint.mode = read_mode(env);
+ ARR_APP1(ir_asm_constraint, output_constraints, constraint);
+ }
+
+ expect_list_begin(env);
+ while (list_has_next(env)) {
+ ident *clobber = read_ident(env);
+ ARR_APP1(ident*, clobbers, clobber);
+ }
+
+ assert(ARR_LEN(input_constraints) == (size_t)numpreds-1);
+
+ newnode = new_r_ASM(preds[0], numpreds-1, preds+1,
+ input_constraints,
+ ARR_LEN(output_constraints),
+ output_constraints,
+ ARR_LEN(clobbers),
+ clobbers,
+ asm_text);
+ DEL_ARR_F(clobbers);
+ DEL_ARR_F(output_constraints);
+ DEL_ARR_F(input_constraints);
+ return newnode;
+}
+
/** Parses an IRG. */
static int parse_graph(io_env_t *env, ir_graph *irg)
{
long entnr = read_long(env);
union symconst_symbol sym;
sym.entity_p = get_entity(env, entnr);
- newnode = new_r_SymConst(irg, mode_P, sym, symconst_addr_ent);
+ ir_mode *mode = read_mode(env);
+ newnode = new_r_SymConst(irg, mode, sym, symconst_addr_ent);
break;
}
break;
}
+ case iro_ASM:
+ newnode = read_ASM(env, numpreds, preds);
+ break;
+
#include "gen_irio_import.inl"
default:
if (mode_is_reference(mode)) {
set_reference_mode_signed_eq(mode, read_mode(env));
set_reference_mode_unsigned_eq(mode, read_mode(env));
+ int is_mode_P = read_int(env);
+ if (is_mode_P) {
+ set_modeP_data(mode);
+ set_modeP_code(mode);
+ }
}
break;
}
firm_verification_t oldver = get_node_verification_mode();
io_env_t ioenv;
io_env_t *env = &ioenv;
- int i, n;
+ size_t i, n;
symtbl_init();
case kw_irg:
{
ir_entity *irgent = get_entity(env, read_long(env));
- long valuetypeid;
ir_graph *irg = new_ir_graph(irgent, 0);
set_irg_frame_type(irg, get_type(env, read_long(env)));
- valuetypeid = read_long(env);
- if (valuetypeid != -1)
- set_method_value_param_type(get_entity_type(irgent),
- get_type(env, valuetypeid));
-
if (!parse_graph(env, irg)) goto end;
break;
}
projects / libfirm / blobdiff