nsz Git - libfirm/blob - ir/be/sparc/sparc_emitter.c

   1 /*
   2  * Copyright (C) 1995-2010 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   emit assembler for a backend graph
  23  * @version $Id$
  24  */
  25 #include "config.h"
  26
  27 #include <limits.h>
  28
  29 #include "xmalloc.h"
  30 #include "tv.h"
  31 #include "iredges.h"
  32 #include "debug.h"
  33 #include "irgwalk.h"
  34 #include "irprintf.h"
  35 #include "irop_t.h"
  36 #include "irargs_t.h"
  37 #include "irprog.h"
  38 #include "irargs_t.h"
  39 #include "error.h"
  40 #include "raw_bitset.h"
  41 #include "dbginfo.h"
  42
  43 #include "../besched.h"
  44 #include "../beblocksched.h"
  45 #include "../beirg.h"
  46 #include "../begnuas.h"
  47 #include "../be_dbgout.h"
  48 #include "../benode.h"
  49
  50 #include "sparc_emitter.h"
  51 #include "gen_sparc_emitter.h"
  52 #include "sparc_nodes_attr.h"
  53 #include "sparc_new_nodes.h"
  54 #include "gen_sparc_regalloc_if.h"
  55
  56 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  57
  58 /**
  59  * Returns the register at in position pos.
  60  */
  61 static const arch_register_t *get_in_reg(const ir_node *node, int pos)
  62 {
  63         ir_node                *op;
  64         const arch_register_t  *reg = NULL;
  65
  66         assert(get_irn_arity(node) > pos && "Invalid IN position");
  67
  68         /* The out register of the operator at position pos is the
  69            in register we need. */
  70         op = get_irn_n(node, pos);
  71
  72         reg = arch_get_irn_register(op);
  73
  74         assert(reg && "no in register found");
  75         return reg;
  76 }
  77
  78 /**
  79  * Returns the register at out position pos.
  80  */
  81 static const arch_register_t *get_out_reg(const ir_node *node, int pos)
  82 {
  83         ir_node                *proj;
  84         const arch_register_t  *reg = NULL;
  85
  86         /* 1st case: irn is not of mode_T, so it has only                 */
  87         /*           one OUT register -> good                             */
  88         /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
  89         /*           Proj with the corresponding projnum for the register */
  90
  91         if (get_irn_mode(node) != mode_T) {
  92                 reg = arch_get_irn_register(node);
  93         } else if (is_sparc_irn(node)) {
  94                 reg = arch_irn_get_register(node, pos);
  95         } else {
  96                 const ir_edge_t *edge;
  97
  98                 foreach_out_edge(node, edge) {
  99                         proj = get_edge_src_irn(edge);
 100                         assert(is_Proj(proj) && "non-Proj from mode_T node");
 101                         if (get_Proj_proj(proj) == pos) {
 102                                 reg = arch_get_irn_register(proj);
 103                                 break;
 104                         }
 105                 }
 106         }
 107
 108         assert(reg && "no out register found");
 109         return reg;
 110 }
 111
 112 void sparc_emit_immediate(const ir_node *node)
 113 {
 114         int const val = get_sparc_attr_const(node)->immediate_value;
 115         assert(-4096 <= val && val < 4096);
 116         be_emit_irprintf("%d", val);
 117 }
 118
 119 void sparc_emit_source_register(const ir_node *node, int pos)
 120 {
 121         const arch_register_t *reg = get_in_reg(node, pos);
 122         be_emit_char('%');
 123         be_emit_string(arch_register_get_name(reg));
 124 }
 125
 126 void sparc_emit_dest_register(const ir_node *node, int pos)
 127 {
 128         const arch_register_t *reg = get_out_reg(node, pos);
 129         be_emit_char('%');
 130         be_emit_string(arch_register_get_name(reg));
 131 }
 132
 133 /**
 134  * Emits either a imm or register depending on arity of node
 135  * @param node
 136  * @param register no (-1 if no register)
 137  */
 138 void sparc_emit_reg_or_imm(const ir_node *node, int pos)
 139 {
 140         if (get_irn_arity(node) > pos) {
 141                 // we have reg input
 142                 sparc_emit_source_register(node, pos);
 143         } else {
 144                 // we have a imm input
 145                 sparc_emit_immediate(node);
 146         }
 147 }
 148
 149 static bool is_stack_pointer_relative(const ir_node *node)
 150 {
 151         const arch_register_t *sp = &sparc_gp_regs[REG_SP];
 152         return (is_sparc_St(node) && get_in_reg(node, n_sparc_St_ptr) == sp)
 153             || (is_sparc_Ld(node) && get_in_reg(node, n_sparc_Ld_ptr) == sp);
 154 }
 155
 156 /**
 157  * emit SP offset
 158  */
 159 void sparc_emit_offset(const ir_node *node)
 160 {
 161         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 162         long                           offset = attr->offset;
 163
 164         /* bad hack: the real stack stuff is behind the always-there spill
 165          * space for the register window and stack */
 166         if (is_stack_pointer_relative(node))
 167                 offset += SPARC_MIN_STACKSIZE;
 168         if (offset != 0) {
 169                 be_emit_irprintf("%+ld", offset);
 170         }
 171 }
 172
 173
 174 /**
 175  *  Emit load mode char
 176  */
 177 void sparc_emit_load_mode(const ir_node *node)
 178 {
 179         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 180         ir_mode *mode      = attr->load_store_mode;
 181         int      bits      = get_mode_size_bits(mode);
 182         bool     is_signed = mode_is_signed(mode);
 183
 184         if (bits == 16) {
 185                 be_emit_string(is_signed ? "sh" : "uh");
 186         } else if (bits == 8) {
 187                 be_emit_string(is_signed ? "sb" : "ub");
 188         } else if (bits == 64) {
 189                 be_emit_string("d");
 190         } else {
 191                 assert(bits == 32);
 192         }
 193 }
 194
 195 /**
 196  * Emit store mode char
 197  */
 198 void sparc_emit_store_mode(const ir_node *node)
 199 {
 200         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 201         ir_mode *mode      = attr->load_store_mode;
 202         int      bits      = get_mode_size_bits(mode);
 203
 204         if (bits == 16) {
 205                 be_emit_string("h");
 206         } else if (bits == 8) {
 207                 be_emit_string("b");
 208         } else if (bits == 64) {
 209                 be_emit_string("d");
 210         } else {
 211                 assert(bits == 32);
 212         }
 213 }
 214
 215 /**
 216  * emit integer signed/unsigned prefix char
 217  */
 218 void sparc_emit_mode_sign_prefix(const ir_node *node)
 219 {
 220         ir_mode *mode      = get_irn_mode(node);
 221         bool     is_signed = mode_is_signed(mode);
 222         be_emit_string(is_signed ? "s" : "u");
 223 }
 224
 225 static void emit_fp_suffix(const ir_mode *mode)
 226 {
 227         unsigned bits = get_mode_size_bits(mode);
 228         assert(mode_is_float(mode));
 229
 230         if (bits == 32) {
 231                 be_emit_char('s');
 232         } else if (bits == 64) {
 233                 be_emit_char('d');
 234         } else if (bits == 128) {
 235                 be_emit_char('q');
 236         } else {
 237                 panic("invalid FP mode");
 238         }
 239 }
 240
 241 void sparc_emit_fp_conv_source(const ir_node *node)
 242 {
 243         const sparc_fp_conv_attr_t *attr = get_sparc_fp_conv_attr_const(node);
 244         emit_fp_suffix(attr->src_mode);
 245 }
 246
 247 void sparc_emit_fp_conv_destination(const ir_node *node)
 248 {
 249         const sparc_fp_conv_attr_t *attr = get_sparc_fp_conv_attr_const(node);
 250         emit_fp_suffix(attr->dest_mode);
 251 }
 252
 253 /**
 254  * emits the FP mode suffix char
 255  */
 256 void sparc_emit_fp_mode_suffix(const ir_node *node)
 257 {
 258         const sparc_fp_attr_t *attr = get_sparc_fp_attr_const(node);
 259         emit_fp_suffix(attr->fp_mode);
 260 }
 261
 262 /**
 263  * Returns the target label for a control flow node.
 264  */
 265 static void sparc_emit_cfop_target(const ir_node *node)
 266 {
 267         ir_node *block = get_irn_link(node);
 268         be_gas_emit_block_name(block);
 269 }
 270
 271 /**
 272  * Emit single entity
 273  */
 274 static void sparc_emit_entity(ir_entity *entity)
 275 {
 276         be_gas_emit_entity(entity);
 277 }
 278
 279 /**
 280  * Emits code for stack space management
 281  */
 282 static void emit_be_IncSP(const ir_node *irn)
 283 {
 284         int offs = -be_get_IncSP_offset(irn);
 285
 286         if (offs == 0)
 287                         return;
 288
 289         /* SPARC stack grows downwards */
 290         if (offs < 0) {
 291                 be_emit_cstring("\tsub ");
 292                 offs = -offs;
 293         } else {
 294                 be_emit_cstring("\tadd ");
 295         }
 296
 297         sparc_emit_source_register(irn, 0);
 298         be_emit_irprintf(", %d", offs);
 299         be_emit_cstring(", ");
 300         sparc_emit_dest_register(irn, 0);
 301         be_emit_finish_line_gas(irn);
 302 }
 303
 304 /**
 305  * emits code for save instruction with min. required stack space
 306  */
 307 static void emit_sparc_Save(const ir_node *irn)
 308 {
 309         const sparc_save_attr_t *save_attr = get_sparc_save_attr_const(irn);
 310         be_emit_cstring("\tsave ");
 311         sparc_emit_source_register(irn, 0);
 312         be_emit_irprintf(", %d, ", -save_attr->initial_stacksize);
 313         sparc_emit_dest_register(irn, 0);
 314         be_emit_finish_line_gas(irn);
 315 }
 316
 317 /**
 318  * emits code to load hi 22 bit of a constant
 319  */
 320 static void emit_sparc_HiImm(const ir_node *irn)
 321 {
 322         const sparc_attr_t *attr = get_sparc_attr_const(irn);
 323         be_emit_cstring("\tsethi ");
 324         be_emit_irprintf("%%hi(%d), ", attr->immediate_value);
 325         sparc_emit_dest_register(irn, 0);
 326         be_emit_finish_line_gas(irn);
 327 }
 328
 329 /**
 330  * emits code to load lo 10bits of a constant
 331  */
 332 static void emit_sparc_LoImm(const ir_node *irn)
 333 {
 334         const sparc_attr_t *attr = get_sparc_attr_const(irn);
 335         be_emit_cstring("\tor ");
 336         sparc_emit_source_register(irn, 0);
 337         be_emit_irprintf(", %%lo(%d), ", attr->immediate_value);
 338         sparc_emit_dest_register(irn, 0);
 339         be_emit_finish_line_gas(irn);
 340 }
 341
 342 /**
 343  * emits code for mulh
 344  */
 345 static void emit_sparc_Mulh(const ir_node *irn)
 346 {
 347         be_emit_cstring("\t");
 348         sparc_emit_mode_sign_prefix(irn);
 349         be_emit_cstring("mul ");
 350
 351         sparc_emit_source_register(irn, 0);
 352         be_emit_cstring(", ");
 353         sparc_emit_reg_or_imm(irn, 1);
 354         be_emit_cstring(", ");
 355         sparc_emit_dest_register(irn, 0);
 356         be_emit_finish_line_gas(irn);
 357
 358         // our result is in the y register now
 359         // we just copy it to the assigned target reg
 360         be_emit_cstring("\tmov ");
 361         be_emit_char('%');
 362         be_emit_string(arch_register_get_name(&sparc_flags_regs[REG_Y]));
 363         be_emit_cstring(", ");
 364         sparc_emit_dest_register(irn, 0);
 365         be_emit_finish_line_gas(irn);
 366 }
 367
 368 /**
 369  * Emits code for return node
 370  */
 371 static void emit_be_Return(const ir_node *irn)
 372 {
 373         be_emit_cstring("\tret");
 374         //be_emit_cstring("\tjmp %i7+8");
 375         be_emit_finish_line_gas(irn);
 376         be_emit_cstring("\trestore");
 377         be_emit_finish_line_gas(irn);
 378 }
 379
 380 /**
 381  * Emits code for Call node
 382  */
 383 static void emit_sparc_Call(const ir_node *node)
 384 {
 385         const sparc_attr_t *attr   = get_sparc_attr_const(node);
 386         ir_entity          *entity = attr->immediate_value_entity;
 387
 388         be_emit_cstring("\tcall ");
 389         if (entity != NULL) {
 390             sparc_emit_entity(entity);
 391                 be_emit_cstring(", 0");
 392         } else {
 393                 int last = get_irn_arity(node);
 394                 sparc_emit_source_register(node, last-1);
 395         }
 396         be_emit_finish_line_gas(node);
 397
 398         /* fill delay slot */
 399         be_emit_cstring("\tnop");
 400         be_emit_finish_line_gas(node);
 401 }
 402
 403 /**
 404  * Emit code for Perm node
 405  */
 406 static void emit_be_Perm(const ir_node *irn)
 407 {
 408         be_emit_cstring("\txor ");
 409         sparc_emit_source_register(irn, 1);
 410         be_emit_cstring(", ");
 411         sparc_emit_source_register(irn, 0);
 412         be_emit_cstring(", ");
 413         sparc_emit_source_register(irn, 0);
 414         be_emit_finish_line_gas(NULL);
 415
 416         be_emit_cstring("\txor ");
 417         sparc_emit_source_register(irn, 1);
 418         be_emit_cstring(", ");
 419         sparc_emit_source_register(irn, 0);
 420         be_emit_cstring(", ");
 421         sparc_emit_source_register(irn, 1);
 422         be_emit_finish_line_gas(NULL);
 423
 424         be_emit_cstring("\txor ");
 425         sparc_emit_source_register(irn, 1);
 426         be_emit_cstring(", ");
 427         sparc_emit_source_register(irn, 0);
 428         be_emit_cstring(", ");
 429         sparc_emit_source_register(irn, 0);
 430         be_emit_finish_line_gas(irn);
 431 }
 432
 433 /**
 434  * TODO: not really tested but seems to work with memperm_arity == 1
 435  */
 436 static void emit_be_MemPerm(const ir_node *node)
 437 {
 438         int i;
 439         int memperm_arity;
 440         int sp_change = 0;
 441         ir_graph          *irg    = get_irn_irg(node);
 442         be_stack_layout_t *layout = be_get_irg_stack_layout(irg);
 443
 444         /* this implementation only works with frame pointers currently */
 445         assert(layout->sp_relative == false);
 446
 447         /* TODO: this implementation is slower than necessary.
 448            The longterm goal is however to avoid the memperm node completely */
 449
 450         memperm_arity = be_get_MemPerm_entity_arity(node);
 451         // we use our local registers - so this is limited to 8 inputs !
 452         if (memperm_arity > 8)
 453                 panic("memperm with more than 8 inputs not supported yet");
 454
 455         be_emit_irprintf("\tsub %%sp, %d, %%sp", memperm_arity*4);
 456         be_emit_finish_line_gas(node);
 457
 458         for (i = 0; i < memperm_arity; ++i) {
 459                 ir_entity *entity = be_get_MemPerm_in_entity(node, i);
 460                 int        offset = be_get_stack_entity_offset(layout, entity, 0);
 461
 462                 /* spill register */
 463                 be_emit_irprintf("\tst %%l%d, [%%sp%+d]", i, sp_change + SPARC_MIN_STACKSIZE);
 464                 be_emit_finish_line_gas(node);
 465
 466                 /* load from entity */
 467                 be_emit_irprintf("\tld [%%fp%+d], %%l%d", offset, i);
 468                 be_emit_finish_line_gas(node);
 469                 sp_change += 4;
 470         }
 471
 472         for (i = memperm_arity-1; i >= 0; --i) {
 473                 ir_entity *entity = be_get_MemPerm_out_entity(node, i);
 474                 int        offset = be_get_stack_entity_offset(layout, entity, 0);
 475
 476                 sp_change -= 4;
 477
 478                 /* store to new entity */
 479                 be_emit_irprintf("\tst %%l%d, [%%fp%+d]", i, offset);
 480                 be_emit_finish_line_gas(node);
 481                 /* restore register */
 482                 be_emit_irprintf("\tld [%%sp%+d], %%l%d", sp_change + SPARC_MIN_STACKSIZE, i);
 483                 be_emit_finish_line_gas(node);
 484         }
 485
 486         be_emit_irprintf("\tadd %%sp, %d, %%sp", memperm_arity*4);
 487         be_emit_finish_line_gas(node);
 488
 489         assert(sp_change == 0);
 490 }
 491
 492 /**
 493  * Emit a SymConst.
 494  */
 495 static void emit_sparc_SymConst(const ir_node *irn)
 496 {
 497         const sparc_symconst_attr_t *attr = get_sparc_symconst_attr_const(irn);
 498
 499         //sethi %hi(const32),%reg
 500         //or    %reg,%lo(const32),%reg
 501
 502         be_emit_cstring("\tsethi %hi(");
 503         be_gas_emit_entity(attr->entity);
 504         be_emit_cstring("), ");
 505         sparc_emit_dest_register(irn, 0);
 506         be_emit_cstring("\n ");
 507
 508         // TODO: could be combined with the following load/store instruction
 509         be_emit_cstring("\tor ");
 510         sparc_emit_dest_register(irn, 0);
 511         be_emit_cstring(", %lo(");
 512         be_gas_emit_entity(attr->entity);
 513         be_emit_cstring("), ");
 514         sparc_emit_dest_register(irn, 0);
 515         be_emit_finish_line_gas(irn);
 516 }
 517
 518 /**
 519  * Emits code for FrameAddr fix
 520  */
 521 static void emit_sparc_FrameAddr(const ir_node *irn)
 522 {
 523         const sparc_symconst_attr_t *attr = get_irn_generic_attr_const(irn);
 524
 525         // no need to fix offset as we are adressing via the framepointer
 526         if (attr->fp_offset >= 0) {
 527                 be_emit_cstring("\tadd ");
 528                 sparc_emit_source_register(irn, 0);
 529                 be_emit_cstring(", ");
 530                 be_emit_irprintf("%ld", attr->fp_offset);
 531         } else {
 532                 be_emit_cstring("\tsub ");
 533                 sparc_emit_source_register(irn, 0);
 534                 be_emit_cstring(", ");
 535                 be_emit_irprintf("%ld", -attr->fp_offset);
 536         }
 537
 538         be_emit_cstring(", ");
 539         sparc_emit_dest_register(irn, 0);
 540         be_emit_finish_line_gas(irn);
 541 }
 542
 543
 544 /**
 545  * Emits code for Branch
 546  */
 547 static void emit_sparc_BXX(const ir_node *node)
 548 {
 549         const sparc_jmp_cond_attr_t *attr = get_sparc_jmp_cond_attr_const(node);
 550         int              proj_num    = attr->proj_num;
 551         bool             is_unsigned = attr->is_unsigned;
 552         const ir_node   *proj_true   = NULL;
 553         const ir_node   *proj_false  = NULL;
 554         const ir_edge_t *edge;
 555         const ir_node   *block;
 556         const ir_node   *next_block;
 557         const char      *suffix;
 558
 559         foreach_out_edge(node, edge) {
 560                 ir_node *proj = get_edge_src_irn(edge);
 561                 long nr = get_Proj_proj(proj);
 562                 if (nr == pn_Cond_true) {
 563                         proj_true = proj;
 564                 } else {
 565                         proj_false = proj;
 566                 }
 567         }
 568
 569         /* for now, the code works for scheduled and non-schedules blocks */
 570         block = get_nodes_block(node);
 571
 572         /* we have a block schedule */
 573         next_block = get_irn_link(block);
 574
 575         assert(proj_num != pn_Cmp_False);
 576         assert(proj_num != pn_Cmp_True);
 577
 578         if (get_irn_link(proj_true) == next_block) {
 579                 /* exchange both proj's so the second one can be omitted */
 580                 const ir_node *t = proj_true;
 581
 582                 proj_true  = proj_false;
 583                 proj_false = t;
 584                 proj_num   = get_negated_pnc(proj_num, mode_Iu);
 585         }
 586
 587         if (is_unsigned) {
 588                 switch (proj_num) {
 589                         case pn_Cmp_Eq:  suffix = "e"; break;
 590                         case pn_Cmp_Lt:  suffix = "lu"; break;
 591                         case pn_Cmp_Le:  suffix = "leu"; break;
 592                         case pn_Cmp_Gt:  suffix = "gu"; break;
 593                         case pn_Cmp_Ge:  suffix = "geu"; break;
 594                         case pn_Cmp_Lg:  suffix = "ne"; break;
 595                         default: panic("Cmp has unsupported pnc");
 596                 }
 597         } else {
 598                 switch (proj_num) {
 599                         case pn_Cmp_Eq:  suffix = "e"; break;
 600                         case pn_Cmp_Lt:  suffix = "l"; break;
 601                         case pn_Cmp_Le:  suffix = "le"; break;
 602                         case pn_Cmp_Gt:  suffix = "g"; break;
 603                         case pn_Cmp_Ge:  suffix = "ge"; break;
 604                         case pn_Cmp_Lg:  suffix = "ne"; break;
 605                         default: panic("Cmp has unsupported pnc");
 606                 }
 607         }
 608
 609         /* emit the true proj */
 610         be_emit_cstring("\tb");
 611         be_emit_string(suffix);
 612         be_emit_char(' ');
 613         sparc_emit_cfop_target(proj_true);
 614         be_emit_finish_line_gas(proj_true);
 615
 616         be_emit_cstring("\tnop");
 617         be_emit_pad_comment();
 618         be_emit_cstring("/* TODO: use delay slot */\n");
 619
 620         if (get_irn_link(proj_false) == next_block) {
 621                 be_emit_cstring("\t/* false-fallthrough to ");
 622                 sparc_emit_cfop_target(proj_false);
 623                 be_emit_cstring(" */");
 624                 be_emit_finish_line_gas(proj_false);
 625         } else {
 626                 be_emit_cstring("\tba ");
 627                 sparc_emit_cfop_target(proj_false);
 628                 be_emit_finish_line_gas(proj_false);
 629                 be_emit_cstring("\tnop\t\t/* TODO: use delay slot */\n");
 630                 be_emit_finish_line_gas(proj_false);
 631         }
 632 }
 633
 634 /**
 635  * emit Jmp (which actually is a branch always (ba) instruction)
 636  */
 637 static void emit_sparc_Ba(const ir_node *node)
 638 {
 639         ir_node *block, *next_block;
 640
 641         /* for now, the code works for scheduled and non-schedules blocks */
 642         block = get_nodes_block(node);
 643
 644         /* we have a block schedule */
 645         next_block = get_irn_link(block);
 646         if (get_irn_link(node) != next_block) {
 647                 be_emit_cstring("\tba ");
 648                 sparc_emit_cfop_target(node);
 649                 be_emit_finish_line_gas(node);
 650                 be_emit_cstring("\tnop\t\t/* TODO: use delay slot */\n");
 651         } else {
 652                 be_emit_cstring("\t/* fallthrough to ");
 653                 sparc_emit_cfop_target(node);
 654                 be_emit_cstring(" */");
 655         }
 656         be_emit_finish_line_gas(node);
 657 }
 658
 659 /**
 660  * emit copy node
 661  */
 662 static void emit_be_Copy(const ir_node *irn)
 663 {
 664         ir_mode *mode = get_irn_mode(irn);
 665
 666         if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
 667                 /* omitted Copy */
 668                 return;
 669         }
 670
 671         if (mode_is_float(mode)) {
 672                 panic("emit_be_Copy: move not supported for FP");
 673         } else if (mode_is_data(mode)) {
 674                 be_emit_cstring("\tmov ");
 675                 sparc_emit_source_register(irn, 0);
 676                 be_emit_cstring(", ");
 677                 sparc_emit_dest_register(irn, 0);
 678                 be_emit_finish_line_gas(irn);
 679         } else {
 680                 panic("emit_be_Copy: move not supported for this mode");
 681         }
 682 }
 683
 684
 685 /**
 686  * dummy emitter for ignored nodes
 687  */
 688 static void emit_nothing(const ir_node *irn)
 689 {
 690         (void) irn;
 691 }
 692
 693
 694
 695 /**
 696  * type of emitter function
 697  */
 698 typedef void (*emit_func) (const ir_node *);
 699
 700 /**
 701  * Set a node emitter. Make it a bit more type safe.
 702  */
 703 static inline void set_emitter(ir_op *op, emit_func sparc_emit_node)
 704 {
 705         op->ops.generic = (op_func)sparc_emit_node;
 706 }
 707
 708 /**
 709  * Enters the emitter functions for handled nodes into the generic
 710  * pointer of an opcode.
 711  */
 712 static void sparc_register_emitters(void)
 713 {
 714         /* first clear the generic function pointer for all ops */
 715         clear_irp_opcodes_generic_func();
 716         /* register all emitter functions defined in spec */
 717         sparc_register_spec_emitters();
 718
 719         /* custom emitter */
 720         set_emitter(op_be_Copy,         emit_be_Copy);
 721         set_emitter(op_be_CopyKeep,     emit_be_Copy);
 722         set_emitter(op_be_IncSP,        emit_be_IncSP);
 723         set_emitter(op_be_MemPerm,      emit_be_MemPerm);
 724         set_emitter(op_be_Perm,         emit_be_Perm);
 725         set_emitter(op_be_Return,       emit_be_Return);
 726         set_emitter(op_sparc_BXX,       emit_sparc_BXX);
 727         set_emitter(op_sparc_Call,      emit_sparc_Call);
 728         set_emitter(op_sparc_FrameAddr, emit_sparc_FrameAddr);
 729         set_emitter(op_sparc_HiImm,     emit_sparc_HiImm);
 730         set_emitter(op_sparc_Ba,        emit_sparc_Ba);
 731         set_emitter(op_sparc_LoImm,     emit_sparc_LoImm);
 732         set_emitter(op_sparc_Mulh,      emit_sparc_Mulh);
 733         set_emitter(op_sparc_Save,      emit_sparc_Save);
 734         set_emitter(op_sparc_SymConst,  emit_sparc_SymConst);
 735
 736         /* no need to emit anything for the following nodes */
 737         set_emitter(op_be_Barrier, emit_nothing);
 738         set_emitter(op_be_Keep,    emit_nothing);
 739         set_emitter(op_be_Start,   emit_nothing);
 740         set_emitter(op_Phi,        emit_nothing);
 741 }
 742
 743 /**
 744  * Emits code for a node.
 745  */
 746 static void sparc_emit_node(const ir_node *node)
 747 {
 748         ir_op               *op       = get_irn_op(node);
 749
 750         if (op->ops.generic) {
 751                 emit_func func = (emit_func) op->ops.generic;
 752                 be_dbg_set_dbg_info(get_irn_dbg_info(node));
 753                 (*func) (node);
 754         } else {
 755                 panic("Error: No emit handler for node %+F (graph %+F)\n",
 756                         node, current_ir_graph);
 757         }
 758 }
 759
 760 /**
 761  * Walks over the nodes in a block connected by scheduling edges
 762  * and emits code for each node.
 763  */
 764 static void sparc_gen_block(ir_node *block, void *data)
 765 {
 766         ir_node *node;
 767         (void) data;
 768
 769         if (! is_Block(block))
 770                 return;
 771
 772         be_gas_emit_block_name(block);
 773         be_emit_cstring(":\n");
 774         be_emit_write_line();
 775
 776         sched_foreach(block, node) {
 777                 sparc_emit_node(node);
 778         }
 779 }
 780
 781
 782 /**
 783  * Emits code for function start.
 784  */
 785 static void sparc_emit_func_prolog(ir_graph *irg)
 786 {
 787         ir_entity *ent = get_irg_entity(irg);
 788         be_gas_emit_function_prolog(ent, 4);
 789         be_emit_write_line();
 790 }
 791
 792 /**
 793  * Emits code for function end
 794  */
 795 static void sparc_emit_func_epilog(ir_graph *irg)
 796 {
 797         ir_entity *ent = get_irg_entity(irg);
 798         const char *irg_name = get_entity_ld_name(ent);
 799         be_emit_write_line();
 800         be_emit_irprintf("\t.size  %s, .-%s\n", irg_name, irg_name);
 801         be_emit_cstring("# -- End ");
 802         be_emit_string(irg_name);
 803         be_emit_cstring("\n");
 804         be_emit_write_line();
 805 }
 806
 807 /**
 808  * Block-walker:
 809  * TODO: Sets labels for control flow nodes (jump target).
 810  * Links control predecessors to there destination blocks.
 811  */
 812 static void sparc_gen_labels(ir_node *block, void *env)
 813 {
 814         ir_node *pred;
 815         int n = get_Block_n_cfgpreds(block);
 816         (void) env;
 817
 818         for (n--; n >= 0; n--) {
 819                 pred = get_Block_cfgpred(block, n);
 820                 set_irn_link(pred, block); // link the pred of a block (which is a jmp)
 821         }
 822 }
 823
 824
 825 /**
 826  * Main driver
 827  */
 828 void sparc_gen_routine(const sparc_code_gen_t *cg, ir_graph *irg)
 829 {
 830         ir_node **blk_sched;
 831         ir_node *last_block = NULL;
 832         ir_entity *entity     = get_irg_entity(irg);
 833         int i, n;
 834         (void) cg;
 835
 836         be_gas_elf_type_char = '#';
 837         be_gas_object_file_format = OBJECT_FILE_FORMAT_ELF_SPARC;
 838
 839         /* register all emitter functions */
 840         sparc_register_emitters();
 841         be_dbg_method_begin(entity);
 842
 843         /* create the block schedule. For now, we don't need it earlier. */
 844         blk_sched = be_create_block_schedule(irg);
 845
 846         // emit function prolog
 847         sparc_emit_func_prolog(irg);
 848
 849         // generate BLOCK labels
 850         irg_block_walk_graph(irg, sparc_gen_labels, NULL, NULL);
 851
 852         // inject block scheduling links & emit code of each block
 853         n = ARR_LEN(blk_sched);
 854         for (i = 0; i < n;) {
 855                 ir_node *block, *next_bl;
 856
 857                 block = blk_sched[i];
 858                 ++i;
 859                 next_bl = i < n ? blk_sched[i] : NULL;
 860
 861                 /* set here the link. the emitter expects to find the next block here */
 862                 set_irn_link(block, next_bl);
 863                 sparc_gen_block(block, last_block);
 864                 last_block = block;
 865         }
 866
 867         // emit function epilog
 868         sparc_emit_func_epilog(irg);
 869 }
 870
 871 void sparc_init_emitter(void)
 872 {
 873         FIRM_DBG_REGISTER(dbg, "firm.be.sparc.emit");
 874 }