nsz Git - libfirm/blob - ir/ir/irio.c

   1 /*
   2  * Copyright (C) 1995-2009 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Write textual representation of firm to file.
  23  * @author  Moritz Kroll
  24  * @version $Id$
  25  */
  26 #include "config.h"
  27
  28 #include <string.h>
  29 #include <ctype.h>
  30 #include <stdbool.h>
  31 #include <stdarg.h>
  32
  33 #include "irio.h"
  34
  35 #include "irnode_t.h"
  36 #include "irprog.h"
  37 #include "irgraph_t.h"
  38 #include "ircons.h"
  39 #include "irgmod.h"
  40 #include "irflag_t.h"
  41 #include "irgwalk.h"
  42 #include "tv.h"
  43 #include "array.h"
  44 #include "error.h"
  45 #include "typerep.h"
  46 #include "adt/set.h"
  47 #include "adt/obst.h"
  48
  49 #define SYMERROR ((unsigned) ~0)
  50
  51 typedef struct io_env_t
  52 {
  53         int c;                /**< currently read char */
  54         FILE *file;
  55         set *idset;           /**< id_entry set, which maps from file ids to new Firm elements */
  56         int ignoreblocks;
  57         const char *inputname;
  58         int line;
  59         ir_type **fixedtypes;
  60         struct obstack obst;
  61 } io_env_t;
  62
  63 typedef enum typetag_t
  64 {
  65         tt_align,
  66         tt_allocation,
  67         tt_builtin,
  68         tt_cond_jmp_predicate,
  69         tt_initializer,
  70         tt_iro,
  71         tt_keyword,
  72         tt_mode_sort,
  73         tt_mode_arithmetic,
  74         tt_pin_state,
  75         tt_tpo,
  76         tt_type_state,
  77         tt_volatility,
  78         tt_linkage,
  79         tt_segment,
  80         tt_visibility
  81 } typetag_t;
  82
  83 typedef enum keyword_t
  84 {
  85         kw_constirg,
  86         kw_entity,
  87         kw_irg,
  88         kw_mode,
  89         kw_modes,
  90         kw_type,
  91         kw_typegraph,
  92         kw_program,
  93         kw_segment_type
  94 } keyword_t;
  95
  96 typedef struct symbol_t
  97 {
  98         const char *str;      /**< The name of this symbol. */
  99         typetag_t   typetag;  /**< The type tag of this symbol. */
 100         unsigned    code;     /**< The value of this symbol. */
 101 } symbol_t;
 102
 103 typedef struct id_entry
 104 {
 105         long id;
 106         void *elem;
 107 } id_entry;
 108
 109 /** The symbol table, a set of symbol_t elements. */
 110 static set *symtbl;
 111
 112 /**
 113  * Compare two symbol table entries.
 114  */
 115 static int symbol_cmp(const void *elt, const void *key, size_t size)
 116 {
 117         int res;
 118         const symbol_t *entry = (const symbol_t *) elt;
 119         const symbol_t *keyentry = (const symbol_t *) key;
 120         (void) size;
 121         res = entry->typetag - keyentry->typetag;
 122         if (res) return res;
 123         return strcmp(entry->str, keyentry->str);
 124 }
 125
 126 static int id_cmp(const void *elt, const void *key, size_t size)
 127 {
 128         const id_entry *entry = (const id_entry *) elt;
 129         const id_entry *keyentry = (const id_entry *) key;
 130         (void) size;
 131         return entry->id - keyentry->id;
 132 }
 133
 134 static void __attribute__((format(printf, 2, 3)))
 135 parse_error(io_env_t *env, const char *fmt, ...)
 136 {
 137         va_list ap;
 138         int     line = env->line;
 139
 140         /* workaround read_c "feature" that a '\n' triggers the line++
 141          * instead of the character after the '\n' */
 142         if (env->c == '\n') {
 143                 line--;
 144         }
 145
 146         fprintf(stderr, "%s:%d: error ", env->inputname, line);
 147
 148         va_start(ap, fmt);
 149         vfprintf(stderr, fmt, ap);
 150         va_end(ap);
 151 }
 152
 153 /** Initializes the symbol table. May be called more than once without problems. */
 154 static void symtbl_init(void)
 155 {
 156         symbol_t key;
 157
 158         /* Only initialize once */
 159         if (symtbl != NULL)
 160                 return;
 161
 162         symtbl = new_set(symbol_cmp, 256);
 163
 164 #define INSERT(tt, s, cod)                                       \
 165         key.str = (s);                                               \
 166         key.typetag = (tt);                                          \
 167         key.code = (cod);                                            \
 168         set_insert(symtbl, &key, sizeof(key), firm_fnv_hash_str(s) + tt * 17)
 169
 170 #define INSERTENUM(tt, e) INSERT(tt, #e, e)
 171 #define INSERTKEYWORD(k) INSERT(tt_keyword, #k, kw_##k)
 172
 173         INSERT(tt_tpo, "array", tpo_array);
 174         INSERT(tt_tpo, "class", tpo_class);
 175         INSERT(tt_tpo, "method", tpo_method);
 176         INSERT(tt_tpo, "pointer", tpo_pointer);
 177         INSERT(tt_tpo, "primitive", tpo_primitive);
 178         INSERT(tt_tpo, "struct", tpo_struct);
 179         INSERT(tt_tpo, "union", tpo_union);
 180         INSERT(tt_tpo, "Unknown", tpo_unknown);
 181
 182         INSERT(tt_mode_sort, "auxiliary", irms_auxiliary);
 183         INSERT(tt_mode_sort, "control_flow", irms_control_flow);
 184         INSERT(tt_mode_sort, "memory", irms_memory);
 185         INSERT(tt_mode_sort, "internal_boolean", irms_internal_boolean);
 186         INSERT(tt_mode_sort, "reference", irms_reference);
 187         INSERT(tt_mode_sort, "int_number", irms_int_number);
 188         INSERT(tt_mode_sort, "float_number", irms_float_number);
 189
 190         INSERT(tt_segment, "global", IR_SEGMENT_GLOBAL);
 191         INSERT(tt_segment, "thread_local", IR_SEGMENT_THREAD_LOCAL);
 192         INSERT(tt_segment, "constructors", IR_SEGMENT_CONSTRUCTORS);
 193         INSERT(tt_segment, "destructors", IR_SEGMENT_DESTRUCTORS);
 194
 195         INSERT(tt_linkage, "constant", IR_LINKAGE_CONSTANT);
 196         INSERT(tt_linkage, "weak", IR_LINKAGE_WEAK);
 197         INSERT(tt_linkage, "garbage_collect", IR_LINKAGE_GARBAGE_COLLECT);
 198         INSERT(tt_linkage, "merge", IR_LINKAGE_MERGE);
 199         INSERT(tt_linkage, "hidden_user", IR_LINKAGE_HIDDEN_USER);
 200
 201         INSERT(tt_visibility, "local", ir_visibility_local);
 202         INSERT(tt_visibility, "external", ir_visibility_external);
 203         INSERT(tt_visibility, "default", ir_visibility_default);
 204         INSERT(tt_visibility, "private", ir_visibility_private);
 205
 206         INSERTKEYWORD(constirg);
 207         INSERTKEYWORD(entity);
 208         INSERTKEYWORD(irg);
 209         INSERTKEYWORD(mode);
 210         INSERTKEYWORD(modes);
 211         INSERTKEYWORD(type);
 212         INSERTKEYWORD(typegraph);
 213         INSERTKEYWORD(program);
 214         INSERTKEYWORD(segment_type);
 215
 216 #include "gen_irio_lex.inl"
 217
 218         INSERTENUM(tt_align, align_non_aligned);
 219         INSERTENUM(tt_align, align_is_aligned);
 220
 221         INSERTENUM(tt_builtin, ir_bk_trap);
 222         INSERTENUM(tt_builtin, ir_bk_debugbreak);
 223         INSERTENUM(tt_builtin, ir_bk_return_address);
 224         INSERTENUM(tt_builtin, ir_bk_frame_address);
 225         INSERTENUM(tt_builtin, ir_bk_prefetch);
 226         INSERTENUM(tt_builtin, ir_bk_ffs);
 227         INSERTENUM(tt_builtin, ir_bk_clz);
 228         INSERTENUM(tt_builtin, ir_bk_ctz);
 229         INSERTENUM(tt_builtin, ir_bk_popcount);
 230         INSERTENUM(tt_builtin, ir_bk_parity);
 231         INSERTENUM(tt_builtin, ir_bk_bswap);
 232         INSERTENUM(tt_builtin, ir_bk_inport);
 233         INSERTENUM(tt_builtin, ir_bk_outport);
 234         INSERTENUM(tt_builtin, ir_bk_inner_trampoline);
 235
 236         INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_NONE);
 237         INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_TRUE);
 238         INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_FALSE);
 239
 240         INSERTENUM(tt_initializer, IR_INITIALIZER_CONST);
 241         INSERTENUM(tt_initializer, IR_INITIALIZER_TARVAL);
 242         INSERTENUM(tt_initializer, IR_INITIALIZER_NULL);
 243         INSERTENUM(tt_initializer, IR_INITIALIZER_COMPOUND);
 244
 245         INSERTENUM(tt_mode_arithmetic, irma_uninitialized);
 246         INSERTENUM(tt_mode_arithmetic, irma_none);
 247         INSERTENUM(tt_mode_arithmetic, irma_twos_complement);
 248         INSERTENUM(tt_mode_arithmetic, irma_ones_complement);
 249         INSERTENUM(tt_mode_arithmetic, irma_int_BCD);
 250         INSERTENUM(tt_mode_arithmetic, irma_ieee754);
 251         INSERTENUM(tt_mode_arithmetic, irma_float_BCD);
 252
 253         INSERTENUM(tt_pin_state, op_pin_state_floats);
 254         INSERTENUM(tt_pin_state, op_pin_state_pinned);
 255         INSERTENUM(tt_pin_state, op_pin_state_exc_pinned);
 256         INSERTENUM(tt_pin_state, op_pin_state_mem_pinned);
 257
 258         INSERTENUM(tt_type_state, layout_undefined);
 259         INSERTENUM(tt_type_state, layout_fixed);
 260
 261         INSERTENUM(tt_volatility, volatility_non_volatile);
 262         INSERTENUM(tt_volatility, volatility_is_volatile);
 263
 264 #undef INSERTKEYWORD
 265 #undef INSERTENUM
 266 #undef INSERT
 267 }
 268
 269 static const char *get_segment_name(ir_segment_t segment)
 270 {
 271         switch (segment) {
 272         case IR_SEGMENT_GLOBAL:       return "global";
 273         case IR_SEGMENT_THREAD_LOCAL: return "thread_local";
 274         case IR_SEGMENT_CONSTRUCTORS: return "constructors";
 275         case IR_SEGMENT_DESTRUCTORS:  return "destructors";
 276         }
 277         return "INVALID_SEGMENT";
 278 }
 279
 280 static const char *get_visibility_name(ir_visibility visibility)
 281 {
 282         switch (visibility) {
 283         case ir_visibility_local:    return "local";
 284         case ir_visibility_external: return "external";
 285         case ir_visibility_default:  return "default";
 286         case ir_visibility_private:  return "private";
 287         }
 288         return "INVALID_VISIBILITY";
 289 }
 290
 291 /** Returns the according symbol value for the given string and tag, or SYMERROR if none was found. */
 292 static unsigned symbol(const char *str, typetag_t typetag)
 293 {
 294         symbol_t key, *entry;
 295
 296         key.str = str;
 297         key.typetag = typetag;
 298
 299         entry = set_find(symtbl, &key, sizeof(key), firm_fnv_hash_str(str) + typetag * 17);
 300         return entry ? entry->code : SYMERROR;
 301 }
 302
 303 static void *get_id(io_env_t *env, long id)
 304 {
 305         id_entry key, *entry;
 306         key.id = id;
 307
 308         entry = set_find(env->idset, &key, sizeof(key), (unsigned) id);
 309         return entry ? entry->elem : NULL;
 310 }
 311
 312 static void set_id(io_env_t *env, long id, void *elem)
 313 {
 314         id_entry key;
 315         key.id = id;
 316         key.elem = elem;
 317         set_insert(env->idset, &key, sizeof(key), (unsigned) id);
 318 }
 319
 320 static void write_mode(io_env_t *env, ir_mode *mode)
 321 {
 322         fputs(get_mode_name(mode), env->file);
 323         fputc(' ', env->file);
 324 }
 325
 326 static void write_tarval(io_env_t *env, tarval *tv)
 327 {
 328         char buf[1024];
 329         write_mode(env, get_tarval_mode(tv));
 330         tarval_snprintf(buf, sizeof(buf), tv);
 331         fputs(buf, env->file);
 332         fputc(' ', env->file);
 333 }
 334
 335 static void write_align(io_env_t *env, ir_node *irn)
 336 {
 337         ir_align align;
 338
 339         if (is_Load(irn))
 340                 align = get_Load_align(irn);
 341         else if (is_Store(irn))
 342                 align = get_Store_align(irn);
 343         else
 344                 panic("Invalid optype for write_align");
 345
 346         fputs(get_align_name(align), env->file);
 347         fputc(' ', env->file);
 348 }
 349
 350 static void write_builtin_kind(io_env_t *env, ir_node *irn)
 351 {
 352         fputs(get_builtin_kind_name(get_Builtin_kind(irn)), env->file);
 353         fputc(' ', env->file);
 354 }
 355
 356 static void write_cond_jmp_predicate(io_env_t *env, ir_node *irn)
 357 {
 358         fputs(get_cond_jmp_predicate_name(get_Cond_jmp_pred(irn)), env->file);
 359         fputc(' ', env->file);
 360 }
 361
 362 static void write_initializer(io_env_t *env, ir_initializer_t *ini)
 363 {
 364         FILE *f = env->file;
 365         ir_initializer_kind_t ini_kind = get_initializer_kind(ini);
 366
 367         fputs(get_initializer_kind_name(ini_kind), f);
 368         fputc(' ', f);
 369
 370         switch (ini_kind) {
 371         case IR_INITIALIZER_CONST:
 372                 fprintf(f, "%ld ", get_irn_node_nr(get_initializer_const_value(ini)));
 373                 break;
 374
 375         case IR_INITIALIZER_TARVAL:
 376                 write_tarval(env, get_initializer_tarval_value(ini));
 377                 break;
 378
 379         case IR_INITIALIZER_NULL:
 380                 break;
 381
 382         case IR_INITIALIZER_COMPOUND: {
 383                 unsigned i, n = get_initializer_compound_n_entries(ini);
 384                 fprintf(f, "%d ", n);
 385                 for (i = 0; i < n; i++)
 386                         write_initializer(env, get_initializer_compound_value(ini, i));
 387                 break;
 388         }
 389
 390         default:
 391                 panic("Unknown initializer kind");
 392         }
 393 }
 394
 395 static void write_pin_state(io_env_t *env, ir_node *irn)
 396 {
 397         fputs(get_op_pin_state_name(get_irn_pinned(irn)), env->file);
 398         fputc(' ', env->file);
 399 }
 400
 401 static void write_volatility(io_env_t *env, ir_node *irn)
 402 {
 403         ir_volatility vol;
 404
 405         if (is_Load(irn))
 406                 vol = get_Load_volatility(irn);
 407         else if (is_Store(irn))
 408                 vol = get_Store_volatility(irn);
 409         else
 410                 panic("Invalid optype for write_volatility");
 411
 412         fputs(get_volatility_name(vol), env->file);
 413         fputc(' ', env->file);
 414 }
 415
 416 static void export_type_common(io_env_t *env, ir_type *tp)
 417 {
 418         fprintf(env->file, "\ttype %ld %s %u %u %s %d ",
 419                 get_type_nr(tp),
 420                 get_type_tpop_name(tp),
 421                 get_type_size_bytes(tp),
 422                 get_type_alignment_bytes(tp),
 423                 get_type_state_name(get_type_state(tp)),
 424                 tp->flags);
 425 }
 426
 427 static void export_compound_name(FILE *f, const ir_type *tp)
 428 {
 429         ident *name = get_compound_ident(tp);
 430         if (name == NULL) {
 431                 fputs("NULL ", f);
 432         } else {
 433                 fprintf(f, "\"%s\" ", get_id_str(name));
 434         }
 435 }
 436
 437 static void export_type_pre(io_env_t *env, ir_type *tp)
 438 {
 439         FILE *f = env->file;
 440
 441         /* skip types to be handled by post walker */
 442         switch (get_type_tpop_code(tp)) {
 443         case tpo_array:
 444         case tpo_method:
 445         case tpo_pointer:
 446                 return;
 447         default:
 448                 break;
 449         }
 450
 451         export_type_common(env, tp);
 452
 453         switch (get_type_tpop_code(tp)) {
 454         case tpo_uninitialized:
 455                 panic("invalid type found");
 456
 457         case tpo_class:
 458                 export_compound_name(f, tp);
 459                 break;
 460
 461         case tpo_primitive:
 462                 write_mode(env, get_type_mode(tp));
 463                 break;
 464
 465         case tpo_union:
 466         case tpo_struct:
 467         case tpo_enumeration:
 468                 export_compound_name(f, tp);
 469                 break;
 470
 471         case tpo_array:
 472         case tpo_method:
 473         case tpo_pointer:
 474         case tpo_code:
 475         case tpo_none:
 476         case tpo_unknown:
 477                 break;
 478         }
 479         fputc('\n', f);
 480 }
 481
 482 static void export_type_post(io_env_t *env, ir_type *tp)
 483 {
 484         FILE *f = env->file;
 485         int i;
 486
 487         /* skip types already handled by pre walker */
 488         switch (get_type_tpop_code(tp)) {
 489         case tpo_class:
 490         case tpo_primitive:
 491         case tpo_struct:
 492         case tpo_union:
 493         case tpo_unknown:
 494         case tpo_uninitialized:
 495         case tpo_code:
 496         case tpo_none:
 497                 return;
 498         case tpo_array:
 499         case tpo_method:
 500         case tpo_pointer:
 501         case tpo_enumeration:
 502                 break;
 503         }
 504
 505         export_type_common(env, tp);
 506
 507         switch (get_type_tpop_code(tp)) {
 508         case tpo_array: {
 509                 int n = get_array_n_dimensions(tp);
 510                 fprintf(f, "%d %ld ", n, get_type_nr(get_array_element_type(tp)));
 511                 for (i = 0; i < n; i++) {
 512                         ir_node *lower = get_array_lower_bound(tp, i);
 513                         ir_node *upper = get_array_upper_bound(tp, i);
 514
 515                         if (is_Const(lower))
 516                                 fprintf(f, "%ld ", get_tarval_long(get_Const_tarval(lower)));
 517                         else
 518                                 panic("Lower array bound is not constant");
 519
 520                         if (is_Const(upper))
 521                                 fprintf(f, "%ld ", get_tarval_long(get_Const_tarval(upper)));
 522                         else if (is_Unknown(upper))
 523                                 fputs("unknown ", f);
 524                         else
 525                                 panic("Upper array bound is not constant");
 526                 }
 527                 break;
 528         }
 529
 530         case tpo_method: {
 531                 int nparams  = get_method_n_params(tp);
 532                 int nresults = get_method_n_ress(tp);
 533                 fprintf(f, "%u %u %d %d ", get_method_calling_convention(tp),
 534                         get_method_additional_properties(tp), nparams, nresults);
 535                 for (i = 0; i < nparams; i++)
 536                         fprintf(f, "%ld ", get_type_nr(get_method_param_type(tp, i)));
 537                 for (i = 0; i < nresults; i++)
 538                         fprintf(f, "%ld ", get_type_nr(get_method_res_type(tp, i)));
 539                 fprintf(f, "%d ", get_method_first_variadic_param_index(tp));
 540                 break;
 541         }
 542
 543         case tpo_pointer:
 544                 write_mode(env, get_type_mode(tp));
 545                 fprintf(f, "%ld ", get_type_nr(get_pointer_points_to_type(tp)));
 546                 break;
 547
 548         case tpo_enumeration:
 549                 fprintf(stderr, "Enumeration type not handled yet by exporter\n");
 550                 break;
 551
 552         default:
 553                 printf("export_type: Unknown type code \"%s\".\n",
 554                        get_type_tpop_name(tp));
 555                 break;
 556         }
 557         fputc('\n', f);
 558 }
 559
 560 static void export_entity(io_env_t *env, ir_entity *ent)
 561 {
 562         FILE          *file       = env->file;
 563         ir_type       *owner      = get_entity_owner(ent);
 564         ir_visibility  visibility = get_entity_visibility(ent);
 565         ir_linkage     linkage    = get_entity_linkage(ent);
 566
 567         /* we don't dump array_element_ent entities. They're a strange concept
 568          * and lead to cycles in type_graph.
 569          */
 570         if (is_Array_type(owner))
 571                 return;
 572
 573         fprintf(env->file, "\tentity %ld \"%s\" ",
 574                 get_entity_nr(ent), get_entity_name(ent));
 575         if (ent->ld_name != NULL) {
 576                 fprintf(env->file, "\"%s\" ", get_entity_ld_name(ent));
 577         } else {
 578                 fprintf(env->file, "NULL ");
 579         }
 580
 581         /* visibility + linkage */
 582         if (visibility != ir_visibility_default) {
 583                 fprintf(file, "%s ", get_visibility_name(visibility));
 584         }
 585         if (linkage & IR_LINKAGE_CONSTANT)
 586                 fputs("constant ", file);
 587         if (linkage & IR_LINKAGE_WEAK)
 588                 fputs("weak ", file);
 589         if (linkage & IR_LINKAGE_GARBAGE_COLLECT)
 590                 fputs("garbage_collect ", file);
 591         if (linkage & IR_LINKAGE_MERGE)
 592                 fputs("merge ", file);
 593         if (linkage & IR_LINKAGE_HIDDEN_USER)
 594                 fputs("hidden_user ", file);
 595
 596         fprintf(file, "%ld %ld %d %u %d %s ",
 597                         get_type_nr(get_entity_type(ent)),
 598                         get_type_nr(owner),
 599                         get_entity_offset(ent),
 600                         (unsigned) get_entity_offset_bits_remainder(ent),
 601                         is_entity_compiler_generated(ent),
 602                         get_volatility_name(get_entity_volatility(ent)));
 603
 604         if (ent->initializer != NULL) {
 605                 fputs("initializer ", env->file);
 606                 write_initializer(env, get_entity_initializer(ent));
 607         } else if (entity_has_compound_ent_values(ent)) {
 608                 int i, n = get_compound_ent_n_values(ent);
 609                 fputs("compoundgraph ", env->file);
 610                 fprintf(env->file, "%d ", n);
 611                 for (i = 0; i < n; i++) {
 612                         ir_entity *member = get_compound_ent_value_member(ent, i);
 613                         ir_node   *irn    = get_compound_ent_value(ent, i);
 614                         fprintf(env->file, "%ld %ld ", get_entity_nr(member), get_irn_node_nr(irn));
 615                 }
 616         } else {
 617                 fputs("none", env->file);
 618         }
 619
 620         fputc('\n', env->file);
 621 }
 622
 623 static void export_type_or_ent_pre(type_or_ent tore, void *ctx)
 624 {
 625         io_env_t *env = (io_env_t *) ctx;
 626         if (get_kind(tore.typ) == k_type)
 627                 export_type_pre(env, tore.typ);
 628 }
 629
 630 static void export_type_or_ent_post(type_or_ent tore, void *ctx)
 631 {
 632         io_env_t *env = (io_env_t *) ctx;
 633
 634         switch (get_kind(tore.ent)) {
 635         case k_entity:
 636                 export_entity(env, tore.ent);
 637                 break;
 638
 639         case k_type:
 640                 export_type_post(env, tore.typ);
 641                 break;
 642
 643         default:
 644                 panic("export_type_or_ent_post: Unknown type or entity.");
 645                 break;
 646         }
 647 }
 648
 649 /**
 650  * Walker: exports every node.
 651  */
 652 static void export_node(ir_node *irn, void *ctx)
 653 {
 654         io_env_t *env = (io_env_t *) ctx;
 655         int i, n;
 656         unsigned opcode = get_irn_opcode(irn);
 657
 658         if (env->ignoreblocks && opcode == iro_Block)
 659                 return;
 660
 661         fprintf(env->file, "\t%s %ld [ ", get_irn_opname(irn), get_irn_node_nr(irn));
 662
 663         n = get_irn_arity(irn);
 664         for (i = -1; i < n; i++) {
 665                 ir_node *pred = get_irn_n(irn, i);
 666                 if (pred == NULL) {
 667                         /* Anchor node may have NULL predecessors */
 668                         assert(is_Anchor(irn));
 669                         fputs("-1 ", env->file);
 670                 } else {
 671                         fprintf(env->file, "%ld ", get_irn_node_nr(pred));
 672                 }
 673         }
 674
 675         fprintf(env->file, "] { ");
 676
 677         switch (opcode) {
 678         #include "gen_irio_export.inl"
 679         }
 680         fputs("}\n", env->file);
 681 }
 682
 683 static const char *get_mode_sort_name(ir_mode_sort sort)
 684 {
 685         switch (sort) {
 686         case irms_auxiliary:        return "auxiliary";
 687         case irms_control_flow:     return "control_flow";
 688         case irms_memory:           return "memory";
 689         case irms_internal_boolean: return "internal_boolean";
 690         case irms_reference:        return "reference";
 691         case irms_int_number:       return "int_number";
 692         case irms_float_number:     return "float_number";
 693         }
 694         panic("invalid mode sort found");
 695 }
 696
 697 static void export_modes(io_env_t *env)
 698 {
 699         int i, n_modes = get_irp_n_modes();
 700
 701         fputs("modes {\n", env->file);
 702
 703         for (i = 0; i < n_modes; i++) {
 704                 ir_mode *mode = get_irp_mode(i);
 705                 switch (get_mode_sort(mode)) {
 706                 case irms_auxiliary:
 707                 case irms_control_flow:
 708                 case irms_memory:
 709                 case irms_internal_boolean:
 710                         /* skip "internal" modes, which may not be user defined */
 711                         continue;
 712                 default:
 713                         break;
 714                 }
 715
 716                 fprintf(env->file, "\tmode \"%s\" %s %d %d %s %d %d ",
 717                         get_mode_name(mode), get_mode_sort_name(get_mode_sort(mode)),
 718                         get_mode_size_bits(mode), get_mode_sign(mode),
 719                         get_mode_arithmetic_name(get_mode_arithmetic(mode)),
 720                         get_mode_modulo_shift(mode),
 721                         get_mode_n_vector_elems(mode));
 722                 if (mode_is_reference(mode)) {
 723                         write_mode(env, get_reference_mode_signed_eq(mode));
 724                         write_mode(env, get_reference_mode_unsigned_eq(mode));
 725                 }
 726                 fputc('\n', env->file);
 727         }
 728
 729         fputs("}\n", env->file);
 730 }
 731
 732 static void export_program(io_env_t *env)
 733 {
 734         FILE         *f = env->file;
 735         ir_segment_t  s;
 736
 737         fputs("\nprogram {\n", f);
 738         if (irp_prog_name_is_set()) {
 739                 fprintf(f, "\tname \"%s\"\n", get_irp_name());
 740         }
 741         /* We need numbers for irgs... */
 742 #if 0
 743         if (get_irp_main_irg() != NULL) {
 744                 fprintf(f, "\tmain_irg %d\n", get_irp_main_irg
 745 #endif
 746
 747         for (s = 0; s <= IR_SEGMENT_LAST; ++s) {
 748                 ir_type *segment_type = get_segment_type(s);
 749                 fprintf(f, "\tsegment_type %s", get_segment_name(s));
 750                 if (segment_type == NULL) {
 751                         fputs(" NULL\n", f);
 752                 } else {
 753                         fprintf(f, " %ld\n", get_type_nr(segment_type));
 754                 }
 755         }
 756         fputs("}\n", f);
 757 }
 758
 759 void ir_export(const char *filename)
 760 {
 761         FILE *file = fopen(filename, "wt");
 762         if (file == NULL) {
 763                 perror(filename);
 764                 return;
 765         }
 766
 767         ir_export_file(file, filename);
 768         fclose(file);
 769 }
 770
 771 /* Exports the whole irp to the given file in a textual form. */
 772 void ir_export_file(FILE *file, const char *outputname)
 773 {
 774         io_env_t env;
 775         int i, n_irgs = get_irp_n_irgs();
 776
 777         (void) outputname;
 778         env.file = file;
 779
 780         export_modes(&env);
 781
 782         fputs("\ntypegraph {\n", env.file);
 783         type_walk_prog(export_type_or_ent_pre, export_type_or_ent_post, &env);
 784         fputs("}\n", env.file);
 785
 786         for (i = 0; i < n_irgs; i++) {
 787                 ir_graph *irg       = get_irp_irg(i);
 788                 ir_type  *valuetype = get_irg_value_param_type(irg);
 789
 790                 fprintf(env.file, "\nirg %ld %ld %ld {\n",
 791                         get_entity_nr(get_irg_entity(irg)),
 792                         get_type_nr(get_irg_frame_type(irg)),
 793                         valuetype == NULL ? -1 : get_type_nr(valuetype));
 794
 795                 env.ignoreblocks = 0;
 796                 irg_block_walk_graph(irg, NULL, export_node, &env);
 797
 798                 env.ignoreblocks = 1;
 799                 irg_walk_anchors(irg, NULL, export_node, &env);
 800
 801                 fputs("}\n", env.file);
 802         }
 803
 804         fprintf(env.file, "\nconstirg %ld {\n", get_irn_node_nr(get_const_code_irg()->current_block));
 805
 806         walk_const_code(NULL, export_node, &env);
 807         fputs("}\n", env.file);
 808
 809         export_program(&env);
 810 }
 811
 812 /* Exports the given irg to the given file. */
 813 void ir_export_irg(ir_graph *irg, FILE *file, const char *outputname)
 814 {
 815         io_env_t env;
 816
 817         (void) outputname;
 818         env.file = file;
 819
 820         export_modes(&env);
 821
 822         fputs("typegraph {\n", env.file);
 823
 824         type_walk_irg(irg, export_type_or_ent_pre, export_type_or_ent_post, &env);
 825
 826         fprintf(env.file, "}\n\nirg %ld {\n", get_entity_nr(get_irg_entity(irg)));
 827
 828         env.ignoreblocks = 0;
 829         irg_block_walk_graph(irg, NULL, export_node, &env);
 830
 831         env.ignoreblocks = 1;
 832         irg_walk_anchors(irg, NULL, export_node, &env);
 833
 834         /* TODO: Only output needed constants */
 835         fprintf(env.file, "}\n\nconstirg %ld {\n", get_irn_node_nr(get_const_code_irg()->current_block));
 836         walk_const_code(NULL, export_node, &env);
 837         fputs("}\n", env.file);
 838 }
 839
 840 static void read_c(io_env_t *env)
 841 {
 842         int c = fgetc(env->file);
 843         env->c = c;
 844         if (c == '\n')
 845                 env->line++;
 846 }
 847
 848 /** Returns the first non-whitespace character or EOF. **/
 849 static void skip_ws(io_env_t *env)
 850 {
 851         while (true) {
 852                 switch (env->c) {
 853                 case ' ':
 854                 case '\t':
 855                 case '\n':
 856                 case '\r':
 857                         read_c(env);
 858                         continue;
 859
 860                 default:
 861                         return;
 862                 }
 863         }
 864 }
 865
 866 static void skip_to(io_env_t *env, char to_ch)
 867 {
 868         while (env->c != to_ch && env->c != EOF) {
 869                 read_c(env);
 870         }
 871 }
 872
 873 static int expect_char(io_env_t *env, char ch)
 874 {
 875         skip_ws(env);
 876         if (env->c != ch) {
 877                 parse_error(env, "Unexpected char '%c', expected '%c'\n",
 878                             env->c, ch);
 879                 return 0;
 880         }
 881         read_c(env);
 882         return 1;
 883 }
 884
 885 #define EXPECT(c) if (expect_char(env, (c))) {} else return 0
 886
 887 static char *read_word(io_env_t *env)
 888 {
 889         skip_ws(env);
 890
 891         assert(obstack_object_size(&env->obst) == 0);
 892         while (true) {
 893                 int c = env->c;
 894                 switch (c) {
 895                 case EOF:
 896                 case ' ':
 897                 case '\t':
 898                 case '\n':
 899                 case '\r':
 900                         goto endofword;
 901
 902                 default:
 903                         obstack_1grow(&env->obst, c);
 904                         break;
 905                 }
 906                 read_c(env);
 907         }
 908
 909 endofword:
 910         obstack_1grow(&env->obst, '\0');
 911         return obstack_finish(&env->obst);
 912 }
 913
 914 static char *read_quoted_string(io_env_t *env)
 915 {
 916         skip_ws(env);
 917         if (env->c != '\"') {
 918                 parse_error(env, "Expected '\"', found '%c'\n", env->c);
 919                 exit(1);
 920         }
 921         read_c(env);
 922
 923         assert(obstack_object_size(&env->obst) == 0);
 924         while (true) {
 925                 int ch = env->c;
 926                 if (ch == EOF) {
 927                         parse_error(env, "Unexpected end of quoted string!\n");
 928                         exit(1);
 929                 }
 930                 if (ch == '\"') {
 931                         read_c(env);
 932                         break;
 933                 }
 934                 obstack_1grow(&env->obst, ch);
 935                 read_c(env);
 936         }
 937         obstack_1grow(&env->obst, '\0');
 938
 939         return obstack_finish(&env->obst);
 940 }
 941
 942 static ident *read_ident(io_env_t *env)
 943 {
 944         char  *str = read_quoted_string(env);
 945         ident *res = new_id_from_str(str);
 946         obstack_free(&env->obst, str);
 947
 948         return res;
 949 }
 950
 951 /*
 952  * reads a "quoted string" or alternatively the token NULL
 953  */
 954 static char *read_quoted_string_null(io_env_t *env)
 955 {
 956         skip_ws(env);
 957         if (env->c == 'N') {
 958                 char *str = read_word(env);
 959                 if (strcmp(str, "NULL") == 0) {
 960                         obstack_free(&env->obst, str);
 961                         return NULL;
 962                 }
 963         } else if (env->c == '"') {
 964                 return read_quoted_string(env);
 965         }
 966
 967         parse_error(env, "Expected \"string\" or NULL\n");
 968         exit(1);
 969 }
 970
 971 static ident *read_ident_null(io_env_t *env)
 972 {
 973         ident *res;
 974         char  *str = read_quoted_string_null(env);
 975         if (str == NULL)
 976                 return NULL;
 977
 978         res = new_id_from_str(str);
 979         obstack_free(&env->obst, str);
 980         return res;
 981 }
 982
 983 static long read_long(io_env_t *env)
 984 {
 985         long  result;
 986         char *str;
 987
 988         skip_ws(env);
 989         if (!isdigit(env->c) && env->c != '-') {
 990                 parse_error(env, "Expected number, got '%c'\n", env->c);
 991                 exit(1);
 992         }
 993
 994         assert(obstack_object_size(&env->obst) == 0);
 995         do {
 996                 obstack_1grow(&env->obst, env->c);
 997                 read_c(env);
 998         } while(isdigit(env->c));
 999         obstack_1grow(&env->obst, 0);
1000
1001         str = obstack_finish(&env->obst);
1002         result = atol(str);
1003         obstack_free(&env->obst, str);
1004
1005         return result;
1006 }
1007
1008 static ir_node *get_node_or_null(io_env_t *env, long nodenr)
1009 {
1010         ir_node *node = (ir_node *) get_id(env, nodenr);
1011         if (node && node->kind != k_ir_node) {
1012                 panic("Irn ID %ld collides with something else in line %d\n",
1013                       nodenr, env->line);
1014         }
1015         return node;
1016 }
1017
1018 static ir_node *get_node(io_env_t *env, long nodenr)
1019 {
1020         ir_node *node = get_node_or_null(env, nodenr);
1021         if (!node)
1022                 panic("Unknown node: %ld in line %d\n", nodenr, env->line);
1023
1024         return node;
1025 }
1026
1027 static ir_node *get_node_or_dummy(io_env_t *env, long nodenr)
1028 {
1029         ir_node *node = get_node_or_null(env, nodenr);
1030         if (node == NULL) {
1031                 node = new_Dummy(mode_X);
1032                 set_id(env, nodenr, node);
1033         }
1034         return node;
1035 }
1036
1037 static ir_type *get_type(io_env_t *env, long typenr)
1038 {
1039         ir_type *type = (ir_type *) get_id(env, typenr);
1040         if (type == NULL)
1041                 panic("unknown type: %ld in line %d\n", typenr, env->line);
1042         else if (type->kind != k_type)
1043                 panic("type ID %ld collides with something else in line %d\n",
1044                       typenr, env->line);
1045         return type;
1046 }
1047
1048 static ir_type *read_type(io_env_t *env)
1049 {
1050         return get_type(env, read_long(env));
1051 }
1052
1053 static ir_entity *get_entity(io_env_t *env, long entnr)
1054 {
1055         ir_entity *entity = (ir_entity *) get_id(env, entnr);
1056         if (entity == NULL) {
1057                 parse_error(env, "unknown entity: %ld\n", entnr);
1058                 exit(1);
1059         } else if (entity->kind != k_entity) {
1060                 panic("Entity ID %ld collides with something else in line %d\n",
1061                       entnr, env->line);
1062         }
1063
1064         return entity;
1065 }
1066
1067 static ir_entity *read_entity(io_env_t *env)
1068 {
1069         return get_entity(env, read_long(env));
1070 }
1071
1072 static ir_mode *read_mode(io_env_t *env)
1073 {
1074         char *str = read_word(env);
1075         int i, n;
1076
1077         n = get_irp_n_modes();
1078         for (i = 0; i < n; i++) {
1079                 ir_mode *mode = get_irp_mode(i);
1080                 if (strcmp(str, get_mode_name(mode)) == 0) {
1081                         obstack_free(&env->obst, str);
1082                         return mode;
1083                 }
1084         }
1085
1086         parse_error(env, "unknown mode \"%s\"\n", str);
1087         exit(1);
1088 }
1089
1090 static const char *get_typetag_name(typetag_t typetag)
1091 {
1092         switch (typetag) {
1093         case tt_align:              return "align";
1094         case tt_allocation:         return "allocation";
1095         case tt_builtin:            return "builtin kind";
1096         case tt_cond_jmp_predicate: return "cond_jmp_predicate";
1097         case tt_initializer:        return "initializer kind";
1098         case tt_iro:                return "opcode";
1099         case tt_keyword:            return "keyword";
1100         case tt_linkage:            return "linkage";
1101         case tt_mode_arithmetic:    return "mode_arithmetic";
1102         case tt_mode_sort:          return "mode_sort";
1103         case tt_pin_state:          return "pin state";
1104         case tt_segment:            return "segment";
1105         case tt_tpo:                return "type";
1106         case tt_type_state:         return "type state";
1107         case tt_volatility:         return "volatility";
1108         case tt_visibility:         return "visibility";
1109         }
1110         return "<UNKNOWN>";
1111 }
1112
1113 /**
1114  * Read and decode an enum constant.
1115  */
1116 static unsigned read_enum(io_env_t *env, typetag_t typetag)
1117 {
1118         char     *str  = read_word(env);
1119         unsigned  code = symbol(str, typetag);
1120
1121         if (code != SYMERROR) {
1122                 obstack_free(&env->obst, str);
1123                 return code;
1124         }
1125
1126         parse_error(env, "invalid %s: \"%s\"\n", get_typetag_name(typetag), str);
1127         return 0;
1128 }
1129
1130 #define read_align(env)              ((ir_align)              read_enum(env, tt_align))
1131 #define read_allocation(env)         ((ir_allocation)         read_enum(env, tt_allocation))
1132 #define read_builtin_kind(env)       ((ir_builtin_kind)       read_enum(env, tt_builtin))
1133 #define read_cond_jmp_predicate(env) ((cond_jmp_predicate)    read_enum(env, tt_cond_jmp_predicate))
1134 #define read_initializer_kind(env)   ((ir_initializer_kind_t) read_enum(env, tt_initializer))
1135 #define read_mode_arithmetic(env)    ((ir_mode_arithmetic)    read_enum(env, tt_mode_arithmetic))
1136 #define read_peculiarity(env)        ((ir_peculiarity)        read_enum(env, tt_peculiarity))
1137 #define read_pin_state(env)          ((op_pin_state)          read_enum(env, tt_pin_state))
1138 #define read_type_state(env)         ((ir_type_state)         read_enum(env, tt_type_state))
1139 #define read_variability(env)        ((ir_variability)        read_enum(env, tt_variability))
1140 #define read_volatility(env)         ((ir_volatility)         read_enum(env, tt_volatility))
1141
1142 static ir_cons_flags get_cons_flags(io_env_t *env)
1143 {
1144         ir_cons_flags flags = cons_none;
1145
1146         op_pin_state pinstate = read_pin_state(env);
1147         switch (pinstate) {
1148         case op_pin_state_floats: flags |= cons_floats; break;
1149         case op_pin_state_pinned: break;
1150         default:
1151                 panic("Error in %d: Invalid pinstate: %s", env->line,
1152                       get_op_pin_state_name(pinstate));
1153         }
1154
1155         if (read_volatility(env) == volatility_is_volatile)
1156                 flags |= cons_volatile;
1157         if (read_align(env) == align_non_aligned)
1158                 flags |= cons_unaligned;
1159
1160         return flags;
1161 }
1162
1163 static tarval *read_tv(io_env_t *env)
1164 {
1165         ir_mode *tvmode = read_mode(env);
1166         char    *str    = read_word(env);
1167         tarval  *tv     = new_tarval_from_str(str, strlen(str), tvmode);
1168         obstack_free(&env->obst, str);
1169
1170         return tv;
1171 }
1172
1173 static ir_initializer_t *read_initializer(io_env_t *env)
1174 {
1175         ir_initializer_kind_t ini_kind = read_initializer_kind(env);
1176
1177         switch (ini_kind) {
1178         case IR_INITIALIZER_CONST: {
1179                 ir_node *irn = get_node_or_dummy(env, read_long(env));
1180                 return create_initializer_const(irn);
1181         }
1182
1183         case IR_INITIALIZER_TARVAL:
1184                 return create_initializer_tarval(read_tv(env));
1185
1186         case IR_INITIALIZER_NULL:
1187                 return get_initializer_null();
1188
1189         case IR_INITIALIZER_COMPOUND: {
1190                 unsigned i, n = (unsigned) read_long(env);
1191                 ir_initializer_t *ini = create_initializer_compound(n);
1192                 for (i = 0; i < n; i++) {
1193                         ir_initializer_t *curini = read_initializer(env);
1194                         set_initializer_compound_value(ini, i, curini);
1195                 }
1196                 return ini;
1197         }
1198
1199         default:
1200                 panic("Unknown initializer kind");
1201         }
1202 }
1203
1204
1205 /** Reads a type description and remembers it by its id. */
1206 static void import_type(io_env_t *env)
1207 {
1208         int            i;
1209         ir_type       *type;
1210         long           typenr = read_long(env);
1211         tp_opcode      tpop   = (tp_opcode) read_enum(env, tt_tpo);
1212         unsigned       size   = (unsigned) read_long(env);
1213         unsigned       align  = (unsigned) read_long(env);
1214         ir_type_state  state  = read_type_state(env);
1215         unsigned       flags  = (unsigned) read_long(env);
1216
1217         switch (tpop) {
1218         case tpo_array: {
1219                 int ndims = (int) read_long(env);
1220                 long elemtypenr = read_long(env);
1221                 ir_type *elemtype = get_type(env, elemtypenr);
1222
1223                 type = new_type_array(ndims, elemtype);
1224                 for (i = 0; i < ndims; i++) {
1225                         char *str = read_word(env);
1226                         if (strcmp(str, "unknown") != 0) {
1227                                 long lowerbound = atol(str);
1228                                 set_array_lower_bound_int(type, i, lowerbound);
1229                         }
1230                         obstack_free(&env->obst, str);
1231
1232                         str = read_word(env);
1233                         if (strcmp(str, "unknown") != 0) {
1234                                 long upperbound = atol(str);
1235                                 set_array_upper_bound_int(type, i, upperbound);
1236                         }
1237                         obstack_free(&env->obst, str);
1238                 }
1239                 set_type_size_bytes(type, size);
1240                 break;
1241         }
1242
1243         case tpo_class: {
1244                 const char *name = read_quoted_string_null(env);
1245                 ident      *id   = name != NULL ? new_id_from_str(name) : NULL;
1246
1247                 if(typenr == (long) IR_SEGMENT_GLOBAL)
1248                         type = get_glob_type();
1249                 else
1250                         type = new_type_class(id);
1251                 set_type_size_bytes(type, size);
1252                 break;
1253         }
1254
1255         case tpo_method: {
1256                 unsigned callingconv = (unsigned) read_long(env);
1257                 unsigned addprops    = (unsigned) read_long(env);
1258                 int nparams          = (int)      read_long(env);
1259                 int nresults         = (int)      read_long(env);
1260                 int variaindex;
1261
1262                 type = new_type_method(nparams, nresults);
1263
1264                 for (i = 0; i < nparams; i++) {
1265                         long     typenr = read_long(env);
1266                         ir_type *paramtype = get_type(env, typenr);
1267
1268                         set_method_param_type(type, i, paramtype);
1269                 }
1270                 for (i = 0; i < nresults; i++) {
1271                         long typenr = read_long(env);
1272                         ir_type *restype = get_type(env, typenr);
1273
1274                         set_method_res_type(type, i, restype);
1275                 }
1276
1277                 variaindex = (int) read_long(env);
1278                 if (variaindex != -1) {
1279                         set_method_variadicity(type, variadicity_variadic);
1280                         if (variaindex != nparams)
1281                                 set_method_first_variadic_param_index(type, variaindex);
1282                 }
1283
1284                 set_method_calling_convention(type, callingconv);
1285                 set_method_additional_properties(type, addprops);
1286                 break;
1287         }
1288
1289         case tpo_pointer: {
1290                 ir_mode *mode     = read_mode(env);
1291                 ir_type *pointsto = get_type(env, read_long(env));
1292                 type = new_type_pointer(pointsto);
1293                 set_type_mode(type, mode);
1294                 break;
1295         }
1296
1297         case tpo_primitive: {
1298                 ir_mode *mode = read_mode(env);
1299                 type = new_type_primitive(mode);
1300                 break;
1301         }
1302
1303         case tpo_struct: {
1304                 const char *name = read_quoted_string_null(env);
1305                 ident      *id   = name != NULL ? new_id_from_str(name) : NULL;
1306                 type = new_type_struct(id);
1307                 set_type_size_bytes(type, size);
1308                 break;
1309         }
1310
1311         case tpo_union: {
1312                 const char *name = read_quoted_string_null(env);
1313                 ident      *id   = name != NULL ? new_id_from_str(name) : NULL;
1314
1315                 type = new_type_union(id);
1316                 set_type_size_bytes(type, size);
1317                 break;
1318         }
1319
1320         case tpo_unknown:
1321                 return;   /* ignore unknown type */
1322
1323         default:
1324                 parse_error(env, "unknown type kind: \"%d\"\n", tpop);
1325                 skip_to(env, '\n');
1326                 return;
1327         }
1328
1329         set_type_alignment_bytes(type, align);
1330         type->flags = flags;
1331
1332         if (state == layout_fixed)
1333                 ARR_APP1(ir_type *, env->fixedtypes, type);
1334
1335         set_id(env, typenr, type);
1336 }
1337
1338 /** Reads an entity description and remembers it by its id. */
1339 static void import_entity(io_env_t *env)
1340 {
1341         long           entnr      = read_long(env);
1342         ident         *name       = read_ident(env);
1343         ident         *ld_name    = read_ident_null(env);
1344         ir_visibility  visibility = ir_visibility_default;
1345         ir_linkage     linkage    = IR_LINKAGE_DEFAULT;
1346         long           typenr;
1347         long           ownertypenr;
1348         const char    *str;
1349         ir_type       *type;
1350         ir_type       *ownertype;
1351         ir_entity     *entity;
1352
1353         skip_ws(env);
1354         while (!isdigit(env->c)) {
1355                 char     *str = read_word(env);
1356                 unsigned  v;
1357
1358                 skip_ws(env);
1359
1360                 v = symbol(str, tt_visibility);
1361                 if (v != SYMERROR) {
1362                         visibility = v;
1363                         continue;
1364                 }
1365                 v = symbol(str, tt_linkage);
1366                 if (v != SYMERROR) {
1367                         linkage |= v;
1368                         continue;
1369                 }
1370                 printf("Parser error, expected visibility or linkage, got '%s'\n",
1371                        str);
1372                 break;
1373         }
1374
1375         typenr      = read_long(env);
1376         ownertypenr = read_long(env);
1377
1378         type      = get_type(env, typenr);
1379         ownertype = !ownertypenr ? get_glob_type() : get_type(env, ownertypenr);
1380         entity    = new_entity(ownertype, name, type);
1381
1382         if (ld_name != NULL)
1383                 set_entity_ld_ident(entity, ld_name);
1384         set_entity_offset(entity, (int) read_long(env));
1385         set_entity_offset_bits_remainder(entity, (unsigned char) read_long(env));
1386         set_entity_compiler_generated(entity, (int) read_long(env));
1387         set_entity_volatility(entity, read_volatility(env));
1388         set_entity_visibility(entity, visibility);
1389         set_entity_linkage(entity, linkage);
1390
1391         str = read_word(env);
1392         if (strcmp(str, "initializer") == 0) {
1393                 set_entity_initializer(entity, read_initializer(env));
1394         } else if (strcmp(str, "compoundgraph") == 0) {
1395                 int n = (int) read_long(env);
1396                 int i;
1397                 for (i = 0; i < n; i++) {
1398                         ir_entity *member = get_entity(env, read_long(env));
1399                         ir_node   *irn    = get_node_or_dummy(env, read_long(env));
1400                         add_compound_ent_value(entity, irn, member);
1401                 }
1402         } else if (strcmp(str, "none") == 0) {
1403                 /* do nothing */
1404         } else {
1405                 parse_error(env, "expected 'initializer', 'compoundgraph' or 'none' got '%s'\n", str);
1406                 exit(1);
1407         }
1408
1409         set_id(env, entnr, entity);
1410 }
1411
1412 /** Parses the whole type graph. */
1413 static int parse_typegraph(io_env_t *env)
1414 {
1415         keyword_t kwkind;
1416
1417         EXPECT('{');
1418
1419         current_ir_graph = get_const_code_irg();
1420
1421         /* parse all types first */
1422         while (true) {
1423                 skip_ws(env);
1424                 if (env->c == '}') {
1425                         read_c(env);
1426                         break;
1427                 }
1428
1429                 kwkind = (keyword_t) read_enum(env, tt_keyword);
1430                 switch (kwkind) {
1431                 case kw_type:
1432                         import_type(env);
1433                         break;
1434
1435                 case kw_entity:
1436                         import_entity(env);
1437                         break;
1438
1439                 default:
1440                         parse_error(env, "type graph element not supported yet: %d\n", kwkind);
1441                         skip_to(env, '\n');
1442                         break;
1443                 }
1444         }
1445         return 1;
1446 }
1447
1448 static int read_node_header(io_env_t *env, long *nodenr, long **preds,
1449                             const char **nodename)
1450 {
1451         int numpreds;
1452
1453         *nodename = read_word(env);
1454         *nodenr   = read_long(env);
1455
1456         ARR_RESIZE(ir_node *, *preds, 0);
1457
1458         EXPECT('[');
1459         for (numpreds = 0; !feof(env->file); numpreds++) {
1460                 long val;
1461
1462                 skip_ws(env);
1463                 if (env->c == ']') {
1464                         read_c(env);
1465                         break;
1466                 }
1467                 val = read_long(env);
1468                 ARR_APP1(long, *preds, val);
1469         }
1470
1471         return numpreds;
1472 }
1473
1474 /** Parses an IRG. */
1475 static int parse_graph(io_env_t *env, ir_graph *irg)
1476 {
1477         long       *preds = NEW_ARR_F(long, 16);
1478         ir_node   **prednodes = NEW_ARR_F(ir_node *, 16);
1479         int         i, numpreds, ret = 1;
1480         long        nodenr;
1481         const char *nodename;
1482         ir_node    *node, *newnode;
1483
1484         current_ir_graph = irg;
1485
1486         EXPECT('{');
1487
1488         while (true) {
1489                 skip_ws(env);
1490                 if (env->c == '}') {
1491                         read_c(env);
1492                         break;
1493                 }
1494
1495                 numpreds = read_node_header(env, &nodenr, &preds, &nodename);
1496                 if (numpreds == -1) break;  /* end-of-graph */
1497                 if (!numpreds) {
1498                         parse_error(env, "node %s %ld is missing predecessors!",
1499                                     nodename, nodenr);
1500                         ret = 0;
1501                         break;
1502                 }
1503
1504                 ARR_RESIZE(ir_node *, prednodes, numpreds);
1505                 for (i = 0; i < numpreds - 1; i++)
1506                         prednodes[i] = get_node_or_dummy(env, preds[i + 1]);
1507
1508                 node = get_node_or_null(env, nodenr);
1509                 newnode = NULL;
1510
1511                 EXPECT('{');
1512
1513                 switch (symbol(nodename, tt_iro)) {
1514                 case iro_End:
1515                 {
1516                         ir_node *newendblock = get_node(env, preds[0]);
1517                         newnode = get_irg_end(current_ir_graph);
1518                         exchange(get_nodes_block(newnode), newendblock);
1519                         for (i = 0; i < numpreds - 1; i++)
1520                                 add_irn_n(newnode, prednodes[i]);
1521                         break;
1522                 }
1523
1524                 case iro_Start:
1525                 {
1526                         ir_node *newstartblock = get_node(env, preds[0]);
1527                         newnode = get_irg_start(current_ir_graph);
1528                         exchange(get_nodes_block(newnode), newstartblock);
1529                         break;
1530                 }
1531
1532                 case iro_Block:
1533                 {
1534                         if (preds[0] != nodenr) {
1535                                 parse_error(env, "invalid block: preds[0] != nodenr (%ld != %ld)\n",
1536                                             preds[0], nodenr);
1537                                 ret = 0;
1538                                 goto endloop;
1539                         }
1540
1541                         newnode = new_Block(numpreds - 1, prednodes);
1542                         break;
1543                 }
1544
1545                 case iro_Anchor:
1546                         newnode = current_ir_graph->anchor;
1547                         for (i = 0; i < numpreds - 1; i++)
1548                                 set_irn_n(newnode, i, prednodes[i]);
1549                         set_irn_n(newnode, -1, get_node(env, preds[0]));
1550                         break;
1551
1552                 case iro_SymConst:
1553                 {
1554                         long entnr = read_long(env);
1555                         union symconst_symbol sym;
1556                         sym.entity_p = get_entity(env, entnr);
1557                         newnode = new_SymConst(mode_P, sym, symconst_addr_ent);
1558                         break;
1559                 }
1560
1561                 #include "gen_irio_import.inl"
1562
1563                 default:
1564                         goto notsupported;
1565                 }
1566
1567                 EXPECT('}');
1568
1569                 if (!newnode) {
1570 notsupported:
1571                         parse_error(env, "node type not supported yet: %s\n", nodename);
1572                         abort();
1573                 }
1574
1575                 if (node)
1576                         exchange(node, newnode);
1577                 /* Always update hash entry to avoid more uses of id nodes */
1578                 set_id(env, nodenr, newnode);
1579         }
1580
1581 endloop:
1582         DEL_ARR_F(preds);
1583         DEL_ARR_F(prednodes);
1584
1585         return ret;
1586 }
1587
1588 static int parse_modes(io_env_t *env)
1589 {
1590         EXPECT('{');
1591
1592         while (true) {
1593                 keyword_t kwkind;
1594
1595                 skip_ws(env);
1596                 if (env->c == '}') {
1597                         read_c(env);
1598                         break;
1599                 }
1600
1601                 kwkind = (keyword_t) read_enum(env, tt_keyword);
1602                 switch (kwkind) {
1603                 case kw_mode: {
1604                         const char *name = read_quoted_string(env);
1605                         ir_mode_sort sort = read_enum(env, tt_mode_sort);
1606                         int size = read_long(env);
1607                         int sign = read_long(env);
1608                         ir_mode_arithmetic arith = read_mode_arithmetic(env);
1609                         unsigned modulo_shift = read_long(env);
1610                         int vector_elems = read_long(env);
1611                         ir_mode *mode;
1612
1613                         if (vector_elems != 1) {
1614                                 panic("no support for import of vector modes yes");
1615                         }
1616
1617                         mode = new_ir_mode(name, sort, size, sign, arith, modulo_shift);
1618                         if (mode_is_reference(mode)) {
1619                                 set_reference_mode_signed_eq(mode, read_mode(env));
1620                                 set_reference_mode_unsigned_eq(mode, read_mode(env));
1621                         }
1622                         break;
1623                 }
1624
1625                 default:
1626                         skip_to(env, '\n');
1627                         break;
1628                 }
1629         }
1630         return 1;
1631 }
1632
1633 static int parse_program(io_env_t *env)
1634 {
1635         EXPECT('{');
1636
1637         while (true) {
1638                 keyword_t kwkind;
1639
1640                 skip_ws(env);
1641                 if (env->c == '}') {
1642                         read_c(env);
1643                         break;
1644                 }
1645
1646                 kwkind = (keyword_t) read_enum(env, tt_keyword);
1647                 switch (kwkind) {
1648                 case kw_segment_type: {
1649                         ir_segment_t  segment = (ir_segment_t) read_enum(env, tt_segment);
1650                         ir_type      *type    = read_type(env);
1651                         set_segment_type(segment, type);
1652                         break;
1653                 }
1654                 default:
1655                         parse_error(env, "unexpected keyword %d\n", kwkind);
1656                         skip_to(env, '\n');
1657                 }
1658         }
1659         return 1;
1660 }
1661
1662 void ir_import(const char *filename)
1663 {
1664         FILE *file = fopen(filename, "rt");
1665         if (file == NULL) {
1666                 perror(filename);
1667                 exit(1);
1668         }
1669
1670         ir_import_file(file, filename);
1671
1672         fclose(file);
1673 }
1674
1675 void ir_import_file(FILE *input, const char *inputname)
1676 {
1677         int oldoptimize = get_optimize();
1678         firm_verification_t oldver = get_node_verification_mode();
1679         io_env_t ioenv;
1680         io_env_t *env = &ioenv;
1681         int i, n;
1682
1683         symtbl_init();
1684
1685         memset(env, 0, sizeof(*env));
1686         obstack_init(&env->obst);
1687         env->idset      = new_set(id_cmp, 128);
1688         env->fixedtypes = NEW_ARR_F(ir_type *, 0);
1689         env->inputname  = inputname;
1690         env->file       = input;
1691         env->line       = 1;
1692
1693         /* read first character */
1694         read_c(env);
1695
1696         set_optimize(0);
1697         do_node_verification(FIRM_VERIFICATION_OFF);
1698
1699         while (true) {
1700                 keyword_t kw;
1701
1702                 skip_ws(env);
1703                 if (env->c == EOF)
1704                         break;
1705
1706                 kw = read_enum(env, tt_keyword);
1707                 switch (kw) {
1708                 case kw_modes:
1709                         if (!parse_modes(env)) goto end;
1710                         break;
1711
1712                 case kw_typegraph:
1713                         if (!parse_typegraph(env)) goto end;
1714                         break;
1715
1716                 case kw_irg:
1717                 {
1718                         ir_entity *irgent = get_entity(env, read_long(env));
1719                         long valuetypeid;
1720                         ir_graph *irg = new_ir_graph(irgent, 0);
1721                         set_irg_frame_type(irg, get_type(env, read_long(env)));
1722                         valuetypeid = read_long(env);
1723                         if (valuetypeid != -1)
1724                                 set_method_value_param_type(get_entity_type(irgent),
1725                                                 get_type(env, valuetypeid));
1726
1727                         if (!parse_graph(env, irg)) goto end;
1728                         break;
1729                 }
1730
1731                 case kw_constirg: {
1732                         ir_graph *constirg = get_const_code_irg();
1733                         long bodyblockid = read_long(env);
1734                         set_id(env, bodyblockid, constirg->current_block);
1735                         if (!parse_graph(env, constirg)) goto end;
1736                         break;
1737                 }
1738
1739                 case kw_program:
1740                         parse_program(env);
1741                         break;
1742
1743                 default: {
1744                         parse_error(env, "Unexpected keyword %d at toplevel\n", kw);
1745                         exit(1);
1746                 }
1747                 }
1748         }
1749
1750 end:
1751         n = ARR_LEN(env->fixedtypes);
1752         for (i = 0; i < n; i++)
1753                 set_type_state(env->fixedtypes[i], layout_fixed);
1754
1755         DEL_ARR_F(env->fixedtypes);
1756
1757         del_set(env->idset);
1758
1759         irp_finalize_cons();
1760
1761         do_node_verification(oldver);
1762         set_optimize(oldoptimize);
1763
1764         obstack_free(&env->obst, NULL);
1765 }