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  * @author  Hannes Rapp, Matthias Braun
  24  */
  25 #include "config.h"
  26
  27 #include <limits.h>
  28
  29 #include "bitfiddle.h"
  30 #include "xmalloc.h"
  31 #include "tv.h"
  32 #include "iredges.h"
  33 #include "debug.h"
  34 #include "irgwalk.h"
  35 #include "irprintf.h"
  36 #include "irop_t.h"
  37 #include "irargs_t.h"
  38 #include "irprog.h"
  39 #include "irargs_t.h"
  40 #include "error.h"
  41 #include "raw_bitset.h"
  42 #include "dbginfo.h"
  43 #include "heights.h"
  44
  45 #include "besched.h"
  46 #include "beblocksched.h"
  47 #include "beirg.h"
  48 #include "begnuas.h"
  49 #include "be_dbgout.h"
  50 #include "benode.h"
  51 #include "bestack.h"
  52 #include "bepeephole.h"
  53
  54 #include "sparc_emitter.h"
  55 #include "gen_sparc_emitter.h"
  56 #include "sparc_nodes_attr.h"
  57 #include "sparc_new_nodes.h"
  58 #include "gen_sparc_regalloc_if.h"
  59
  60 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  61
  62 static ir_heights_t  *heights;
  63 static const ir_node *delay_slot_filler; /**< this node has been choosen to fill
  64                                               the next delay slot */
  65
  66 static void sparc_emit_node(const ir_node *node);
  67 static bool emitting_delay_slot;
  68
  69 void sparc_emit_indent(void)
  70 {
  71         be_emit_char('\t');
  72         if (emitting_delay_slot)
  73                 be_emit_char(' ');
  74 }
  75
  76 void sparc_emit_immediate(const ir_node *node)
  77 {
  78         const sparc_attr_t *attr   = get_sparc_attr_const(node);
  79         ir_entity          *entity = attr->immediate_value_entity;
  80
  81         if (entity == NULL) {
  82                 int32_t value = attr->immediate_value;
  83                 assert(sparc_is_value_imm_encodeable(value));
  84                 be_emit_irprintf("%d", value);
  85         } else {
  86                 if (get_entity_owner(entity) == get_tls_type()) {
  87                         be_emit_cstring("%tle_lox10(");
  88                 } else {
  89                         be_emit_cstring("%lo(");
  90                 }
  91                 be_gas_emit_entity(entity);
  92                 if (attr->immediate_value != 0) {
  93                         be_emit_irprintf("%+d", attr->immediate_value);
  94                 }
  95                 be_emit_char(')');
  96         }
  97 }
  98
  99 void sparc_emit_high_immediate(const ir_node *node)
 100 {
 101         const sparc_attr_t *attr   = get_sparc_attr_const(node);
 102         ir_entity          *entity = attr->immediate_value_entity;
 103
 104         if (entity == NULL) {
 105                 uint32_t value = (uint32_t) attr->immediate_value;
 106                 be_emit_irprintf("%%hi(0x%X)", value);
 107         } else {
 108                 if (get_entity_owner(entity) == get_tls_type()) {
 109                         be_emit_cstring("%tle_hix22(");
 110                 } else {
 111                         be_emit_cstring("%hi(");
 112                 }
 113                 be_gas_emit_entity(entity);
 114                 if (attr->immediate_value != 0) {
 115                         be_emit_irprintf("%+d", attr->immediate_value);
 116                 }
 117                 be_emit_char(')');
 118         }
 119 }
 120
 121 void sparc_emit_source_register(const ir_node *node, int pos)
 122 {
 123         const arch_register_t *reg = arch_get_irn_register_in(node, pos);
 124         be_emit_char('%');
 125         be_emit_string(arch_register_get_name(reg));
 126 }
 127
 128 void sparc_emit_dest_register(const ir_node *node, int pos)
 129 {
 130         const arch_register_t *reg = arch_get_irn_register_out(node, pos);
 131         be_emit_char('%');
 132         be_emit_string(arch_register_get_name(reg));
 133 }
 134
 135 /**
 136  * Emits either a imm or register depending on arity of node
 137  * @param node
 138  * @param register no (-1 if no register)
 139  */
 140 void sparc_emit_reg_or_imm(const ir_node *node, int pos)
 141 {
 142         if (arch_get_irn_flags(node) & ((arch_irn_flags_t)sparc_arch_irn_flag_immediate_form)) {
 143                 // we have a imm input
 144                 sparc_emit_immediate(node);
 145         } else {
 146                 // we have reg input
 147                 sparc_emit_source_register(node, pos);
 148         }
 149 }
 150
 151 /**
 152  * emit SP offset
 153  */
 154 void sparc_emit_offset(const ir_node *node, int offset_node_pos)
 155 {
 156         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 157
 158         if (attr->is_reg_reg) {
 159                 assert(!attr->is_frame_entity);
 160                 assert(attr->base.immediate_value == 0);
 161                 assert(attr->base.immediate_value_entity == NULL);
 162                 be_emit_char('+');
 163                 sparc_emit_source_register(node, offset_node_pos);
 164         } else if (attr->is_frame_entity) {
 165                 int32_t offset = attr->base.immediate_value;
 166                 if (offset != 0) {
 167                         assert(sparc_is_value_imm_encodeable(offset));
 168                         be_emit_irprintf("%+ld", offset);
 169                 }
 170         } else if (attr->base.immediate_value != 0
 171                         || attr->base.immediate_value_entity != NULL) {
 172                 be_emit_char('+');
 173                 sparc_emit_immediate(node);
 174         }
 175 }
 176
 177 void sparc_emit_source_reg_and_offset(const ir_node *node, int regpos,
 178                                       int offpos)
 179 {
 180         const arch_register_t *reg = arch_get_irn_register_in(node, regpos);
 181         const sparc_load_store_attr_t *attr;
 182
 183 #ifdef DEBUG_libfirm
 184         if (reg == &sparc_registers[REG_SP]) {
 185                 attr = get_sparc_load_store_attr_const(node);
 186                 if (!attr->is_reg_reg
 187                     && attr->base.immediate_value < SPARC_SAVE_AREA_SIZE) {
 188
 189                         ir_fprintf(stderr, "warning: emitting stack pointer relative load/store with offset < %d\n", SPARC_SAVE_AREA_SIZE);
 190                 }
 191         }
 192 #endif
 193
 194         sparc_emit_source_register(node, regpos);
 195         sparc_emit_offset(node, offpos);
 196 }
 197
 198 void sparc_emit_float_load_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         assert(mode_is_float(mode));
 205
 206         switch (bits) {
 207         case 32:  return;
 208         case 64:  be_emit_char('d'); return;
 209         case 128: be_emit_char('q'); return;
 210         }
 211         panic("invalid float load/store mode %+F", mode);
 212 }
 213
 214 /**
 215  *  Emit load mode char
 216  */
 217 void sparc_emit_load_mode(const ir_node *node)
 218 {
 219         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 220         ir_mode *mode      = attr->load_store_mode;
 221         int      bits      = get_mode_size_bits(mode);
 222         bool     is_signed = mode_is_signed(mode);
 223
 224         if (bits == 16) {
 225                 be_emit_string(is_signed ? "sh" : "uh");
 226         } else if (bits == 8) {
 227                 be_emit_string(is_signed ? "sb" : "ub");
 228         } else if (bits == 64) {
 229                 be_emit_char('d');
 230         } else {
 231                 assert(bits == 32);
 232         }
 233 }
 234
 235 /**
 236  * Emit store mode char
 237  */
 238 void sparc_emit_store_mode(const ir_node *node)
 239 {
 240         const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(node);
 241         ir_mode *mode      = attr->load_store_mode;
 242         int      bits      = get_mode_size_bits(mode);
 243
 244         if (bits == 16) {
 245                 be_emit_string("h");
 246         } else if (bits == 8) {
 247                 be_emit_string("b");
 248         } else if (bits == 64) {
 249                 be_emit_char('d');
 250         } else {
 251                 assert(bits == 32);
 252         }
 253 }
 254
 255 static void emit_fp_suffix(const ir_mode *mode)
 256 {
 257         unsigned bits = get_mode_size_bits(mode);
 258         assert(mode_is_float(mode));
 259
 260         if (bits == 32) {
 261                 be_emit_char('s');
 262         } else if (bits == 64) {
 263                 be_emit_char('d');
 264         } else if (bits == 128) {
 265                 be_emit_char('q');
 266         } else {
 267                 panic("invalid FP mode");
 268         }
 269 }
 270
 271 void sparc_emit_fp_conv_source(const ir_node *node)
 272 {
 273         const sparc_fp_conv_attr_t *attr = get_sparc_fp_conv_attr_const(node);
 274         emit_fp_suffix(attr->src_mode);
 275 }
 276
 277 void sparc_emit_fp_conv_destination(const ir_node *node)
 278 {
 279         const sparc_fp_conv_attr_t *attr = get_sparc_fp_conv_attr_const(node);
 280         emit_fp_suffix(attr->dest_mode);
 281 }
 282
 283 /**
 284  * emits the FP mode suffix char
 285  */
 286 void sparc_emit_fp_mode_suffix(const ir_node *node)
 287 {
 288         const sparc_fp_attr_t *attr = get_sparc_fp_attr_const(node);
 289         emit_fp_suffix(attr->fp_mode);
 290 }
 291
 292 static ir_node *get_jump_target(const ir_node *jump)
 293 {
 294         return (ir_node*)get_irn_link(jump);
 295 }
 296
 297 /**
 298  * Returns the target label for a control flow node.
 299  */
 300 static void sparc_emit_cfop_target(const ir_node *node)
 301 {
 302         ir_node *block = get_jump_target(node);
 303         be_gas_emit_block_name(block);
 304 }
 305
 306 /**
 307  * returns true if a sparc_call calls a register and not an immediate
 308  */
 309 static bool is_sparc_reg_call(const ir_node *node)
 310 {
 311         const sparc_attr_t *attr = get_sparc_attr_const(node);
 312         return attr->immediate_value_entity == NULL;
 313 }
 314
 315 static int get_sparc_Call_dest_addr_pos(const ir_node *node)
 316 {
 317         assert(is_sparc_reg_call(node));
 318         return get_irn_arity(node)-1;
 319 }
 320
 321 static bool ba_is_fallthrough(const ir_node *node)
 322 {
 323         ir_node *block      = get_nodes_block(node);
 324         ir_node *next_block = (ir_node*)get_irn_link(block);
 325         return get_irn_link(node) == next_block;
 326 }
 327
 328 static bool is_no_instruction(const ir_node *node)
 329 {
 330         /* copies are nops if src_reg == dest_reg */
 331         if (be_is_Copy(node) || be_is_CopyKeep(node)) {
 332                 const arch_register_t *src_reg  = arch_get_irn_register_in(node, 0);
 333                 const arch_register_t *dest_reg = arch_get_irn_register_out(node, 0);
 334
 335                 if (src_reg == dest_reg)
 336                         return true;
 337         }
 338         if (be_is_IncSP(node) && be_get_IncSP_offset(node) == 0)
 339                 return true;
 340         /* Ba is not emitted if it is a simple fallthrough */
 341         if (is_sparc_Ba(node) && ba_is_fallthrough(node))
 342                 return true;
 343
 344         return be_is_Keep(node) || be_is_Start(node) || is_Phi(node);
 345 }
 346
 347 static bool has_delay_slot(const ir_node *node)
 348 {
 349         if (is_sparc_Ba(node)) {
 350                 return !ba_is_fallthrough(node);
 351         }
 352
 353         return arch_get_irn_flags(node) & sparc_arch_irn_flag_has_delay_slot;
 354 }
 355
 356 /** returns true if the emitter for this sparc node can produce more than one
 357  * actual sparc instruction.
 358  * Usually it is a bad sign if we have to add instructions here. We should
 359  * rather try to get them lowered down. So we can actually put them into
 360  * delay slots and make them more accessible to the scheduler.
 361  */
 362 static bool emits_multiple_instructions(const ir_node *node)
 363 {
 364         if (has_delay_slot(node))
 365                 return true;
 366
 367         if (is_sparc_Call(node)) {
 368                 return arch_get_irn_flags(node) & sparc_arch_irn_flag_aggregate_return;
 369         }
 370
 371         return is_sparc_SMulh(node) || is_sparc_UMulh(node)
 372                 || is_sparc_SDiv(node) || is_sparc_UDiv(node)
 373                 || be_is_MemPerm(node) || be_is_Perm(node);
 374 }
 375
 376 static bool uses_reg(const ir_node *node, const arch_register_t *reg)
 377 {
 378         int arity = get_irn_arity(node);
 379         int i;
 380
 381         for (i = 0; i < arity; ++i) {
 382                 const arch_register_t *in_reg = arch_get_irn_register_in(node, i);
 383                 if (reg == in_reg)
 384                         return true;
 385         }
 386         return false;
 387 }
 388
 389 static bool writes_reg(const ir_node *node, const arch_register_t *reg)
 390 {
 391         unsigned n_outs = arch_get_irn_n_outs(node);
 392         unsigned o;
 393         for (o = 0; o < n_outs; ++o) {
 394                 const arch_register_t *out_reg = arch_get_irn_register_out(node, o);
 395                 if (out_reg == reg)
 396                         return true;
 397         }
 398         return false;
 399 }
 400
 401 static bool can_move_into_delayslot(const ir_node *node, const ir_node *to)
 402 {
 403         if (!be_can_move_before(heights, node, to))
 404                 return false;
 405
 406         if (is_sparc_Call(to)) {
 407                 ir_node *check;
 408                 /** all deps are used after the delay slot so, we're fine */
 409                 if (!is_sparc_reg_call(to))
 410                         return true;
 411
 412                 check = get_irn_n(to, get_sparc_Call_dest_addr_pos(to));
 413                 if (skip_Proj(check) == node)
 414                         return false;
 415
 416                 /* the Call also destroys the value of %o7, but since this is
 417                  * currently marked as ignore register in the backend, it
 418                  * should never be used by the instruction in the delay slot. */
 419                 if (uses_reg(node, &sparc_registers[REG_O7]))
 420                         return false;
 421                 return true;
 422         } else if (is_sparc_Return(to)) {
 423                 /* return uses the value of %o7, all other values are not
 424                  * immediately used */
 425                 if (writes_reg(node, &sparc_registers[REG_O7]))
 426                         return false;
 427                 return true;
 428         } else {
 429                 /* the node must not use our computed values */
 430                 int arity = get_irn_arity(to);
 431                 int i;
 432                 for (i = 0; i < arity; ++i) {
 433                         ir_node *in = get_irn_n(to, i);
 434                         if (skip_Proj(in) == node)
 435                                 return false;
 436                 }
 437                 return true;
 438         }
 439 }
 440
 441 /**
 442  * search for an instruction that can fill the delay slot of @p node
 443  */
 444 static const ir_node *pick_delay_slot_for(const ir_node *node)
 445 {
 446         const ir_node *schedpoint = node;
 447         unsigned       tries      = 0;
 448         /* currently we don't track which registers are still alive, so we can't
 449          * pick any other instructions other than the one directly preceding */
 450         static const unsigned PICK_DELAY_SLOT_MAX_DISTANCE = 10;
 451
 452         assert(has_delay_slot(node));
 453
 454         while (sched_has_prev(schedpoint)) {
 455                 schedpoint = sched_prev(schedpoint);
 456
 457                 if (has_delay_slot(schedpoint))
 458                         break;
 459
 460                 /* skip things which don't really result in instructions */
 461                 if (is_no_instruction(schedpoint))
 462                         continue;
 463
 464                 if (tries++ >= PICK_DELAY_SLOT_MAX_DISTANCE)
 465                         break;
 466
 467                 if (emits_multiple_instructions(schedpoint))
 468                         continue;
 469
 470                 if (!can_move_into_delayslot(schedpoint, node))
 471                         continue;
 472
 473                 /* found something */
 474                 return schedpoint;
 475         }
 476
 477         return NULL;
 478 }
 479
 480 /**
 481  * Emits code for stack space management
 482  */
 483 static void emit_be_IncSP(const ir_node *irn)
 484 {
 485         int offset = be_get_IncSP_offset(irn);
 486
 487         if (offset == 0)
 488                 return;
 489
 490         /* SPARC stack grows downwards */
 491         sparc_emit_indent();
 492         if (offset < 0) {
 493                 be_emit_cstring("sub ");
 494                 offset = -offset;
 495         } else {
 496                 be_emit_cstring("add ");
 497         }
 498
 499         sparc_emit_source_register(irn, 0);
 500         be_emit_irprintf(", %d", -offset);
 501         be_emit_cstring(", ");
 502         sparc_emit_dest_register(irn, 0);
 503         be_emit_finish_line_gas(irn);
 504 }
 505
 506 /**
 507  * emits code for mulh
 508  */
 509 static void emit_sparc_Mulh(const ir_node *irn)
 510 {
 511         sparc_emit_indent();
 512         if (is_sparc_UMulh(irn)) {
 513                 be_emit_char('u');
 514         } else {
 515                 assert(is_sparc_SMulh(irn));
 516                 be_emit_char('s');
 517         }
 518         be_emit_cstring("mul ");
 519
 520         sparc_emit_source_register(irn, 0);
 521         be_emit_cstring(", ");
 522         sparc_emit_reg_or_imm(irn, 1);
 523         be_emit_cstring(", ");
 524         sparc_emit_dest_register(irn, 0);
 525         be_emit_finish_line_gas(irn);
 526
 527         // our result is in the y register now
 528         // we just copy it to the assigned target reg
 529         sparc_emit_indent();
 530         be_emit_cstring("mov %y, ");
 531         sparc_emit_dest_register(irn, 0);
 532         be_emit_finish_line_gas(irn);
 533 }
 534
 535 static void fill_delay_slot(void)
 536 {
 537         emitting_delay_slot = true;
 538         if (delay_slot_filler != NULL) {
 539                 sparc_emit_node(delay_slot_filler);
 540                 delay_slot_filler = NULL;
 541         } else {
 542                 sparc_emit_indent();
 543                 be_emit_cstring("nop\n");
 544                 be_emit_write_line();
 545         }
 546         emitting_delay_slot = false;
 547 }
 548
 549 static void emit_sparc_Div(const ir_node *node, bool is_signed)
 550 {
 551         /* can we get the delay count of the wr instruction somewhere? */
 552         unsigned wry_delay_count = 3;
 553         unsigned i;
 554
 555         sparc_emit_indent();
 556         be_emit_cstring("wr ");
 557         sparc_emit_source_register(node, 0);
 558         be_emit_cstring(", 0, %y");
 559         be_emit_finish_line_gas(node);
 560
 561         for (i = 0; i < wry_delay_count; ++i) {
 562                 fill_delay_slot();
 563         }
 564
 565         sparc_emit_indent();
 566         be_emit_irprintf("%s ", is_signed ? "sdiv" : "udiv");
 567         sparc_emit_source_register(node, 1);
 568         be_emit_cstring(", ");
 569         sparc_emit_reg_or_imm(node, 2);
 570         be_emit_cstring(", ");
 571         sparc_emit_dest_register(node, 0);
 572         be_emit_finish_line_gas(node);
 573 }
 574
 575 static void emit_sparc_SDiv(const ir_node *node)
 576 {
 577         emit_sparc_Div(node, true);
 578 }
 579
 580 static void emit_sparc_UDiv(const ir_node *node)
 581 {
 582         emit_sparc_Div(node, false);
 583 }
 584
 585 static void emit_sparc_Call(const ir_node *node)
 586 {
 587         sparc_emit_indent();
 588         be_emit_cstring("call ");
 589         if (is_sparc_reg_call(node)) {
 590                 int dest_addr = get_sparc_Call_dest_addr_pos(node);
 591                 sparc_emit_source_register(node, dest_addr);
 592         } else {
 593                 const sparc_attr_t *attr   = get_sparc_attr_const(node);
 594                 ir_entity          *entity = attr->immediate_value_entity;
 595             be_gas_emit_entity(entity);
 596             if (attr->immediate_value != 0) {
 597                         be_emit_irprintf("%+d", attr->immediate_value);
 598                 }
 599                 be_emit_cstring(", 0");
 600         }
 601         be_emit_finish_line_gas(node);
 602
 603         fill_delay_slot();
 604
 605         if (arch_get_irn_flags(node) & sparc_arch_irn_flag_aggregate_return) {
 606                 sparc_emit_indent();
 607                 be_emit_cstring("unimp 8\n");
 608                 be_emit_write_line();
 609         }
 610 }
 611
 612 static void emit_be_Perm(const ir_node *irn)
 613 {
 614         sparc_emit_indent();
 615         be_emit_cstring("xor ");
 616         sparc_emit_source_register(irn, 1);
 617         be_emit_cstring(", ");
 618         sparc_emit_source_register(irn, 0);
 619         be_emit_cstring(", ");
 620         sparc_emit_source_register(irn, 0);
 621         be_emit_finish_line_gas(NULL);
 622
 623         sparc_emit_indent();
 624         be_emit_cstring("xor ");
 625         sparc_emit_source_register(irn, 1);
 626         be_emit_cstring(", ");
 627         sparc_emit_source_register(irn, 0);
 628         be_emit_cstring(", ");
 629         sparc_emit_source_register(irn, 1);
 630         be_emit_finish_line_gas(NULL);
 631
 632         sparc_emit_indent();
 633         be_emit_cstring("xor ");
 634         sparc_emit_source_register(irn, 1);
 635         be_emit_cstring(", ");
 636         sparc_emit_source_register(irn, 0);
 637         be_emit_cstring(", ");
 638         sparc_emit_source_register(irn, 0);
 639         be_emit_finish_line_gas(irn);
 640 }
 641
 642 /* The stack pointer must always be SPARC_STACK_ALIGNMENT bytes aligned, so get
 643  * the next bigger integer that's evenly divisible by it. */
 644 static unsigned get_aligned_sp_change(const unsigned num_regs)
 645 {
 646         const unsigned bytes = num_regs * SPARC_REGISTER_SIZE;
 647         return round_up2(bytes, SPARC_STACK_ALIGNMENT);
 648 }
 649
 650 /* Spill register l0 or both l0 and l1, depending on n_spilled and n_to_spill.*/
 651 static void memperm_emit_spill_registers(const ir_node *node, int n_spilled,
 652                                          int n_to_spill)
 653 {
 654         assert(n_spilled < n_to_spill);
 655
 656         if (n_spilled == 0) {
 657                 /* We always reserve stack space for two registers because during copy
 658                  * processing we don't know yet if we also need to handle a cycle which
 659                  * needs two registers.  More complicated code in emit_MemPerm would
 660                  * prevent wasting SPARC_REGISTER_SIZE bytes of stack space but
 661                  * it is not worth the worse readability of emit_MemPerm. */
 662
 663                 /* Keep stack pointer aligned. */
 664                 unsigned sp_change = get_aligned_sp_change(2);
 665                 sparc_emit_indent();
 666                 be_emit_irprintf("sub %%sp, %u, %%sp", sp_change);
 667                 be_emit_finish_line_gas(node);
 668
 669                 /* Spill register l0. */
 670                 sparc_emit_indent();
 671                 be_emit_irprintf("st %%l0, [%%sp%+d]", SPARC_MIN_STACKSIZE);
 672                 be_emit_finish_line_gas(node);
 673         }
 674
 675         if (n_to_spill == 2) {
 676                 /* Spill register l1. */
 677                 sparc_emit_indent();
 678                 be_emit_irprintf("st %%l1, [%%sp%+d]", SPARC_MIN_STACKSIZE + SPARC_REGISTER_SIZE);
 679                 be_emit_finish_line_gas(node);
 680         }
 681 }
 682
 683 /* Restore register l0 or both l0 and l1, depending on n_spilled. */
 684 static void memperm_emit_restore_registers(const ir_node *node, int n_spilled)
 685 {
 686         unsigned sp_change;
 687
 688         if (n_spilled == 2) {
 689                 /* Restore register l1. */
 690                 sparc_emit_indent();
 691                 be_emit_irprintf("ld [%%sp%+d], %%l1", SPARC_MIN_STACKSIZE + SPARC_REGISTER_SIZE);
 692                 be_emit_finish_line_gas(node);
 693         }
 694
 695         /* Restore register l0. */
 696         sparc_emit_indent();
 697         be_emit_irprintf("ld [%%sp%+d], %%l0", SPARC_MIN_STACKSIZE);
 698         be_emit_finish_line_gas(node);
 699
 700         /* Restore stack pointer. */
 701         sp_change = get_aligned_sp_change(2);
 702         sparc_emit_indent();
 703         be_emit_irprintf("add %%sp, %u, %%sp", sp_change);
 704         be_emit_finish_line_gas(node);
 705 }
 706
 707 /* Emit code to copy in_ent to out_ent.  Only uses l0. */
 708 static void memperm_emit_copy(const ir_node *node, ir_entity *in_ent,
 709                               ir_entity *out_ent)
 710 {
 711         ir_graph          *irg     = get_irn_irg(node);
 712         be_stack_layout_t *layout  = be_get_irg_stack_layout(irg);
 713         int                off_in  = be_get_stack_entity_offset(layout, in_ent, 0);
 714         int                off_out = be_get_stack_entity_offset(layout, out_ent, 0);
 715
 716         /* Load from input entity. */
 717         sparc_emit_indent();
 718         be_emit_irprintf("ld [%%fp%+d], %%l0", off_in);
 719         be_emit_finish_line_gas(node);
 720
 721         /* Store to output entity. */
 722         sparc_emit_indent();
 723         be_emit_irprintf("st %%l0, [%%fp%+d]", off_out);
 724         be_emit_finish_line_gas(node);
 725 }
 726
 727 /* Emit code to swap ent1 and ent2.  Uses l0 and l1. */
 728 static void memperm_emit_swap(const ir_node *node, ir_entity *ent1,
 729                               ir_entity *ent2)
 730 {
 731         ir_graph          *irg     = get_irn_irg(node);
 732         be_stack_layout_t *layout  = be_get_irg_stack_layout(irg);
 733         int                off1    = be_get_stack_entity_offset(layout, ent1, 0);
 734         int                off2    = be_get_stack_entity_offset(layout, ent2, 0);
 735
 736         /* Load from first input entity. */
 737         sparc_emit_indent();
 738         be_emit_irprintf("ld [%%fp%+d], %%l0", off1);
 739         be_emit_finish_line_gas(node);
 740
 741         /* Load from second input entity. */
 742         sparc_emit_indent();
 743         be_emit_irprintf("ld [%%fp%+d], %%l1", off2);
 744         be_emit_finish_line_gas(node);
 745
 746         /* Store first value to second output entity. */
 747         sparc_emit_indent();
 748         be_emit_irprintf("st %%l0, [%%fp%+d]", off2);
 749         be_emit_finish_line_gas(node);
 750
 751         /* Store second value to first output entity. */
 752         sparc_emit_indent();
 753         be_emit_irprintf("st %%l1, [%%fp%+d]", off1);
 754         be_emit_finish_line_gas(node);
 755 }
 756
 757 /* Find the index of ent in ents or return -1 if not found. */
 758 static int get_index(ir_entity **ents, int n, ir_entity *ent)
 759 {
 760         int i;
 761
 762         for (i = 0; i < n; ++i)
 763                 if (ents[i] == ent)
 764                         return i;
 765
 766         return -1;
 767 }
 768
 769 /*
 770  * Emit code for a MemPerm node.
 771  *
 772  * Analyze MemPerm for copy chains and cyclic swaps and resolve them using
 773  * loads and stores.
 774  * This function is conceptually very similar to permute_values in
 775  * beprefalloc.c.
 776  */
 777 static void emit_be_MemPerm(const ir_node *node)
 778 {
 779         int         memperm_arity = be_get_MemPerm_entity_arity(node);
 780         /* Upper limit for the number of participating entities is twice the
 781          * arity, e.g., for a simple copying MemPerm node with one input/output. */
 782         int         max_size      = 2 * memperm_arity;
 783         ir_entity **entities      = ALLOCANZ(ir_entity *, max_size);
 784         /* sourceof contains the input entity for each entity.  If an entity is
 785          * never used as an output, its entry in sourceof is a fix point. */
 786         int        *sourceof      = ALLOCANZ(int,         max_size);
 787         /* n_users counts how many output entities use this entity as their input.*/
 788         int        *n_users       = ALLOCANZ(int,         max_size);
 789         /* n_spilled records the number of spilled registers, either 1 or 2. */
 790         int         n_spilled     = 0;
 791         int         i, n, oidx;
 792
 793         /* This implementation currently only works with frame pointers. */
 794         ir_graph          *irg    = get_irn_irg(node);
 795         be_stack_layout_t *layout = be_get_irg_stack_layout(irg);
 796         assert(!layout->sp_relative && "MemPerms currently do not work without frame pointers");
 797
 798         for (i = 0; i < max_size; ++i) {
 799                 sourceof[i] = i;
 800         }
 801
 802         for (i = n = 0; i < memperm_arity; ++i) {
 803                 ir_entity *out  = be_get_MemPerm_out_entity(node, i);
 804                 ir_entity *in   = be_get_MemPerm_in_entity(node, i);
 805                 int              oidx; /* Out index */
 806                 int              iidx; /* In index */
 807
 808                 /* Insert into entities to be able to operate on unique indices. */
 809                 if (get_index(entities, n, out) == -1)
 810                         entities[n++] = out;
 811                 if (get_index(entities, n, in) == -1)
 812                         entities[n++] = in;
 813
 814                 oidx = get_index(entities, n, out);
 815                 iidx = get_index(entities, n, in);
 816
 817                 sourceof[oidx] = iidx; /* Remember the source. */
 818                 ++n_users[iidx]; /* Increment number of users of this entity. */
 819         }
 820
 821         /* First do all the copies. */
 822         for (oidx = 0; oidx < n; /* empty */) {
 823                 int iidx = sourceof[oidx];
 824
 825                 /* Nothing to do for fix points.
 826                  * Also, if entities[oidx] is used as an input by another copy, we
 827                  * can't overwrite entities[oidx] yet.*/
 828                 if (iidx == oidx || n_users[oidx] > 0) {
 829                         ++oidx;
 830                         continue;
 831                 }
 832
 833                 /* We found the end of a 'chain', so do the copy. */
 834                 if (n_spilled == 0) {
 835                         memperm_emit_spill_registers(node, n_spilled, /*n_to_spill=*/1);
 836                         n_spilled = 1;
 837                 }
 838                 memperm_emit_copy(node, entities[iidx], entities[oidx]);
 839
 840                 /* Mark as done. */
 841                 sourceof[oidx] = oidx;
 842
 843                 assert(n_users[iidx] > 0);
 844                 /* Decrementing the number of users might enable us to do another
 845                  * copy. */
 846                 --n_users[iidx];
 847
 848                 if (iidx < oidx && n_users[iidx] == 0) {
 849                         oidx = iidx;
 850                 } else {
 851                         ++oidx;
 852                 }
 853         }
 854
 855         /* The rest are cycles. */
 856         for (oidx = 0; oidx < n; /* empty */) {
 857                 int iidx = sourceof[oidx];
 858                 int tidx;
 859
 860                 /* Nothing to do for fix points. */
 861                 if (iidx == oidx) {
 862                         ++oidx;
 863                         continue;
 864                 }
 865
 866                 assert(n_users[iidx] == 1);
 867
 868                 /* Swap the two values to resolve the cycle. */
 869                 if (n_spilled < 2) {
 870                         memperm_emit_spill_registers(node, n_spilled, /*n_to_spill=*/2);
 871                         n_spilled = 2;
 872                 }
 873                 memperm_emit_swap(node, entities[iidx], entities[oidx]);
 874
 875                 tidx = sourceof[iidx];
 876                 /* Mark as done. */
 877                 sourceof[iidx] = iidx;
 878
 879                 /* The source of oidx is now the old source of iidx, because we swapped
 880                  * the two entities. */
 881                 sourceof[oidx] = tidx;
 882         }
 883
 884 #ifdef DEBUG_libfirm
 885         /* Only fix points should remain. */
 886         for (i = 0; i < max_size; ++i) {
 887                 assert(sourceof[i] == i);
 888         }
 889 #endif
 890
 891         assert(n_spilled > 0 && "Useless MemPerm node");
 892
 893         memperm_emit_restore_registers(node, n_spilled);
 894 }
 895
 896 static void emit_sparc_Return(const ir_node *node)
 897 {
 898         ir_graph  *irg    = get_irn_irg(node);
 899         ir_entity *entity = get_irg_entity(irg);
 900         ir_type   *type   = get_entity_type(entity);
 901
 902         const char *destreg = "%o7";
 903
 904         /* hack: we don't explicitely model register changes because of the
 905          * restore node. So we have to do it manually here */
 906         if (delay_slot_filler != NULL &&
 907                         (is_sparc_Restore(delay_slot_filler)
 908                          || is_sparc_RestoreZero(delay_slot_filler))) {
 909                 destreg = "%i7";
 910         }
 911         sparc_emit_indent();
 912         be_emit_cstring("jmp ");
 913         be_emit_string(destreg);
 914         if (get_method_calling_convention(type) & cc_compound_ret) {
 915                 be_emit_cstring("+12");
 916         } else {
 917                 be_emit_cstring("+8");
 918         }
 919         be_emit_finish_line_gas(node);
 920         fill_delay_slot();
 921 }
 922
 923 static const arch_register_t *map_i_to_o_reg(const arch_register_t *reg)
 924 {
 925         unsigned idx = reg->global_index;
 926         if (idx < REG_I0 || idx > REG_I7)
 927                 return reg;
 928         idx += REG_O0 - REG_I0;
 929         assert(REG_O0 <= idx && idx <= REG_O7);
 930         return &sparc_registers[idx];
 931 }
 932
 933 static void emit_sparc_Restore(const ir_node *node)
 934 {
 935         const arch_register_t *destreg
 936                 = arch_get_irn_register_out(node, pn_sparc_Restore_res);
 937         sparc_emit_indent();
 938         be_emit_cstring("restore ");
 939         sparc_emit_source_register(node, 1);
 940         be_emit_cstring(", ");
 941         sparc_emit_reg_or_imm(node, 2);
 942         be_emit_cstring(", ");
 943         destreg = map_i_to_o_reg(destreg);
 944         be_emit_char('%');
 945         be_emit_string(arch_register_get_name(destreg));
 946         be_emit_finish_line_gas(node);
 947 }
 948
 949 static void emit_sparc_FrameAddr(const ir_node *node)
 950 {
 951         const sparc_attr_t *attr   = get_sparc_attr_const(node);
 952         int32_t             offset = attr->immediate_value;
 953
 954         sparc_emit_indent();
 955         if (offset < 0) {
 956                 be_emit_cstring("add ");
 957                 sparc_emit_source_register(node, 0);
 958                 be_emit_cstring(", ");
 959                 assert(sparc_is_value_imm_encodeable(offset));
 960                 be_emit_irprintf("%ld", offset);
 961         } else {
 962                 be_emit_cstring("sub ");
 963                 sparc_emit_source_register(node, 0);
 964                 be_emit_cstring(", ");
 965                 assert(sparc_is_value_imm_encodeable(-offset));
 966                 be_emit_irprintf("%ld", -offset);
 967         }
 968
 969         be_emit_cstring(", ");
 970         sparc_emit_dest_register(node, 0);
 971         be_emit_finish_line_gas(node);
 972 }
 973
 974 static const char *get_icc_unsigned(ir_relation relation)
 975 {
 976         switch (relation & (ir_relation_less_equal_greater)) {
 977         case ir_relation_false:              return "bn";
 978         case ir_relation_equal:              return "be";
 979         case ir_relation_less:               return "blu";
 980         case ir_relation_less_equal:         return "bleu";
 981         case ir_relation_greater:            return "bgu";
 982         case ir_relation_greater_equal:      return "bgeu";
 983         case ir_relation_less_greater:       return "bne";
 984         case ir_relation_less_equal_greater: return "ba";
 985         default: panic("Cmp has unsupported relation");
 986         }
 987 }
 988
 989 static const char *get_icc_signed(ir_relation relation)
 990 {
 991         switch (relation & (ir_relation_less_equal_greater)) {
 992         case ir_relation_false:              return "bn";
 993         case ir_relation_equal:              return "be";
 994         case ir_relation_less:               return "bl";
 995         case ir_relation_less_equal:         return "ble";
 996         case ir_relation_greater:            return "bg";
 997         case ir_relation_greater_equal:      return "bge";
 998         case ir_relation_less_greater:       return "bne";
 999         case ir_relation_less_equal_greater: return "ba";
1000         default: panic("Cmp has unsupported relation");
1001         }
1002 }
1003
1004 static const char *get_fcc(ir_relation relation)
1005 {
1006         switch (relation) {
1007         case ir_relation_false:                   return "fbn";
1008         case ir_relation_equal:                   return "fbe";
1009         case ir_relation_less:                    return "fbl";
1010         case ir_relation_less_equal:              return "fble";
1011         case ir_relation_greater:                 return "fbg";
1012         case ir_relation_greater_equal:           return "fbge";
1013         case ir_relation_less_greater:            return "fblg";
1014         case ir_relation_less_equal_greater:      return "fbo";
1015         case ir_relation_unordered:               return "fbu";
1016         case ir_relation_unordered_equal:         return "fbue";
1017         case ir_relation_unordered_less:          return "fbul";
1018         case ir_relation_unordered_less_equal:    return "fbule";
1019         case ir_relation_unordered_greater:       return "fbug";
1020         case ir_relation_unordered_greater_equal: return "fbuge";
1021         case ir_relation_unordered_less_greater:  return "fbne";
1022         case ir_relation_true:                    return "fba";
1023         }
1024         panic("invalid relation");
1025 }
1026
1027 typedef const char* (*get_cc_func)(ir_relation relation);
1028
1029 static void emit_sparc_branch(const ir_node *node, get_cc_func get_cc)
1030 {
1031         const sparc_jmp_cond_attr_t *attr = get_sparc_jmp_cond_attr_const(node);
1032         ir_relation      relation    = attr->relation;
1033         const ir_node   *proj_true   = NULL;
1034         const ir_node   *proj_false  = NULL;
1035         const ir_edge_t *edge;
1036         const ir_node   *block;
1037         const ir_node   *next_block;
1038
1039         foreach_out_edge(node, edge) {
1040                 ir_node *proj = get_edge_src_irn(edge);
1041                 long nr = get_Proj_proj(proj);
1042                 if (nr == pn_Cond_true) {
1043                         proj_true = proj;
1044                 } else {
1045                         proj_false = proj;
1046                 }
1047         }
1048
1049         /* for now, the code works for scheduled and non-schedules blocks */
1050         block = get_nodes_block(node);
1051
1052         /* we have a block schedule */
1053         next_block = (ir_node*)get_irn_link(block);
1054
1055         if (get_irn_link(proj_true) == next_block) {
1056                 /* exchange both proj's so the second one can be omitted */
1057                 const ir_node *t = proj_true;
1058
1059                 proj_true  = proj_false;
1060                 proj_false = t;
1061                 relation   = get_negated_relation(relation);
1062         }
1063
1064         /* emit the true proj */
1065         sparc_emit_indent();
1066         be_emit_string(get_cc(relation));
1067         be_emit_char(' ');
1068         sparc_emit_cfop_target(proj_true);
1069         be_emit_finish_line_gas(proj_true);
1070
1071         fill_delay_slot();
1072
1073         sparc_emit_indent();
1074         if (get_irn_link(proj_false) == next_block) {
1075                 be_emit_cstring("/* fallthrough to ");
1076                 sparc_emit_cfop_target(proj_false);
1077                 be_emit_cstring(" */");
1078                 be_emit_finish_line_gas(proj_false);
1079         } else {
1080                 be_emit_cstring("ba ");
1081                 sparc_emit_cfop_target(proj_false);
1082                 be_emit_finish_line_gas(proj_false);
1083                 fill_delay_slot();
1084         }
1085 }
1086
1087 static void emit_sparc_Bicc(const ir_node *node)
1088 {
1089         const sparc_jmp_cond_attr_t *attr = get_sparc_jmp_cond_attr_const(node);
1090         bool             is_unsigned = attr->is_unsigned;
1091         emit_sparc_branch(node, is_unsigned ? get_icc_unsigned : get_icc_signed);
1092 }
1093
1094 static void emit_sparc_fbfcc(const ir_node *node)
1095 {
1096         /* if the flags producing node was immediately in front of us, emit
1097          * a nop */
1098         ir_node *flags = get_irn_n(node, n_sparc_fbfcc_flags);
1099         ir_node *prev  = sched_prev(node);
1100         if (is_Block(prev)) {
1101                 /* TODO: when the flags come from another block, then we have to do
1102                  * more complicated tests to see wether the flag producing node is
1103                  * potentially in front of us (could happen for fallthroughs) */
1104                 panic("TODO: fbfcc flags come from other block");
1105         }
1106         if (skip_Proj(flags) == prev) {
1107                 sparc_emit_indent();
1108                 be_emit_cstring("nop\n");
1109         }
1110         emit_sparc_branch(node, get_fcc);
1111 }
1112
1113 static void emit_sparc_Ba(const ir_node *node)
1114 {
1115         sparc_emit_indent();
1116         if (ba_is_fallthrough(node)) {
1117                 be_emit_cstring("/* fallthrough to ");
1118                 sparc_emit_cfop_target(node);
1119                 be_emit_cstring(" */");
1120                 be_emit_finish_line_gas(node);
1121         } else {
1122                 be_emit_cstring("ba ");
1123                 sparc_emit_cfop_target(node);
1124                 be_emit_finish_line_gas(node);
1125                 fill_delay_slot();
1126         }
1127 }
1128
1129 static void emit_sparc_SwitchJmp(const ir_node *node)
1130 {
1131         const sparc_switch_jmp_attr_t *attr = get_sparc_switch_jmp_attr_const(node);
1132
1133         sparc_emit_indent();
1134         be_emit_cstring("jmp ");
1135         sparc_emit_source_register(node, 0);
1136         be_emit_finish_line_gas(node);
1137         fill_delay_slot();
1138
1139         be_emit_jump_table(node, attr->table, attr->table_entity, get_jump_target);
1140 }
1141
1142 static void emit_fmov(const ir_node *node, const arch_register_t *src_reg,
1143                       const arch_register_t *dst_reg)
1144 {
1145         sparc_emit_indent();
1146         be_emit_cstring("fmovs %");
1147         be_emit_string(arch_register_get_name(src_reg));
1148         be_emit_cstring(", %");
1149         be_emit_string(arch_register_get_name(dst_reg));
1150         be_emit_finish_line_gas(node);
1151 }
1152
1153 static const arch_register_t *get_next_fp_reg(const arch_register_t *reg)
1154 {
1155         unsigned idx = reg->global_index;
1156         assert(reg == &sparc_registers[idx]);
1157         idx++;
1158         assert(idx - REG_F0 < N_sparc_fp_REGS);
1159         return &sparc_registers[idx];
1160 }
1161
1162 static void emit_be_Copy(const ir_node *node)
1163 {
1164         ir_mode               *mode    = get_irn_mode(node);
1165         const arch_register_t *src_reg = arch_get_irn_register_in(node, 0);
1166         const arch_register_t *dst_reg = arch_get_irn_register_out(node, 0);
1167
1168         if (src_reg == dst_reg)
1169                 return;
1170
1171         if (mode_is_float(mode)) {
1172                 unsigned bits = get_mode_size_bits(mode);
1173                 int      n    = bits > 32 ? bits > 64 ? 3 : 1 : 0;
1174                 int      i;
1175                 emit_fmov(node, src_reg, dst_reg);
1176                 for (i = 0; i < n; ++i) {
1177                         src_reg = get_next_fp_reg(src_reg);
1178                         dst_reg = get_next_fp_reg(dst_reg);
1179                         emit_fmov(node, src_reg, dst_reg);
1180                 }
1181         } else if (mode_is_data(mode)) {
1182                 sparc_emit_indent();
1183                 be_emit_cstring("mov ");
1184                 sparc_emit_source_register(node, 0);
1185                 be_emit_cstring(", ");
1186                 sparc_emit_dest_register(node, 0);
1187                 be_emit_finish_line_gas(node);
1188         } else {
1189                 panic("emit_be_Copy: invalid mode");
1190         }
1191 }
1192
1193 static void emit_nothing(const ir_node *irn)
1194 {
1195         (void) irn;
1196 }
1197
1198 typedef void (*emit_func) (const ir_node *);
1199
1200 static inline void set_emitter(ir_op *op, emit_func sparc_emit_node)
1201 {
1202         op->ops.generic = (op_func)sparc_emit_node;
1203 }
1204
1205 /**
1206  * Enters the emitter functions for handled nodes into the generic
1207  * pointer of an opcode.
1208  */
1209 static void sparc_register_emitters(void)
1210 {
1211         /* first clear the generic function pointer for all ops */
1212         clear_irp_opcodes_generic_func();
1213         /* register all emitter functions defined in spec */
1214         sparc_register_spec_emitters();
1215
1216         /* custom emitter */
1217         set_emitter(op_be_Copy,         emit_be_Copy);
1218         set_emitter(op_be_CopyKeep,     emit_be_Copy);
1219         set_emitter(op_be_IncSP,        emit_be_IncSP);
1220         set_emitter(op_be_MemPerm,      emit_be_MemPerm);
1221         set_emitter(op_be_Perm,         emit_be_Perm);
1222         set_emitter(op_sparc_Ba,        emit_sparc_Ba);
1223         set_emitter(op_sparc_Bicc,      emit_sparc_Bicc);
1224         set_emitter(op_sparc_Call,      emit_sparc_Call);
1225         set_emitter(op_sparc_fbfcc,     emit_sparc_fbfcc);
1226         set_emitter(op_sparc_FrameAddr, emit_sparc_FrameAddr);
1227         set_emitter(op_sparc_SMulh,     emit_sparc_Mulh);
1228         set_emitter(op_sparc_UMulh,     emit_sparc_Mulh);
1229         set_emitter(op_sparc_Restore,   emit_sparc_Restore);
1230         set_emitter(op_sparc_Return,    emit_sparc_Return);
1231         set_emitter(op_sparc_SDiv,      emit_sparc_SDiv);
1232         set_emitter(op_sparc_SwitchJmp, emit_sparc_SwitchJmp);
1233         set_emitter(op_sparc_UDiv,      emit_sparc_UDiv);
1234
1235         /* no need to emit anything for the following nodes */
1236         set_emitter(op_be_Keep,     emit_nothing);
1237         set_emitter(op_sparc_Start, emit_nothing);
1238         set_emitter(op_Phi,         emit_nothing);
1239 }
1240
1241 /**
1242  * Emits code for a node.
1243  */
1244 static void sparc_emit_node(const ir_node *node)
1245 {
1246         ir_op *op = get_irn_op(node);
1247
1248         if (op->ops.generic) {
1249                 emit_func func = (emit_func) op->ops.generic;
1250                 be_dbg_set_dbg_info(get_irn_dbg_info(node));
1251                 (*func) (node);
1252         } else {
1253                 panic("No emit handler for node %+F (graph %+F)\n", node,
1254                       current_ir_graph);
1255         }
1256 }
1257
1258 static ir_node *find_next_delay_slot(ir_node *from)
1259 {
1260         ir_node *schedpoint = from;
1261         while (!has_delay_slot(schedpoint)) {
1262                 if (!sched_has_next(schedpoint))
1263                         return NULL;
1264                 schedpoint = sched_next(schedpoint);
1265         }
1266         return schedpoint;
1267 }
1268
1269 static bool block_needs_label(const ir_node *block, const ir_node *sched_prev)
1270 {
1271         int n_cfgpreds;
1272
1273         if (has_Block_entity(block))
1274                 return true;
1275
1276         n_cfgpreds = get_Block_n_cfgpreds(block);
1277         if (n_cfgpreds == 0) {
1278                 return false;
1279         } else if (n_cfgpreds > 1) {
1280                 return true;
1281         } else {
1282                 ir_node *cfgpred       = get_Block_cfgpred(block, 0);
1283                 ir_node *cfgpred_block = get_nodes_block(cfgpred);
1284                 if (is_Proj(cfgpred) && is_sparc_SwitchJmp(get_Proj_pred(cfgpred)))
1285                         return true;
1286                 return sched_prev != cfgpred_block || get_irn_link(cfgpred) != block;
1287         }
1288 }
1289
1290 /**
1291  * Walks over the nodes in a block connected by scheduling edges
1292  * and emits code for each node.
1293  */
1294 static void sparc_emit_block(ir_node *block, ir_node *prev)
1295 {
1296         ir_node *node;
1297         ir_node *next_delay_slot;
1298
1299         assert(is_Block(block));
1300
1301         if (block_needs_label(block, prev)) {
1302                 be_gas_emit_block_name(block);
1303                 be_emit_cstring(":\n");
1304                 be_emit_write_line();
1305         }
1306
1307         next_delay_slot = find_next_delay_slot(sched_first(block));
1308         if (next_delay_slot != NULL)
1309                 delay_slot_filler = pick_delay_slot_for(next_delay_slot);
1310
1311         sched_foreach(block, node) {
1312                 if (node == delay_slot_filler) {
1313                         continue;
1314                 }
1315
1316                 sparc_emit_node(node);
1317
1318                 if (node == next_delay_slot) {
1319                         assert(delay_slot_filler == NULL);
1320                         next_delay_slot = find_next_delay_slot(sched_next(node));
1321                         if (next_delay_slot != NULL)
1322                                 delay_slot_filler = pick_delay_slot_for(next_delay_slot);
1323                 }
1324         }
1325 }
1326
1327 /**
1328  * Emits code for function start.
1329  */
1330 static void sparc_emit_func_prolog(ir_graph *irg)
1331 {
1332         ir_entity *entity = get_irg_entity(irg);
1333         be_gas_emit_function_prolog(entity, 4);
1334 }
1335
1336 /**
1337  * Emits code for function end
1338  */
1339 static void sparc_emit_func_epilog(ir_graph *irg)
1340 {
1341         ir_entity *entity = get_irg_entity(irg);
1342         be_gas_emit_function_epilog(entity);
1343 }
1344
1345 static void sparc_gen_labels(ir_node *block, void *env)
1346 {
1347         ir_node *pred;
1348         int n = get_Block_n_cfgpreds(block);
1349         (void) env;
1350
1351         for (n--; n >= 0; n--) {
1352                 pred = get_Block_cfgpred(block, n);
1353                 set_irn_link(pred, block); // link the pred of a block (which is a jmp)
1354         }
1355 }
1356
1357 void sparc_emit_routine(ir_graph *irg)
1358 {
1359         ir_node **block_schedule;
1360         size_t    i;
1361         size_t    n;
1362
1363         heights = heights_new(irg);
1364
1365         /* register all emitter functions */
1366         sparc_register_emitters();
1367
1368         /* create the block schedule. For now, we don't need it earlier. */
1369         block_schedule = be_create_block_schedule(irg);
1370
1371         sparc_emit_func_prolog(irg);
1372         irg_block_walk_graph(irg, sparc_gen_labels, NULL, NULL);
1373
1374         /* inject block scheduling links & emit code of each block */
1375         n = ARR_LEN(block_schedule);
1376         for (i = 0; i < n; ++i) {
1377                 ir_node *block      = block_schedule[i];
1378                 ir_node *next_block = i+1 < n ? block_schedule[i+1] : NULL;
1379                 set_irn_link(block, next_block);
1380         }
1381
1382         for (i = 0; i < n; ++i) {
1383                 ir_node *block = block_schedule[i];
1384                 ir_node *prev  = i>=1 ? block_schedule[i-1] : NULL;
1385                 if (block == get_irg_end_block(irg))
1386                         continue;
1387                 sparc_emit_block(block, prev);
1388         }
1389
1390         /* emit function epilog */
1391         sparc_emit_func_epilog(irg);
1392
1393         heights_free(heights);
1394 }
1395
1396 void sparc_init_emitter(void)
1397 {
1398         FIRM_DBG_REGISTER(dbg, "firm.be.sparc.emit");
1399 }