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