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

   1 /*
   2  * Copyright (C) 1995-2008 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
  55 #define SNPRINTF_BUF_LEN 128
  56 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  57
  58 /**
  59  * attribute of SAVE node which follows immediatelly after the START node
  60  * we need this to correct all offsets since SPARC expects
  61  * some reserved stack space after the stackpointer
  62  */
  63 const sparc_save_attr_t *save_attr;
  64
  65 /**
  66  * Returns the register at in position pos.
  67  */
  68 static const arch_register_t *get_in_reg(const ir_node *node, int pos)
  69 {
  70         ir_node                *op;
  71         const arch_register_t  *reg = NULL;
  72
  73         assert(get_irn_arity(node) > pos && "Invalid IN position");
  74
  75         /* The out register of the operator at position pos is the
  76            in register we need. */
  77         op = get_irn_n(node, pos);
  78
  79         reg = arch_get_irn_register(op);
  80
  81         assert(reg && "no in register found");
  82         return reg;
  83 }
  84
  85 /**
  86  * Returns the register at out position pos.
  87  */
  88 static const arch_register_t *get_out_reg(const ir_node *node, int pos)
  89 {
  90         ir_node                *proj;
  91         const arch_register_t  *reg = NULL;
  92
  93         /* 1st case: irn is not of mode_T, so it has only                 */
  94         /*           one OUT register -> good                             */
  95         /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
  96         /*           Proj with the corresponding projnum for the register */
  97
  98         if (get_irn_mode(node) != mode_T) {
  99                 reg = arch_get_irn_register(node);
 100         } else if (is_sparc_irn(node)) {
 101                 reg = arch_irn_get_register(node, pos);
 102         } else {
 103                 const ir_edge_t *edge;
 104
 105                 foreach_out_edge(node, edge) {
 106                         proj = get_edge_src_irn(edge);
 107                         assert(is_Proj(proj) && "non-Proj from mode_T node");
 108                         if (get_Proj_proj(proj) == pos) {
 109                                 reg = arch_get_irn_register(proj);
 110                                 break;
 111                         }
 112                 }
 113         }
 114
 115         assert(reg && "no out register found");
 116         return reg;
 117 }
 118
 119 /*************************************************************
 120  *             _       _    __   _          _
 121  *            (_)     | |  / _| | |        | |
 122  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
 123  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
 124  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
 125  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
 126  * | |                                       | |
 127  * |_|                                       |_|
 128  *************************************************************/
 129
 130 void sparc_emit_immediate(const ir_node *node)
 131 {
 132         // TODO: make sure it's a valid simm13 ?
 133         const sparc_attr_t *attr = get_sparc_attr_const(node);
 134
 135         assert(!(attr->immediate_value < -4096 || attr->immediate_value > 4096));
 136
 137         be_emit_irprintf("%d", attr->immediate_value);
 138 }
 139
 140 void sparc_emit_source_register(const ir_node *node, int pos)
 141 {
 142         const arch_register_t *reg = get_in_reg(node, pos);
 143         be_emit_char('%');
 144         be_emit_string(arch_register_get_name(reg));
 145 }
 146
 147 void sparc_emit_dest_register(const ir_node *node, int pos)
 148 {
 149         const arch_register_t *reg = get_out_reg(node, pos);
 150         be_emit_char('%');
 151         be_emit_string(arch_register_get_name(reg));
 152 }
 153
 154 /**
 155  * Emits either a imm or register depending on arity of node
 156  * @param node
 157  * @param register no (-1 if no register)
 158  */
 159 void sparc_emit_reg_or_imm(const ir_node *node, int pos)
 160 {
 161         if (get_irn_arity(node) > pos) {
 162                 // we have reg input
 163                 sparc_emit_source_register(node, pos);
 164         } else {
 165                 // we have a imm input
 166                 sparc_emit_immediate(node);
 167         }
 168 }
 169
 170 /**
 171  * emit SP offset
 172  */
 173 void sparc_emit_offset(const ir_node *node)
 174 {
 175         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 176         assert(attr->base.is_load_store);
 177
 178         if (attr->offset > 0)
 179                 be_emit_irprintf("+%ld", attr->offset);
 180 }
 181
 182
 183 /**
 184  *  Emit load mode char
 185  */
 186 void sparc_emit_load_mode(const ir_node *node)
 187 {
 188         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 189     ir_mode *mode      = attr->load_store_mode;
 190     int      bits      = get_mode_size_bits(mode);
 191     bool     is_signed = mode_is_signed(mode);
 192
 193     if (bits == 16) {
 194         be_emit_string(is_signed ? "sh" : "uh");
 195     } else if (bits == 8) {
 196         be_emit_string(is_signed ? "sb" : "ub");
 197     } else if (bits == 64) {
 198         be_emit_string("d");
 199     } else {
 200         assert(bits == 32);
 201     }
 202 }
 203
 204 /**
 205  * Emit store mode char
 206  */
 207 void sparc_emit_store_mode(const ir_node *node)
 208 {
 209         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 210     ir_mode *mode      = attr->load_store_mode;
 211     int      bits      = get_mode_size_bits(mode);
 212
 213     if (bits == 16) {
 214         be_emit_string("h");
 215     } else if (bits == 8) {
 216         be_emit_string("b");
 217     } else if (bits == 64) {
 218         be_emit_string("d");
 219     } else {
 220         assert(bits == 32);
 221     }
 222 }
 223
 224 /**
 225  * Returns the target label for a control flow node.
 226  */
 227 static void sparc_emit_cfop_target(const ir_node *node)
 228 {
 229         ir_node *block = get_irn_link(node);
 230         be_gas_emit_block_name(block);
 231 }
 232
 233 /**
 234  * Emit single entity
 235  */
 236 static void sparc_emit_entity(ir_entity *entity)
 237 {
 238         be_gas_emit_entity(entity);
 239 }
 240
 241 /***********************************************************************************
 242  *                  _          __                                             _
 243  *                 (_)        / _|                                           | |
 244  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
 245  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
 246  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
 247  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
 248  *
 249  ***********************************************************************************/
 250
 251
 252 /**
 253  * Emits code for stack space management
 254  */
 255 static void emit_be_IncSP(const ir_node *irn)
 256 {
 257         int offs = -be_get_IncSP_offset(irn);
 258
 259         if (offs == 0)
 260                         return;
 261
 262         /* SPARC stack grows downwards */
 263         if (offs < 0) {
 264                 be_emit_cstring("\tsub ");
 265                 offs = -offs;
 266         } else {
 267                 be_emit_cstring("\tadd ");
 268         }
 269
 270         sparc_emit_source_register(irn, 0);
 271         be_emit_irprintf(", %d", offs);
 272         be_emit_cstring(", ");
 273         sparc_emit_dest_register(irn, 0);
 274         be_emit_finish_line_gas(irn);
 275 }
 276
 277 /**
 278  * emits code for save instruction
 279  * and sets the current save_attr pointer
 280  */
 281 static void emit_sparc_Save(const ir_node *irn)
 282 {
 283         save_attr = get_sparc_save_attr_const(irn);
 284         be_emit_cstring("\tsave ");
 285         sparc_emit_source_register(irn, 0);
 286         be_emit_irprintf(", %d, ", -save_attr->initial_stacksize);
 287         sparc_emit_dest_register(irn, 0);
 288         be_emit_finish_line_gas(irn);
 289 }
 290
 291 /**
 292  * emits code to load hi 22 bit of a constant
 293  */
 294 static void emit_sparc_HiImm(const ir_node *irn)
 295 {
 296         const sparc_attr_t *attr = get_sparc_attr_const(irn);
 297         be_emit_cstring("\tsethi ");
 298         be_emit_irprintf("%%hi(%d), ", attr->immediate_value);
 299         sparc_emit_dest_register(irn, 0);
 300         be_emit_finish_line_gas(irn);
 301 }
 302
 303 /**
 304  * emits code to load lo 10bits of a constant
 305  */
 306 static void emit_sparc_LoImm(const ir_node *irn)
 307 {
 308         const sparc_attr_t *attr = get_sparc_attr_const(irn);
 309         be_emit_cstring("\tor ");
 310         sparc_emit_source_register(irn, 0);
 311         be_emit_irprintf(", %%lo(%d), ", attr->immediate_value);
 312         sparc_emit_dest_register(irn, 0);
 313         be_emit_finish_line_gas(irn);
 314 }
 315
 316
 317 /**
 318  * Emits code for return node
 319  */
 320 static void emit_be_Return(const ir_node *irn)
 321 {
 322         be_emit_cstring("\tret");
 323         //be_emit_cstring("\tjmp %i7+8");
 324         be_emit_finish_line_gas(irn);
 325         be_emit_cstring("\trestore");
 326         be_emit_finish_line_gas(irn);
 327 }
 328
 329 /**
 330  * Emits code for Call node
 331  */
 332 static void emit_be_Call(const ir_node *irn)
 333 {
 334         ir_entity *entity = be_Call_get_entity(irn);
 335
 336         if (entity != NULL) {
 337                 be_emit_cstring("\tcall ");
 338             sparc_emit_entity(entity);
 339                 be_emit_cstring(", 0");
 340                 be_emit_finish_line_gas(irn);
 341                 be_emit_cstring("\tnop");
 342                 be_emit_pad_comment();
 343                 be_emit_cstring("/* TODO: use delay slot */\n");
 344         } else {
 345                 be_emit_cstring("\tnop\n");
 346                 be_emit_pad_comment();
 347                 be_emit_cstring("/* TODO: Entity == NULL */\n");
 348                 be_emit_finish_line_gas(irn);
 349         }
 350 }
 351
 352 /**
 353  * TODO: check if this is correct
 354  */
 355 static void emit_be_Perm(const ir_node *irn)
 356 {
 357         be_emit_cstring("\txor ");
 358         sparc_emit_source_register(irn, 1);
 359         be_emit_cstring(", ");
 360         sparc_emit_source_register(irn, 0);
 361         be_emit_cstring(", ");
 362         sparc_emit_source_register(irn, 0);
 363         be_emit_finish_line_gas(NULL);
 364
 365         be_emit_cstring("\txor ");
 366         sparc_emit_source_register(irn, 1);
 367         be_emit_cstring(", ");
 368         sparc_emit_source_register(irn, 0);
 369         be_emit_cstring(", ");
 370         sparc_emit_source_register(irn, 1);
 371         be_emit_finish_line_gas(NULL);
 372
 373         be_emit_cstring("\txor ");
 374         sparc_emit_source_register(irn, 1);
 375         be_emit_cstring(", ");
 376         sparc_emit_source_register(irn, 0);
 377         be_emit_cstring(", ");
 378         sparc_emit_source_register(irn, 0);
 379         be_emit_finish_line_gas(irn);
 380 }
 381
 382 /**
 383  * Emit a SymConst.
 384  */
 385 static void emit_sparc_SymConst(const ir_node *irn)
 386 {
 387         const sparc_symconst_attr_t *attr = get_sparc_symconst_attr_const(irn);
 388
 389         //sethi %hi(const32),%reg
 390         //or    %reg,%lo(const32),%reg
 391
 392         be_emit_cstring("\tsethi %hi(");
 393         be_gas_emit_entity(attr->entity);
 394         be_emit_cstring("), ");
 395         sparc_emit_dest_register(irn, 0);
 396         be_emit_cstring("\n ");
 397
 398         // TODO: could be combined with the following load/store instruction
 399         be_emit_cstring("\tor ");
 400         sparc_emit_dest_register(irn, 0);
 401         be_emit_cstring(", %lo(");
 402         be_gas_emit_entity(attr->entity);
 403         be_emit_cstring("), ");
 404         sparc_emit_dest_register(irn, 0);
 405         be_emit_finish_line_gas(irn);
 406 }
 407
 408
 409 /**
 410  * Emits code for FrameAddr fix
 411  */
 412 static void emit_sparc_FrameAddr(const ir_node *irn)
 413 {
 414         const sparc_symconst_attr_t *attr = get_irn_generic_attr_const(irn);
 415
 416         // no need to fix offset as we are adressing via the framepointer
 417         if (attr->fp_offset >= 0) {
 418                 be_emit_cstring("\tadd ");
 419                 sparc_emit_source_register(irn, 0);
 420                 be_emit_cstring(", ");
 421                 be_emit_irprintf("%ld", attr->fp_offset + save_attr->initial_stacksize);
 422         } else {
 423                 be_emit_cstring("\tsub ");
 424                 sparc_emit_source_register(irn, 0);
 425                 be_emit_cstring(", ");
 426                 be_emit_irprintf("%ld", -attr->fp_offset);
 427         }
 428
 429         be_emit_cstring(", ");
 430         sparc_emit_dest_register(irn, 0);
 431         be_emit_finish_line_gas(irn);
 432 }
 433
 434
 435 /**
 436  * Emits code for Branch
 437  */
 438 static void emit_sparc_Branch(const ir_node *irn)
 439 {
 440         const ir_edge_t *edge;
 441         const ir_node *proj_true  = NULL;
 442         const ir_node *proj_false = NULL;
 443         const ir_node *block;
 444         const ir_node *next_block;
 445         ir_node *op1 = get_irn_n(irn, 0);
 446         const char *suffix;
 447         int proj_num = get_sparc_jmp_cond_proj_num(irn);
 448         const sparc_cmp_attr_t *cmp_attr = get_irn_generic_attr_const(op1);
 449         // bool is_signed = !cmp_attr->is_unsigned;
 450
 451         assert(is_sparc_Cmp(op1) || is_sparc_Tst(op1));
 452
 453         foreach_out_edge(irn, edge) {
 454                 ir_node *proj = get_edge_src_irn(edge);
 455                 long nr = get_Proj_proj(proj);
 456                 if (nr == pn_Cond_true) {
 457                         proj_true = proj;
 458                 } else {
 459                         proj_false = proj;
 460                 }
 461         }
 462
 463         if (cmp_attr->ins_permuted) {
 464                 proj_num = get_mirrored_pnc(proj_num);
 465         }
 466
 467         /* for now, the code works for scheduled and non-schedules blocks */
 468         block = get_nodes_block(irn);
 469
 470         /* we have a block schedule */
 471         next_block = get_irn_link(block);
 472
 473         assert(proj_num != pn_Cmp_False);
 474         assert(proj_num != pn_Cmp_True);
 475
 476         if (get_irn_link(proj_true) == next_block) {
 477                 /* exchange both proj's so the second one can be omitted */
 478                 const ir_node *t = proj_true;
 479
 480                 proj_true  = proj_false;
 481                 proj_false = t;
 482                 proj_num   = get_negated_pnc(proj_num, mode_Iu);
 483         }
 484
 485
 486         switch (proj_num) {
 487                 case pn_Cmp_Eq:  suffix = "e"; break;
 488                 case pn_Cmp_Lt:  suffix = "l"; break;
 489                 case pn_Cmp_Le:  suffix = "le"; break;
 490                 case pn_Cmp_Gt:  suffix = "g"; break;
 491                 case pn_Cmp_Ge:  suffix = "ge"; break;
 492                 case pn_Cmp_Lg:  suffix = "ne"; break;
 493                 case pn_Cmp_Leg: suffix = "a"; break;
 494                 default: panic("Cmp has unsupported pnc");
 495         }
 496
 497         /* emit the true proj */
 498         be_emit_irprintf("\tb%s ", suffix);
 499         sparc_emit_cfop_target(proj_true);
 500         be_emit_finish_line_gas(proj_true);
 501
 502         be_emit_cstring("\tnop");
 503         be_emit_pad_comment();
 504         be_emit_cstring("/* TODO: use delay slot */\n");
 505
 506         if (get_irn_link(proj_false) == next_block) {
 507                 be_emit_cstring("\t/* false-fallthrough to ");
 508                 sparc_emit_cfop_target(proj_false);
 509                 be_emit_cstring(" */");
 510                 be_emit_finish_line_gas(proj_false);
 511         } else {
 512                 be_emit_cstring("\tba ");
 513                 sparc_emit_cfop_target(proj_false);
 514                 be_emit_finish_line_gas(proj_false);
 515                 be_emit_cstring("\tnop\t\t/* TODO: use delay slot */\n");
 516                 be_emit_finish_line_gas(proj_false);
 517         }
 518 }
 519
 520 /**
 521  * emit Jmp (which actually is a branch always (ba) instruction)
 522  */
 523 static void emit_sparc_Jmp(const ir_node *node)
 524 {
 525         ir_node *block, *next_block;
 526
 527         /* for now, the code works for scheduled and non-schedules blocks */
 528         block = get_nodes_block(node);
 529
 530         /* we have a block schedule */
 531         next_block = get_irn_link(block);
 532         if (get_irn_link(node) != next_block) {
 533                 be_emit_cstring("\tba ");
 534                 sparc_emit_cfop_target(node);
 535                 be_emit_finish_line_gas(node);
 536                 be_emit_cstring("\tnop\t\t/* TODO: use delay slot */\n");
 537         } else {
 538                 be_emit_cstring("\t/* fallthrough to ");
 539                 sparc_emit_cfop_target(node);
 540                 be_emit_cstring(" */");
 541         }
 542         be_emit_finish_line_gas(node);
 543 }
 544
 545 /**
 546  * emit copy node
 547  */
 548 static void emit_be_Copy(const ir_node *irn)
 549 {
 550         ir_mode *mode = get_irn_mode(irn);
 551
 552         if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
 553                 /* omitted Copy */
 554                 return;
 555         }
 556
 557         if (mode_is_float(mode)) {
 558                 panic("emit_be_Copy: move not supported for FP");
 559         } else if (mode_is_data(mode)) {
 560                 be_emit_cstring("\tmov ");
 561                 sparc_emit_source_register(irn, 0);
 562                 be_emit_cstring(", ");
 563                 sparc_emit_dest_register(irn, 0);
 564                 be_emit_finish_line_gas(irn);
 565         } else {
 566                 panic("emit_be_Copy: move not supported for this mode");
 567         }
 568 }
 569
 570
 571 /**
 572  * dummy emitter for ignored nodes
 573  */
 574 static void emit_nothing(const ir_node *irn)
 575 {
 576         (void) irn;
 577 }
 578
 579
 580
 581 /**
 582  * type of emitter function
 583  */
 584 typedef void (*emit_func) (const ir_node *);
 585
 586 /**
 587  * Set a node emitter. Make it a bit more type safe.
 588  */
 589 static inline void set_emitter(ir_op *op, emit_func sparc_emit_node)
 590 {
 591         op->ops.generic = (op_func)sparc_emit_node;
 592 }
 593
 594 /**
 595  * Enters the emitter functions for handled nodes into the generic
 596  * pointer of an opcode.
 597  */
 598 static void sparc_register_emitters(void)
 599 {
 600
 601         /* first clear the generic function pointer for all ops */
 602         clear_irp_opcodes_generic_func();
 603
 604         /* register all emitter functions defined in spec */
 605         sparc_register_spec_emitters();
 606
 607         /* custom emitter */
 608     set_emitter(op_be_IncSP,       emit_be_IncSP);
 609     set_emitter(op_be_Return,      emit_be_Return);
 610     set_emitter(op_be_Call,        emit_be_Call);
 611     set_emitter(op_sparc_FrameAddr,  emit_sparc_FrameAddr);
 612     set_emitter(op_sparc_Branch,   emit_sparc_Branch);
 613     set_emitter(op_sparc_SymConst,   emit_sparc_SymConst);
 614     set_emitter(op_sparc_Jmp,        emit_sparc_Jmp);
 615     set_emitter(op_sparc_Save,        emit_sparc_Save);
 616
 617     set_emitter(op_sparc_HiImm,        emit_sparc_HiImm);
 618     set_emitter(op_sparc_LoImm,        emit_sparc_LoImm);
 619
 620     set_emitter(op_be_Copy,        emit_be_Copy);
 621     set_emitter(op_be_CopyKeep,    emit_be_Copy);
 622
 623     set_emitter(op_be_Perm,        emit_be_Perm);
 624
 625 /*
 626     set_emitter(op_arm_B,          emit_arm_B);
 627     set_emitter(op_arm_CopyB,      emit_arm_CopyB);
 628     set_emitter(op_arm_fpaConst,   emit_arm_fpaConst);
 629     set_emitter(op_arm_fpaDbl2GP,  emit_arm_fpaDbl2GP);
 630     set_emitter(op_arm_LdTls,      emit_arm_LdTls);
 631     set_emitter(op_arm_SwitchJmp,  emit_arm_SwitchJmp);
 632     set_emitter(op_be_MemPerm,     emit_be_MemPerm);
 633
 634 */
 635     /* no need to emit anything for the following nodes */
 636         set_emitter(op_Phi,            emit_nothing);
 637         set_emitter(op_be_Keep,        emit_nothing);
 638         set_emitter(op_be_Start,       emit_nothing);
 639         set_emitter(op_be_Barrier,     emit_nothing);
 640
 641 }
 642
 643 /**
 644  * Emits code for a node.
 645  */
 646 static void sparc_emit_node(const ir_node *node)
 647 {
 648         ir_op               *op       = get_irn_op(node);
 649
 650         if (op->ops.generic) {
 651                 emit_func func = (emit_func) op->ops.generic;
 652                 be_dbg_set_dbg_info(get_irn_dbg_info(node));
 653                 (*func) (node);
 654         } else {
 655                 panic("Error: No emit handler for node %+F (graph %+F)\n",
 656                         node, current_ir_graph);
 657         }
 658 }
 659
 660 /**
 661  * Walks over the nodes in a block connected by scheduling edges
 662  * and emits code for each node.
 663  */
 664 static void sparc_gen_block(ir_node *block, void *data)
 665 {
 666         ir_node *node;
 667         (void) data;
 668
 669         if (! is_Block(block))
 670                 return;
 671
 672         be_gas_emit_block_name(block);
 673         be_emit_cstring(":\n");
 674         be_emit_write_line();
 675
 676         sched_foreach(block, node) {
 677                 sparc_emit_node(node);
 678         }
 679 }
 680
 681
 682 /**
 683  * Emits code for function start.
 684  */
 685 static void sparc_emit_func_prolog(ir_graph *irg)
 686 {
 687         ir_entity *ent = get_irg_entity(irg);
 688         be_gas_emit_function_prolog(ent, 4);
 689         be_emit_write_line();
 690 }
 691
 692 /**
 693  * Emits code for function end
 694  */
 695 static void sparc_emit_func_epilog(ir_graph *irg)
 696 {
 697         ir_entity *ent = get_irg_entity(irg);
 698         const char *irg_name = get_entity_ld_name(ent);
 699         be_emit_write_line();
 700         be_emit_irprintf("\t.size  %s, .-%s\n", irg_name, irg_name);
 701         be_emit_cstring("# -- End ");
 702         be_emit_string(irg_name);
 703         be_emit_cstring("\n");
 704         be_emit_write_line();
 705 }
 706
 707 /**
 708  * Block-walker:
 709  * TODO: Sets labels for control flow nodes (jump target).
 710  * Links control predecessors to there destination blocks.
 711  */
 712 static void sparc_gen_labels(ir_node *block, void *env)
 713 {
 714         ir_node *pred;
 715         int n = get_Block_n_cfgpreds(block);
 716         (void) env;
 717
 718         for (n--; n >= 0; n--) {
 719                 pred = get_Block_cfgpred(block, n);
 720                 set_irn_link(pred, block); // link the pred of a block (which is a jmp)
 721         }
 722 }
 723
 724
 725 /**
 726  * Main driver
 727  */
 728 void sparc_gen_routine(const sparc_code_gen_t *cg, ir_graph *irg)
 729 {
 730         ir_node **blk_sched;
 731         ir_node *last_block = NULL;
 732         ir_entity *entity     = get_irg_entity(irg);
 733         int i, n;
 734         (void) cg;
 735
 736         be_gas_elf_type_char = '#';
 737         be_gas_object_file_format = OBJECT_FILE_FORMAT_ELF_SPARC;
 738
 739         /* register all emitter functions */
 740         sparc_register_emitters();
 741         be_dbg_method_begin(entity);
 742
 743         /* create the block schedule. For now, we don't need it earlier. */
 744         blk_sched = be_create_block_schedule(irg);
 745
 746         // emit function prolog
 747         sparc_emit_func_prolog(irg);
 748
 749         // generate BLOCK labels
 750         irg_block_walk_graph(irg, sparc_gen_labels, NULL, NULL);
 751
 752         // inject block scheduling links & emit code of each block
 753         n = ARR_LEN(blk_sched);
 754         for (i = 0; i < n;) {
 755                 ir_node *block, *next_bl;
 756
 757                 block = blk_sched[i];
 758                 ++i;
 759                 next_bl = i < n ? blk_sched[i] : NULL;
 760
 761                 /* set here the link. the emitter expects to find the next block here */
 762                 set_irn_link(block, next_bl);
 763                 sparc_gen_block(block, last_block);
 764                 last_block = block;
 765         }
 766
 767
 768         //irg_walk_blkwise_graph(irg, NULL, sparc_gen_block, NULL);
 769
 770         // emit function epilog
 771         sparc_emit_func_epilog(irg);
 772 }
 773
 774 void sparc_init_emitter(void)
 775 {
 776         FIRM_DBG_REGISTER(dbg, "firm.be.sparc.emit");
 777 }