nsz Git - libfirm/blob - ir/be/amd64/amd64_emitter.c

   1 /*
   2  * Copyright (C) 1995-2011 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: amd64_emitter.c 26746 2009-11-27 08:53:15Z matze $
  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
  39 #include "../besched.h"
  40 #include "../begnuas.h"
  41 #include "../beblocksched.h"
  42 #include "../be_dbgout.h"
  43
  44 #include "amd64_emitter.h"
  45 #include "gen_amd64_emitter.h"
  46 #include "gen_amd64_regalloc_if.h"
  47 #include "amd64_nodes_attr.h"
  48 #include "amd64_new_nodes.h"
  49
  50 #define SNPRINTF_BUF_LEN 128
  51
  52 #include "../benode.h"
  53
  54 /**
  55  * Returns the register at in position pos.
  56  */
  57 static const arch_register_t *get_in_reg(const ir_node *node, int pos)
  58 {
  59         ir_node *op = get_irn_n(node, pos);
  60         return arch_get_irn_register(op);
  61 }
  62
  63 /*************************************************************
  64  *             _       _    __   _          _
  65  *            (_)     | |  / _| | |        | |
  66  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
  67  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
  68  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
  69  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
  70  * | |                                       | |
  71  * |_|                                       |_|
  72  *************************************************************/
  73
  74 void amd64_emit_register(const arch_register_t *reg)
  75 {
  76         be_emit_char('%');
  77         be_emit_string(arch_register_get_name(reg));
  78 }
  79
  80 void amd64_emit_immediate(const ir_node *node)
  81 {
  82         const amd64_attr_t *attr = get_amd64_attr_const (node);
  83         be_emit_char('$');
  84         be_emit_irprintf("0x%X", attr->ext.imm_value);
  85 }
  86
  87 void amd64_emit_fp_offset(const ir_node *node)
  88 {
  89         const amd64_SymConst_attr_t *attr = get_amd64_SymConst_attr_const(node);
  90         if (attr->fp_offset)
  91                 be_emit_irprintf("%d", attr->fp_offset);
  92 }
  93
  94 void amd64_emit_source_register(const ir_node *node, int pos)
  95 {
  96         amd64_emit_register(get_in_reg(node, pos));
  97 }
  98
  99 void amd64_emit_dest_register(const ir_node *node, int pos)
 100 {
 101         amd64_emit_register(arch_irn_get_register(node, pos));
 102 }
 103
 104 /**
 105  * Returns the target label for a control flow node.
 106  */
 107 /*
 108 static void amd64_emit_cfop_target(const ir_node *node)
 109 {
 110         ir_node *block = get_irn_link(node);
 111
 112         be_emit_irprintf("BLOCK_%ld", get_irn_node_nr(block));
 113 }
 114 */
 115
 116 /***********************************************************************************
 117  *                  _          __                                             _
 118  *                 (_)        / _|                                           | |
 119  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
 120  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
 121  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
 122  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
 123  *
 124  ***********************************************************************************/
 125
 126 /**
 127  * Default emitter for anything that we don't want to generate code for.
 128  */
 129 static void emit_nothing(const ir_node *node)
 130 {
 131         (void) node;
 132 }
 133
 134 /**
 135  * Emit a SymConst.
 136  */
 137 static void emit_amd64_SymConst(const ir_node *irn)
 138 {
 139         const amd64_SymConst_attr_t *attr = get_amd64_SymConst_attr_const(irn);
 140 #if 0
 141         sym_or_tv_t key, *entry;
 142         unsigned label;
 143
 144         key.u.id     = get_entity_ld_ident(attr->entity);
 145         key.is_ident = 1;
 146         key.label    = 0;
 147         entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
 148         if (entry->label == 0) {
 149                 /* allocate a label */
 150                 entry->label = get_unique_label();
 151         }
 152         label = entry->label;
 153 #endif
 154
 155         be_emit_cstring("\tmov $");
 156         be_gas_emit_entity(attr->entity);
 157         be_emit_cstring(", ");
 158         amd64_emit_dest_register(irn, 0);
 159         be_emit_finish_line_gas(irn);
 160 }
 161
 162 /**
 163  * Emit a Conv.
 164  */
 165 static void emit_amd64_Conv(const ir_node *irn)
 166 {
 167         be_emit_cstring("\tmov ");
 168         amd64_emit_source_register(irn, 0);
 169         be_emit_cstring(", ");
 170         amd64_emit_dest_register(irn, 0);
 171         be_emit_finish_line_gas(irn);
 172 }
 173
 174
 175 /**
 176  * Returns the next block in a block schedule.
 177  */
 178 static ir_node *sched_next_block(const ir_node *block)
 179 {
 180     return (ir_node*)get_irn_link(block);
 181 }
 182
 183 /**
 184  * Returns the target block for a control flow node.
 185  */
 186 static ir_node *get_cfop_target_block(const ir_node *irn)
 187 {
 188         return (ir_node*)get_irn_link(irn);
 189 }
 190
 191 /**
 192  * Emit the target label for a control flow node.
 193  */
 194 static void amd64_emit_cfop_target(const ir_node *irn)
 195 {
 196         ir_node *block = get_cfop_target_block(irn);
 197
 198         be_gas_emit_block_name(block);
 199 }
 200
 201 /**
 202  * Emit a Jmp.
 203  */
 204 static void emit_amd64_Jmp(const ir_node *node)
 205 {
 206         ir_node *block, *next_block;
 207
 208         /* for now, the code works for scheduled and non-schedules blocks */
 209         block = get_nodes_block(node);
 210
 211         /* we have a block schedule */
 212         next_block = sched_next_block(block);
 213         if (get_cfop_target_block(node) != next_block) {
 214                 be_emit_cstring("\tjmp ");
 215                 amd64_emit_cfop_target(node);
 216         } else {
 217                 be_emit_cstring("\t/* fallthrough to ");
 218                 amd64_emit_cfop_target(node);
 219                 be_emit_cstring(" */");
 220         }
 221         be_emit_finish_line_gas(node);
 222 }
 223
 224 /**
 225  * Emit a Compare with conditional branch.
 226  */
 227 static void emit_amd64_Jcc(const ir_node *irn)
 228 {
 229         const ir_edge_t      *edge;
 230         const ir_node        *proj_true  = NULL;
 231         const ir_node        *proj_false = NULL;
 232         const ir_node        *block;
 233         const ir_node        *next_block;
 234         const char           *suffix;
 235         const amd64_attr_t   *attr      = get_amd64_attr_const(irn);
 236         ir_relation           relation  = attr->ext.relation;
 237         ir_node              *op1       = get_irn_n(irn, 0);
 238         const amd64_attr_t   *cmp_attr  = get_amd64_attr_const(op1);
 239         bool                  is_signed = !cmp_attr->data.cmp_unsigned;
 240
 241         assert(is_amd64_Cmp(op1));
 242
 243         foreach_out_edge(irn, edge) {
 244                 ir_node *proj = get_edge_src_irn(edge);
 245                 long nr = get_Proj_proj(proj);
 246                 if (nr == pn_Cond_true) {
 247                         proj_true = proj;
 248                 } else {
 249                         proj_false = proj;
 250                 }
 251         }
 252
 253         if (cmp_attr->data.ins_permuted) {
 254                 relation = get_inversed_relation(relation);
 255         }
 256
 257         /* for now, the code works for scheduled and non-schedules blocks */
 258         block = get_nodes_block(irn);
 259
 260         /* we have a block schedule */
 261         next_block = sched_next_block(block);
 262
 263         assert(relation != ir_relation_false);
 264         assert(relation != ir_relation_true);
 265
 266         if (get_cfop_target_block(proj_true) == next_block) {
 267                 /* exchange both proj's so the second one can be omitted */
 268                 const ir_node *t = proj_true;
 269
 270                 proj_true  = proj_false;
 271                 proj_false = t;
 272                 relation   = get_negated_relation(relation);
 273         }
 274
 275         switch (relation & ir_relation_less_equal_greater) {
 276                 case ir_relation_equal:              suffix = "e"; break;
 277                 case ir_relation_less:               suffix = is_signed ? "l"  : "b"; break;
 278                 case ir_relation_less_equal:         suffix = is_signed ? "le" : "be"; break;
 279                 case ir_relation_greater:            suffix = is_signed ? "g"  : "a"; break;
 280                 case ir_relation_greater_equal:      suffix = is_signed ? "ge" : "ae"; break;
 281                 case ir_relation_less_greater:       suffix = "ne"; break;
 282                 case ir_relation_less_equal_greater: suffix = "mp"; break;
 283                 default: panic("Cmp has unsupported pnc");
 284         }
 285
 286         /* emit the true proj */
 287         be_emit_irprintf("\tj%s ", suffix);
 288         amd64_emit_cfop_target(proj_true);
 289         be_emit_finish_line_gas(proj_true);
 290
 291         if (get_cfop_target_block(proj_false) == next_block) {
 292                 be_emit_cstring("\t/* fallthrough to ");
 293                 amd64_emit_cfop_target(proj_false);
 294                 be_emit_cstring(" */");
 295                 be_emit_finish_line_gas(proj_false);
 296         } else {
 297                 be_emit_cstring("\tjmp ");
 298                 amd64_emit_cfop_target(proj_false);
 299                 be_emit_finish_line_gas(proj_false);
 300         }
 301 }
 302
 303 /**
 304  * Emits code for a call.
 305  */
 306 static void emit_be_Call(const ir_node *node)
 307 {
 308         ir_entity *entity = be_Call_get_entity(node);
 309
 310         /* %eax/%rax is used in AMD64 to pass the number of vector parameters for
 311          * variable argument counts */
 312         if (get_method_variadicity (be_Call_get_type((ir_node *) node))) {
 313                 /* But this still is a hack... */
 314                 be_emit_cstring("\txor %rax, %rax");
 315                 be_emit_finish_line_gas(node);
 316         }
 317
 318         if (entity) {
 319                 be_emit_cstring("\tcall ");
 320                 be_gas_emit_entity (be_Call_get_entity(node));
 321                 be_emit_finish_line_gas(node);
 322         } else {
 323                 be_emit_pad_comment();
 324                 be_emit_cstring("/* FIXME: call NULL entity?! */\n");
 325         }
 326 }
 327
 328 /**
 329  * emit copy node
 330  */
 331 static void emit_be_Copy(const ir_node *irn)
 332 {
 333         ir_mode *mode = get_irn_mode(irn);
 334
 335         if (get_in_reg(irn, 0) == arch_irn_get_register(irn, 0)) {
 336                 /* omitted Copy */
 337                 return;
 338         }
 339
 340         if (mode_is_float(mode)) {
 341                 panic("emit_be_Copy: move not supported for FP");
 342         } else if (mode_is_data(mode)) {
 343                 be_emit_cstring("\tmov ");
 344                 amd64_emit_source_register(irn, 0);
 345                 be_emit_cstring(", ");
 346                 amd64_emit_dest_register(irn, 0);
 347                 be_emit_finish_line_gas(irn);
 348         } else {
 349                 panic("emit_be_Copy: move not supported for this mode");
 350         }
 351 }
 352
 353 static void emit_be_Perm(const ir_node *node)
 354 {
 355         const arch_register_t *in0, *in1;
 356         const arch_register_class_t *cls0, *cls1;
 357
 358         in0 = arch_get_irn_register(get_irn_n(node, 0));
 359         in1 = arch_get_irn_register(get_irn_n(node, 1));
 360
 361         cls0 = arch_register_get_class(in0);
 362         cls1 = arch_register_get_class(in1);
 363
 364         assert(cls0 == cls1 && "Register class mismatch at Perm");
 365
 366         be_emit_cstring("\txchg ");
 367         amd64_emit_register (in0);
 368         be_emit_cstring(", ");
 369         amd64_emit_register (in1);
 370         be_emit_finish_line_gas(node);
 371
 372         if (cls0 != &amd64_reg_classes[CLASS_amd64_gp]) {
 373                 panic("unexpected register class in be_Perm (%+F)", node);
 374         }
 375 }
 376
 377 static void emit_amd64_FrameAddr(const ir_node *irn)
 378 {
 379         const amd64_SymConst_attr_t *attr =
 380                 (const amd64_SymConst_attr_t*) get_amd64_attr_const(irn);
 381
 382         be_emit_cstring("\tmov ");
 383         amd64_emit_source_register(irn, 0);
 384         be_emit_cstring(", ");
 385         amd64_emit_dest_register(irn, 0);
 386         be_emit_finish_line_gas(irn);
 387
 388         be_emit_cstring("\tadd ");
 389         be_emit_irprintf("$0x%X", attr->fp_offset);
 390         be_emit_cstring(", ");
 391         amd64_emit_dest_register(irn, 0);
 392         be_emit_finish_line_gas(irn);
 393 }
 394
 395 /**
 396  * Emits code to increase stack pointer.
 397  */
 398 static void emit_be_IncSP(const ir_node *node)
 399 {
 400         int offs = be_get_IncSP_offset(node);
 401
 402         if (offs == 0)
 403                 return;
 404
 405         if (offs > 0) {
 406                 be_emit_irprintf("\tsub ");
 407                 be_emit_irprintf("$%u, ", offs);
 408                 amd64_emit_dest_register(node, 0);
 409                 be_emit_finish_line_gas(node);
 410         } else {
 411                 be_emit_irprintf("\tadd ");
 412                 be_emit_irprintf("$%u, ", -offs);
 413                 amd64_emit_dest_register(node, 0);
 414                 be_emit_finish_line_gas(node);
 415         }
 416 }
 417
 418 /**
 419  * Emits code for a return.
 420  */
 421 static void emit_be_Return(const ir_node *node)
 422 {
 423         be_emit_cstring("\tret");
 424         be_emit_finish_line_gas(node);
 425 }
 426
 427
 428 static void emit_amd64_binop_op(const ir_node *irn, int second_op)
 429 {
 430         if (irn->op == op_amd64_Add) {
 431                 be_emit_cstring("\tadd ");
 432                 amd64_emit_source_register(irn, second_op);
 433                 be_emit_cstring(", ");
 434                 amd64_emit_dest_register(irn, 0);
 435                 be_emit_finish_line_gas(irn);
 436         } else if (irn->op == op_amd64_Sub) {
 437                 be_emit_cstring("\tneg ");
 438                 amd64_emit_source_register(irn, second_op);
 439                 be_emit_finish_line_gas(irn);
 440                 be_emit_cstring("\tadd ");
 441                 amd64_emit_source_register(irn, second_op);
 442                 be_emit_cstring(", ");
 443                 amd64_emit_dest_register(irn, 0);
 444                 be_emit_finish_line_gas(irn);
 445                 be_emit_cstring("\tneg ");
 446                 amd64_emit_source_register(irn, second_op);
 447                 be_emit_finish_line_gas(irn);
 448         }
 449
 450 }
 451
 452 /**
 453  * Emits an arithmetic operation that handles arbitraty input registers.
 454  */
 455 static void emit_amd64_binop(const ir_node *irn)
 456 {
 457         const arch_register_t *reg_s1 = get_in_reg(irn, 0);
 458         const arch_register_t *reg_s2 = get_in_reg(irn, 1);
 459         const arch_register_t *reg_d1 = arch_irn_get_register(irn, 0);
 460
 461         int second_op = 0;
 462
 463         if (reg_d1 != reg_s1 && reg_d1 != reg_s2) {
 464                 be_emit_cstring("\tmov ");
 465                 amd64_emit_register(reg_s1);
 466                 be_emit_cstring(", ");
 467                 amd64_emit_register(reg_d1);
 468                 be_emit_finish_line_gas(irn);
 469                 second_op = 1;
 470
 471         } else if (reg_d1 == reg_s2 && reg_d1 != reg_s1) {
 472                 second_op = 0;
 473
 474         }
 475
 476         emit_amd64_binop_op(irn, second_op);
 477 }
 478
 479 /**
 480  * The type of a emitter function.
 481  */
 482 typedef void (emit_func)(const ir_node *irn);
 483
 484 /**
 485  * Set a node emitter. Make it a bit more type safe.
 486  */
 487 static inline void set_emitter(ir_op *op, emit_func arm_emit_node)
 488 {
 489         op->ops.generic = (op_func)arm_emit_node;
 490 }
 491
 492 /**
 493  * Enters the emitter functions for handled nodes into the generic
 494  * pointer of an opcode.
 495  */
 496 static void amd64_register_emitters(void)
 497 {
 498         /* first clear the generic function pointer for all ops */
 499         clear_irp_opcodes_generic_func();
 500
 501         /* register all emitter functions defined in spec */
 502         amd64_register_spec_emitters();
 503
 504         set_emitter(op_amd64_SymConst,   emit_amd64_SymConst);
 505         set_emitter(op_amd64_Jmp,        emit_amd64_Jmp);
 506         set_emitter(op_amd64_Jcc,        emit_amd64_Jcc);
 507         set_emitter(op_amd64_Conv,       emit_amd64_Conv);
 508         set_emitter(op_amd64_FrameAddr,  emit_amd64_FrameAddr);
 509         set_emitter(op_be_Return,        emit_be_Return);
 510         set_emitter(op_be_Call,          emit_be_Call);
 511         set_emitter(op_be_Copy,          emit_be_Copy);
 512         set_emitter(op_be_IncSP,         emit_be_IncSP);
 513         set_emitter(op_be_Perm,          emit_be_Perm);
 514
 515         set_emitter(op_amd64_Add,        emit_amd64_binop);
 516         set_emitter(op_amd64_Sub,        emit_amd64_binop);
 517
 518         set_emitter(op_be_Start,         emit_nothing);
 519         set_emitter(op_be_Keep,          emit_nothing);
 520         set_emitter(op_Phi,              emit_nothing);
 521 }
 522
 523 typedef void (*emit_func_ptr) (const ir_node *);
 524
 525 /**
 526  * Emits code for a node.
 527  */
 528 static void amd64_emit_node(const ir_node *node)
 529 {
 530         ir_op               *op       = get_irn_op(node);
 531
 532         if (op->ops.generic) {
 533                 emit_func_ptr func = (emit_func_ptr) op->ops.generic;
 534                 (*func) (node);
 535         } else {
 536                 ir_fprintf(stderr, "No emitter for node %+F\n", node);
 537         }
 538 }
 539
 540 /**
 541  * Walks over the nodes in a block connected by scheduling edges
 542  * and emits code for each node.
 543  */
 544 static void amd64_gen_block(ir_node *block, void *data)
 545 {
 546         ir_node *node;
 547         (void) data;
 548
 549         if (! is_Block(block))
 550                 return;
 551
 552         be_gas_emit_block_name(block);
 553         be_emit_char(':');
 554
 555         be_emit_write_line();
 556
 557         sched_foreach(block, node) {
 558                 amd64_emit_node(node);
 559         }
 560 }
 561
 562
 563 /**
 564  * Sets labels for control flow nodes (jump target)
 565  * TODO: Jump optimization
 566  */
 567 static void amd64_gen_labels(ir_node *block, void *env)
 568 {
 569         ir_node *pred;
 570         int n = get_Block_n_cfgpreds(block);
 571         (void) env;
 572
 573         for (n--; n >= 0; n--) {
 574                 pred = get_Block_cfgpred(block, n);
 575                 set_irn_link(pred, block);
 576         }
 577 }
 578
 579 /**
 580  * Main driver
 581  */
 582 void amd64_gen_routine(ir_graph *irg)
 583 {
 584         ir_entity *entity = get_irg_entity(irg);
 585         ir_node  **blk_sched;
 586         size_t i, n;
 587
 588         /* register all emitter functions */
 589         amd64_register_emitters();
 590
 591         blk_sched = be_create_block_schedule(irg);
 592
 593         be_dbg_method_begin(entity);
 594         be_gas_emit_function_prolog(entity, 4);
 595
 596         irg_block_walk_graph(irg, amd64_gen_labels, NULL, NULL);
 597
 598         n = ARR_LEN(blk_sched);
 599         for (i = 0; i < n; i++) {
 600                 ir_node *block = blk_sched[i];
 601                 ir_node *next  = (i + 1) < n ? blk_sched[i+1] : NULL;
 602
 603                 set_irn_link(block, next);
 604         }
 605
 606         for (i = 0; i < n; ++i) {
 607                 ir_node *block = blk_sched[i];
 608
 609                 amd64_gen_block(block, 0);
 610         }
 611
 612         be_gas_emit_function_epilog(entity);
 613         be_dbg_method_end();
 614         be_emit_char('\n');
 615         be_emit_write_line();
 616 }