nsz Git - cparser/blob - driver/gen_firm_asm.c

   1 /*
   2  * Generate Firm assembler from Firm graphs.
   3  *
   4  * (C) 2005-2009  Michael Beck   beck@ipd.info.uni-karlsruhe.de
   5  */
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <libfirm/firm.h>
   9 #include "firm_opt.h"
  10
  11 /**
  12  * The variable context. Contains information
  13  * about needed variables.
  14  */
  15 typedef struct var_ctx {
  16   FILE *f;              /**< File handle for output. */
  17   int max_arity;        /**< Maximum arity of in array. */
  18   int need_tv;          /**< If set, need a tv variable. */
  19   int need_unknown_X;   /**< If set, need an unknown_X variable. */
  20   int need_unknown;     /**< If set, need an unknown variable. */
  21 } var_ctx;
  22
  23 /**
  24  * A context for backedge fixes.
  25  */
  26 typedef struct fix_ctx {
  27   FILE *f;              /**< File handle for output. */
  28   ir_node *start_block; /**< The start block of the current graph. */
  29   int has_backedges;    /**< If set the current graph contains backedges. */
  30 } fix_ctx;
  31
  32 /**
  33  * Print the name of an IR-node as <prefix><op>_<idx><suffix>.
  34  *
  35  * @param f       the output file handle
  36  * @param prefix  a prefix to print before the node name
  37  * @param n       the IR-node
  38  * @param suffix  a suffix to print after the node name
  39  */
  40 static void name(FILE *f, const char *prefix, ir_node *n, const char *suffix)
  41 {
  42   const char *op_name = get_op_name(get_irn_op(n));
  43   unsigned    index   = get_irn_idx(n);
  44   if(prefix == NULL)
  45     prefix = "";
  46   if(suffix == NULL)
  47     suffix = "";
  48
  49   fprintf(f, "%s%s_%u%s", prefix, op_name, index, suffix);
  50 }
  51
  52 /**
  53  * Generate the header of the function.
  54  *
  55  * @param f    the output file handle
  56  * @param irg  the graph
  57  */
  58 static void generate_header(FILE *f, ir_graph *irg)
  59 {
  60   int i, n;
  61   ir_entity *ent = get_irg_entity(irg);
  62   ir_type *tp = get_entity_type(ent);
  63   const char *s = get_entity_name(ent);
  64   fprintf(f,
  65     "/**\n"
  66     " * Generates the Firm code for\n"
  67     " * ");
  68
  69   if (get_method_n_ress(tp) == 0)
  70     fprintf(f, "void");
  71   else
  72     fputs(get_type_name(get_method_res_type(tp, 0)), f);
  73   fprintf(f, " %s(", s);
  74   n = get_method_n_params(tp);
  75   if (n == 0)
  76     fputs(get_method_variadicity(tp) == variadicity_variadic ? "" : "void", f);
  77   else {
  78     for (i = 0; i < n; ++i) {
  79       if (i > 0)
  80         fprintf(f, ", ");
  81       fputs(get_type_name(get_method_param_type(tp, i)), f);
  82     }
  83     if (get_method_variadicity(tp) == variadicity_variadic)
  84       fprintf(f, ", ...");
  85   }
  86   fprintf(f, ")\n");
  87
  88   fprintf(f,
  89     " *\n"
  90     " * @param func  the entity for the generated graph\n"
  91     " */\n"
  92     "void gen_firm_%s(ir_entity *func)\n"
  93     "{\n", s);
  94   fprintf(f,
  95     "  ir_graph *rem = current_ir_graph;\n");
  96 }
  97
  98 /**
  99  * Generate the function prolog.
 100  *
 101  * @param env   a variable context
 102  * @param irg   the graph
 103  */
 104 static void generate_prolog(var_ctx *env, ir_graph *irg)
 105 {
 106   FILE *f = env->f;
 107   (void) irg;
 108   fprintf(f,
 109     "  irg = new_ir_graph(func, 0);\n"
 110     "  /* kill the current block */\n"
 111     "  tmp = get_cur_block();\n"
 112     "  mature_immBlock(tmp);\n"
 113     "  set_Block_dead(tmp);\n");
 114   if (env->need_unknown_X)
 115     fprintf(f, "  unknownX = new_r_Unknown(irg, mode_X);\n");
 116 }
 117
 118 /**
 119  * Walker: Fix Block and Phi nodes containing backedges.
 120  */
 121 static void fix_block_and_phi(ir_node *n, void *ctx)
 122 {
 123   fix_ctx *env = ctx;
 124   int i, arity;
 125   FILE *f;
 126
 127   if (is_Block(n) || is_Phi(n)) {
 128     arity = get_irn_arity(n);
 129
 130     /* ignore the start block */
 131     if (n == env->start_block)
 132       return;
 133
 134     f = env->f;
 135     for (i = 0; i < arity; ++i) {
 136       if (is_backedge(n, i)) {
 137         name(f, "  set_irn_n(", n, NULL);
 138         fprintf(f, ", %d, ", i);
 139         name(f, NULL, get_irn_n(n, i), ");\n");
 140       }
 141     }
 142   }
 143 }
 144
 145 /**
 146  * Generate the function epilog.
 147  *
 148  * @param env   the backedge fix context
 149  * @param irg   the graph
 150  */
 151 static void generate_epilog(fix_ctx *env, ir_graph *irg)
 152 {
 153   FILE *f = env->f;
 154   ir_node *end;
 155   int i, n;
 156
 157   /* Fix backedges if there was any */
 158   if (env->has_backedges) {
 159     fprintf(f, "  /* fix Blocks and Phis */\n");
 160     env->start_block = get_irg_start_block(irg);
 161     irg_walk_graph(irg, NULL, fix_block_and_phi, env);
 162   }
 163
 164   /* create the keep-alives */
 165   end = get_irg_end(irg);
 166   n = get_End_n_keepalives(end);
 167   for (i = 0; i < n; ++i) {
 168     name(f, "  add_End_keepalive(", end, NULL);
 169     name(f, ", ", get_End_keepalive(end, i), ");\n");
 170   }
 171   name(f, "  mature_immBlock(", get_irg_end_block(irg), ");\n");
 172   fprintf(f, "  current_ir_graph = rem;\n");
 173   fprintf(f, "}  /* gen_firm_%s */\n\n", get_entity_name(get_irg_entity(irg)));
 174 }
 175
 176 /**
 177  * Walker: Create a variable declaration for a given node.
 178  * The variable name is <op>_<node idx>, see name().
 179  *
 180  * @param n    the current IR-node
 181  * @param ctx  a variable context
 182  */
 183 static void dump_var_def(ir_node *n, void *ctx)
 184 {
 185   var_ctx *env = ctx;
 186   int arity = get_irn_arity(n);
 187
 188   name(env->f, "  ir_node *", n, " = NULL;\n");
 189   if (arity > env->max_arity)
 190      env->max_arity = arity;
 191   if (get_irn_op(n) == op_Const)
 192     env->need_tv = 1;
 193   if (has_backedges(n)) {
 194     if (is_Block(n))
 195       env->need_unknown_X = 1;
 196     else
 197       env->need_unknown = 1;
 198   }
 199 }
 200
 201 /**
 202  * Generate all needed variable declarations for a graph.
 203  *
 204  * @param env  a variable context
 205  * @param irg  the graph
 206  */
 207 static void generate_var_decls(var_ctx *env, ir_graph *irg)
 208 {
 209   FILE *f = env->f;
 210
 211   irg_walk_graph(irg, NULL, dump_var_def, env);
 212   fprintf(f, "  ir_node *in[%d];\n", env->max_arity);
 213   if (env->need_tv)
 214     fprintf(f, "  tarval *tv = NULL;\n");
 215   fprintf(f, "  const char *s = NULL;\n");
 216   fprintf(f, "  ir_entity *ent = NULL;\n");
 217   fprintf(f, "  ir_mode *mode = NULL;\n");
 218   fprintf(f, "  ir_graph *irg = NULL;\n");
 219   fprintf(f, "  ir_node *tmp = NULL;\n");
 220   fprintf(f, "  symconst_symbol sym;\n");
 221   if (env->need_unknown_X)
 222     fprintf(f, "  ir_node *unknownX = NULL;\n");
 223   if (env->need_unknown)
 224     fprintf(f, "  ir_node *unknown = NULL;\n");
 225   fprintf(f, "\n");
 226 }
 227
 228 /**
 229  * Generate code for a predefined node.
 230  *
 231  * @param f   file handle for output
 232  * @param n   the node
 233  *
 234  * @return non-zero if n was a predefined node, 0 else
 235  */
 236 static int generate_predef_node(FILE *f, ir_node *n)
 237 {
 238   ir_graph *irg = current_ir_graph;
 239
 240 #define X(code)                         \
 241   else if (n == code)                   \
 242     name(f, "  ", n, " = " #code ";\n");
 243
 244   if (0);
 245   X(get_irg_start(irg))
 246   X(get_irg_start_block(irg))
 247   X(get_irg_end(irg))
 248   X(get_irg_end_block(irg))
 249   X(get_irg_initial_exec(irg))
 250   X(get_irg_frame(irg))
 251   X(get_irg_tls(irg))
 252   X(get_irg_initial_mem(irg))
 253   X(get_irg_no_mem(irg))
 254   else
 255     return 0;
 256   return 1;
 257
 258 #undef X
 259 }
 260
 261 /**
 262  * Generate code for a Binop node.
 263  *
 264  * @param f   file handle for output
 265  * @param n   the node
 266  */
 267 static void generate_code_Binop(FILE *f, ir_node *n)
 268 {
 269   ir_op *op = get_irn_op(n);
 270   ir_node *right = get_binop_right(n);
 271
 272   name(f, "  ", n, " = ");
 273   fprintf(f, "new_r_%s(irg, ", get_op_name(op));
 274   name(f, NULL, get_nodes_block(n), ", ");
 275   name(f, NULL, right, ", ");
 276   name(f, NULL, get_binop_left(n), ", get_irn_mode(");
 277   name(f, NULL, right, "));\n");
 278 }
 279
 280 /**
 281  * Generate code for a Divop node.
 282  *
 283  * @param f   file handle for output
 284  * @param n   the node
 285  */
 286 static void generate_code_Divop(FILE *f, ir_node *n)
 287 {
 288   ir_op *op = get_irn_op(n);
 289   ir_node *right = get_binop_right(n);
 290   ir_mode *mode = get_divop_resmod(n);
 291
 292   name(f, "  ", n, " = ");
 293   fprintf(f, "new_r_%s(irg, ", get_op_name(op));
 294   name(f, NULL, get_nodes_block(n), ", ");
 295   name(f, NULL, get_fragile_op_mem(n), ", ");
 296   name(f, NULL, get_binop_left(n), ", ");
 297   name(f, NULL, right, ", ");
 298
 299   /* avoid to print the mode name if possible */
 300   if (mode == get_irn_mode(right)) {
 301     name(f, "get_irn_mode(", right, ");\n");
 302   } else {
 303     fprintf(f, "mode_%s);\n", get_mode_name(mode));
 304   }
 305 }
 306
 307 /**
 308  * Generate code for an Unop node.
 309  *
 310  * @param f   file handle for output
 311  * @param n   the node
 312  */
 313 static void generate_code_Unop(FILE *f, ir_node *n)
 314 {
 315   ir_op *op = get_irn_op(n);
 316   ir_node *irn = get_unop_op(n);
 317
 318   name(f, "  ", n, " = ");
 319   fprintf(f, "new_r_%s(irg, ", get_op_name(op));
 320   name(f, NULL, get_nodes_block(n), ", ");
 321   name(f, NULL, irn, ", get_irn_mode(");
 322   name(f, NULL, irn, "));\n");
 323 }
 324
 325 /**
 326  * Generate code for a Load.
 327  *
 328  * @param f   file handle for output
 329  * @param n   the node
 330  */
 331 static void generate_code_Load(FILE *f, ir_node *n)
 332 {
 333   ir_node       *ptr = get_Load_ptr(n);
 334   ir_op         *op = get_irn_op(ptr);
 335   ir_volatility vol;
 336
 337   /* try to detect the mode */
 338   if (op == op_Sel) {
 339     name(f, "  ent = get_Sel_entity(", ptr, ");\n");
 340     fprintf(f, "  mode = get_type_mode(get_entity_type(ent));\n");
 341   }
 342   else if (op == op_SymConst && get_SymConst_kind(ptr) == symconst_addr_ent) {
 343     name(f, "  ent = get_SymConst_entity(", ptr, ");\n");
 344     fprintf(f, "  mode = get_type_mode(get_entity_type(ent));\n");
 345   }
 346   else
 347     fprintf(f, "  mode = mode_%s;\n", get_mode_name(get_Load_mode(n)));
 348
 349   name(f, "  ", n, " = ");
 350   fprintf(f, "new_r_Load(irg, ");
 351   name(f, NULL, get_nodes_block(n), ", ");
 352   name(f, NULL, get_Load_mem(n), ", ");
 353   name(f, NULL, ptr, ", mode);\n");
 354   vol = get_Load_volatility(n);
 355   if (vol != volatility_non_volatile) {
 356     name(f, "  set_Load_volatility(", n, ", ");
 357     fprintf(f, "%s);\n", get_volatility_name(vol));
 358   }
 359 }
 360
 361 /**
 362  * Generate code for a Store.
 363  *
 364  * @param f   file handle for output
 365  * @param n   the node
 366  */
 367 static void generate_code_Store(FILE *f, ir_node *n)
 368 {
 369   ir_volatility vol;
 370
 371   name(f, "  ", n, " = ");
 372   fprintf(f, "new_r_Store(irg, ");
 373   name(f, NULL, get_nodes_block(n), ", ");
 374   name(f, NULL, get_Store_mem(n), ", ");
 375   name(f, NULL, get_Store_ptr(n), ", ");
 376   name(f, NULL, get_Store_value(n), ")\n");
 377   vol = get_Store_volatility(n);
 378   if (vol != volatility_non_volatile) {
 379     name(f, "  set_Store_volatility(", n, ", ");
 380     fprintf(f, "%s);\n", get_volatility_name(vol));
 381   }
 382 }
 383
 384 /**
 385  * Generate code for a Return.
 386  */
 387 static void generate_code_Return(FILE *f, ir_node *n)
 388 {
 389   int i, n_res = get_Return_n_ress(n);
 390
 391   if (n_res > 1)
 392     for (i = 0; i < n_res; ++i) {
 393       fprintf(f, "  in[%d] = ", i);
 394       name(f, NULL, get_Return_res(n, i), ";\n");
 395     }
 396   name(f, "  ", n, " = ");
 397   fprintf(f, "new_r_Return(irg, ");
 398   name(f, NULL, get_nodes_block(n), ", ");
 399   name(f, NULL, get_Return_mem(n), ", ");
 400   if (n_res > 1)
 401     fprintf(f, "%d, in);\n", n_res);
 402   else if (n_res == 1)
 403     name(f, "1, &", get_Return_res(n, 0), ");\n");
 404   else
 405     fprintf(f, "0, NULL);\n");
 406 }
 407
 408 /**
 409  * Generate code for a Raise.
 410  *
 411  * @param f   file handle for output
 412  * @param n   the node
 413  */
 414 static void generate_code_Raise(FILE *f, ir_node *n)
 415 {
 416   name(f, "  ", n, " = new_r_Return(irg, ");
 417   name(f, NULL, get_nodes_block(n), ", ");
 418   name(f, NULL, get_Raise_mem(n), ", ");
 419   name(f, NULL, get_Raise_exo_ptr(n), ");\n");
 420 }
 421
 422 /**
 423  * Generate code for a Bound.
 424  *
 425  * @param f   file handle for output
 426  * @param n   the node
 427  */
 428 static void generate_code_Bound(FILE *f, ir_node *n)
 429 {
 430   name(f, NULL, get_nodes_block(n), ", ");
 431   name(f, NULL, get_Bound_mem(n), ", ");
 432   name(f, NULL, get_Bound_index(n), ", ");
 433   name(f, NULL, get_Bound_lower(n), ", ");
 434   name(f, NULL, get_Bound_upper(n), ");\n");
 435 }
 436
 437 /**
 438  * Generate code for an Unknown.
 439  *
 440  * @param f   file handle for output
 441  * @param n   the node
 442  */
 443 static void generate_code_Unknown(FILE *f, ir_node *n)
 444 {
 445   name(f, "  ", n, " = new_r_Unknown(irg, ");
 446   fprintf(f, "mode_%s);\n", get_mode_name(get_irn_mode(n)));
 447 }
 448
 449 /**
 450  * Generate code for a Bad.
 451  *
 452  * @param f   file handle for output
 453  * @param n   the node
 454  */
 455 static void generate_code_Bad(FILE *f, ir_node *n)
 456 {
 457   name(f, "  ", n, " = new_r_Bad(irg);\n");
 458 }
 459
 460 /**
 461  * Generate code for a Const.
 462  *
 463  * @param f   file handle for output
 464  * @param n   the node
 465  */
 466 static void generate_code_Const(FILE *f, ir_node *n)
 467 {
 468   ir_type *tp = get_Const_type(n);
 469   tarval *tv = get_Const_tarval(n);
 470   ir_mode *mode = get_irn_mode(n);
 471   char buf[256];
 472
 473   if (tp == get_unknown_type()) {
 474     name(f, "  ", n, " = new_r_Const(irg, ");
 475   }
 476   else {
 477     name(f, "  ", n, " = new_r_Const_type(irg, ");
 478   }
 479   name(f, NULL, get_nodes_block(n), ", ");
 480   fprintf(f, "mode_%s, ", get_mode_name(mode));
 481
 482   if (! mode_is_reference(mode)) {
 483     if (tv == get_tarval_null(mode))
 484       fprintf(f, "get_tarval_null(mode)");
 485     else if (tv == get_tarval_one(mode))
 486       fprintf(f, "get_tarval_one(mode)");
 487     else if (tv == get_tarval_b_false())
 488       fprintf(f, "get_tarval_b_false()");
 489     else if (tv == get_tarval_b_true())
 490       fprintf(f, "get_tarval_b_true()");
 491         else if (tv == get_tarval_minus_one(mode))
 492           fprintf(f, "get_tarval_minus_one(mode)");
 493     else if (mode_is_float(mode)) {
 494                 if (tv == get_tarval_nan(mode))
 495                   fprintf(f, "get_tarval_nan(mode)");
 496                 else if (tv == get_tarval_minus_inf(mode))
 497                   fprintf(f, "get_tarval_minus_inf(mode)");
 498                 else if (tv == get_tarval_plus_inf(mode))
 499                   fprintf(f, "get_tarval_plus_inf(mode)");
 500                 else
 501                   goto def_mode;
 502         }
 503     else
 504       goto def_mode;
 505   }
 506   else {
 507     if (tv == get_tarval_null(mode))
 508       fprintf(f, "get_tarval_null(mode)");
 509     else {
 510 def_mode:
 511       tarval_snprintf(buf, sizeof(buf), tv);
 512       fprintf(f, "new_tarval_from_str(\"%s\", %u, ", buf, (unsigned) strlen(buf));
 513       fprintf(f, "mode_%s)", get_mode_name(mode));
 514     }
 515   }
 516
 517   if (tp != get_unknown_type())
 518     fprintf(f, ", %s", get_type_name(tp));
 519   fprintf(f, ");\n");
 520 }
 521
 522 /**
 523  * Generate code for a SymConst.
 524  *
 525  * @param f   file handle for output
 526  * @param n   the node
 527  */
 528 static void generate_code_SymConst(FILE *f, ir_node *n)
 529 {
 530   ident *id;
 531   ir_type *tp;
 532   ir_entity *ent;
 533   symconst_kind kind = get_SymConst_kind(n);
 534   const char *k_name = "NULL";
 535   const char *str;
 536
 537   switch (kind) {
 538   case symconst_addr_ent:
 539     fprintf(f, "  sym.entity_p = ENTITY(%s);\n", get_entity_name(get_SymConst_entity(n)));
 540     k_name = "symconst_addr_ent";
 541     break;
 542   case symconst_addr_name:
 543     id = get_SymConst_name(n);
 544     str = get_id_str(id);
 545     fprintf(f, "  sym.ident_p = new_id_from_chars(\"%s\", %d);\n", str, get_id_strlen(id));
 546     k_name = "symconst_addr_name";
 547     break;
 548   case symconst_type_size:
 549     tp = get_SymConst_type(n);
 550     fprintf(f, "  sym.type_p = %s;\n", get_type_name(tp));
 551     k_name = "symconst_type_size";
 552     break;
 553   case symconst_type_align:
 554     tp = get_SymConst_type(n);
 555     fprintf(f, "  sym.type_p = %s;\n", get_type_name(tp));
 556     k_name = "symconst_type_align";
 557     break;
 558   case symconst_type_tag:
 559     tp = get_SymConst_type(n);
 560     fprintf(f, "  sym.type_p = %s;\n", get_type_name(tp));
 561     k_name = "symconst_type_tag";
 562     break;
 563   case symconst_ofs_ent:
 564     ent = get_SymConst_entity(n);
 565     fprintf(f, "  sym.entity_p = %s;\n", get_entity_name(ent));
 566     k_name = "symconst_ofs_ent";
 567     break;
 568   case symconst_enum_const:
 569     id = get_SymConst_name(n);
 570     str = get_id_str(id);
 571     fprintf(f, "  sym.ident_p = new_id_from_chars(\"%s\", %d);\n", str, get_id_strlen(id));
 572     k_name = "symconst_enum_const";
 573     break;
 574   }
 575   name(f, "  ", n, " = new_r_SymConst(irg, ");
 576   name(f, NULL, get_nodes_block(n), ", sym, ");
 577   fprintf(f, "%s);\n", k_name);
 578 }
 579
 580 /**
 581  * Generate code for a Sel.
 582  *
 583  * @param f   file handle for output
 584  * @param n   the node
 585  */
 586 static void generate_code_Sel(FILE *f, ir_node *n)
 587 {
 588   int n_index = get_Sel_n_indexs(n);
 589   int i;
 590   ir_op *op;
 591   ir_node *ptr = get_Sel_ptr(n);
 592   ir_entity *ent = get_Sel_entity(n);
 593   int have_ent = 0;
 594
 595   if (n_index > 0) {
 596     ir_type *tp;
 597     ir_entity *up_ent;
 598
 599     /* try to detect the array entity */
 600     op = get_irn_op(ptr);
 601     if (op == op_SymConst && get_SymConst_kind(ptr) == symconst_addr_ent) {
 602       up_ent = get_SymConst_entity(ptr);
 603       tp = get_entity_type(up_ent);
 604       if (is_Array_type(tp) && get_array_element_entity(tp) == ent) {
 605         name(f, "  ent = get_SymConst_entity(", ptr, ");\n");
 606         fprintf(f, "  ent = get_array_element_entity(get_entity_type(ent));\n");
 607         have_ent = 1;
 608       }
 609     }
 610     else if (op == op_Sel) {
 611       up_ent = get_Sel_entity(ptr);
 612       tp = get_entity_type(up_ent);
 613       if (is_Array_type(tp) && get_array_element_entity(tp) == ent) {
 614         name(f, "  ent = get_Sel_entity(", ptr, ");\n");
 615         fprintf(f, "  ent = get_array_element_entity(get_entity_type(ent));\n");
 616         have_ent = 1;
 617       }
 618     }
 619   }
 620   if (n_index > 1)
 621     for (i = 0; i < n_index; ++i) {
 622       fprintf(f, "  in[%d] = ", i);
 623       name(f, NULL, get_Sel_index(n, i), ";\n");
 624     }
 625
 626   if (n_index == 0)
 627     name(f, "  ", n, " = new_r_simpleSel(irg, ");
 628   else
 629     name(f, "  ", n, " = new_r_Sel(irg, ");
 630   name(f, NULL, get_nodes_block(n), ", ");
 631   name(f, NULL, get_Sel_mem(n), ", ");
 632   name(f, NULL, ptr, ", ");
 633   if (n_index == 1)
 634     name(f, "1, &", get_Sel_index(n, 0), ", ");
 635   else if (n_index > 0)
 636     fprintf(f, "%d, in, ", n_index);
 637
 638   ent = get_Sel_entity(n);
 639   if (have_ent)
 640     fprintf(f, "ent);\n");
 641   else
 642     fprintf(f, "ENTITY(%s));\n", get_entity_name(get_Sel_entity(n)));
 643 }
 644
 645 /**
 646  * Generate code for a Block. Break loops here.
 647  *
 648  * @param f   file handle for output
 649  * @param n   the node
 650  */
 651 static void generate_code_Block(fix_ctx *env, ir_node *n)
 652 {
 653   FILE *f = env->f;
 654   int i, arity = get_irn_arity(n);
 655   for (i = 0; i < arity; ++i) {
 656     fprintf(f, "  in[%d] = ", i);
 657     if (is_backedge(n, i)) {
 658       fprintf(f, "unknownX;\n");
 659       env->has_backedges = 1;
 660     }
 661     else
 662       name(f, NULL, get_irn_n(n, i), ";\n");
 663   }
 664
 665   name(f, "  ", n, " = new_r_Block(irg, ");
 666   fprintf(f, "%d, in);\n", arity);
 667 }
 668
 669 /**
 670  * Generate code for a Phi. Break loops here.
 671  *
 672  * @param f   file handle for output
 673  * @param n   the node
 674  */
 675 static void generate_code_Phi(fix_ctx *env, ir_node *n)
 676 {
 677   FILE *f = env->f;
 678   int i, arity = get_irn_arity(n);
 679   ir_mode *mode = get_irn_mode(n);
 680
 681   if (has_backedges(n)) {
 682     fprintf(f, "  unknown = new_r_Unknown(irg, mode_%s);\n", get_mode_name(mode));
 683     env->has_backedges = 1;
 684   }
 685   for (i = 0; i < arity; ++i) {
 686     fprintf(f, "  in[%d] = ", i);
 687     if (is_backedge(n, i))
 688       fprintf(f, "unknown;\n");
 689     else
 690       name(f, NULL, get_irn_n(n, i), ";\n");
 691   }
 692
 693   name(f, "  ", n, " = new_r_Phi(irg, ");
 694   fprintf(f, "%d, in, mode_%s);\n", arity, get_mode_name(mode));
 695 }
 696
 697 /**
 698  * Generate code for a Proj(Load).
 699  *
 700  * @param f   file handle for output
 701  * @param n   the node
 702  */
 703 static void generate_code_Proj_Load(FILE *f, ir_node *n)
 704 {
 705   ir_node *pred = get_Proj_pred(n);
 706   ir_node *block = get_nodes_block(n);
 707   long proj_nr = get_Proj_proj(n);
 708   const char *mode = "NULL";
 709   const char *proj= "-1";
 710
 711   switch(proj_nr) {
 712   case pn_Load_M:
 713     mode = "mode_M";
 714     proj = "pn_Load_M";
 715     break;
 716   case pn_Load_X_regular:
 717     mode = "mode_X";
 718     proj = "pn_Load_X_regular";
 719     break;
 720   case pn_Load_X_except:
 721     mode = "mode_X";
 722     proj = "pn_Load_X_except";
 723     break;
 724   case pn_Load_res:
 725     mode = "mode";
 726     proj = "pn_Load_res";
 727     name(f, "  mode = get_Load_mode(", pred, ");\n");
 728     break;
 729   }
 730   name(f, "  ", n, " = new_r_Proj(irg, ");
 731   name(f, NULL, block, ", ");
 732   name(f, NULL, pred, ", ");
 733   fprintf(f, "%s, %s);\n", mode, proj);
 734 }
 735
 736 /**
 737  * Generate code for a Proj(Store).
 738  *
 739  * @param f   file handle for output
 740  * @param n   the node
 741  */
 742 static void generate_code_Proj_Store(FILE *f, ir_node *n)
 743 {
 744   ir_node *pred = get_Proj_pred(n);
 745   ir_node *block = get_nodes_block(n);
 746   long proj_nr = get_Proj_proj(n);
 747   const char *mode = "NULL";
 748   const char *proj= "-1";
 749
 750   switch(proj_nr) {
 751   case pn_Store_M:
 752     mode = "mode_M";
 753     proj = "pn_Store_M";
 754     break;
 755   case pn_Store_X_regular:
 756     mode = "mode_X";
 757     proj = "pn_Store_X_regular";
 758     break;
 759   case pn_Store_X_except:
 760     mode = "mode_X";
 761     proj = "pn_Store_X_except";
 762     break;
 763   }
 764   name(f, "  ", n, " = new_r_Proj(irg, ");
 765   name(f, NULL, block, ", ");
 766   name(f, NULL, pred, ", ");
 767   fprintf(f, "%s, %s);\n", mode, proj);
 768 }
 769
 770 /**
 771  * Generate code for a Proj(Div).
 772  *
 773  * @param f   file handle for output
 774  * @param n   the node
 775  */
 776 static void generate_code_Proj_Div(FILE *f, ir_node *n)
 777 {
 778   ir_node *pred = get_Proj_pred(n);
 779   ir_node *block = get_nodes_block(n);
 780   long proj_nr = get_Proj_proj(n);
 781   const char *mode = "NULL";
 782   const char *proj= "-1";
 783
 784   switch(proj_nr) {
 785   case pn_Div_M:
 786     mode = "mode_M";
 787     proj = "pn_Div_M";
 788     break;
 789   case pn_Div_X_regular:
 790     mode = "mode_X";
 791     proj = "pn_Div_X_regular";
 792     break;
 793   case pn_Div_X_except:
 794     mode = "mode_X";
 795     proj = "pn_Div_X_except";
 796     break;
 797   case pn_Div_res:
 798     mode = "mode";
 799     proj = "pn_Div_res";
 800     name(f, "  mode = get_Div_resmode(", pred, ");\n");
 801     break;
 802   }
 803   name(f, "  ", n, " = new_r_Proj(irg, ");
 804   name(f, NULL, block, ", ");
 805   name(f, NULL, pred, ", ");
 806   fprintf(f, "%s, %s);\n", mode, proj);
 807 }
 808
 809 /**
 810  * Generate code for a Proj(Mod).
 811  *
 812  * @param f   file handle for output
 813  * @param n   the node
 814  */
 815 static void generate_code_Proj_Mod(FILE *f, ir_node *n)
 816 {
 817   ir_node *pred = get_Proj_pred(n);
 818   ir_node *block = get_nodes_block(n);
 819   long proj_nr = get_Proj_proj(n);
 820   const char *mode = "NULL";
 821   const char *proj= "-1";
 822
 823   switch(proj_nr) {
 824   case pn_Mod_M:
 825     mode = "mode_M";
 826     proj = "pn_Mod_M";
 827     break;
 828   case pn_Mod_X_regular:
 829     mode = "mode_X";
 830     proj = "pn_Mod_X_regular";
 831     break;
 832   case pn_Mod_X_except:
 833     mode = "mode_X";
 834     proj = "pn_Mod_X_except";
 835     break;
 836   case pn_Mod_res:
 837     mode = "mode";
 838     proj = "pn_Mod_res";
 839     name(f, "  mode = get_Mod_resmode(", pred, ");\n");
 840     break;
 841   }
 842   name(f, "  ", n, " = new_r_Proj(irg, ");
 843   name(f, NULL, block, ", ");
 844   name(f, NULL, pred, ", ");
 845   fprintf(f, "%s, %s);\n", mode, proj);
 846 }
 847
 848 /**
 849  * Generate code for a Proj(DivMod).
 850  *
 851  * @param f   file handle for output
 852  * @param n   the node
 853  */
 854 static void generate_code_Proj_DivMod(FILE *f, ir_node *n)
 855 {
 856   ir_node *pred = get_Proj_pred(n);
 857   ir_node *block = get_nodes_block(n);
 858   long proj_nr = get_Proj_proj(n);
 859   const char *mode = "NULL";
 860   const char *proj= "-1";
 861
 862   switch(proj_nr) {
 863   case pn_DivMod_M:
 864     mode = "mode_M";
 865     proj = "pn_DivMod_M";
 866     break;
 867   case pn_DivMod_X_except:
 868     mode = "mode_X";
 869     proj = "pn_DivMod_X_except";
 870     break;
 871   case pn_DivMod_res_div:
 872     mode = "mode";
 873     proj = "pn_DivMod_res_div";
 874     name(f, "  mode = get_DivMod_resmode(", pred, ");\n");
 875     break;
 876   case pn_DivMod_res_mod:
 877     mode = "mode";
 878     proj = "pn_DivMod_res_mod";
 879     name(f, "  mode = get_DivMod_resmode(", pred, ");\n");
 880     break;
 881   }
 882   name(f, "  ", n, " = new_r_Proj(irg, ");
 883   name(f, NULL, block, ", ");
 884   name(f, NULL, pred, ", ");
 885   fprintf(f, "%s, %s);\n", mode, proj);
 886 }
 887
 888 /**
 889  * Generate code for a Proj(Cmp).
 890  *
 891  * @param f   file handle for output
 892  * @param n   the node
 893  */
 894 static void generate_code_Proj_Cmp(FILE *f, ir_node *n)
 895 {
 896   long proj_nr = get_Proj_proj(n);
 897
 898   name(f, "  ", n, " = new_r_Proj(irg, ");
 899   name(f, NULL, get_nodes_block(n), ", ");
 900   name(f, NULL, get_Proj_pred(n), ", ");
 901   fprintf(f, "mode_b, %s);\n", get_pnc_string(proj_nr));
 902 }
 903
 904 /**
 905  * Generate code for a Proj(Cond).
 906  *
 907  * @param f   file handle for output
 908  * @param n   the node
 909  */
 910 static void generate_code_Proj_Cond(FILE *f, ir_node *n)
 911 {
 912   ir_node *cond = get_Proj_pred(n);
 913   ir_node *sel = get_Cond_selector(cond);
 914   ir_node *block = get_nodes_block(n);
 915   long proj_nr = get_Proj_proj(n);
 916
 917   if (get_irn_mode(sel) == mode_b) {
 918     name(f, "  ", n, " = new_r_Proj(irg, ");
 919     name(f, NULL, block, ", ");
 920     name(f, NULL, cond, ", ");
 921     fprintf(f, "mode_b, %s);\n", proj_nr ? "pn_Cond_true" : "pn_Cond_false");
 922   }
 923   else {
 924     if (proj_nr == get_Cond_default_proj(cond))
 925       name(f, "  ", n, " = new_r_defaultProj(irg, ");
 926     else
 927       name(f, "  ", n, " = new_r_Proj(irg, ");
 928
 929     name(f, NULL, block, ", ");
 930     name(f, NULL, cond, ", ");
 931     fprintf(f, "mode_%s, %ld);\n", get_mode_name(get_irn_mode(n)), proj_nr);
 932   }
 933 }
 934
 935 /**
 936  * Generate code for a Proj.
 937  *
 938  * @param f   file handle for output
 939  * @param n   the node
 940  */
 941 static void generate_code_Proj(FILE *f, ir_node *n)
 942 {
 943   ir_node *pred = get_Proj_pred(n);
 944
 945   switch (get_irn_opcode(pred)) {
 946   case iro_Load:
 947     generate_code_Proj_Load(f, n);
 948     break;
 949   case iro_Store:
 950     generate_code_Proj_Store(f, n);
 951     break;
 952   case iro_Div:
 953     generate_code_Proj_Div(f, n);
 954     break;
 955   case iro_Mod:
 956     generate_code_Proj_Mod(f, n);
 957     break;
 958   case iro_DivMod:
 959     generate_code_Proj_DivMod(f, n);
 960     break;
 961   case iro_Cmp:
 962     generate_code_Proj_Cmp(f, n);
 963     break;
 964   case iro_Cond:
 965     generate_code_Proj_Cond(f, n);
 966     break;
 967   default: {
 968     const char *mode_name = get_mode_name(get_irn_mode(n));
 969     name(f, "  ", n, " = new_r_Proj(irg, ");
 970     name(f, NULL, get_nodes_block(n), ", ");
 971     name(f, NULL, get_Proj_pred(n), ", ");
 972     fprintf(f, "mode_%s, %ld);\n", mode_name, get_Proj_proj(n));
 973   }
 974   }
 975 }
 976
 977 /**
 978  * Generate code for a Jmp.
 979  *
 980  * @param f   file handle for output
 981  * @param n   the node
 982  */
 983 static void generate_code_Jmp(FILE *f, ir_node *n)
 984 {
 985   name(f, "  ", n, " = new_r_Jmp(irg, ");
 986   name(f, NULL, get_nodes_block(n), ");\n");
 987 }
 988
 989 /**
 990  * Generate code for a Cond.
 991  *
 992  * @param f   file handle for output
 993  * @param n   the node
 994  */
 995 static void generate_code_Cond(FILE *f, ir_node *n)
 996 {
 997   name(f, "  ", n, " = new_r_Cond(irg, ");
 998   name(f, NULL, get_nodes_block(n), ", ");
 999   name(f, NULL, get_Cond_selector(n), ");\n");
1000 }
1001
1002 /**
1003  * Generate code for a Call.
1004  *
1005  * @param f   file handle for output
1006  * @param n   the node
1007  */
1008 static void generate_code_Call(FILE *f, ir_node *n)
1009 {
1010   int i, n_param = get_Call_n_params(n);
1011   ir_node *ptr = get_Call_ptr(n);
1012   ir_op *op = get_irn_op(ptr);
1013   ir_entity *ent;
1014   ir_type *tp = get_Call_type(n);
1015   int have_tp = 0;
1016
1017   /* try to detect the type */
1018   if (op == op_Sel) {
1019     ent = get_Sel_entity(ptr);
1020     if (tp == get_entity_type(ent)) {
1021       name(f, "  ent = get_Sel_entity(", ptr, ");\n");
1022       fprintf(f, "  tp = get_entity_type(ent);\n");
1023       have_tp = 1;
1024     }
1025   }
1026   else if (op == op_SymConst && get_SymConst_kind(ptr) == symconst_addr_ent) {
1027     ent = get_SymConst_entity(ptr);
1028     if (tp == get_entity_type(ent)) {
1029       name(f, "  ent = get_SymConst_entity(", ptr, ");\n");
1030       fprintf(f, "  tp = get_entity_type(ent);\n");
1031       have_tp = 1;
1032     }
1033   }
1034   if (! have_tp)
1035     fprintf(f, "  tp = TYPE(%s);\n", get_type_name(tp));
1036
1037   for (i = 0; i < n_param; ++i) {
1038     fprintf(f, "  in[%d] = ", i);
1039     name(f, NULL, get_Call_param(n, i), ";\n");
1040   }
1041   name(f, "  ", n, " = ");
1042   fprintf(f, "new_r_Call(irg, ");
1043   name(f, NULL, get_nodes_block(n), ", ");
1044   name(f, NULL, get_Call_mem(n), ", ");
1045   if (n_param > 0)
1046     fprintf(f, "%d, in, tp);\n", n_param);
1047   else
1048     fprintf(f, "0, NULL, tp);\n");
1049 }
1050
1051 /**
1052  * Create code for the given Alloc node
1053  *
1054  * @param f   file handle for output
1055  * @param n   the node
1056  */
1057 static void generate_code_Alloc(FILE *f, ir_node *n)
1058 {
1059   name(f, "  ", n, " = new_r_Alloc(irg, ");
1060   name(f, NULL, get_nodes_block(n), ", ");
1061   name(f, NULL, get_Alloc_mem(n), ", ");
1062   name(f, NULL, get_Alloc_size(n), ", tp, ");
1063   fprintf(f, get_Alloc_where(n) == stack_alloc ? "stack_alloc);\n" : "heap_alloc);\n");
1064 }
1065
1066 /**
1067  * Create code for the given Free node
1068  *
1069  * @param f   file handle for output
1070  * @param n   the node
1071  */
1072 static void generate_code_Free(FILE *f, ir_node *n)
1073 {
1074   fprintf(f, "  tp = TYPE(%s);\n", get_type_name(get_Free_type(n)));
1075   name(f, "  ", n, " = new_r_Alloc(irg, ");
1076   name(f, NULL, get_nodes_block(n), ", ");
1077   name(f, NULL, get_Free_ptr(n), ", ");
1078   name(f, NULL, get_Free_size(n), ", tp, ");
1079   fprintf(f, get_Free_where(n) == stack_alloc ? "stack_alloc);\n" : "heap_alloc);\n");
1080 }
1081
1082 /**
1083  * Create code for the given node constructor.
1084  *
1085  * @param f   file handle for output
1086  * @param n   the node
1087  */
1088 static void generate_node(fix_ctx *env, ir_node *n)
1089 {
1090   FILE *f = env->f;
1091   ir_op *op = get_irn_op(n);
1092
1093   if (op == op_Div || op == op_Mod || op == op_DivMod || op == op_Quot)
1094     generate_code_Divop(f, n);
1095   else if (op == op_Load)
1096     generate_code_Load(f, n);
1097   else if (op == op_Store)
1098     generate_code_Store(f, n);
1099   else if (op == op_Return)
1100     generate_code_Return(f, n);
1101   else if (op == op_Raise)
1102     generate_code_Raise(f, n);
1103   else if (op == op_Bound)
1104     generate_code_Bound(f, n);
1105   else if (op == op_Unknown)
1106     generate_code_Unknown(f, n);
1107   else if (op == op_Bad)
1108     generate_code_Bad(f, n);
1109   else if (op == op_Const)
1110     generate_code_Const(f, n);
1111   else if (op == op_SymConst)
1112     generate_code_SymConst(f, n);
1113   else if (op == op_Sel)
1114     generate_code_Sel(f, n);
1115   else if (op == op_Block)
1116     generate_code_Block(env, n);
1117   else if (op == op_Phi)
1118     generate_code_Phi(env, n);
1119   else if (op == op_Proj)
1120     generate_code_Proj(f, n);
1121   else if (op == op_Jmp)
1122     generate_code_Jmp(f, n);
1123   else if (op == op_Cond)
1124     generate_code_Cond(f, n);
1125   else if (op == op_Call)
1126     generate_code_Call(f, n);
1127   else if (op == op_Alloc)
1128     generate_code_Alloc(f, n);
1129   else if (op == op_Free)
1130     generate_code_Free(f, n);
1131   else if (is_binop(n))
1132     generate_code_Binop(f, n);
1133   else if (is_unop(n))
1134     generate_code_Unop(f, n);
1135   else
1136     name(f, "  ", n, " = NULL;\n");
1137 }
1138
1139 /**
1140  * Walker: Create code for the given node.
1141  */
1142 static void dump_code(ir_node *n, void *ctx)
1143 {
1144   fix_ctx *env = ctx;
1145
1146   if (! generate_predef_node(env->f, n))
1147     generate_node(env, n);
1148 }
1149
1150 /**
1151  * Generate Firm code.
1152  *
1153  * @param env  a fix environment
1154  * @param irg  the graph
1155  */
1156 static void generate_code(fix_ctx *env, ir_graph *irg)
1157 {
1158   irg_walk_graph(irg, NULL, dump_code, env);
1159 }
1160
1161 /**
1162  * Generate Firm assembler for a given graph
1163  *
1164  * @param f    the output file handle
1165  * @param irg  the graph
1166  */
1167 static void gen_Firm_assembler_irg(FILE *f, ir_graph *irg)
1168 {
1169   fix_ctx fenv;
1170   var_ctx venv;
1171
1172   venv.f              = f;
1173   venv.max_arity      = 0;
1174   venv.need_tv        = 0;
1175   venv.need_unknown_X = 0;
1176   venv.need_unknown   = 0;
1177
1178   fenv.f              = f;
1179   fenv.start_block    = get_irg_start_block(irg);
1180   fenv.has_backedges  = 0;
1181
1182   /* needed to detect loops */
1183   construct_backedges(irg);
1184
1185   generate_header(f, irg);
1186   generate_var_decls(&venv, irg);
1187   generate_prolog(&venv, irg);
1188   generate_code(&fenv, irg);
1189   generate_epilog(&fenv, irg);
1190 }
1191
1192 void gen_Firm_assembler(const char *input_filename)
1193 {
1194   FILE     *f;
1195   ir_graph *irg;
1196   int      i, n;
1197   (void) input_filename;
1198
1199   f = fopen("firm_output.c", "w");
1200   if (f) {
1201     for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
1202       irg = get_irp_irg(i);
1203       gen_Firm_assembler_irg(f, irg);
1204     }
1205   }
1206   else {
1207     /* report some error here */
1208   }
1209   fclose(f);
1210 }