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