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

   1 /*
   2  * Copyright (C) 1995-2011 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, Matthias Braun
  24  */
  25 #include "config.h"
  26
  27 #include <string.h>
  28 #include <ctype.h>
  29 #include <stdbool.h>
  30 #include <stdarg.h>
  31
  32 #include "irio.h"
  33
  34 #include "irnode_t.h"
  35 #include "irprog.h"
  36 #include "irgraph_t.h"
  37 #include "irprintf.h"
  38 #include "ircons_t.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 "set.h"
  47 #include "obst.h"
  48 #include "pmap.h"
  49 #include "pdeq.h"
  50
  51 #define SYMERROR ((unsigned) ~0)
  52
  53 static void register_generated_node_readers(void);
  54 static void register_generated_node_writers(void);
  55
  56 typedef struct delayed_initializer_t {
  57         ir_initializer_t *initializer;
  58         long              node_nr;
  59 } delayed_initializer_t;
  60
  61 typedef struct delayed_pred_t {
  62         ir_node *node;
  63         int      n_preds;
  64         long     preds[];
  65 } delayed_pred_t;
  66
  67 typedef struct read_env_t {
  68         int            c;           /**< currently read char */
  69         FILE          *file;
  70         const char    *inputname;
  71         unsigned       line;
  72
  73         ir_graph      *irg;
  74         set           *idset;       /**< id_entry set, which maps from file ids to
  75                                          new Firm elements */
  76         ir_type      **fixedtypes;
  77         bool           read_errors;
  78         struct obstack obst;
  79         struct obstack preds_obst;
  80         delayed_initializer_t *delayed_initializers;
  81         const delayed_pred_t **delayed_preds;
  82 } read_env_t;
  83
  84 typedef struct write_env_t {
  85         FILE *file;
  86         pdeq *write_queue;
  87 } write_env_t;
  88
  89 typedef enum typetag_t {
  90         tt_align,
  91         tt_builtin_kind,
  92         tt_cond_jmp_predicate,
  93         tt_initializer,
  94         tt_irg_inline_property,
  95         tt_keyword,
  96         tt_linkage,
  97         tt_mode_arithmetic,
  98         tt_pin_state,
  99         tt_segment,
 100         tt_throws,
 101         tt_tpo,
 102         tt_type_state,
 103         tt_visibility,
 104         tt_volatility,
 105         tt_where_alloc,
 106 } typetag_t;
 107
 108 typedef enum keyword_t {
 109         kw_asm,
 110         kw_compound_member,
 111         kw_constirg,
 112         kw_entity,
 113         kw_float_mode,
 114         kw_int_mode,
 115         kw_irg,
 116         kw_label,
 117         kw_method,
 118         kw_modes,
 119         kw_parameter,
 120         kw_program,
 121         kw_reference_mode,
 122         kw_segment_type,
 123         kw_type,
 124         kw_typegraph,
 125         kw_unknown,
 126 } keyword_t;
 127
 128 typedef struct symbol_t {
 129         const char *str;      /**< The name of this symbol. */
 130         typetag_t   typetag;  /**< The type tag of this symbol. */
 131         unsigned    code;     /**< The value of this symbol. */
 132 } symbol_t;
 133
 134 typedef struct id_entry {
 135         long id;
 136         void *elem;
 137 } id_entry;
 138
 139 /** The symbol table, a set of symbol_t elements. */
 140 static set *symtbl;
 141
 142 /**
 143  * Compare two symbol table entries.
 144  */
 145 static int symbol_cmp(const void *elt, const void *key, size_t size)
 146 {
 147         int res;
 148         const symbol_t *entry = (const symbol_t *) elt;
 149         const symbol_t *keyentry = (const symbol_t *) key;
 150         (void) size;
 151         res = entry->typetag - keyentry->typetag;
 152         if (res) return res;
 153         return strcmp(entry->str, keyentry->str);
 154 }
 155
 156 static int id_cmp(const void *elt, const void *key, size_t size)
 157 {
 158         const id_entry *entry = (const id_entry *) elt;
 159         const id_entry *keyentry = (const id_entry *) key;
 160         (void) size;
 161         return entry->id - keyentry->id;
 162 }
 163
 164 static void __attribute__((format(printf, 2, 3)))
 165 parse_error(read_env_t *env, const char *fmt, ...)
 166 {
 167         va_list  ap;
 168         unsigned line = env->line;
 169
 170         /* workaround read_c "feature" that a '\n' triggers the line++
 171          * instead of the character after the '\n' */
 172         if (env->c == '\n') {
 173                 line--;
 174         }
 175
 176         fprintf(stderr, "%s:%u: error ", env->inputname, line);
 177         env->read_errors = true;
 178
 179         /* let's hope firm doesn't die on further errors */
 180         do_node_verification(FIRM_VERIFICATION_OFF);
 181
 182         va_start(ap, fmt);
 183         vfprintf(stderr, fmt, ap);
 184         va_end(ap);
 185 }
 186
 187 /** Initializes the symbol table. May be called more than once without problems. */
 188 static void symtbl_init(void)
 189 {
 190         symbol_t key;
 191
 192         /* Only initialize once */
 193         if (symtbl != NULL)
 194                 return;
 195
 196         symtbl = new_set(symbol_cmp, 256);
 197
 198 #define INSERT(tt, s, cod)                                       \
 199         key.str = (s);                                               \
 200         key.typetag = (tt);                                          \
 201         key.code = (cod);                                            \
 202         (void)set_insert(symbol_t, symtbl, &key, sizeof(key), hash_str(s) + tt * 17)
 203
 204 #define INSERTENUM(tt, e) INSERT(tt, #e, e)
 205 #define INSERTKEYWORD(k) INSERT(tt_keyword, #k, kw_##k)
 206
 207         INSERT(tt_tpo, "array", tpo_array);
 208         INSERT(tt_tpo, "class", tpo_class);
 209         INSERT(tt_tpo, "method", tpo_method);
 210         INSERT(tt_tpo, "pointer", tpo_pointer);
 211         INSERT(tt_tpo, "primitive", tpo_primitive);
 212         INSERT(tt_tpo, "struct", tpo_struct);
 213         INSERT(tt_tpo, "union", tpo_union);
 214         INSERT(tt_tpo, "Unknown", tpo_unknown);
 215
 216         INSERT(tt_segment, "global", IR_SEGMENT_GLOBAL);
 217         INSERT(tt_segment, "thread_local", IR_SEGMENT_THREAD_LOCAL);
 218         INSERT(tt_segment, "constructors", IR_SEGMENT_CONSTRUCTORS);
 219         INSERT(tt_segment, "destructors", IR_SEGMENT_DESTRUCTORS);
 220
 221         INSERT(tt_linkage, "constant", IR_LINKAGE_CONSTANT);
 222         INSERT(tt_linkage, "weak", IR_LINKAGE_WEAK);
 223         INSERT(tt_linkage, "garbage_collect", IR_LINKAGE_GARBAGE_COLLECT);
 224         INSERT(tt_linkage, "merge", IR_LINKAGE_MERGE);
 225         INSERT(tt_linkage, "hidden_user", IR_LINKAGE_HIDDEN_USER);
 226
 227         INSERT(tt_visibility, "local", ir_visibility_local);
 228         INSERT(tt_visibility, "external", ir_visibility_external);
 229         INSERT(tt_visibility, "private", ir_visibility_private);
 230
 231         INSERT(tt_throws, "throw",   true);
 232         INSERT(tt_throws, "nothrow", false);
 233
 234         INSERTKEYWORD(asm);
 235         INSERTKEYWORD(compound_member);
 236         INSERTKEYWORD(constirg);
 237         INSERTKEYWORD(entity);
 238         INSERTKEYWORD(float_mode);
 239         INSERTKEYWORD(int_mode);
 240         INSERTKEYWORD(irg);
 241         INSERTKEYWORD(label);
 242         INSERTKEYWORD(method);
 243         INSERTKEYWORD(modes);
 244         INSERTKEYWORD(parameter);
 245         INSERTKEYWORD(program);
 246         INSERTKEYWORD(reference_mode);
 247         INSERTKEYWORD(segment_type);
 248         INSERTKEYWORD(type);
 249         INSERTKEYWORD(typegraph);
 250         INSERTKEYWORD(unknown);
 251
 252         INSERTENUM(tt_align, align_non_aligned);
 253         INSERTENUM(tt_align, align_is_aligned);
 254
 255         INSERTENUM(tt_builtin_kind, ir_bk_trap);
 256         INSERTENUM(tt_builtin_kind, ir_bk_debugbreak);
 257         INSERTENUM(tt_builtin_kind, ir_bk_return_address);
 258         INSERTENUM(tt_builtin_kind, ir_bk_frame_address);
 259         INSERTENUM(tt_builtin_kind, ir_bk_prefetch);
 260         INSERTENUM(tt_builtin_kind, ir_bk_ffs);
 261         INSERTENUM(tt_builtin_kind, ir_bk_clz);
 262         INSERTENUM(tt_builtin_kind, ir_bk_ctz);
 263         INSERTENUM(tt_builtin_kind, ir_bk_popcount);
 264         INSERTENUM(tt_builtin_kind, ir_bk_parity);
 265         INSERTENUM(tt_builtin_kind, ir_bk_bswap);
 266         INSERTENUM(tt_builtin_kind, ir_bk_inport);
 267         INSERTENUM(tt_builtin_kind, ir_bk_outport);
 268         INSERTENUM(tt_builtin_kind, ir_bk_inner_trampoline);
 269
 270         INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_NONE);
 271         INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_TRUE);
 272         INSERTENUM(tt_cond_jmp_predicate, COND_JMP_PRED_FALSE);
 273
 274         INSERTENUM(tt_initializer, IR_INITIALIZER_CONST);
 275         INSERTENUM(tt_initializer, IR_INITIALIZER_TARVAL);
 276         INSERTENUM(tt_initializer, IR_INITIALIZER_NULL);
 277         INSERTENUM(tt_initializer, IR_INITIALIZER_COMPOUND);
 278
 279         INSERT(tt_mode_arithmetic, "uninitialized",      irma_uninitialized);
 280         INSERT(tt_mode_arithmetic, "none",               irma_none);
 281         INSERT(tt_mode_arithmetic, "twos_complement",    irma_twos_complement);
 282         INSERT(tt_mode_arithmetic, "ieee754",            irma_ieee754);
 283         INSERT(tt_mode_arithmetic, "x86_extended_float", irma_x86_extended_float);
 284
 285         INSERT(tt_irg_inline_property, "any",            irg_inline_any);
 286         INSERT(tt_irg_inline_property, "recommended",    irg_inline_recomended);
 287         INSERT(tt_irg_inline_property, "forbidden",      irg_inline_forbidden);
 288         INSERT(tt_irg_inline_property, "forced",         irg_inline_forced);
 289         INSERT(tt_irg_inline_property, "forced_no_body", irg_inline_forced_no_body);
 290
 291         INSERTENUM(tt_pin_state, op_pin_state_floats);
 292         INSERTENUM(tt_pin_state, op_pin_state_pinned);
 293         INSERTENUM(tt_pin_state, op_pin_state_exc_pinned);
 294         INSERTENUM(tt_pin_state, op_pin_state_mem_pinned);
 295
 296         INSERTENUM(tt_type_state, layout_undefined);
 297         INSERTENUM(tt_type_state, layout_fixed);
 298
 299         INSERTENUM(tt_volatility, volatility_non_volatile);
 300         INSERTENUM(tt_volatility, volatility_is_volatile);
 301
 302         INSERTENUM(tt_where_alloc, stack_alloc);
 303         INSERTENUM(tt_where_alloc, heap_alloc);
 304
 305 #undef INSERTKEYWORD
 306 #undef INSERTENUM
 307 #undef INSERT
 308 }
 309
 310 static const char *get_segment_name(ir_segment_t segment)
 311 {
 312         switch (segment) {
 313         case IR_SEGMENT_GLOBAL:       return "global";
 314         case IR_SEGMENT_THREAD_LOCAL: return "thread_local";
 315         case IR_SEGMENT_CONSTRUCTORS: return "constructors";
 316         case IR_SEGMENT_DESTRUCTORS:  return "destructors";
 317         }
 318         panic("INVALID_SEGMENT");
 319 }
 320
 321 static const char *get_visibility_name(ir_visibility visibility)
 322 {
 323         switch (visibility) {
 324         case ir_visibility_local:    return "local";
 325         case ir_visibility_external: return "external";
 326         case ir_visibility_private:  return "private";
 327         }
 328         panic("INVALID_VISIBILITY");
 329 }
 330
 331 static const char *get_mode_arithmetic_name(ir_mode_arithmetic arithmetic)
 332 {
 333         switch (arithmetic) {
 334         case irma_uninitialized:      return "uninitialized";
 335         case irma_none:               return "none";
 336         case irma_twos_complement:    return "twos_complement";
 337         case irma_ieee754:            return "ieee754";
 338         case irma_x86_extended_float: return "x86_extended_float";
 339         }
 340         panic("invalid mode_arithmetic");
 341 }
 342
 343 static const char *get_irg_inline_property_name(irg_inline_property prop)
 344 {
 345         switch (prop) {
 346         case irg_inline_any:            return "any";
 347         case irg_inline_recomended:     return "recommended";
 348         case irg_inline_forbidden:      return "forbidden";
 349         case irg_inline_forced:         return "forced";
 350         case irg_inline_forced_no_body: return "forced_no_body";
 351         }
 352         panic("invalid irg_inline_property");
 353 }
 354
 355 /** Returns the according symbol value for the given string and tag, or SYMERROR if none was found. */
 356 static unsigned symbol(const char *str, typetag_t typetag)
 357 {
 358         symbol_t key, *entry;
 359
 360         key.str = str;
 361         key.typetag = typetag;
 362
 363         entry = set_find(symbol_t, symtbl, &key, sizeof(key), hash_str(str) + typetag * 17);
 364         return entry ? entry->code : SYMERROR;
 365 }
 366
 367 static void write_long(write_env_t *env, long value)
 368 {
 369         fprintf(env->file, "%ld ", value);
 370 }
 371
 372 static void write_int(write_env_t *env, int value)
 373 {
 374         fprintf(env->file, "%d ", value);
 375 }
 376
 377 static void write_unsigned(write_env_t *env, unsigned value)
 378 {
 379         fprintf(env->file, "%u ", value);
 380 }
 381
 382 static void write_size_t(write_env_t *env, size_t value)
 383 {
 384         ir_fprintf(env->file, "%zu ", value);
 385 }
 386
 387 static void write_symbol(write_env_t *env, const char *symbol)
 388 {
 389         fputs(symbol, env->file);
 390         fputc(' ', env->file);
 391 }
 392
 393 static void write_entity_ref(write_env_t *env, ir_entity *entity)
 394 {
 395         write_long(env, get_entity_nr(entity));
 396 }
 397
 398 static void write_type_ref(write_env_t *env, ir_type *type)
 399 {
 400         switch (get_type_tpop_code(type)) {
 401         case tpo_unknown:
 402                 write_symbol(env, "unknown");
 403                 return;
 404         case tpo_none:
 405                 write_symbol(env, "none");
 406                 return;
 407         case tpo_code:
 408                 write_symbol(env, "code");
 409                 return;
 410         default:
 411                 break;
 412         }
 413         write_long(env, get_type_nr(type));
 414 }
 415
 416 static void write_string(write_env_t *env, const char *string)
 417 {
 418         const char *c;
 419         fputc('"', env->file);
 420         for (c = string; *c != '\0'; ++c) {
 421                 switch (*c) {
 422                 case '\n':
 423                         fputc('\\', env->file);
 424                         fputc('n', env->file);
 425                         break;
 426                 case '"':
 427                 case '\\':
 428                         fputc('\\', env->file);
 429                         /* FALLTHROUGH */
 430                 default:
 431                         fputc(*c, env->file);
 432                         break;
 433                 }
 434         }
 435         fputc('"', env->file);
 436         fputc(' ', env->file);
 437 }
 438
 439 static void write_ident(write_env_t *env, ident *id)
 440 {
 441         write_string(env, get_id_str(id));
 442 }
 443
 444 static void write_ident_null(write_env_t *env, ident *id)
 445 {
 446         if (id == NULL) {
 447                 fputs("NULL ", env->file);
 448         } else {
 449                 write_ident(env, id);
 450         }
 451 }
 452
 453 static void write_mode_ref(write_env_t *env, ir_mode *mode)
 454 {
 455         write_string(env, get_mode_name(mode));
 456 }
 457
 458 static void write_tarval(write_env_t *env, ir_tarval *tv)
 459 {
 460         write_mode_ref(env, get_tarval_mode(tv));
 461         if (tv == tarval_bad) {
 462                 write_symbol(env, "bad");
 463         } else {
 464                 char buf[1024];
 465                 tarval_snprintf(buf, sizeof(buf), tv);
 466                 fputs(buf, env->file);
 467                 fputc(' ', env->file);
 468         }
 469 }
 470
 471 static void write_align(write_env_t *env, ir_align align)
 472 {
 473         fputs(get_align_name(align), env->file);
 474         fputc(' ', env->file);
 475 }
 476
 477 static void write_builtin_kind(write_env_t *env, const ir_node *node)
 478 {
 479         fputs(get_builtin_kind_name(get_Builtin_kind(node)), env->file);
 480         fputc(' ', env->file);
 481 }
 482
 483 static void write_cond_jmp_predicate(write_env_t *env, const ir_node *node)
 484 {
 485         fputs(get_cond_jmp_predicate_name(get_Cond_jmp_pred(node)), env->file);
 486         fputc(' ', env->file);
 487 }
 488
 489 static void write_relation(write_env_t *env, ir_relation relation)
 490 {
 491         write_long(env, (long)relation);
 492 }
 493
 494 static void write_where_alloc(write_env_t *env, ir_where_alloc where_alloc)
 495 {
 496         switch (where_alloc) {
 497         case stack_alloc: write_symbol(env, "stack_alloc"); return;
 498         case heap_alloc:  write_symbol(env, "heap_alloc");  return;
 499         }
 500         panic("invalid where_alloc value");
 501 }
 502
 503 static void write_throws(write_env_t *env, bool throws)
 504 {
 505         write_symbol(env, throws ? "throw" : "nothrow");
 506 }
 507
 508 static void write_list_begin(write_env_t *env)
 509 {
 510         fputs("[", env->file);
 511 }
 512
 513 static void write_list_end(write_env_t *env)
 514 {
 515         fputs("] ", env->file);
 516 }
 517
 518 static void write_scope_begin(write_env_t *env)
 519 {
 520         fputs("{\n", env->file);
 521 }
 522
 523 static void write_scope_end(write_env_t *env)
 524 {
 525         fputs("}\n\n", env->file);
 526 }
 527
 528 static void write_node_ref(write_env_t *env, const ir_node *node)
 529 {
 530         write_long(env, get_irn_node_nr(node));
 531 }
 532
 533 static void write_initializer(write_env_t *env, ir_initializer_t *ini)
 534 {
 535         FILE *f = env->file;
 536         ir_initializer_kind_t ini_kind = get_initializer_kind(ini);
 537
 538         fputs(get_initializer_kind_name(ini_kind), f);
 539         fputc(' ', f);
 540
 541         switch (ini_kind) {
 542         case IR_INITIALIZER_CONST:
 543                 write_node_ref(env, get_initializer_const_value(ini));
 544                 return;
 545
 546         case IR_INITIALIZER_TARVAL:
 547                 write_tarval(env, get_initializer_tarval_value(ini));
 548                 return;
 549
 550         case IR_INITIALIZER_NULL:
 551                 return;
 552
 553         case IR_INITIALIZER_COMPOUND: {
 554                 size_t i, n = get_initializer_compound_n_entries(ini);
 555                 write_size_t(env, n);
 556                 for (i = 0; i < n; ++i)
 557                         write_initializer(env, get_initializer_compound_value(ini, i));
 558                 return;
 559         }
 560         }
 561         panic("Unknown initializer kind");
 562 }
 563
 564 static void write_pin_state(write_env_t *env, op_pin_state state)
 565 {
 566         fputs(get_op_pin_state_name(state), env->file);
 567         fputc(' ', env->file);
 568 }
 569
 570 static void write_volatility(write_env_t *env, ir_volatility vol)
 571 {
 572         fputs(get_volatility_name(vol), env->file);
 573         fputc(' ', env->file);
 574 }
 575
 576 static void write_inline_property(write_env_t *env, irg_inline_property prop)
 577 {
 578         fputs(get_irg_inline_property_name(prop), env->file);
 579         fputc(' ', env->file);
 580 }
 581
 582 static void write_type_state(write_env_t *env, ir_type_state state)
 583 {
 584         fputs(get_type_state_name(state), env->file);
 585         fputc(' ', env->file);
 586 }
 587
 588 static void write_visibility(write_env_t *env, ir_visibility visibility)
 589 {
 590         fputs(get_visibility_name(visibility), env->file);
 591         fputc(' ', env->file);
 592 }
 593
 594 static void write_mode_arithmetic(write_env_t *env, ir_mode_arithmetic arithmetic)
 595 {
 596         fputs(get_mode_arithmetic_name(arithmetic), env->file);
 597         fputc(' ', env->file);
 598 }
 599
 600 static void write_type(write_env_t *env, ir_type *tp);
 601 static void write_entity(write_env_t *env, ir_entity *entity);
 602
 603 static void write_type_common(write_env_t *env, ir_type *tp)
 604 {
 605         fputc('\t', env->file);
 606         write_symbol(env, "type");
 607         write_long(env, get_type_nr(tp));
 608         write_symbol(env, get_type_tpop_name(tp));
 609         write_unsigned(env, get_type_size_bytes(tp));
 610         write_unsigned(env, get_type_alignment_bytes(tp));
 611         write_type_state(env, get_type_state(tp));
 612         write_unsigned(env, tp->flags);
 613 }
 614
 615 static void write_type_primitive(write_env_t *env, ir_type *tp)
 616 {
 617         ir_type *base_type = get_primitive_base_type(tp);
 618
 619         if (base_type != NULL)
 620                 write_type(env, base_type);
 621
 622         write_type_common(env, tp);
 623         write_mode_ref(env, get_type_mode(tp));
 624         if (base_type == NULL)
 625                 base_type = get_none_type();
 626         write_type_ref(env, base_type);
 627         fputc('\n', env->file);
 628 }
 629
 630 static void write_type_compound(write_env_t *env, ir_type *tp)
 631 {
 632         size_t n_members = get_compound_n_members(tp);
 633         size_t i;
 634
 635         if (is_Class_type(tp)) {
 636                 if (get_class_n_subtypes(tp) > 0 || get_class_n_supertypes(tp) > 0
 637                     || get_class_type_info(tp) != NULL || get_class_vtable_size(tp) > 0) {
 638                         /* sub/superclass export not implemented yet, it's unclear wether
 639                          * class types will stay in libfirm anyway */
 640                         panic("can't export class types yet");
 641                 }
 642         }
 643         write_type_common(env, tp);
 644         write_ident_null(env, get_compound_ident(tp));
 645         fputc('\n', env->file);
 646
 647         for (i = 0; i < n_members; ++i) {
 648                 ir_entity *member = get_compound_member(tp, i);
 649                 write_entity(env, member);
 650         }
 651 }
 652
 653 static void write_type_array(write_env_t *env, ir_type *tp)
 654 {
 655         size_t     n_dimensions   = get_array_n_dimensions(tp);
 656         ir_type   *element_type   = get_array_element_type(tp);
 657         ir_entity *element_entity = get_array_element_entity(tp);
 658         size_t   i;
 659
 660         write_type(env, element_type);
 661
 662         write_type_common(env, tp);
 663         write_size_t(env, n_dimensions);
 664         write_type_ref(env, get_array_element_type(tp));
 665         for (i = 0; i < n_dimensions; i++) {
 666                 ir_node *lower = get_array_lower_bound(tp, i);
 667                 ir_node *upper = get_array_upper_bound(tp, i);
 668
 669                 if (is_Const(lower))
 670                         write_long(env, get_tarval_long(get_Const_tarval(lower)));
 671                 else
 672                         panic("Lower array bound is not constant");
 673
 674                 if (is_Const(upper))
 675                         write_long(env, get_tarval_long(get_Const_tarval(upper)));
 676                 else if (is_Unknown(upper))
 677                         write_symbol(env, "unknown");
 678                 else
 679                         panic("Upper array bound is not constant");
 680         }
 681         /* note that we just write a reference to the element entity
 682          * but never the entity itself */
 683         write_entity_ref(env, element_entity);
 684         fputc('\n', env->file);
 685 }
 686
 687 static void write_type_method(write_env_t *env, ir_type *tp)
 688 {
 689         size_t nparams  = get_method_n_params(tp);
 690         size_t nresults = get_method_n_ress(tp);
 691         size_t i;
 692
 693         for (i = 0; i < nparams; i++)
 694                 write_type(env, get_method_param_type(tp, i));
 695         for (i = 0; i < nresults; i++)
 696                 write_type(env, get_method_res_type(tp, i));
 697
 698         write_type_common(env, tp);
 699         write_unsigned(env, get_method_calling_convention(tp));
 700         write_unsigned(env, get_method_additional_properties(tp));
 701         write_size_t(env, nparams);
 702         write_size_t(env, nresults);
 703         for (i = 0; i < nparams; i++)
 704                 write_type_ref(env, get_method_param_type(tp, i));
 705         for (i = 0; i < nresults; i++)
 706                 write_type_ref(env, get_method_res_type(tp, i));
 707         write_unsigned(env, get_method_variadicity(tp));
 708         fputc('\n', env->file);
 709 }
 710
 711 static void write_type_pointer(write_env_t *env, ir_type *tp)
 712 {
 713         ir_type *points_to = get_pointer_points_to_type(tp);
 714
 715         write_type(env, points_to);
 716
 717         write_type_common(env, tp);
 718         write_mode_ref(env, get_type_mode(tp));
 719         write_type_ref(env, points_to);
 720         fputc('\n', env->file);
 721 }
 722
 723 static void write_type_enumeration(write_env_t *env, ir_type *tp)
 724 {
 725         write_type_common(env, tp);
 726         write_ident_null(env, get_enumeration_ident(tp));
 727         fputc('\n', env->file);
 728 }
 729
 730 static void write_type(write_env_t *env, ir_type *tp)
 731 {
 732         if (type_visited(tp))
 733                 return;
 734         mark_type_visited(tp);
 735
 736         switch ((tp_opcode)get_type_tpop_code(tp)) {
 737         case tpo_none:
 738         case tpo_unknown:
 739         case tpo_code:
 740         case tpo_uninitialized:
 741                 /* no need to write special builtin types */
 742                 return;
 743
 744         case tpo_union:
 745         case tpo_struct:
 746         case tpo_class:
 747                 write_type_compound(env, tp);
 748                 return;
 749
 750         case tpo_primitive:    write_type_primitive(env, tp);   return;
 751         case tpo_enumeration:  write_type_enumeration(env, tp); return;
 752         case tpo_method:       write_type_method(env, tp);      return;
 753         case tpo_pointer:      write_type_pointer(env, tp);     return;
 754         case tpo_array:        write_type_array(env, tp);       return;
 755         }
 756         panic("can't write invalid type %+F\n", tp);
 757 }
 758
 759 static void write_entity(write_env_t *env, ir_entity *ent)
 760 {
 761         ir_type       *type       = get_entity_type(ent);
 762         ir_type       *owner      = get_entity_owner(ent);
 763         ir_visibility  visibility = get_entity_visibility(ent);
 764         ir_linkage     linkage    = get_entity_linkage(ent);
 765
 766         if (entity_visited(ent))
 767                 return;
 768         mark_entity_visited(ent);
 769
 770         write_type(env, type);
 771         write_type(env, owner);
 772
 773         fputc('\t', env->file);
 774         switch ((ir_entity_kind)ent->entity_kind) {
 775         case IR_ENTITY_NORMAL:          write_symbol(env, "entity");          break;
 776         case IR_ENTITY_METHOD:          write_symbol(env, "method");          break;
 777         case IR_ENTITY_LABEL:           write_symbol(env, "label");           break;
 778         case IR_ENTITY_COMPOUND_MEMBER: write_symbol(env, "compound_member"); break;
 779         case IR_ENTITY_PARAMETER:       write_symbol(env, "parameter");       break;
 780         case IR_ENTITY_UNKNOWN:
 781                 write_symbol(env, "unknown");
 782                 write_long(env, get_entity_nr(ent));
 783                 return;
 784         }
 785         write_long(env, get_entity_nr(ent));
 786
 787         if (ent->entity_kind != IR_ENTITY_LABEL
 788             && ent->entity_kind != IR_ENTITY_PARAMETER) {
 789                 write_ident_null(env, get_entity_ident(ent));
 790                 if (!entity_has_ld_ident(ent)) {
 791                         write_ident_null(env, NULL);
 792                 } else {
 793                         write_ident_null(env, get_entity_ld_ident(ent));
 794                 }
 795         }
 796
 797         write_visibility(env, visibility);
 798         write_list_begin(env);
 799         if (linkage & IR_LINKAGE_CONSTANT)
 800                 write_symbol(env, "constant");
 801         if (linkage & IR_LINKAGE_WEAK)
 802                 write_symbol(env, "weak");
 803         if (linkage & IR_LINKAGE_GARBAGE_COLLECT)
 804                 write_symbol(env, "garbage_collect");
 805         if (linkage & IR_LINKAGE_MERGE)
 806                 write_symbol(env, "merge");
 807         if (linkage & IR_LINKAGE_HIDDEN_USER)
 808                 write_symbol(env, "hidden_user");
 809         write_list_end(env);
 810
 811         write_type_ref(env, type);
 812         if (ent->entity_kind != IR_ENTITY_LABEL)
 813                 write_type_ref(env, owner);
 814         write_long(env, is_entity_compiler_generated(ent));
 815         write_volatility(env, get_entity_volatility(ent));
 816
 817         switch ((ir_entity_kind)ent->entity_kind) {
 818         case IR_ENTITY_NORMAL:
 819                 if (ent->initializer != NULL) {
 820                         write_symbol(env, "initializer");
 821                         write_initializer(env, get_entity_initializer(ent));
 822                 } else {
 823                         write_symbol(env, "none");
 824                 }
 825                 break;
 826         case IR_ENTITY_COMPOUND_MEMBER:
 827                 write_long(env, get_entity_offset(ent));
 828                 write_unsigned(env, get_entity_offset_bits_remainder(ent));
 829                 break;
 830         case IR_ENTITY_PARAMETER: {
 831                 size_t num = get_entity_parameter_number(ent);
 832                 if (num == IR_VA_START_PARAMETER_NUMBER) {
 833                         write_symbol(env, "va_start");
 834                 } else {
 835                         write_size_t(env, num);
 836                 }
 837                 break;
 838         }
 839         case IR_ENTITY_UNKNOWN:
 840         case IR_ENTITY_LABEL:
 841         case IR_ENTITY_METHOD:
 842                 break;
 843         }
 844
 845         fputc('\n', env->file);
 846 }
 847
 848 static void write_switch_table(write_env_t *env, const ir_switch_table *table)
 849 {
 850         size_t n_entries = ir_switch_table_get_n_entries(table);
 851         size_t i;
 852
 853         write_size_t(env, n_entries);
 854         for (i = 0; i < n_entries; ++i) {
 855                 long       pn  = ir_switch_table_get_pn(table, i);
 856                 ir_tarval *min = ir_switch_table_get_min(table, i);
 857                 ir_tarval *max = ir_switch_table_get_max(table, i);
 858                 write_long(env, pn);
 859                 write_tarval(env, min);
 860                 write_tarval(env, max);
 861         }
 862 }
 863
 864 static void write_pred_refs(write_env_t *env, const ir_node *node, int from)
 865 {
 866         int arity = get_irn_arity(node);
 867         int i;
 868         write_list_begin(env);
 869         assert(from <= arity);
 870         for (i = from; i < arity; ++i) {
 871                 ir_node *pred = get_irn_n(node, i);
 872                 write_node_ref(env, pred);
 873         }
 874         write_list_end(env);
 875 }
 876
 877 static void write_node_nr(write_env_t *env, const ir_node *node)
 878 {
 879         write_long(env, get_irn_node_nr(node));
 880 }
 881
 882 static void write_ASM(write_env_t *env, const ir_node *node)
 883 {
 884         write_symbol(env, "ASM");
 885         write_node_nr(env, node);
 886         write_node_nr(env, get_nodes_block(node));
 887         write_node_nr(env, get_ASM_mem(node));
 888
 889         write_ident(env, get_ASM_text(node));
 890         write_list_begin(env);
 891         ir_asm_constraint *input_constraints = get_ASM_input_constraints(node);
 892         int                n_inputs          = get_ASM_n_inputs(node);
 893         for (int i = 0; i < n_inputs; ++i) {
 894                 const ir_asm_constraint *constraint = &input_constraints[i];
 895                 write_unsigned(env, constraint->pos);
 896                 write_ident(env, constraint->constraint);
 897                 write_mode_ref(env, constraint->mode);
 898         }
 899         write_list_end(env);
 900
 901         write_list_begin(env);
 902         ir_asm_constraint *output_constraints  = get_ASM_output_constraints(node);
 903         size_t            n_output_constraints = get_ASM_n_output_constraints(node);
 904         for (size_t i = 0; i < n_output_constraints; ++i) {
 905                 const ir_asm_constraint *constraint = &output_constraints[i];
 906                 write_unsigned(env, constraint->pos);
 907                 write_ident(env, constraint->constraint);
 908                 write_mode_ref(env, constraint->mode);
 909         }
 910         write_list_end(env);
 911
 912         write_list_begin(env);
 913         ident **clobbers   = get_ASM_clobbers(node);
 914         size_t  n_clobbers = get_ASM_n_clobbers(node);
 915         for (size_t i = 0; i < n_clobbers; ++i) {
 916                 ident *clobber = clobbers[i];
 917                 write_ident(env, clobber);
 918         }
 919         write_list_end(env);
 920
 921         write_pin_state(env, get_irn_pinned(node));
 922         write_pred_refs(env, node, n_ASM_max+1);
 923 }
 924
 925 static void write_Phi(write_env_t *env, const ir_node *node)
 926 {
 927         write_symbol(env, "Phi");
 928         write_node_nr(env, node);
 929         write_node_ref(env, get_nodes_block(node));
 930         write_mode_ref(env, get_irn_mode(node));
 931         write_pred_refs(env, node, 0);
 932 }
 933
 934 static void write_Block(write_env_t *env, const ir_node *node)
 935 {
 936         ir_entity *entity = get_Block_entity(node);
 937
 938         if (entity != NULL) {
 939                 write_symbol(env, "BlockL");
 940                 write_node_nr(env, node);
 941                 write_entity_ref(env, entity);
 942         } else {
 943                 write_symbol(env, "Block");
 944                 write_node_nr(env, node);
 945         }
 946         write_pred_refs(env, node, 0);
 947 }
 948
 949 static void write_Anchor(write_env_t *env, const ir_node *node)
 950 {
 951         write_symbol(env, "Anchor");
 952         write_node_nr(env, node);
 953         write_pred_refs(env, node, 0);
 954 }
 955
 956 static void write_SymConst(write_env_t *env, const ir_node *node)
 957 {
 958         /* TODO: only symconst_addr_ent implemented yet */
 959         if (get_SymConst_kind(node) != symconst_addr_ent)
 960                 panic("Can't export %+F (only symconst_addr_ent supported)", node);
 961
 962         write_symbol(env, "SymConst");
 963         write_node_nr(env, node);
 964         write_mode_ref(env, get_irn_mode(node));
 965         write_entity_ref(env, get_SymConst_entity(node));
 966 }
 967
 968 typedef void (*write_node_func)(write_env_t *env, const ir_node *node);
 969
 970 static void register_node_writer(ir_op *op, write_node_func func)
 971 {
 972         set_generic_function_ptr(op, (op_func)func);
 973 }
 974
 975 static void writers_init(void)
 976 {
 977         ir_clear_opcodes_generic_func();
 978         register_node_writer(op_Anchor,   write_Anchor);
 979         register_node_writer(op_ASM,      write_ASM);
 980         register_node_writer(op_Block,    write_Block);
 981         register_node_writer(op_Phi,      write_Phi);
 982         register_node_writer(op_SymConst, write_SymConst);
 983         register_generated_node_writers();
 984 }
 985
 986 static void write_node(const ir_node *node, write_env_t *env)
 987 {
 988         ir_op          *op   = get_irn_op(node);
 989         write_node_func func = (write_node_func) get_generic_function_ptr(op);
 990
 991         fputc('\t', env->file);
 992         if (func == NULL)
 993                 panic("No write_node_func for %+F", node);
 994         func(env, node);
 995         fputc('\n', env->file);
 996 }
 997
 998 static void write_node_recursive(ir_node *node, write_env_t *env);
 999
