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