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_emit_ident(get_entity_ld_ident(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_finish_line_gas(irn);
 324         be_emit_cstring("\trestore");
 325         be_emit_finish_line_gas(irn);
 326 }
 327
 328 /**
 329  * Emits code for Call node
 330  */
 331 static void emit_be_Call(const ir_node *irn)
 332 {
 333         ir_entity *entity = be_Call_get_entity(irn);
 334
 335         if (entity != NULL) {
 336                 be_emit_cstring("\tcall ");
 337             sparc_emit_entity(entity);
 338                 be_emit_finish_line_gas(irn);
 339                 be_emit_cstring("\tnop");
 340                 be_emit_pad_comment();
 341                 be_emit_cstring("/* TODO: use delay slot */\n");
 342         } else {
 343                 be_emit_cstring("\tnop\n");
 344                 be_emit_pad_comment();
 345                 be_emit_cstring("/* TODO: Entity == NULL */\n");
 346                 be_emit_finish_line_gas(irn);
 347         }
 348 }
 349
 350 /**
 351  * TODO: check if this is correct
 352  */
 353 static void emit_be_Perm(const ir_node *irn)
 354 {
 355         be_emit_cstring("\txor ");
 356         sparc_emit_source_register(irn, 1);
 357         be_emit_cstring(", ");
 358         sparc_emit_source_register(irn, 0);
 359         be_emit_cstring(", ");
 360         sparc_emit_source_register(irn, 0);
 361         be_emit_finish_line_gas(NULL);
 362
 363         be_emit_cstring("\txor ");
 364         sparc_emit_source_register(irn, 1);
 365         be_emit_cstring(", ");
 366         sparc_emit_source_register(irn, 0);
 367         be_emit_cstring(", ");
 368         sparc_emit_source_register(irn, 1);
 369         be_emit_finish_line_gas(NULL);
 370
 371         be_emit_cstring("\txor ");
 372         sparc_emit_source_register(irn, 1);
 373         be_emit_cstring(", ");
 374         sparc_emit_source_register(irn, 0);
 375         be_emit_cstring(", ");
 376         sparc_emit_source_register(irn, 0);
 377         be_emit_finish_line_gas(irn);
 378 }
 379
 380 /**
 381  * Emit a SymConst.
 382  */
 383 static void emit_sparc_SymConst(const ir_node *irn)
 384 {
 385         const sparc_symconst_attr_t *attr = get_sparc_symconst_attr_const(irn);
 386         ident *id_symconst = get_entity_ident(attr->entity);
 387         const char *label = get_id_str(id_symconst);
 388
 389         //sethi %hi(const32),%reg
 390         //or    %reg,%lo(const32),%reg
 391
 392         be_emit_irprintf("\tsethi %%hi(%s), ", label);
 393         sparc_emit_dest_register(irn, 0);
 394         be_emit_cstring("\n ");
 395
 396         // TODO: could be combined with the following load/store instruction
 397         be_emit_cstring("\tor ");
 398         sparc_emit_dest_register(irn, 0);
 399         be_emit_irprintf(", %%lo(%s), ", label);
 400         sparc_emit_dest_register(irn, 0);
 401         be_emit_finish_line_gas(irn);
 402 }
 403
 404
 405 /**
 406  * Emits code for FrameAddr fix
 407  */
 408 static void emit_sparc_FrameAddr(const ir_node *irn)
 409 {
 410         const sparc_symconst_attr_t *attr = get_irn_generic_attr_const(irn);
 411
 412         // no need to fix offset as we are adressing via the framepointer
 413         if (attr->fp_offset >= 0) {
 414                 be_emit_cstring("\tadd ");
 415                 sparc_emit_source_register(irn, 0);
 416                 be_emit_cstring(", ");
 417                 be_emit_irprintf("%ld", attr->fp_offset + save_attr->initial_stacksize);
 418         } else {
 419                 be_emit_cstring("\tsub ");
 420                 sparc_emit_source_register(irn, 0);
 421                 be_emit_cstring(", ");
 422                 be_emit_irprintf("%ld", -attr->fp_offset);
 423         }
 424
 425         be_emit_cstring(", ");
 426         sparc_emit_dest_register(irn, 0);
 427         be_emit_finish_line_gas(irn);
 428 }
 429
 430
 431 /**
 432  * Emits code for Branch
 433  */
 434 static void emit_sparc_Branch(const ir_node *irn)
 435 {
 436         const ir_edge_t *edge;
 437         const ir_node *proj_true  = NULL;
 438         const ir_node *proj_false = NULL;
 439         const ir_node *block;
 440         const ir_node *next_block;
 441         ir_node *op1 = get_irn_n(irn, 0);
 442         const char *suffix;
 443         int proj_num = get_sparc_jmp_cond_proj_num(irn);
 444         const sparc_cmp_attr_t *cmp_attr = get_irn_generic_attr_const(op1);
 445         // bool is_signed = !cmp_attr->is_unsigned;
 446
 447         assert(is_sparc_Cmp(op1) || is_sparc_Tst(op1));
 448
 449         foreach_out_edge(irn, edge) {
 450                 ir_node *proj = get_edge_src_irn(edge);
 451                 long nr = get_Proj_proj(proj);
 452                 if (nr == pn_Cond_true) {
 453                         proj_true = proj;
 454                 } else {
 455                         proj_false = proj;
 456                 }
 457         }
 458
 459         if (cmp_attr->ins_permuted) {
 460                 proj_num = get_mirrored_pnc(proj_num);
 461         }
 462
 463         /* for now, the code works for scheduled and non-schedules blocks */
 464         block = get_nodes_block(irn);
 465
 466         /* we have a block schedule */
 467         next_block = get_irn_link(block);
 468
 469         assert(proj_num != pn_Cmp_False);
 470         assert(proj_num != pn_Cmp_True);
 471
 472         if (get_irn_link(proj_true) == next_block) {
 473                 /* exchange both proj's so the second one can be omitted */
 474                 const ir_node *t = proj_true;
 475
 476                 proj_true  = proj_false;
 477                 proj_false = t;
 478                 proj_num   = get_negated_pnc(proj_num, mode_Iu);
 479         }
 480
 481
 482         switch (proj_num) {
 483                 case pn_Cmp_Eq:  suffix = "e"; break;
 484                 case pn_Cmp_Lt:  suffix = "l"; break;
 485                 case pn_Cmp_Le:  suffix = "le"; break;
 486                 case pn_Cmp_Gt:  suffix = "g"; break;
 487                 case pn_Cmp_Ge:  suffix = "ge"; break;
 488                 case pn_Cmp_Lg:  suffix = "ne"; break;
 489                 case pn_Cmp_Leg: suffix = "a"; break;
 490                 default: panic("Cmp has unsupported pnc");
 491         }
 492
 493         /* emit the true proj */
 494         be_emit_irprintf("\tb%s ", suffix);
 495         sparc_emit_cfop_target(proj_true);
 496         be_emit_finish_line_gas(proj_true);
 497
 498         be_emit_cstring("\tnop");
 499         be_emit_pad_comment();
 500         be_emit_cstring("/* TODO: use delay slot */\n");
 501
 502         if (get_irn_link(proj_false) == next_block) {
 503                 be_emit_cstring("\t/* false-fallthrough to ");
 504                 sparc_emit_cfop_target(proj_false);
 505                 be_emit_cstring(" */");
 506                 be_emit_finish_line_gas(proj_false);
 507         } else {
 508                 be_emit_cstring("\tba ");
 509                 sparc_emit_cfop_target(proj_false);
 510                 be_emit_finish_line_gas(proj_false);
 511                 be_emit_cstring("\tnop\t\t/* TODO: use delay slot */\n");
 512                 be_emit_finish_line_gas(proj_false);
 513         }
 514 }
 515
 516 /**
 517  * emit Jmp (which actually is a branch always (ba) instruction)
 518  */
 519 static void emit_sparc_Jmp(const ir_node *node)
 520 {
 521         ir_node *block, *next_block;
 522
 523         /* for now, the code works for scheduled and non-schedules blocks */
 524         block = get_nodes_block(node);
 525
 526         /* we have a block schedule */
 527         next_block = get_irn_link(block);
 528         if (get_irn_link(node) != next_block) {
 529                 be_emit_cstring("\tba ");
 530                 sparc_emit_cfop_target(node);
 531                 be_emit_finish_line_gas(node);
 532                 be_emit_cstring("\tnop\t\t/* TODO: use delay slot */\n");
 533         } else {
 534                 be_emit_cstring("\t/* fallthrough to ");
 535                 sparc_emit_cfop_target(node);
 536                 be_emit_cstring(" */");
 537         }
 538         be_emit_finish_line_gas(node);
 539 }
 540
 541 /**
 542  * emit copy node
 543  */
 544 static void emit_be_Copy(const ir_node *irn)
 545 {
 546         ir_mode *mode = get_irn_mode(irn);
 547
 548         if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
 549                 /* omitted Copy */
 550                 return;
 551         }
 552
 553         if (mode_is_float(mode)) {
 554                 panic("emit_be_Copy: move not supported for FP");
 555         } else if (mode_is_data(mode)) {
 556                 be_emit_cstring("\tmov ");
 557                 sparc_emit_source_register(irn, 0);
 558                 be_emit_cstring(", ");
 559                 sparc_emit_dest_register(irn, 0);
 560                 be_emit_finish_line_gas(irn);
 561         } else {
 562                 panic("emit_be_Copy: move not supported for this mode");
 563         }
 564 }
 565
 566
 567 /**
 568  * dummy emitter for ignored nodes
 569  */
 570 static void emit_nothing(const ir_node *irn)
 571 {
 572         (void) irn;
 573 }
 574
 575
 576
 577 /**
 578  * type of emitter function
 579  */
 580 typedef void (*emit_func) (const ir_node *);
 581
 582 /**
 583  * Set a node emitter. Make it a bit more type safe.
 584  */
 585 static inline void set_emitter(ir_op *op, emit_func sparc_emit_node)
 586 {
 587         op->ops.generic = (op_func)sparc_emit_node;
 588 }
 589
 590 /**
 591  * Enters the emitter functions for handled nodes into the generic
 592  * pointer of an opcode.
 593  */
 594 static void sparc_register_emitters(void)
 595 {
 596
 597         /* first clear the generic function pointer for all ops */
 598         clear_irp_opcodes_generic_func();
 599
 600         /* register all emitter functions defined in spec */
 601         sparc_register_spec_emitters();
 602
 603         /* custom emitter */
 604     set_emitter(op_be_IncSP,       emit_be_IncSP);
 605     set_emitter(op_be_Return,      emit_be_Return);
 606     set_emitter(op_be_Call,        emit_be_Call);
 607     set_emitter(op_sparc_FrameAddr,  emit_sparc_FrameAddr);
 608     set_emitter(op_sparc_Branch,   emit_sparc_Branch);
 609     set_emitter(op_sparc_SymConst,   emit_sparc_SymConst);
 610     set_emitter(op_sparc_Jmp,        emit_sparc_Jmp);
 611     set_emitter(op_sparc_Save,        emit_sparc_Save);
 612
 613     set_emitter(op_sparc_HiImm,        emit_sparc_HiImm);
 614     set_emitter(op_sparc_LoImm,        emit_sparc_LoImm);
 615
 616     set_emitter(op_be_Copy,        emit_be_Copy);
 617     set_emitter(op_be_CopyKeep,    emit_be_Copy);
 618
 619     set_emitter(op_be_Perm,        emit_be_Perm);
 620
 621 /*
 622     set_emitter(op_arm_B,          emit_arm_B);
 623     set_emitter(op_arm_CopyB,      emit_arm_CopyB);
 624     set_emitter(op_arm_fpaConst,   emit_arm_fpaConst);
 625     set_emitter(op_arm_fpaDbl2GP,  emit_arm_fpaDbl2GP);
 626     set_emitter(op_arm_LdTls,      emit_arm_LdTls);
 627     set_emitter(op_arm_SwitchJmp,  emit_arm_SwitchJmp);
 628     set_emitter(op_be_MemPerm,     emit_be_MemPerm);
 629
 630 */
 631     /* no need to emit anything for the following nodes */
 632         set_emitter(op_Phi,            emit_nothing);
 633         set_emitter(op_be_Keep,        emit_nothing);
 634         set_emitter(op_be_Start,       emit_nothing);
 635         set_emitter(op_be_Barrier,     emit_nothing);
 636
 637 }
 638
 639 /**
 640  * Emits code for a node.
 641  */
 642 static void sparc_emit_node(const ir_node *node)
 643 {
 644         ir_op               *op       = get_irn_op(node);
 645
 646         if (op->ops.generic) {
 647                 emit_func func = (emit_func) op->ops.generic;
 648                 be_dbg_set_dbg_info(get_irn_dbg_info(node));
 649                 (*func) (node);
 650         } else {
 651                 panic("Error: No emit handler for node %+F (graph %+F)\n",
 652                         node, current_ir_graph);
 653         }
 654 }
 655
 656 /**
 657  * Walks over the nodes in a block connected by scheduling edges
 658  * and emits code for each node.
 659  */
 660 static void sparc_gen_block(ir_node *block, void *data)
 661 {
 662         ir_node *node;
 663         (void) data;
 664
 665         if (! is_Block(block))
 666                 return;
 667
 668         be_gas_emit_block_name(block);
 669         be_emit_cstring(":\n");
 670         be_emit_write_line();
 671
 672         sched_foreach(block, node) {
 673                 sparc_emit_node(node);
 674         }
 675 }
 676
 677
 678 /**
 679  * Emits code for function start.
 680  */
 681 static void sparc_emit_func_prolog(ir_graph *irg)
 682 {
 683         ir_entity *ent = get_irg_entity(irg);
 684         be_gas_emit_function_prolog(ent, 4);
 685         be_emit_write_line();
 686 }
 687
 688 /**
 689  * Emits code for function end
 690  */
 691 static void sparc_emit_func_epilog(ir_graph *irg)
 692 {
 693         ir_entity *ent = get_irg_entity(irg);
 694         const char *irg_name = get_entity_ld_name(ent);
 695         be_emit_write_line();
 696         be_emit_irprintf("\t.size  %s, .-%s\n", irg_name, irg_name);
 697         be_emit_cstring("# -- End ");
 698         be_emit_string(irg_name);
 699         be_emit_cstring("\n");
 700         be_emit_write_line();
 701 }
 702
 703 /**
 704  * Block-walker:
 705  * TODO: Sets labels for control flow nodes (jump target).
 706  * Links control predecessors to there destination blocks.
 707  */
 708 static void sparc_gen_labels(ir_node *block, void *env)
 709 {
 710         ir_node *pred;
 711         int n = get_Block_n_cfgpreds(block);
 712         (void) env;
 713
 714         for (n--; n >= 0; n--) {
 715                 pred = get_Block_cfgpred(block, n);
 716                 set_irn_link(pred, block); // link the pred of a block (which is a jmp)
 717         }
 718 }
 719
 720
 721 /**
 722  * Main driver
 723  */
 724 void sparc_gen_routine(const sparc_code_gen_t *cg, ir_graph *irg)
 725 {
 726         ir_node **blk_sched;
 727         ir_node *last_block = NULL;
 728         ir_entity *entity     = get_irg_entity(irg);
 729         int i, n;
 730
 731         be_gas_elf_type_char = '#';
 732
 733         /* register all emitter functions */
 734         sparc_register_emitters();
 735         be_dbg_method_begin(entity, be_abi_get_stack_layout(cg->birg->abi));
 736
 737         /* create the block schedule. For now, we don't need it earlier. */
 738         blk_sched = be_create_block_schedule(cg->irg, cg->birg->exec_freq);
 739
 740         // emit function prolog
 741         sparc_emit_func_prolog(irg);
 742
 743         // generate BLOCK labels
 744         irg_block_walk_graph(irg, sparc_gen_labels, NULL, NULL);
 745
 746         // inject block scheduling links & emit code of each block
 747         n = ARR_LEN(blk_sched);
 748         for (i = 0; i < n;) {
 749                 ir_node *block, *next_bl;
 750
 751                 block = blk_sched[i];
 752                 ++i;
 753                 next_bl = i < n ? blk_sched[i] : NULL;
 754
 755                 /* set here the link. the emitter expects to find the next block here */
 756                 set_irn_link(block, next_bl);
 757                 sparc_gen_block(block, last_block);
 758                 last_block = block;
 759         }
 760
 761
 762         //irg_walk_blkwise_graph(irg, NULL, sparc_gen_block, NULL);
 763
 764         // emit function epilog
 765         sparc_emit_func_epilog(irg);
 766 }
 767
 768 void sparc_init_emitter(void)
 769 {
 770         FIRM_DBG_REGISTER(dbg, "firm.be.sparc.emit");
 771 }