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