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