nsz Git - libfirm/blob - ir/be/ppc32/ppc32_emitter.c

   1 /*
   2  * Copyright (C) 1995-2007 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   ppc emitter
  23  * @author  Moritz Kroll, Jens Mueller
  24  * @version $Id$
  25  */
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <limits.h>
  31
  32 #include "xmalloc.h"
  33 #include "tv.h"
  34 #include "iredges.h"
  35 #include "debug.h"
  36 #include "irgwalk.h"
  37 #include "irprintf.h"
  38 #include "irop_t.h"
  39 #include "irnode_t.h"
  40 #include "irargs_t.h"
  41 #include "error.h"
  42
  43 #include "../besched_t.h"
  44 #include "../benode_t.h"
  45
  46 #include "ppc32_emitter.h"
  47 #include "gen_ppc32_emitter.h"
  48 #include "gen_ppc32_regalloc_if.h"
  49 #include "ppc32_nodes_attr.h"
  50 #include "ppc32_new_nodes.h"
  51 #include "ppc32_map_regs.h"
  52
  53 #define SNPRINTF_BUF_LEN 128
  54
  55 static char printbuf[SNPRINTF_BUF_LEN];
  56
  57 extern int isleaf;
  58
  59
  60 /*************************************************************
  61  *             _       _    __   _          _
  62  *            (_)     | |  / _| | |        | |
  63  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
  64  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
  65  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
  66  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
  67  * | |                                       | |
  68  * |_|                                       |_|
  69  *************************************************************/
  70 /**
  71  * Returns the register at in position pos.
  72  */
  73 static const arch_register_t *get_in_reg(const arch_env_t *arch_env, const ir_node *irn, int pos) {
  74         ir_node                *op;
  75         const arch_register_t  *reg = NULL;
  76
  77         assert(get_irn_arity(irn) > pos && "Invalid IN position");
  78
  79         /* The out register of the operator at position pos is the
  80            in register we need. */
  81         op = get_irn_n(irn, pos);
  82
  83         reg = arch_get_irn_register(arch_env, op);
  84
  85         assert(reg && "no in register found");
  86         return reg;
  87 }
  88
  89 /**
  90  * Returns the register at out position pos.
  91  */
  92 static const arch_register_t *get_out_reg(const arch_env_t *arch_env, const ir_node *irn, int pos) {
  93         ir_node                *proj;
  94         const arch_register_t  *reg = NULL;
  95
  96         assert(get_irn_n_edges(irn) > pos && "Invalid OUT position");
  97
  98         /* 1st case: irn is not of mode_T, so it has only                 */
  99         /*           one OUT register -> good                             */
 100         /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
 101         /*           Proj with the corresponding projnum for the register */
 102
 103         if (get_irn_mode(irn) != mode_T) {
 104                 reg = arch_get_irn_register(arch_env, irn);
 105         } else if (is_ppc32_irn(irn)) {
 106                 reg = get_ppc32_out_reg(irn, pos);
 107         } else {
 108                 const ir_edge_t *edge;
 109
 110                 foreach_out_edge(irn, edge) {
 111                         proj = get_edge_src_irn(edge);
 112                         assert(is_Proj(proj) && "non-Proj from mode_T node");
 113                         if (get_Proj_proj(proj) == pos) {
 114                                 reg = arch_get_irn_register(arch_env, proj);
 115                                 break;
 116                         }
 117                 }
 118         }
 119
 120         assert(reg && "no out register found");
 121         return reg;
 122 }
 123
 124 /**
 125  * Emit the name of the source register at given input position.
 126  */
 127 void ppc32_emit_source_register(ppc32_emit_env_t *env, const ir_node *node, int pos) {
 128         const arch_register_t *reg = get_in_reg(env->arch_env, node, pos);
 129         be_emit_string(env->emit, arch_register_get_name(reg));
 130 }
 131
 132 /**
 133  * Emit the name of the destination register at given output position.
 134  */
 135 void ppc32_emit_dest_register(ppc32_emit_env_t *env, const ir_node *node, int pos) {
 136         const arch_register_t *reg = get_out_reg(env->arch_env, node, pos);
 137         be_emit_string(env->emit, arch_register_get_name(reg));
 138 }
 139
 140 void ppc32_emit_rlwimi_helper(ppc32_emit_env_t *env, const ir_node *n) {
 141         rlwimi_const_t *rlwimi_const = get_ppc32_rlwimi_const(n);
 142
 143         be_emit_irprintf(env->emit, "%i, %i, %i", rlwimi_const->shift,
 144                 rlwimi_const->maskA, rlwimi_const->maskB);
 145 }
 146
 147 /**
 148  * Emit a const or symconst.
 149  */
 150 void ppc32_emit_immediate(ppc32_emit_env_t *env, const ir_node *n) {
 151         const char *buf;
 152
 153         switch (get_ppc32_type(n)) {
 154         case ppc32_ac_Const:
 155                 tarval_snprintf(printbuf, SNPRINTF_BUF_LEN, get_ppc32_constant_tarval(n));
 156                 buf = printbuf;
 157                 break;
 158         case ppc32_ac_SymConst:
 159                 buf = get_id_str(get_ppc32_symconst_ident(n));
 160                 break;
 161         case ppc32_ac_Offset:
 162                 be_emit_irprintf(env->emit, "%i", get_ppc32_offset(n));
 163                 return;
 164         default:
 165                 assert(0 && "node_const_to_str(): Illegal offset type");
 166                 return;
 167         }
 168         switch (get_ppc32_offset_mode(n)) {
 169         case ppc32_ao_None:
 170                 be_emit_string(env->emit, buf);
 171                 return;
 172         case ppc32_ao_Lo16:
 173                 be_emit_irprintf(env->emit, "lo16(%s)", buf);
 174                 return;
 175         case ppc32_ao_Hi16:
 176                 be_emit_irprintf(env->emit, "hi16(%s)", buf);
 177                 return;
 178         case ppc32_ao_Ha16:
 179                 be_emit_irprintf(env->emit, "ha16(%s)", buf);
 180                 return;
 181         default:
 182                 assert(0 && "node_const_to_str(): Illegal offset mode");
 183                 return;
 184         }
 185 }
 186
 187 /**
 188  * Emits a node's offset.
 189  */
 190 void ppc32_emit_offset(ppc32_emit_env_t *env, const ir_node *n) {
 191         const char *buf;
 192         if (get_ppc32_type(n) == ppc32_ac_None) {
 193                 be_emit_char(env->emit, '0');
 194                 return;
 195         }
 196
 197         switch (get_ppc32_type(n)) {
 198         case ppc32_ac_Const:
 199                 tarval_snprintf(printbuf, SNPRINTF_BUF_LEN, get_ppc32_constant_tarval(n));
 200                 buf = printbuf;
 201                 break;
 202         case ppc32_ac_SymConst:
 203                 buf = get_id_str(get_ppc32_symconst_ident(n));
 204                 break;
 205         case ppc32_ac_Offset:
 206                 be_emit_irprintf(env->emit, "%i", get_ppc32_offset(n));
 207                 return;
 208         default:
 209                 assert(0 && "node_offset_to_str(): Illegal offset type");
 210                 return;
 211         }
 212         switch (get_ppc32_offset_mode(n)) {
 213         case ppc32_ao_None:
 214                 be_emit_string(env->emit, buf);
 215                 return;
 216         case ppc32_ao_Lo16:
 217                 be_emit_irprintf(env->emit, "lo16(%s)", buf);
 218                 return;
 219         case ppc32_ao_Hi16:
 220                 be_emit_irprintf(env->emit, "hi16(%s)", buf);
 221                 return;
 222         case ppc32_ao_Ha16:
 223                 be_emit_irprintf(env->emit, "ha16(%s)", buf);
 224                 return;
 225         default:
 226                 assert(0 && "node_offset_to_str(): Illegal offset mode");
 227                 return;
 228         }
 229 }
 230
 231 /**
 232  * Returns the target label for a control flow node.
 233  */
 234 static char *get_cfop_target(const ir_node *irn, char *buf) {
 235         ir_node *bl = get_irn_link(irn);
 236
 237         snprintf(buf, SNPRINTF_BUF_LEN, "BLOCK_%ld", get_irn_node_nr(bl));
 238         return buf;
 239 }
 240
 241 /**
 242  * Emits code for a unconditional jump.
 243  */
 244 static void emit_Jmp(ppc32_emit_env_t *env, const ir_node *irn) {
 245         ir_node *block = get_nodes_block(irn);
 246
 247         if (get_irn_link(irn) != get_irn_link(block)) {
 248                 be_emit_irprintf(env->emit, "\tb %s", get_cfop_target(irn, printbuf));
 249         } else {
 250                 be_emit_irprintf(env->emit, "/* fallthrough(%+F) */", get_irn_link(irn));
 251         }
 252         be_emit_finish_line_gas(env->emit, irn);
 253 }
 254
 255 /**
 256  * Emits code for a call
 257  */
 258 static void emit_be_Call(ppc32_emit_env_t *env, const ir_node *irn) {
 259         ir_entity *call_ent = be_Call_get_entity(irn);
 260
 261         if (call_ent) {
 262                 mark_entity_visited(call_ent);
 263                 be_emit_irprintf(env->emit, "\tbl %s", get_entity_ld_name(call_ent));
 264         } else {
 265                 be_emit_cstring(env->emit, "\tmtlr ");
 266                 ppc32_emit_source_register(env, irn, be_pos_Call_ptr);
 267                 be_emit_pad_comment(env->emit);
 268                 be_emit_cstring(env->emit, "/* Move to link register and link */\n");
 269                 be_emit_write_line(env->emit);
 270                 be_emit_cstring(env->emit, "\tblrl");
 271         }
 272         be_emit_finish_line_gas(env->emit, irn);
 273 }
 274
 275 static void emit_ppc32_Branch(ppc32_emit_env_t *env, const ir_node *irn) {
 276         static const char *branchops[8] = { 0, "beq", "blt", "ble", "bgt", "bge", "bne", "b" };
 277         int projnum = get_ppc32_proj_nr(irn);
 278
 279         const ir_edge_t *edge = get_irn_out_edge_first(irn);
 280         ir_node *proj = get_edge_src_irn(edge);
 281
 282         int opind;
 283
 284         if (get_Proj_proj(proj) == pn_Cond_true)
 285                 opind = projnum;
 286         else
 287                 opind = 7 - projnum;
 288
 289         assert(opind>=0 && opind<8);
 290
 291         if (opind){
 292                 get_cfop_target(proj, printbuf);
 293                 be_emit_irprintf(env->emit, "\t%8s", branchops[opind]);
 294                 ppc32_emit_source_register(env, irn, 0);
 295                 be_emit_cstring(env->emit, ", ");
 296                 be_emit_string(env->emit, printbuf);
 297                 be_emit_finish_line_gas(env->emit, irn);
 298         }
 299
 300         edge = get_irn_out_edge_next(irn, edge);
 301         if (edge) {
 302                 ir_node *blk = get_edge_src_irn(edge);
 303                 be_emit_cstring(env->emit, "\tb ");
 304                 be_emit_string(env->emit, get_cfop_target(blk, printbuf));
 305                 be_emit_finish_line_gas(env->emit, irn);
 306         }
 307 }
 308
 309 static void emit_ppc32_LoopCopy(ppc32_emit_env_t *env, const ir_node *irn) {
 310         be_emit_irprintf(env->emit, "LOOP_%ld:\n", get_irn_node_nr(irn));
 311         be_emit_write_line(env->emit);
 312
 313         be_emit_cstring(env->emit, "\tlwzu ");
 314         ppc32_emit_dest_register(env, irn, 4);
 315         be_emit_cstring(env->emit, ", 4(");
 316         ppc32_emit_source_register(env, irn, 1);
 317         be_emit_char(env->emit, ')');
 318         be_emit_pad_comment(env->emit);
 319         be_emit_cstring(env->emit, "/* Load with update */\n");
 320         be_emit_write_line(env->emit);
 321
 322         be_emit_cstring(env->emit, "\tstwu ");
 323         ppc32_emit_dest_register(env, irn, 4);
 324         be_emit_cstring(env->emit, ", 4(");
 325         ppc32_emit_source_register(env, irn, 2);
 326         be_emit_char(env->emit, ')');
 327         be_emit_pad_comment(env->emit);
 328         be_emit_cstring(env->emit, "/* Store with update */\n");
 329         be_emit_write_line(env->emit);
 330
 331         be_emit_irprintf(env->emit, "\tbdnz LOOP_%i", get_irn_node_nr(irn));
 332         be_emit_finish_line_gas(env->emit, irn);
 333 }
 334
 335 static void emit_ppc32_Switch(ppc32_emit_env_t *env, const ir_node *irn) {
 336         ir_node *proj, *defproj = NULL;
 337         int pn;
 338
 339         const ir_edge_t* edge;
 340         foreach_out_edge(irn, edge) {
 341                 proj = get_edge_src_irn(edge);
 342                 assert(is_Proj(proj) && "Only proj allowed at Switch");
 343                 if (get_irn_mode(proj) != mode_X) continue;
 344
 345                 pn = get_Proj_proj(proj);
 346                 /* check for default proj */
 347                 if (pn == get_ppc32_proj_nr(irn)) {
 348                         assert(defproj == NULL && "found two defProjs at Switch");
 349                         defproj = proj;
 350                 } else {
 351                         be_emit_cstring(env->emit, "\taddis ");
 352                         ppc32_emit_source_register(env, irn, 1);
 353                         be_emit_irprintf(env->emit, ", 0, hi16(%i)", pn);
 354                         be_emit_pad_comment(env->emit);
 355                         be_emit_cstring(env->emit, "/* Load upper immediate */\n");
 356                         be_emit_write_line(env->emit);
 357
 358                         be_emit_cstring(env->emit, "\tori ");
 359                         ppc32_emit_source_register(env, irn, 1);
 360                         be_emit_cstring(env->emit, ", ");
 361                         ppc32_emit_source_register(env, irn, 1);
 362                         be_emit_irprintf(env->emit, ", lo16(%i)", pn);
 363                         be_emit_pad_comment(env->emit);
 364                         be_emit_cstring(env->emit, "/* Load lower immediate */\n");
 365                         be_emit_write_line(env->emit);
 366
 367                         be_emit_cstring(env->emit, "\tcmp ");
 368                         ppc32_emit_source_register(env, irn, 2);
 369                         be_emit_cstring(env->emit, ", ");
 370                         ppc32_emit_source_register(env, irn, 0);
 371                         be_emit_cstring(env->emit, ", ");
 372                         ppc32_emit_source_register(env, irn, 1);
 373                         be_emit_pad_comment(env->emit);
 374                         be_emit_cstring(env->emit, "/* Compare */\n");
 375                         be_emit_write_line(env->emit);
 376
 377                         be_emit_cstring(env->emit, "\tbeq ");
 378                         ppc32_emit_source_register(env, irn, 2);
 379                         be_emit_irprintf(env->emit, ", %s", get_cfop_target(proj, printbuf));
 380                         be_emit_cstring(env->emit, "/* Branch if equal */\n");
 381                         be_emit_write_line(env->emit);
 382                 }
 383         }
 384         assert(defproj != NULL && "didn't find defProj at Switch");
 385         be_emit_irprintf(env->emit, "\tb %s", get_cfop_target(defproj, printbuf));
 386         be_emit_finish_line_gas(env->emit, irn);
 387 }
 388
 389 /**
 390  * Emits code for a backend Copy node
 391  */
 392 static void emit_be_Copy(ppc32_emit_env_t *env,const ir_node *irn) {
 393         const arch_register_class_t *regclass = arch_get_irn_reg_class(env->arch_env, irn, 0);
 394
 395         if (regclass == &ppc32_reg_classes[CLASS_ppc32_gp]) {
 396                 be_emit_cstring(env->emit, "\tmr ");
 397         } else if (regclass == &ppc32_reg_classes[CLASS_ppc32_fp]) {
 398                 be_emit_cstring(env->emit, "\tfmr ");
 399         } else if (regclass == &ppc32_reg_classes[CLASS_ppc32_condition]) {
 400                 be_emit_cstring(env->emit, "\tmcrf ");
 401         } else {
 402                 assert(0 && "Illegal register class for Copy");
 403                 panic("ppc32 Emitter: Illegal register class for Copy");
 404         }
 405         ppc32_emit_dest_register(env, irn, 0);
 406         be_emit_cstring(env->emit, ", ");
 407         ppc32_emit_source_register(env, irn, 0);
 408         be_emit_finish_line_gas(env->emit, irn);
 409 }
 410
 411 /**
 412  * Emits code for a backend Perm node
 413  */
 414 static void emit_be_Perm(ppc32_emit_env_t *env, const ir_node *irn) {
 415         const arch_register_class_t *regclass = arch_get_irn_reg_class(env->arch_env, irn, 0);
 416
 417         if (regclass == &ppc32_reg_classes[CLASS_ppc32_gp]) {
 418                 be_emit_cstring(env->emit, "\txor ");
 419                 ppc32_emit_source_register(env, irn, 0);
 420                 be_emit_cstring(env->emit, ", ");
 421                 ppc32_emit_source_register(env, irn, 0);
 422                 be_emit_cstring(env->emit, ", ");
 423                 ppc32_emit_source_register(env, irn, 1);
 424                 be_emit_pad_comment(env->emit);
 425                 be_emit_cstring(env->emit, "/* Swap with XOR */\n");
 426                 be_emit_write_line(env->emit);
 427
 428                 be_emit_cstring(env->emit, "\txor ");
 429                 ppc32_emit_source_register(env, irn, 1);
 430                 be_emit_cstring(env->emit, ", ");
 431                 ppc32_emit_source_register(env, irn, 0);
 432                 be_emit_cstring(env->emit, ", ");
 433                 ppc32_emit_source_register(env, irn, 1);
 434                 be_emit_pad_comment(env->emit);
 435                 be_emit_cstring(env->emit, "/* (continued) */\n");
 436                 be_emit_write_line(env->emit);
 437
 438                 be_emit_cstring(env->emit, "\txor ");
 439                 ppc32_emit_source_register(env, irn, 0);
 440                 be_emit_cstring(env->emit, ", ");
 441                 ppc32_emit_source_register(env, irn, 0);
 442                 be_emit_cstring(env->emit, ", ");
 443                 ppc32_emit_source_register(env, irn, 1);
 444         } else if (regclass == &ppc32_reg_classes[CLASS_ppc32_fp]) {
 445                 be_emit_cstring(env->emit, "\tfmr f0, ");
 446                 ppc32_emit_source_register(env, irn, 0);
 447                 be_emit_pad_comment(env->emit);
 448                 be_emit_cstring(env->emit, "/* Swap with moves */\n");
 449                 be_emit_write_line(env->emit);
 450
 451                 be_emit_cstring(env->emit, "\tfmr ");
 452                 ppc32_emit_source_register(env, irn, 0);
 453                 be_emit_cstring(env->emit, ", ");
 454                 ppc32_emit_source_register(env, irn, 1);
 455                 be_emit_pad_comment(env->emit);
 456                 be_emit_cstring(env->emit, "/* (continued) */\n");
 457                 be_emit_write_line(env->emit);
 458
 459                 be_emit_cstring(env->emit, "\tfmr ");
 460                 ppc32_emit_source_register(env, irn, 1);
 461                 be_emit_cstring(env->emit, ", f0");
 462         } else if (regclass == &ppc32_reg_classes[CLASS_ppc32_condition]) {
 463                 be_emit_cstring(env->emit, "\tmcrf cr7, ");
 464                 ppc32_emit_source_register(env, irn, 0);
 465                 be_emit_pad_comment(env->emit);
 466                 be_emit_cstring(env->emit, "/* Swap with moves */\n");
 467                 be_emit_write_line(env->emit);
 468
 469                 be_emit_cstring(env->emit, "\tmcrf ");
 470                 ppc32_emit_source_register(env, irn, 0);
 471                 be_emit_cstring(env->emit, ", ");
 472                 ppc32_emit_source_register(env, irn, 1);
 473                 be_emit_pad_comment(env->emit);
 474                 be_emit_cstring(env->emit, "/* (continued) */\n");
 475                 be_emit_write_line(env->emit);
 476
 477                 be_emit_cstring(env->emit, "\tmcrf ");
 478                 ppc32_emit_source_register(env, irn, 1);
 479                 be_emit_cstring(env->emit, ", cr7");
 480         } else {
 481                 assert(0 && "Illegal register class for Perm");
 482                 panic("ppc32 Emitter: Illegal register class for Perm");
 483         }
 484         be_emit_finish_line_gas(env->emit, irn);
 485 }
 486
 487
 488 /**
 489  * Emits code for a proj -> node
 490  */
 491 static void emit_Proj(ppc32_emit_env_t *env, const ir_node *irn) {
 492         ir_node *pred = get_Proj_pred(irn);
 493
 494         if (get_irn_op(pred) == op_Start) {
 495                 if (get_Proj_proj(irn) == pn_Start_X_initial_exec) {
 496                         emit_Jmp(env, irn);
 497                 }
 498         }
 499 }
 500
 501 static void emit_be_IncSP(ppc32_emit_env_t *env, const ir_node *irn) {
 502         int offs = be_get_IncSP_offset(irn);
 503
 504         be_emit_irprintf(env->emit, "\t/* ignored IncSP with %d */", -offs);
 505         be_emit_finish_line_gas(env->emit, irn);
 506
 507 //      if (offs) {
 508 //              assert(offs<=0x7fff);
 509 //              lc_efprintf(ppc32_get_arg_env(), F, "\taddi    %1S, %1S, %d\t\t\t/* %+F (IncSP) */\n", irn, irn,
 510 //                      -offs, irn);
 511 //      }
 512 //      else {
 513 //              fprintf(F, "\t\t\t\t\t/* omitted IncSP with 0 */\n");
 514 //      }
 515 }
 516
 517 /*static void emit_Spill(const ir_node *irn, ppc32_emit_env_t *emit_env) {
 518         ir_node *context = be_get_Spill_context(irn);
 519         ir_entity *entity = be_get_spill_entity(irn);
 520 }*/
 521
 522 /***********************************************************************************
 523  *                  _          __                                             _
 524  *                 (_)        / _|                                           | |
 525  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
 526  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
 527  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
 528  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
 529  *
 530  ***********************************************************************************/
 531 /**
 532  * The type of a emitter function.
 533  */
 534 typedef void (emit_func)(ppc32_emit_env_t *env, const ir_node *irn);
 535
 536 /**
 537  * Set a node emitter. Make it a bit more type safe.
 538  */
 539 static INLINE void set_emitter(ir_op *op, emit_func ppc32_emit_node) {
 540         op->ops.generic = (op_func)ppc32_emit_node;
 541 }
 542
 543 static void ppc32_register_emitters(void) {
 544         /* first clear generic function pointers */
 545         clear_irp_opcodes_generic_func();
 546
 547         /* register generated emitter functions */
 548         ppc32_register_spec_emitters();
 549
 550         set_emitter(op_ppc32_Branch, emit_ppc32_Branch);
 551         set_emitter(op_ppc32_LoopCopy, emit_ppc32_LoopCopy);
 552         set_emitter(op_ppc32_Switch, emit_ppc32_Switch);
 553         set_emitter(op_be_Call, emit_be_Call);
 554         set_emitter(op_Jmp, emit_Jmp);
 555         set_emitter(op_Proj, emit_Proj);
 556         set_emitter(op_be_IncSP, emit_be_IncSP);
 557         set_emitter(op_be_Copy, emit_be_Copy);
 558         set_emitter(op_be_Perm, emit_be_Perm);
 559 //      set_emitter(op_Spill, emit_Spill);
 560 //      set_emitter(op_Reload, emit_Reload);
 561 }
 562
 563 /**
 564  * Emits code for a node.
 565  */
 566 static void ppc32_emit_node(ppc32_emit_env_t *env, const ir_node *irn) {
 567         ir_op *op = get_irn_op(irn);
 568
 569         if (op->ops.generic) {
 570                 emit_func *emit = (emit_func *)op->ops.generic;
 571                 (*emit)(env, irn);
 572         } else {
 573                 be_emit_cstring(env->emit, "\t/* TODO */");
 574                 be_emit_finish_line_gas(env->emit, irn);
 575         }
 576 }
 577
 578
 579 /**
 580  * Walks over the nodes in a block connected by scheduling edges
 581  * and emits code for each node.
 582  */
 583 static void ppc32_gen_block(ppc32_emit_env_t *env, const ir_node *block) {
 584         ir_node *irn;
 585
 586         if (! is_Block(block))
 587                 return;
 588
 589         be_emit_irprintf(env->emit, "BLOCK_%ld:\n", get_irn_node_nr(block));
 590         be_emit_write_line(env->emit);
 591         sched_foreach(block, irn) {
 592                 ppc32_emit_node(env, irn);
 593         }
 594 }
 595
 596
 597 /**
 598  * Emits code for function start.
 599  */
 600 static void ppc32_emit_start(ppc32_emit_env_t *env, ir_graph *irg) {
 601         const char *irg_name  = get_entity_ld_name(get_irg_entity(irg));
 602         int         framesize = get_type_size_bytes(get_irg_frame_type(env->cg->irg));
 603
 604         if(! strcmp(irg_name, "main")) {                                           // XXX: underscore hack
 605                 irg_name = "_main";
 606         }
 607
 608         be_emit_irprintf(env->emit, "\t.text\n\t.globl %s\n\t.align 4\n%s:\n", irg_name, irg_name);
 609
 610         if (framesize > 24) {
 611                 be_emit_cstring(env->emit, "\tmflr    r0\n");
 612                 be_emit_cstring(env->emit, "\tstw     r0, 8(r1)\n");
 613                 be_emit_irprintf(env->emit, "\tstwu    r1, -%i(r1)\n", framesize);
 614         } else {
 615                 be_emit_irprintf(env->emit, "\t/* set new frame (%d) omitted */\n", framesize);
 616         }
 617         be_emit_write_line(env->emit);
 618
 619 /*      if(!isleaf) {
 620                 // store link register in linkage area (TODO: if needed)
 621
 622                 be_emit_cstring(env->emit, "\tmflr    r0\n");
 623                 be_emit_cstring(env->emit, "\tstwu    r0, -4(r1)\n");   // stw r0, 8(SP)
 624                 be_emit_write_line(env->emit);
 625         }*/
 626 }
 627
 628 /**
 629  * Emits code for function end
 630  */
 631 static void ppc32_emit_end(ppc32_emit_env_t *env, ir_graph *irg) {
 632         int framesize = get_type_size_bytes(get_irg_frame_type(env->cg->irg));
 633
 634 /*      if(!isleaf) {
 635                 // restore link register
 636
 637                 be_emit_cstring(env->emit, "\tlwz     r0, 0(r1)\n");
 638                 be_emit_cstring(env->emit, "\taddi    r1, r1, 4\n");
 639                 be_emit_cstring(env->emit, "\tmtlr    r0\n");
 640                 be_emit_write_line(env->emit);
 641         }*/
 642         if(framesize > 24) {
 643                 be_emit_cstring(env->emit, "\tlwz    r1, 0(r1)\n");
 644                 be_emit_cstring(env->emit, "\tlwz    r0, 8(r1)\n");
 645                 be_emit_cstring(env->emit, "\tmtlr   r0\n");
 646                 be_emit_write_line(env->emit);
 647         }
 648         be_emit_cstring(env->emit, "\tblr\n\n");
 649         be_emit_write_line(env->emit);
 650 }
 651
 652 /**
 653  * Sets labels for control flow nodes (jump target)
 654  * TODO: Jump optimization
 655  */
 656 void ppc32_gen_labels(ir_node *block, void *env) {
 657         ir_node *pred;
 658         int n;
 659
 660         for (n = get_Block_n_cfgpreds(block) - 1; n >= 0; --n) {
 661                 pred = get_Block_cfgpred(block, n);
 662                 set_irn_link(pred, block);
 663         }
 664 }
 665
 666 /**
 667  * Main driver: generates code for one routine
 668  */
 669 void ppc32_gen_routine(const ppc32_code_gen_t *cg, ir_graph *irg)
 670 {
 671         ppc32_emit_env_t emit_env;
 672         ir_node *block;
 673         int i, n;
 674
 675         emit_env.emit     = &cg->isa->emit;
 676         emit_env.arch_env = cg->arch_env;
 677         emit_env.cg       = cg;
 678         FIRM_DBG_REGISTER(emit_env.mod, "firm.be.ppc.emit");
 679
 680         ppc32_register_emitters();
 681
 682         ppc32_emit_start(&emit_env, irg);
 683         irg_block_walk_graph(irg, ppc32_gen_labels, NULL, &emit_env);
 684
 685         n = ARR_LEN(cg->blk_sched);
 686         for (i = 0; i < n;) {
 687                 ir_node *next_bl;
 688
 689                 block   = cg->blk_sched[i];
 690                 ++i;
 691                 next_bl = i < n ? cg->blk_sched[i] : NULL;
 692
 693                 /* set here the link. the emitter expects to find the next block here */
 694                 set_irn_link(block, next_bl);
 695                 ppc32_gen_block(&emit_env, block);
 696         }
 697         ppc32_emit_end(&emit_env, irg);
 698 }