1000 static void write_preds(ir_node *node, write_env_t *env)
1001 {
1002         int arity = get_irn_arity(node);
1003         int i;
1004         for (i = 0; i < arity; ++i) {
1005                 ir_node *pred = get_irn_n(node, i);
1006                 write_node_recursive(pred, env);
1007         }
1008 }
1009
1010 /**
1011  * Recursively write nodes.
1012  * The reader expects nodes in a way that except for block/phi/anchor nodes
1013  * all predecessors are already defined when we reach them. So usually we
1014  * recurse to all our predecessors except for block/phi/anchor nodes where
1015  * we put the predecessors into a queue for later processing.
1016  */
1017 static void write_node_recursive(ir_node *node, write_env_t *env)
1018 {
1019         if (irn_visited_else_mark(node))
1020                 return;
1021
1022         if (!is_Block(node)) {
1023                 write_node_recursive(get_nodes_block(node), env);
1024         }
1025         /* write predecessors */
1026         if (!is_Phi(node) && !is_Block(node) && !is_Anchor(node)) {
1027                 write_preds(node, env);
1028         } else {
1029                 int arity = get_irn_arity(node);
1030                 int i;
1031                 for (i = 0; i < arity; ++i) {
1032                         ir_node *pred = get_irn_n(node, i);
1033                         pdeq_putr(env->write_queue, pred);
1034                 }
1035         }
1036         write_node(node, env);
1037 }
1038
1039 static void write_mode(write_env_t *env, ir_mode *mode)
1040 {
1041         if (mode_is_int(mode)) {
1042                 write_symbol(env, "int_mode");
1043                 write_string(env, get_mode_name(mode));
1044                 write_mode_arithmetic(env, get_mode_arithmetic(mode));
1045                 write_unsigned(env, get_mode_size_bits(mode));
1046                 write_int(env, get_mode_sign(mode));
1047                 write_unsigned(env, get_mode_modulo_shift(mode));
1048         } else if (mode_is_reference(mode)) {
1049                 write_symbol(env, "reference_mode");
1050                 write_string(env, get_mode_name(mode));
1051                 write_mode_arithmetic(env, get_mode_arithmetic(mode));
1052                 write_unsigned(env, get_mode_size_bits(mode));
1053                 write_unsigned(env, get_mode_modulo_shift(mode));
1054
1055                 write_mode_ref(env, get_reference_mode_signed_eq(mode));
1056                 write_mode_ref(env, get_reference_mode_unsigned_eq(mode));
1057                 write_int(env, (mode == mode_P ? 1 : 0));
1058         } else if (mode_is_float(mode)) {
1059                 write_symbol(env, "float_mode");
1060                 write_string(env, get_mode_name(mode));
1061                 write_mode_arithmetic(env, get_mode_arithmetic(mode));
1062                 write_unsigned(env, get_mode_exponent_size(mode));
1063                 write_unsigned(env, get_mode_mantissa_size(mode));
1064         } else {
1065                 panic("Can't write internal modes");
1066         }
1067 }
1068
1069 static void write_modes(write_env_t *env)
1070 {
1071         size_t n_modes = ir_get_n_modes();
1072         size_t i;
1073
1074         write_symbol(env, "modes");
1075         fputs("{\n", env->file);
1076
1077         for (i = 0; i < n_modes; i++) {
1078                 ir_mode *mode = ir_get_mode(i);
1079                 if (!mode_is_int(mode) && !mode_is_reference(mode)
1080                     && !mode_is_float(mode)) {
1081                     /* skip internal modes */
1082                     continue;
1083                 }
1084                 fputc('\t', env->file);
1085                 write_mode(env, mode);
1086                 fputc('\n', env->file);
1087         }
1088
1089         fputs("}\n\n", env->file);
1090 }
1091
1092 static void write_program(write_env_t *env)
1093 {
1094         ir_segment_t s;
1095         size_t n_asms = get_irp_n_asms();
1096         size_t i;
1097
1098         write_symbol(env, "program");
1099         write_scope_begin(env);
1100         if (irp_prog_name_is_set()) {
1101                 fputc('\t', env->file);
1102                 write_symbol(env, "name");
1103                 write_string(env, get_irp_name());
1104                 fputc('\n', env->file);
1105         }
1106
1107         for (s = IR_SEGMENT_FIRST; s <= IR_SEGMENT_LAST; ++s) {
1108                 ir_type *segment_type = get_segment_type(s);
1109                 fputc('\t', env->file);
1110                 write_symbol(env, "segment_type");
1111                 write_symbol(env, get_segment_name(s));
1112                 if (segment_type == NULL) {
1113                         write_symbol(env, "NULL");
1114                 } else {
1115                         write_type_ref(env, segment_type);
1116                 }
1117                 fputc('\n', env->file);
1118         }
1119
1120         for (i = 0; i < n_asms; ++i) {
1121                 ident *asm_text = get_irp_asm(i);
1122                 fputc('\t', env->file);
1123                 write_symbol(env, "asm");
1124                 write_ident(env, asm_text);
1125                 fputc('\n', env->file);
1126         }
1127         write_scope_end(env);
1128 }
1129
1130 int ir_export(const char *filename)
1131 {
1132         FILE *file = fopen(filename, "wt");
1133         int   res  = 0;
1134         if (file == NULL) {
1135                 perror(filename);
1136                 return 1;
1137         }
1138
1139         ir_export_file(file);
1140         res = ferror(file);
1141         fclose(file);
1142         return res;
1143 }
1144
1145 static void write_node_cb(ir_node *node, void *ctx)
1146 {
1147         write_env_t *env = (write_env_t*)ctx;
1148         write_node(node, env);
1149 }
1150
1151 static void write_typegraph(write_env_t *env)
1152 {
1153         size_t n_types = get_irp_n_types();
1154         size_t i;
1155
1156         write_symbol(env, "typegraph");
1157         write_scope_begin(env);
1158         irp_reserve_resources(irp, IRP_RESOURCE_TYPE_VISITED);
1159         inc_master_type_visited();
1160         for (i = 0; i < n_types; ++i) {
1161                 ir_type *type = get_irp_type(i);
1162                 write_type(env, type);
1163         }
1164         irp_free_resources(irp, IRP_RESOURCE_TYPE_VISITED);
1165         write_scope_end(env);
1166 }
1167
1168 static void write_irg(write_env_t *env, ir_graph *irg)
1169 {
1170         write_symbol(env, "irg");
1171         write_entity_ref(env, get_irg_entity(irg));
1172         write_type_ref(env, get_irg_frame_type(irg));
1173         write_inline_property(env, get_irg_inline_property(irg));
1174         write_unsigned(env, get_irg_additional_properties(irg));
1175         write_scope_begin(env);
1176         ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
1177         inc_irg_visited(irg);
1178         assert(pdeq_empty(env->write_queue));
1179         pdeq_putr(env->write_queue, irg->anchor);
1180         do {
1181                 ir_node *node = (ir_node*) pdeq_getl(env->write_queue);
1182                 write_node_recursive(node, env);
1183         } while (!pdeq_empty(env->write_queue));
1184         ir_free_resources(irg, IR_RESOURCE_IRN_VISITED);
1185         write_scope_end(env);
1186 }
1187
1188 /* Exports the whole irp to the given file in a textual form. */
1189 void ir_export_file(FILE *file)
1190 {
1191         write_env_t my_env;
1192         write_env_t *env = &my_env;
1193         size_t i, n_irgs = get_irp_n_irgs();
1194
1195         memset(env, 0, sizeof(*env));
1196         env->file        = file;
1197         env->write_queue = new_pdeq();
1198
1199         writers_init();
1200         write_modes(env);
1201
1202         write_typegraph(env);
1203
1204         for (i = 0; i < n_irgs; i++) {
1205                 ir_graph *irg = get_irp_irg(i);
1206                 write_irg(env, irg);
1207         }
1208
1209         write_symbol(env, "constirg");
1210         write_node_ref(env, get_const_code_irg()->current_block);
1211         write_scope_begin(env);
1212         walk_const_code(NULL, write_node_cb, env);
1213         write_scope_end(env);
1214
1215         write_program(env);
1216
1217         del_pdeq(env->write_queue);
1218 }
1219
1220
1221
1222 static void read_c(read_env_t *env)
1223 {
1224         int c = fgetc(env->file);
1225         env->c = c;
1226         if (c == '\n')
1227                 env->line++;
1228 }
1229
1230 /** Returns the first non-whitespace character or EOF. **/
1231 static void skip_ws(read_env_t *env)
1232 {
1233         while (true) {
1234                 switch (env->c) {
1235                 case ' ':
1236                 case '\t':
1237                 case '\n':
1238                 case '\r':
1239                         read_c(env);
1240                         continue;
1241
1242                 default:
1243                         return;
1244                 }
1245         }
1246 }
1247
1248 static void skip_to(read_env_t *env, char to_ch)
1249 {
1250         while (env->c != to_ch && env->c != EOF) {
1251                 read_c(env);
1252         }
1253 }
1254
1255 static bool expect_char(read_env_t *env, char ch)
1256 {
1257         skip_ws(env);
1258         if (env->c != ch) {
1259                 parse_error(env, "Unexpected char '%c', expected '%c'\n",
1260                             env->c, ch);
1261                 return false;
1262         }
1263         read_c(env);
1264         return true;
1265 }
1266
1267 #define EXPECT(c) if (expect_char(env, (c))) {} else return
1268
1269 static char *read_word(read_env_t *env)
1270 {
1271         skip_ws(env);
1272
1273         assert(obstack_object_size(&env->obst) == 0);
1274         while (true) {
1275                 int c = env->c;
1276                 switch (c) {
1277                 case EOF:
1278                 case ' ':
1279                 case '\t':
1280                 case '\n':
1281                 case '\r':
1282                         goto endofword;
1283
1284                 default:
1285                         obstack_1grow(&env->obst, c);
1286                         break;
1287                 }
1288                 read_c(env);
1289         }
1290
1291 endofword:
1292         obstack_1grow(&env->obst, '\0');
1293         return (char*)obstack_finish(&env->obst);
1294 }
1295
1296 static char *read_string(read_env_t *env)
1297 {
1298         skip_ws(env);
1299         if (env->c != '"') {
1300                 parse_error(env, "Expected string, got '%c'\n", env->c);
1301                 exit(1);
1302         }
1303         read_c(env);
1304
1305         assert(obstack_object_size(&env->obst) == 0);
1306         while (env->c != '"') {
1307                 if (env->c == EOF) {
1308                         parse_error(env, "Unexpected EOF while parsing string\n");
1309                         exit(1);
1310                 }
1311
1312                 if (env->c == '\\') {
1313                         read_c(env);
1314                         switch (env->c) {
1315                         case 'n':
1316                                 obstack_1grow(&env->obst, '\n');
1317                                 break;
1318                         case '"':
1319                         case '\\':
1320                                 obstack_1grow(&env->obst, env->c);
1321                                 break;
1322                         default:
1323                                 parse_error(env, "Unknown escape sequence '\\%c'\n", env->c);
1324                                 exit(1);
1325                         }
1326                 } else {
1327                         obstack_1grow(&env->obst, env->c);
1328                 }
1329                 read_c(env);
1330         }
1331         read_c(env);
1332         obstack_1grow(&env->obst, 0);
1333
1334         return (char*)obstack_finish(&env->obst);
1335 }
1336
1337 static ident *read_ident(read_env_t *env)
1338 {
1339         char  *str = read_string(env);
1340         ident *res = new_id_from_str(str);
1341         obstack_free(&env->obst, str);
1342         return res;
1343 }
1344
1345 static ident *read_symbol(read_env_t *env)
1346 {
1347         char  *str = read_word(env);
1348         ident *res = new_id_from_str(str);
1349         obstack_free(&env->obst, str);
1350         return res;
1351 }
1352
1353 /*
1354  * reads a "quoted string" or alternatively the token NULL
1355  */
1356 static char *read_string_null(read_env_t *env)
1357 {
1358         skip_ws(env);
1359         if (env->c == 'N') {
1360                 char *str = read_word(env);
1361                 if (strcmp(str, "NULL") == 0) {
1362                         obstack_free(&env->obst, str);
1363                         return NULL;
1364                 }
1365         } else if (env->c == '"') {
1366                 return read_string(env);
1367         }
1368
1369         parse_error(env, "Expected \"string\" or NULL\n");
1370         exit(1);
1371 }
1372
1373 static ident *read_ident_null(read_env_t *env)
1374 {
1375         ident *res;
1376         char  *str = read_string_null(env);
1377         if (str == NULL)
1378                 return NULL;
1379
1380         res = new_id_from_str(str);
1381         obstack_free(&env->obst, str);
1382         return res;
1383 }
1384
1385 static long read_long(read_env_t *env)
1386 {
1387         long  result;
1388         char *str;
1389
1390         skip_ws(env);
1391         if (!isdigit(env->c) && env->c != '-') {
1392                 parse_error(env, "Expected number, got '%c'\n", env->c);
1393                 exit(1);
1394         }
1395
1396         assert(obstack_object_size(&env->obst) == 0);
1397         do {
1398                 obstack_1grow(&env->obst, env->c);
1399                 read_c(env);
1400         } while (isdigit(env->c));
1401         obstack_1grow(&env->obst, 0);
1402
1403         str = (char*)obstack_finish(&env->obst);
1404         result = atol(str);
1405         obstack_free(&env->obst, str);
1406
1407         return result;
1408 }
1409
1410 static int read_int(read_env_t *env)
1411 {
1412         return (int) read_long(env);
1413 }
1414
1415 static unsigned read_unsigned(read_env_t *env)
1416 {
1417         return (unsigned) read_long(env);
1418 }
1419
1420 static size_t read_size_t(read_env_t *env)
1421 {
1422         /* FIXME */
1423         return (size_t) read_unsigned(env);
1424 }
1425
1426 static void expect_list_begin(read_env_t *env)
1427 {
1428         skip_ws(env);
1429         if (env->c != '[') {
1430                 parse_error(env, "Expected list, got '%c'\n", env->c);
1431                 exit(1);
1432         }
1433         read_c(env);
1434 }
1435
1436 static bool list_has_next(read_env_t *env)
1437 {
1438         if (feof(env->file)) {
1439                 parse_error(env, "Unexpected EOF while reading list");
1440                 exit(1);
1441         }
1442         skip_ws(env);
1443         if (env->c == ']') {
1444                 read_c(env);
1445                 return false;
1446         }
1447
1448         return true;
1449 }
1450
1451 static void *get_id(read_env_t *env, long id)
1452 {
1453         id_entry key, *entry;
1454         key.id = id;
1455
1456         entry = set_find(id_entry, env->idset, &key, sizeof(key), (unsigned) id);
1457         return entry ? entry->elem : NULL;
1458 }
1459
1460 static void set_id(read_env_t *env, long id, void *elem)
1461 {
1462         id_entry key;
1463         key.id = id;
1464         key.elem = elem;
1465         (void)set_insert(id_entry, env->idset, &key, sizeof(key), (unsigned) id);
1466 }
1467
1468 static ir_node *get_node_or_null(read_env_t *env, long nodenr)
1469 {
1470         ir_node *node = (ir_node *) get_id(env, nodenr);
1471         if (node && node->kind != k_ir_node) {
1472                 parse_error(env, "Irn ID %ld collides with something else\n",
1473                             nodenr);
1474                 return NULL;
1475         }
1476         return node;
1477 }
1478
1479 static ir_type *get_type(read_env_t *env, long typenr)
1480 {
1481         ir_type *type = (ir_type *) get_id(env, typenr);
1482         if (type == NULL) {
1483                 parse_error(env, "Type %ld not defined (yet?)\n", typenr);
1484                 return get_unknown_type();
1485         }
1486         if (type->kind != k_type) {
1487                 parse_error(env, "Object %ld is not a type (but should be)\n", typenr);
1488                 return get_unknown_type();
1489         }
1490         return type;
1491 }
1492
1493 static ir_type *read_type_ref(read_env_t *env)
1494 {
1495         char *str = read_word(env);
1496         if (strcmp(str, "none") == 0) {
1497                 obstack_free(&env->obst, str);
1498                 return get_none_type();
1499         }
1500         if (strcmp(str, "unknown") == 0) {
1501                 obstack_free(&env->obst, str);
1502                 return get_unknown_type();
1503         }
1504         if (strcmp(str, "code") == 0) {
1505                 obstack_free(&env->obst, str);
1506                 return get_code_type();
1507         }
1508         long nr = atol(str);
1509         obstack_free(&env->obst, str);
1510
1511         return get_type(env, nr);
1512 }
1513
1514 static ir_entity *create_error_entity(void)
1515 {
1516         ir_entity *res = new_entity(get_glob_type(), new_id_from_str("error"),
1517                                     get_unknown_type());
1518         return res;
1519 }
1520
1521 static ir_entity *get_entity(read_env_t *env, long entnr)
1522 {
1523         ir_entity *entity = (ir_entity *) get_id(env, entnr);
1524         if (entity == NULL) {
1525                 parse_error(env, "unknown entity: %ld\n", entnr);
1526                 return create_error_entity();
1527         }
1528         if (entity->kind != k_entity) {
1529                 parse_error(env, "Object %ld is not an entity (but should be)\n",
1530                             entnr);
1531                 return create_error_entity();
1532         }
1533
1534         return entity;
1535 }
1536
1537 static ir_entity *read_entity_ref(read_env_t *env)
1538 {
1539         long nr = read_long(env);
1540         return get_entity(env, nr);
1541 }
1542
1543 static ir_mode *read_mode_ref(read_env_t *env)
1544 {
1545         char  *str = read_string(env);
1546         size_t n   = ir_get_n_modes();
1547         size_t i;
1548
1549         for (i = 0; i < n; i++) {
1550                 ir_mode *mode = ir_get_mode(i);
1551                 if (strcmp(str, get_mode_name(mode)) == 0) {
1552                         obstack_free(&env->obst, str);
1553                         return mode;
1554                 }
1555         }
1556
1557         parse_error(env, "unknown mode \"%s\"\n", str);
1558         return mode_ANY;
1559 }
1560
1561 static const char *get_typetag_name(typetag_t typetag)
1562 {
1563         switch (typetag) {
1564         case tt_align:               return "align";
1565         case tt_builtin_kind:        return "builtin kind";
1566         case tt_cond_jmp_predicate:  return "cond_jmp_predicate";
1567         case tt_initializer:         return "initializer kind";
1568         case tt_irg_inline_property: return "irg_inline_property";
1569         case tt_keyword:             return "keyword";
1570         case tt_linkage:             return "linkage";
1571         case tt_mode_arithmetic:     return "mode_arithmetic";
1572         case tt_pin_state:           return "pin state";
1573         case tt_segment:             return "segment";
1574         case tt_throws:              return "throws";
1575         case tt_tpo:                 return "type";
1576         case tt_type_state:          return "type state";
1577         case tt_visibility:          return "visibility";
1578         case tt_volatility:          return "volatility";
1579         case tt_where_alloc:         return "where alloc";
1580         }
1581         return "<UNKNOWN>";
1582 }
1583
1584 /**
1585  * Read and decode an enum constant.
1586  */
1587 static unsigned read_enum(read_env_t *env, typetag_t typetag)
1588 {
1589         char     *str  = read_word(env);
1590         unsigned  code = symbol(str, typetag);
1591
1592         if (code != SYMERROR) {
1593                 obstack_free(&env->obst, str);
1594                 return code;
1595         }
1596
1597         parse_error(env, "invalid %s: \"%s\"\n", get_typetag_name(typetag), str);
1598         return 0;
1599 }
1600
1601 static ir_align read_align(read_env_t *env)
1602 {
1603         return (ir_align)read_enum(env, tt_align);
1604 }
1605
1606 static ir_builtin_kind read_builtin_kind(read_env_t *env)
1607 {
1608         return (ir_builtin_kind)read_enum(env, tt_builtin_kind);
1609 }
1610
1611 static cond_jmp_predicate read_cond_jmp_predicate(read_env_t *env)
1612 {
1613         return (cond_jmp_predicate)read_enum(env, tt_cond_jmp_predicate);
1614 }
1615
1616 static ir_initializer_kind_t read_initializer_kind(read_env_t *env)
1617 {
1618         return (ir_initializer_kind_t)read_enum(env, tt_initializer);
1619 }
1620
1621 static ir_mode_arithmetic read_mode_arithmetic(read_env_t *env)
1622 {
1623         return (ir_mode_arithmetic)read_enum(env, tt_mode_arithmetic);
1624 }
1625
1626 static op_pin_state read_pin_state(read_env_t *env)
1627 {
1628         return (op_pin_state)read_enum(env, tt_pin_state);
1629 }
1630
1631 static ir_type_state read_type_state(read_env_t *env)
1632 {
1633         return (ir_type_state)read_enum(env, tt_type_state);
1634 }
1635
1636 static ir_visibility read_visibility(read_env_t *env)
1637 {
1638         return (ir_visibility)read_enum(env, tt_visibility);
1639 }
1640
1641 static ir_linkage read_linkage(read_env_t *env)
1642 {
1643         return (ir_linkage)read_enum(env, tt_linkage);
1644 }
1645
1646 static ir_volatility read_volatility(read_env_t *env)
1647 {
1648         return (ir_volatility)read_enum(env, tt_volatility);
1649 }
1650
1651 static ir_where_alloc read_where_alloc(read_env_t *env)
1652 {
1653         return (ir_where_alloc)read_enum(env, tt_where_alloc);
1654 }
1655
1656 static bool read_throws(read_env_t *env)
1657 {
1658         return (bool)read_enum(env, tt_throws);
1659 }
1660
1661 static keyword_t read_keyword(read_env_t *env)
1662 {
1663         return (keyword_t)read_enum(env, tt_keyword);
1664 }
1665
1666 static irg_inline_property read_inline_property(read_env_t *env)
1667 {
1668         return (irg_inline_property)read_enum(env, tt_irg_inline_property);
1669 }
1670
1671 static ir_relation read_relation(read_env_t *env)
1672 {
1673         return (ir_relation)read_long(env);
1674 }
1675
1676 static ir_tarval *read_tarval(read_env_t *env)
1677 {
1678         ir_mode   *tvmode = read_mode_ref(env);
1679         char      *str    = read_word(env);
1680         ir_tarval *tv;
1681         if (strcmp(str, "bad") == 0)
1682                 return tarval_bad;
1683         tv = new_tarval_from_str(str, strlen(str), tvmode);
1684         if (tv == tarval_bad)
1685                 parse_error(env, "problem while parsing tarval '%s'\n", str);
1686         obstack_free(&env->obst, str);
1687
1688         return tv;
1689 }
1690
1691 static ir_switch_table *read_switch_table(read_env_t *env)
1692 {
1693         size_t           n_entries = read_size_t(env);
1694         ir_switch_table *table     = ir_new_switch_table(env->irg, n_entries);
1695         size_t           i;
1696
1697         for (i = 0; i < n_entries; ++i) {
1698                 long       pn  = read_long(env);
1699                 ir_tarval *min = read_tarval(env);
1700                 ir_tarval *max = read_tarval(env);
1701                 ir_switch_table_set(table, i, min, max, pn);
1702         }
1703         return table;
1704 }
1705
1706 static ir_initializer_t *read_initializer(read_env_t *env)
1707 {
1708         ir_initializer_kind_t ini_kind = read_initializer_kind(env);
1709
1710         switch (ini_kind) {
1711         case IR_INITIALIZER_CONST: {
1712                 long nr = read_long(env);
1713                 ir_node *node = get_node_or_null(env, nr);
1714                 ir_initializer_t *initializer = create_initializer_const(node);
1715                 if (node == NULL) {
1716                         delayed_initializer_t di;
1717                         di.initializer = initializer;
1718                         di.node_nr     = nr;
1719                         ARR_APP1(delayed_initializer_t, env->delayed_initializers, di);
1720                 }
1721                 return initializer;
1722         }
1723
1724         case IR_INITIALIZER_TARVAL:
1725                 return create_initializer_tarval(read_tarval(env));
1726
1727         case IR_INITIALIZER_NULL:
1728                 return get_initializer_null();
1729
1730         case IR_INITIALIZER_COMPOUND: {
1731                 size_t i, n = read_size_t(env);
1732                 ir_initializer_t *ini = create_initializer_compound(n);
1733                 for (i = 0; i < n; i++) {
1734                         ir_initializer_t *curini = read_initializer(env);
1735                         set_initializer_compound_value(ini, i, curini);
1736                 }
1737                 return ini;
1738         }
1739         }
1740
1741         panic("Unknown initializer kind");
1742 }
1743
1744 /** Reads a type description and remembers it by its id. */
1745 static void read_type(read_env_t *env)
1746 {
1747         long           typenr = read_long(env);
1748         tp_opcode      tpop   = (tp_opcode) read_enum(env, tt_tpo);
1749         unsigned       size   = (unsigned) read_long(env);
1750         unsigned       align  = (unsigned) read_long(env);
1751         ir_type_state  state  = read_type_state(env);
1752         unsigned       flags  = (unsigned) read_long(env);
1753         ir_type       *type;
1754
1755         switch (tpop) {
1756         case tpo_array: {
1757                 size_t     n_dimensions = read_size_t(env);
1758                 ir_type   *elemtype     = read_type_ref(env);
1759                 size_t     i;
1760                 ir_entity *element_entity;
1761                 long       element_entity_nr;
1762
1763                 type = new_type_array(n_dimensions, elemtype);
1764                 for (i = 0; i < n_dimensions; i++) {
1765                         char *str = read_word(env);
1766                         if (strcmp(str, "unknown") != 0) {
1767                                 long lowerbound = atol(str);
1768                                 set_array_lower_bound_int(type, i, lowerbound);
1769                         }
1770                         obstack_free(&env->obst, str);
1771
1772                         str = read_word(env);
1773                         if (strcmp(str, "unknown") != 0) {
1774                                 long upperbound = atol(str);
1775                                 set_array_upper_bound_int(type, i, upperbound);
1776                         }
1777                         obstack_free(&env->obst, str);
1778                 }
1779
1780                 element_entity_nr = read_long(env);
1781                 element_entity = get_array_element_entity(type);
1782                 set_id(env, element_entity_nr, element_entity);
1783
1784                 set_type_size_bytes(type, size);
1785                 goto finish_type;
1786         }
1787
1788         case tpo_class: {
1789                 ident *id = read_ident_null(env);
1790
1791                 if (typenr == (long) IR_SEGMENT_GLOBAL)
1792                         type = get_glob_type();
1793                 else
1794                         type = new_type_class(id);
1795                 set_type_size_bytes(type, size);
1796                 goto finish_type;
1797         }
1798
1799         case tpo_method: {
1800                 unsigned                  callingconv = read_unsigned(env);
1801                 mtp_additional_properties addprops
1802                         = (mtp_additional_properties) read_long(env);
1803                 size_t nparams  = read_size_t(env);
1804                 size_t nresults = read_size_t(env);
1805                 size_t i;
1806                 ir_variadicity variadicity;
1807
1808                 type = new_type_method(nparams, nresults);
1809
1810                 for (i = 0; i < nparams; i++) {
1811                         long ptypenr = read_long(env);
1812                         ir_type *paramtype = get_type(env, ptypenr);
1813
1814                         set_method_param_type(type, i, paramtype);
1815                 }
1816                 for (i = 0; i < nresults; i++) {
1817                         long ptypenr = read_long(env);
1818                         ir_type *restype = get_type(env, ptypenr);
1819
1820                         set_method_res_type(type, i, restype);
1821                 }
1822
1823                 variadicity = (ir_variadicity) read_long(env);
1824                 set_method_variadicity(type, variadicity);
1825
1826                 set_method_calling_convention(type, callingconv);
1827                 set_method_additional_properties(type, addprops);
1828                 goto finish_type;
1829         }
1830
1831         case tpo_pointer: {
1832                 ir_mode *mode     = read_mode_ref(env);
1833                 ir_type *pointsto = get_type(env, read_long(env));
1834                 type = new_type_pointer(pointsto);
1835                 set_type_mode(type, mode);
1836                 goto finish_type;
1837         }
1838
1839         case tpo_primitive: {
1840                 ir_mode *mode = read_mode_ref(env);
1841                 ir_type *base_type = read_type_ref(env);
1842                 type = new_type_primitive(mode);
1843                 if (base_type != get_none_type()) {
1844                         set_primitive_base_type(type, base_type);
1845                 }
1846                 goto finish_type;
1847         }
1848
1849         case tpo_struct: {
1850                 ident *id = read_ident_null(env);
1851                 type = new_type_struct(id);
1852                 set_type_size_bytes(type, size);
1853                 goto finish_type;
1854         }
1855
1856         case tpo_union: {
1857                 ident *id = read_ident_null(env);
1858                 type = new_type_union(id);
1859                 set_type_size_bytes(type, size);
1860                 goto finish_type;
1861         }
1862
1863         case tpo_none:
1864         case tpo_code:
1865         case tpo_unknown:
1866         case tpo_enumeration:
1867         case tpo_uninitialized:
1868                 parse_error(env, "can't import this type kind (%d)", tpop);
1869                 return;
1870         }
1871         parse_error(env, "unknown type kind: \"%d\"\n", tpop);
1872         skip_to(env, '\n');
1873         return;
1874
1875 finish_type:
1876         set_type_alignment_bytes(type, align);
1877         type->flags = flags;
1878
1879         if (state == layout_fixed)
1880                 ARR_APP1(ir_type *, env->fixedtypes, type);
1881
1882         set_id(env, typenr, type);
1883 }
1884
1885 static void read_unknown_entity(read_env_t *env)
1886 {
1887         long       entnr  = read_long(env);
1888         ir_entity *entity = get_unknown_entity();
1889         set_id(env, entnr, entity);
1890 }
1891
1892 /** Reads an entity description and remembers it by its id. */
1893 static void read_entity(read_env_t *env, ir_entity_kind kind)
1894 {
1895         long           entnr      = read_long(env);
1896         ident         *name       = NULL;
1897         ident         *ld_name    = NULL;
1898         ir_visibility  visibility = ir_visibility_external;
1899         ir_linkage     linkage    = IR_LINKAGE_DEFAULT;
1900         ir_type       *owner      = NULL;
1901         ir_entity     *entity     = NULL;
1902         int            compiler_generated;
1903         ir_volatility  volatility;
1904         const char    *str;
1905         ir_type       *type;
1906
1907         if (kind != IR_ENTITY_LABEL && kind != IR_ENTITY_PARAMETER) {
1908                 name    = read_ident(env);
1909                 ld_name = read_ident_null(env);
1910         }
1911
1912         visibility = read_visibility(env);
1913         expect_list_begin(env);
1914         while (list_has_next(env)) {
1915                 linkage |= read_linkage(env);
1916         }
1917
1918         type = read_type_ref(env);
1919         if (kind != IR_ENTITY_LABEL)
1920                 owner = read_type_ref(env);
1921
1922         compiler_generated = read_long(env) != 0;
1923         volatility         = read_volatility(env);
1924
1925         switch (kind) {
1926         case IR_ENTITY_NORMAL:
1927                 entity = new_entity(owner, name, type);
1928                 if (ld_name != NULL)
1929                         set_entity_ld_ident(entity, ld_name);
1930                 str = read_word(env);
1931                 if (strcmp(str, "initializer") == 0) {
1932                         ir_initializer_t *initializer = read_initializer(env);
1933                         if (initializer != NULL)
1934                                 set_entity_initializer(entity, initializer);
1935                 } else if (strcmp(str, "none") == 0) {
1936                         /* do nothing */
1937                 } else {
1938                         parse_error(env, "expected 'initializer' or 'none' got '%s'\n", str);
1939                 }
1940                 break;
1941         case IR_ENTITY_COMPOUND_MEMBER:
1942                 entity = new_entity(owner, name, type);
1943                 if (ld_name != NULL)
1944                         set_entity_ld_ident(entity, ld_name);
1945                 set_entity_offset(entity, (int) read_long(env));
1946                 set_entity_offset_bits_remainder(entity, (unsigned char) read_long(env));
1947                 break;
1948         case IR_ENTITY_METHOD:
1949                 entity = new_entity(owner, name, type);
1950                 if (ld_name != NULL)
1951                         set_entity_ld_ident(entity, ld_name);
1952                 break;
1953         case IR_ENTITY_PARAMETER: {
1954                 char  *str = read_word(env);
1955                 size_t parameter_number;
1956                 if (strcmp(str, "va_start") == 0) {
1957                         parameter_number = IR_VA_START_PARAMETER_NUMBER;
1958                 } else {
1959                         parameter_number = atol(str);
1960                 }
1961                 obstack_free(&env->obst, str);
1962                 entity = new_parameter_entity(owner, parameter_number, type);
1963                 break;
1964         }
1965         case IR_ENTITY_LABEL: {
1966                 ir_label_t nr = get_irp_next_label_nr();
1967                 entity = new_label_entity(nr);
1968                 break;
1969         }
1970         case IR_ENTITY_UNKNOWN:
1971                 panic("read_entity with IR_ENTITY_UNKNOWN?");
1972         }
1973
1974         set_entity_compiler_generated(entity, compiler_generated);
1975         set_entity_volatility(entity, volatility);
1976         set_entity_visibility(entity, visibility);
1977         set_entity_linkage(entity, linkage);
1978
1979         if (owner != NULL && is_Array_type(owner)) {
1980                 set_array_element_entity(owner, entity);
1981         }
1982
1983         set_id(env, entnr, entity);
1984 }
1985
1986 /** Parses the whole type graph. */
1987 static void read_typegraph(read_env_t *env)
1988 {
1989         ir_graph *old_irg = env->irg;
1990
1991         EXPECT('{');
1992
1993         env->irg = get_const_code_irg();
1994
1995         /* parse all types first */
1996         while (true) {
1997                 keyword_t kwkind;
1998                 skip_ws(env);
1999                 if (env->c == '}') {
2000                         read_c(env);
2001                         break;
2002                 }
2003
2004                 kwkind = read_keyword(env);
2005                 switch (kwkind) {
2006                 case kw_type:
2007                         read_type(env);
2008                         break;
2009
2010                 case kw_entity:
2011                         read_entity(env, IR_ENTITY_NORMAL);
2012                         break;
2013                 case kw_label:
2014                         read_entity(env, IR_ENTITY_LABEL);
2015                         break;
2016                 case kw_method:
2017                         read_entity(env, IR_ENTITY_METHOD);
2018                         break;
2019                 case kw_compound_member:
2020                         read_entity(env, IR_ENTITY_COMPOUND_MEMBER);
2021                         break;
2022                 case kw_parameter:
2023                         read_entity(env, IR_ENTITY_PARAMETER);
2024                         break;
2025                 case kw_unknown:
2026                         read_unknown_entity(env);
2027                         break;
2028                 default:
2029                         parse_error(env, "type graph element not supported yet: %d\n", kwkind);
2030                         skip_to(env, '\n');
2031                         break;
2032                 }
2033         }
2034         env->irg = old_irg;
2035 }
2036
2037 /**
2038  * Read a node reference and return the node for it. This assumes that the node
2039  * was previously read. This is fine for all normal nodes.
2040  * (Note: that we "break" loops by having special code for phi, block or anchor
2041  *  nodes in place, firm guarantees us that a loop in the graph always contains
2042  *  a phi, block or anchor node)
2043  */
2044 static ir_node *read_node_ref(read_env_t *env)
2045 {
2046         long     nr   = read_long(env);
2047         ir_node *node = get_node_or_null(env, nr);
2048         if (node == NULL) {
2049                 parse_error(env, "node %ld not defined (yet?)\n", nr);
2050                 return new_r_Bad(env->irg, mode_ANY);
2051         }
2052         return node;
2053 }
2054
2055 static int read_preds(read_env_t *env)
2056 {
2057         expect_list_begin(env);
2058         assert(obstack_object_size(&env->preds_obst) == 0);
2059         while (list_has_next(env)) {
2060                 ir_node *pred = read_node_ref(env);
2061                 obstack_grow(&env->preds_obst, &pred, sizeof(pred));
2062         }
2063         return obstack_object_size(&env->preds_obst) / sizeof(ir_node*);
2064 }
2065
2066 static void read_preds_delayed(read_env_t *env, ir_node *node)
2067 {
2068         int             n_preds = 0;
2069         delayed_pred_t *d;
2070
2071         expect_list_begin(env);
2072         assert(obstack_object_size(&env->preds_obst) == 0);
2073         obstack_blank(&env->preds_obst, sizeof(delayed_pred_t));
2074         while (list_has_next(env)) {
2075                 long pred_nr = read_long(env);
2076                 obstack_grow(&env->preds_obst, &pred_nr, sizeof(pred_nr));
2077                 ++n_preds;
2078         }
2079         d          = (delayed_pred_t*) obstack_finish(&env->preds_obst);
2080         d->node    = node;
2081         d->n_preds = n_preds;
2082
2083         ARR_APP1(const delayed_pred_t*, env->delayed_preds, d);
2084 }
2085
2086 static ir_node *read_ASM(read_env_t *env)
2087 {
2088         int                n_in;
2089         ir_node          **in;
2090         ir_node           *newnode;
2091         ir_asm_constraint *input_constraints  = NEW_ARR_F(ir_asm_constraint, 0);
2092         ir_asm_constraint *output_constraints = NEW_ARR_F(ir_asm_constraint, 0);
2093         ident            **clobbers           = NEW_ARR_F(ident*, 0);
2094         ir_node           *block              = read_node_ref(env);
2095         ir_node           *mem                = read_node_ref(env);
2096         op_pin_state       pin_state;
2097
2098         ident *asm_text = read_ident(env);
2099
2100         expect_list_begin(env);
2101         while (list_has_next(env)) {
2102                 ir_asm_constraint constraint;
2103                 constraint.pos        = read_unsigned(env);
2104                 constraint.constraint = read_ident(env);
2105                 constraint.mode       = read_mode_ref(env);
2106                 ARR_APP1(ir_asm_constraint, input_constraints, constraint);
2107         }
2108
2109         expect_list_begin(env);
2110         while (list_has_next(env)) {
2111                 ir_asm_constraint constraint;
2112                 constraint.pos        = read_unsigned(env);
2113                 constraint.constraint = read_ident(env);
2114                 constraint.mode       = read_mode_ref(env);
2115                 ARR_APP1(ir_asm_constraint, output_constraints, constraint);
2116         }
2117
2118         expect_list_begin(env);
2119         while (list_has_next(env)) {
2120                 ident *clobber = read_ident(env);
2121                 ARR_APP1(ident*, clobbers, clobber);
2122         }
2123
2124         pin_state = read_pin_state(env);
2125
2126         n_in = read_preds(env);
2127         in   = (ir_node**)obstack_finish(&env->preds_obst);
2128
2129         if (ARR_LEN(input_constraints) != (size_t)n_in) {
2130                 parse_error(env, "input_constraints != n_in in ir file");
2131                 return new_r_Bad(env->irg, mode_T);
2132         }
2133
2134         newnode = new_r_ASM(block, mem, n_in, in,
2135                 input_constraints, ARR_LEN(output_constraints),
2136                 output_constraints, ARR_LEN(clobbers),
2137                 clobbers, asm_text);
2138         set_irn_pinned(newnode, pin_state);
2139         obstack_free(&env->preds_obst, in);
2140         DEL_ARR_F(clobbers);
2141         DEL_ARR_F(output_constraints);
2142         DEL_ARR_F(input_constraints);
2143         return newnode;
2144 }
2145
2146 static ir_node *read_Phi(read_env_t *env)
2147 {
2148         ir_node *block = read_node_ref(env);
2149         ir_mode *mode  = read_mode_ref(env);
2150         ir_node *res   = new_r_Phi(block, 0, NULL, mode);
2151         read_preds_delayed(env, res);
2152         return res;
2153 }
2154
2155 static ir_node *read_Block(read_env_t *env)
2156 {
2157         ir_node *res = new_r_Block(env->irg, 0, NULL);
2158         read_preds_delayed(env, res);
2159         return res;
2160 }
2161
2162 static ir_node *read_labeled_Block(read_env_t *env)
2163 {
2164         ir_node   *res    = new_r_Block(env->irg, 0, NULL);
2165         ir_entity *entity = read_entity_ref(env);
2166         read_preds_delayed(env, res);
2167         set_Block_entity(res, entity);
2168         return res;
2169 }
2170
2171 static ir_node *read_SymConst(read_env_t *env)
2172 {
2173         ir_mode   *mode   = read_mode_ref(env);
2174         ir_entity *entity = read_entity_ref(env);
2175         ir_node   *res;
2176         symconst_symbol sym;
2177
2178         sym.entity_p = entity;
2179         res = new_r_SymConst(env->irg, mode, sym, symconst_addr_ent);
2180         return res;
2181 }
2182
2183 static ir_node *read_Anchor(read_env_t *env)
2184 {
2185         ir_node *res = new_r_Anchor(env->irg);
2186         read_preds_delayed(env, res);
2187         return res;
2188 }
2189
2190 typedef ir_node* read_node_func(read_env_t *env);
2191 static pmap *node_readers;
2192
2193 static void register_node_reader(ident *ident, read_node_func* func)
2194 {
2195         pmap_insert(node_readers, ident, (void*)func);
2196 }
2197
2198 static ir_node *read_node(read_env_t *env)
2199 {
2200         ident          *id   = read_symbol(env);
2201         read_node_func *func = pmap_get(read_node_func, node_readers, id);
2202         long            nr   = read_long(env);
2203         ir_node        *res;
2204         if (func == NULL) {
2205                 parse_error(env, "Unknown nodetype '%s'", get_id_str(id));
2206                 skip_to(env, '\n');
2207                 res = new_r_Bad(env->irg, mode_ANY);
2208         } else {
2209                 res = func(env);
2210         }
2211         set_id(env, nr, res);
2212         return res;
2213 }
2214
2215 static void readers_init(void)
2216 {
2217         assert(node_readers == NULL);
2218         node_readers = pmap_create();
2219         register_node_reader(new_id_from_str("Anchor"),   read_Anchor);
2220         register_node_reader(new_id_from_str("ASM"),      read_ASM);
2221         register_node_reader(new_id_from_str("Block"),    read_Block);
2222         register_node_reader(new_id_from_str("BlockL"),   read_labeled_Block);
2223         register_node_reader(new_id_from_str("Phi"),      read_Phi);
2224         register_node_reader(new_id_from_str("SymConst"), read_SymConst);
2225         register_generated_node_readers();
2226 }
2227
2228 static void read_graph(read_env_t *env, ir_graph *irg)
2229 {
2230         size_t n_delayed_preds;
2231         size_t i;
2232         env->irg = irg;
2233
2234         env->delayed_preds = NEW_ARR_F(const delayed_pred_t*, 0);
2235
2236         EXPECT('{');
2237         while (true) {
2238                 skip_ws(env);
2239                 if (env->c == '}' || env->c == EOF) {
2240                         read_c(env);
2241                         break;
2242                 }
2243
2244                 read_node(env);
2245         }
2246
2247         /* resolve delayed preds */
2248         n_delayed_preds = ARR_LEN(env->delayed_preds);
2249         for (i = 0; i < n_delayed_preds; ++i) {
2250                 const delayed_pred_t *dp  = env->delayed_preds[i];
2251                 ir_node             **ins = ALLOCAN(ir_node*, dp->n_preds);
2252                 int                   i;
2253                 for (i = 0; i < dp->n_preds; ++i) {
2254                         long     pred_nr = dp->preds[i];
2255                         ir_node *pred    = get_node_or_null(env, pred_nr);
2256                         if (pred == NULL) {
2257                                 parse_error(env, "predecessor %ld of a node not defined\n",
2258                                             pred_nr);
2259                                 goto next_delayed_pred;
2260                         }
2261                         ins[i] = pred;
2262                 }
2263                 set_irn_in(dp->node, dp->n_preds, ins);
2264                 if (is_Anchor(dp->node)) {
2265                         irg_anchors a;
2266                         for (a = anchor_first; a <= anchor_last; ++a) {
2267                                 ir_node *old_anchor = get_irg_anchor(irg, a);
2268                                 ir_node *new_anchor = ins[a];
2269                                 exchange(old_anchor, new_anchor);
2270                         }
2271                 }
2272 next_delayed_pred: ;
2273         }
2274         DEL_ARR_F(env->delayed_preds);
2275         env->delayed_preds = NULL;
2276 }
2277
2278 static ir_graph *read_irg(read_env_t *env)
2279 {
2280         ir_entity          *irgent = get_entity(env, read_long(env));
2281         ir_graph           *irg    = new_ir_graph(irgent, 0);
2282         ir_type            *frame  = read_type_ref(env);
2283         irg_inline_property prop   = read_inline_property(env);
2284         unsigned            props  = read_unsigned(env);
2285         set_irg_frame_type(irg, frame);
2286         set_irg_inline_property(irg, prop);
2287         set_irg_additional_properties(irg, (mtp_additional_properties)props);
2288         read_graph(env, irg);
2289         irg_finalize_cons(irg);
2290         return irg;
2291 }
2292
2293 static void read_modes(read_env_t *env)
2294 {
2295         EXPECT('{');
2296
2297         while (true) {
2298                 keyword_t kwkind;
2299
2300                 skip_ws(env);
2301                 if (env->c == '}' || env->c == EOF) {
2302                         read_c(env);
2303                         break;
2304                 }
2305
2306                 kwkind = read_keyword(env);
2307                 switch (kwkind) {
2308                 case kw_int_mode: {
2309                         const char *name = read_string(env);
2310                         ir_mode_arithmetic arith = read_mode_arithmetic(env);
2311                         int size = read_long(env);
2312                         int sign = read_long(env);
2313                         unsigned modulo_shift = read_long(env);
2314                         new_int_mode(name, arith, size, sign, modulo_shift);
2315                         break;
2316                 }
2317                 case kw_reference_mode: {
2318                         const char *name = read_string(env);
2319                         ir_mode_arithmetic arith = read_mode_arithmetic(env);
2320                         int size = read_long(env);
2321                         unsigned modulo_shift = read_long(env);
2322                         ir_mode *mode = new_reference_mode(name, arith, size, modulo_shift);
2323                         set_reference_mode_signed_eq(mode, read_mode_ref(env));
2324                         set_reference_mode_unsigned_eq(mode, read_mode_ref(env));
2325                         int is_mode_P = read_int(env);
2326                         if (is_mode_P) {
2327                                 set_modeP_data(mode);
2328                                 set_modeP_code(mode);
2329                         }
2330                         break;
2331                 }
2332                 case kw_float_mode: {
2333                         const char *name = read_string(env);
2334                         ir_mode_arithmetic arith = read_mode_arithmetic(env);
2335                         int exponent_size = read_long(env);
2336                         int mantissa_size = read_long(env);
2337                         new_float_mode(name, arith, exponent_size, mantissa_size);
2338                         break;
2339                 }
2340
2341                 default:
2342                         skip_to(env, '\n');
2343                         break;
2344                 }
2345         }
2346 }
2347
2348 static void read_program(read_env_t *env)
2349 {
2350         EXPECT('{');
2351
2352         while (true) {
2353                 keyword_t kwkind;
2354
2355                 skip_ws(env);
2356                 if (env->c == '}') {
2357                         read_c(env);
2358                         break;
2359                 }
2360
2361                 kwkind = read_keyword(env);
2362                 switch (kwkind) {
2363                 case kw_segment_type: {
2364                         ir_segment_t  segment = (ir_segment_t) read_enum(env, tt_segment);
2365                         ir_type      *type    = read_type_ref(env);
2366                         set_segment_type(segment, type);
2367                         break;
2368                 }
2369                 case kw_asm: {
2370                         ident *text = read_ident(env);
2371                         add_irp_asm(text);
2372                         break;
2373                 }
2374                 default:
2375                         parse_error(env, "unexpected keyword %d\n", kwkind);
2376                         skip_to(env, '\n');
2377                 }
2378         }
2379 }
2380
2381 int ir_import(const char *filename)
2382 {
2383         FILE *file = fopen(filename, "rt");
2384         int   res;
2385         if (file == NULL) {
2386                 perror(filename);
2387                 return 1;
2388         }
2389
2390         res = ir_import_file(file, filename);
2391         fclose(file);
2392
2393         return res;
2394 }
2395
2396 int ir_import_file(FILE *input, const char *inputname)
2397 {
2398         read_env_t          myenv;
2399         int                 oldoptimize = get_optimize();
2400         read_env_t         *env         = &myenv;
2401         size_t              i;
2402         size_t              n;
2403         size_t              n_delayed_initializers;
2404
2405         readers_init();
2406         symtbl_init();
2407
2408         memset(env, 0, sizeof(*env));
2409         obstack_init(&env->obst);
2410         obstack_init(&env->preds_obst);
2411         env->idset      = new_set(id_cmp, 128);
2412         env->fixedtypes = NEW_ARR_F(ir_type *, 0);
2413         env->inputname  = inputname;
2414         env->file       = input;
2415         env->line       = 1;
2416         env->delayed_initializers = NEW_ARR_F(delayed_initializer_t, 0);
2417
2418         /* read first character */
2419         read_c(env);
2420
2421         set_optimize(0);
2422
2423         while (true) {
2424                 keyword_t kw;
2425
2426                 skip_ws(env);
2427                 if (env->c == EOF)
2428                         break;
2429
2430                 kw = read_keyword(env);
2431                 switch (kw) {
2432                 case kw_modes:
2433                         read_modes(env);
2434                         break;
2435
2436                 case kw_typegraph:
2437                         read_typegraph(env);
2438                         break;
2439
2440                 case kw_irg:
2441                         read_irg(env);
2442                         break;
2443
2444                 case kw_constirg: {
2445                         ir_graph *constirg = get_const_code_irg();
2446                         long bodyblockid = read_long(env);
2447                         set_id(env, bodyblockid, constirg->current_block);
2448                         read_graph(env, constirg);
2449                         break;
2450                 }
2451
2452                 case kw_program:
2453                         read_program(env);
2454                         break;
2455
2456                 default: {
2457                         parse_error(env, "Unexpected keyword %d at toplevel\n", kw);
2458                         exit(1);
2459                 }
2460                 }
2461         }
2462
2463         n = ARR_LEN(env->fixedtypes);
2464         for (i = 0; i < n; i++)
2465                 set_type_state(env->fixedtypes[i], layout_fixed);
2466
2467         DEL_ARR_F(env->fixedtypes);
2468
2469         /* resolve delayed initializers */
2470         n_delayed_initializers = ARR_LEN(env->delayed_initializers);
2471         for (i = 0; i < n_delayed_initializers; ++i) {
2472                 const delayed_initializer_t *di   = &env->delayed_initializers[i];
2473                 ir_node                     *node = get_node_or_null(env, di->node_nr);
2474                 if (node == NULL) {
2475                         parse_error(env, "node %ld mentioned in an initializer was never defined\n",
2476                                     di->node_nr);
2477                         continue;
2478                 }
2479                 assert(di->initializer->kind == IR_INITIALIZER_CONST);
2480                 di->initializer->consti.value = node;
2481         }
2482         DEL_ARR_F(env->delayed_initializers);
2483         env->delayed_initializers = NULL;
2484
2485         del_set(env->idset);
2486
2487         irp_finalize_cons();
2488
2489         set_optimize(oldoptimize);
2490
2491         obstack_free(&env->preds_obst, NULL);
2492         obstack_free(&env->obst, NULL);
2493
2494         pmap_destroy(node_readers);
2495         node_readers = NULL;
2496
2497         return env->read_errors;
2498 }
2499
2500 #include "gen_irio.inl"