nsz Git - libfirm/blob - ir/be/amd64/bearch_amd64.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    The main amd64 backend driver file.
  23  * @version  $Id: bearch_amd64.c 26909 2010-01-05 15:56:54Z matze $
  24  */
  25 #include "config.h"
  26
  27 #include "irgwalk.h"
  28 #include "irprog.h"
  29 #include "irprintf.h"
  30 #include "ircons.h"
  31 #include "irgmod.h"
  32 #include "irdump.h"
  33
  34 #include "bitset.h"
  35 #include "debug.h"
  36
  37 #include "be.h"
  38 #include "../bearch.h"
  39 #include "../benode.h"
  40 #include "../belower.h"
  41 #include "../besched.h"
  42 #include "../beabi.h"
  43 #include "../bemodule.h"
  44 #include "../begnuas.h"
  45 #include "../belistsched.h"
  46 #include "../beflags.h"
  47 #include "../bespillslots.h"
  48
  49 #include "bearch_amd64_t.h"
  50
  51 #include "amd64_new_nodes.h"
  52 #include "gen_amd64_regalloc_if.h"
  53 #include "amd64_transform.h"
  54 #include "amd64_emitter.h"
  55
  56 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  57
  58 static arch_irn_class_t amd64_classify(const ir_node *irn)
  59 {
  60         (void) irn;
  61         return 0;
  62 }
  63
  64 static ir_entity *amd64_get_frame_entity(const ir_node *node)
  65 {
  66         if (is_amd64_FrameAddr(node)) {
  67                 const amd64_SymConst_attr_t *attr = get_irn_generic_attr_const(node);
  68                 return attr->entity;
  69
  70         } else if (is_amd64_Store(node)) {
  71                 const amd64_SymConst_attr_t *attr = get_irn_generic_attr_const(node);
  72                 return attr->entity;
  73
  74         } else if (is_amd64_Load(node)) {
  75                 const amd64_SymConst_attr_t *attr = get_irn_generic_attr_const(node);
  76                 return attr->entity;
  77         }
  78
  79         (void) node;
  80         /* TODO: return the ir_entity assigned to the frame */
  81         return NULL;
  82 }
  83
  84 /**
  85  * This function is called by the generic backend to correct offsets for
  86  * nodes accessing the stack.
  87  */
  88 static void amd64_set_frame_offset(ir_node *irn, int offset)
  89 {
  90         if (is_amd64_FrameAddr(irn)) {
  91                 amd64_SymConst_attr_t *attr = get_irn_generic_attr(irn);
  92                 attr->fp_offset += offset;
  93
  94         } else if (is_amd64_Store(irn)) {
  95                 amd64_SymConst_attr_t *attr = get_irn_generic_attr(irn);
  96                 attr->fp_offset += offset;
  97
  98         } else if (is_amd64_Load(irn)) {
  99                 amd64_SymConst_attr_t *attr = get_irn_generic_attr(irn);
 100                 attr->fp_offset += offset;
 101
 102         }
 103 }
 104
 105 static int amd64_get_sp_bias(const ir_node *irn)
 106 {
 107         (void) irn;
 108         return 0;
 109 }
 110
 111 /* fill register allocator interface */
 112
 113 static const arch_irn_ops_t amd64_irn_ops = {
 114         get_amd64_in_req,
 115         amd64_classify,
 116         amd64_get_frame_entity,
 117         amd64_set_frame_offset,
 118         amd64_get_sp_bias,
 119         NULL,    /* get_inverse             */
 120         NULL,    /* get_op_estimated_cost   */
 121         NULL,    /* possible_memory_operand */
 122         NULL,    /* perform_memory_operand  */
 123 };
 124
 125
 126
 127 /**
 128  * Transforms the standard firm graph into
 129  * a amd64 firm graph
 130  */
 131 static void amd64_prepare_graph(void *self)
 132 {
 133         amd64_code_gen_t *cg = self;
 134
 135         amd64_transform_graph (cg);
 136
 137         if (cg->dump)
 138                 dump_ir_graph(cg->irg, "transformed");
 139 }
 140
 141
 142 /**
 143  * Called immediatly before emit phase.
 144  */
 145 static void amd64_finish_irg(void *self)
 146 {
 147         amd64_code_gen_t *cg = self;
 148         ir_graph         *irg = cg->irg;
 149
 150         dump_ir_graph(irg, "amd64-finished");
 151 }
 152
 153 static void amd64_before_ra(void *self)
 154 {
 155         amd64_code_gen_t *cg = self;
 156
 157         be_sched_fix_flags(cg->irg, &amd64_reg_classes[CLASS_amd64_flags],
 158                            NULL, NULL);
 159 }
 160
 161
 162 static void transform_Reload(ir_node *node)
 163 {
 164         ir_graph  *irg    = get_irn_irg(node);
 165         ir_node   *block  = get_nodes_block(node);
 166         dbg_info  *dbgi   = get_irn_dbg_info(node);
 167         ir_node   *ptr    = get_irg_frame(irg);
 168         ir_node   *mem    = get_irn_n(node, be_pos_Reload_mem);
 169         ir_mode   *mode   = get_irn_mode(node);
 170         ir_entity *entity = be_get_frame_entity(node);
 171         const arch_register_t *reg;
 172         ir_node   *proj;
 173         ir_node   *load;
 174
 175         ir_node  *sched_point = sched_prev(node);
 176
 177         load = new_bd_amd64_Load(dbgi, block, ptr, mem, entity);
 178         sched_add_after(sched_point, load);
 179         sched_remove(node);
 180
 181         proj = new_rd_Proj(dbgi, load, mode, pn_amd64_Load_res);
 182
 183         reg = arch_get_irn_register(node);
 184         arch_set_irn_register(proj, reg);
 185
 186         exchange(node, proj);
 187 }
 188
 189 static void transform_Spill(ir_node *node)
 190 {
 191         ir_graph  *irg    = get_irn_irg(node);
 192         ir_node   *block  = get_nodes_block(node);
 193         dbg_info  *dbgi   = get_irn_dbg_info(node);
 194         ir_node   *ptr    = get_irg_frame(irg);
 195         ir_node   *mem    = new_NoMem();
 196         ir_node   *val    = get_irn_n(node, be_pos_Spill_val);
 197         //ir_mode   *mode   = get_irn_mode(val);
 198         ir_entity *entity = be_get_frame_entity(node);
 199         ir_node   *sched_point;
 200         ir_node   *store;
 201
 202         sched_point = sched_prev(node);
 203         store = new_bd_amd64_Store(dbgi, block, ptr, val, mem, entity);
 204
 205         sched_remove(node);
 206         sched_add_after(sched_point, store);
 207
 208         exchange(node, store);
 209 }
 210
 211 static void amd64_after_ra_walker(ir_node *block, void *data)
 212 {
 213         ir_node *node, *prev;
 214         (void) data;
 215
 216         for (node = sched_last(block); !sched_is_begin(node); node = prev) {
 217                 prev = sched_prev(node);
 218
 219                 if (be_is_Reload(node)) {
 220                         transform_Reload(node);
 221                 } else if (be_is_Spill(node)) {
 222                         transform_Spill(node);
 223                 }
 224         }
 225 }
 226
 227 static void amd64_after_ra(void *self)
 228 {
 229         amd64_code_gen_t *cg = self;
 230         be_coalesce_spillslots(cg->irg);
 231
 232         irg_block_walk_graph(cg->irg, NULL, amd64_after_ra_walker, NULL);
 233 }
 234
 235
 236 /**
 237  * Emits the code, closes the output file and frees
 238  * the code generator interface.
 239  */
 240 static void amd64_emit_and_done(void *self)
 241 {
 242         amd64_code_gen_t *cg  = self;
 243         ir_graph         *irg = cg->irg;
 244
 245         amd64_gen_routine(cg, irg);
 246
 247         /* de-allocate code generator */
 248         free(cg);
 249 }
 250
 251 static void *amd64_cg_init(ir_graph *irg);
 252
 253 static const arch_code_generator_if_t amd64_code_gen_if = {
 254         amd64_cg_init,
 255         NULL,                    /* get_pic_base hook */
 256         NULL,                    /* before abi introduce hook */
 257         amd64_prepare_graph,
 258         NULL,                    /* spill hook */
 259         amd64_before_ra,      /* before register allocation hook */
 260         amd64_after_ra,       /* after register allocation hook */
 261         amd64_finish_irg,
 262         amd64_emit_and_done
 263 };
 264
 265 /**
 266  * Initializes the code generator.
 267  */
 268 static void *amd64_cg_init(ir_graph *irg)
 269 {
 270         const arch_env_t *arch_env = be_get_irg_arch_env(irg);
 271         amd64_isa_t      *isa      = (amd64_isa_t *) arch_env;
 272         amd64_code_gen_t *cg       = XMALLOC(amd64_code_gen_t);
 273
 274         cg->impl     = &amd64_code_gen_if;
 275         cg->irg      = irg;
 276         cg->isa      = isa;
 277         cg->dump     = (be_get_irg_options(irg)->dump_flags & DUMP_BE) ? 1 : 0;
 278
 279         return (arch_code_generator_t *)cg;
 280 }
 281
 282
 283 typedef ir_node *(*create_const_node_func) (dbg_info *dbg, ir_node *block);
 284
 285 /**
 286  * Used to create per-graph unique pseudo nodes.
 287  */
 288 static inline ir_node *create_const(amd64_code_gen_t *cg, ir_node **place,
 289                                     create_const_node_func func,
 290                                     const arch_register_t* reg)
 291 {
 292         ir_node *block, *res;
 293
 294         if (*place != NULL)
 295                 return *place;
 296
 297         block = get_irg_start_block(cg->irg);
 298         res = func(NULL, block);
 299         arch_set_irn_register(res, reg);
 300         *place = res;
 301
 302         return res;
 303 }
 304
 305 const arch_isa_if_t amd64_isa_if;
 306 static amd64_isa_t amd64_isa_template = {
 307         {
 308                 &amd64_isa_if,             /* isa interface implementation */
 309                 &amd64_gp_regs[REG_RSP],  /* stack pointer register */
 310                 &amd64_gp_regs[REG_RBP],  /* base pointer register */
 311                 &amd64_reg_classes[CLASS_amd64_gp],  /* link pointer register class */
 312                 -1,                          /* stack direction */
 313                 3,                           /* power of two stack alignment for calls, 2^2 == 4 */
 314                 NULL,                        /* main environment */
 315                 7,                           /* costs for a spill instruction */
 316                 5,                           /* costs for a reload instruction */
 317                 false,                       /* no custom abi handling */
 318         },
 319 };
 320
 321 /**
 322  * Initializes the backend ISA
 323  */
 324 static arch_env_t *amd64_init(FILE *outfile)
 325 {
 326         static int run_once = 0;
 327         amd64_isa_t *isa;
 328
 329         if(run_once)
 330                 return NULL;
 331         run_once = 1;
 332
 333         isa = XMALLOC(amd64_isa_t);
 334         memcpy(isa, &amd64_isa_template, sizeof(*isa));
 335
 336         be_emit_init(outfile);
 337
 338         amd64_register_init();
 339         amd64_create_opcodes(&amd64_irn_ops);
 340
 341         return &isa->base;
 342 }
 343
 344
 345
 346 /**
 347  * Closes the output file and frees the ISA structure.
 348  */
 349 static void amd64_done(void *self)
 350 {
 351         amd64_isa_t *isa = self;
 352
 353         /* emit now all global declarations */
 354         be_gas_emit_decls(isa->base.main_env);
 355
 356         be_emit_exit();
 357         free(self);
 358 }
 359
 360
 361 static unsigned amd64_get_n_reg_class(void)
 362 {
 363         return N_CLASSES;
 364 }
 365
 366 static const arch_register_class_t *amd64_get_reg_class(unsigned i)
 367 {
 368         assert(i < N_CLASSES);
 369         return &amd64_reg_classes[i];
 370 }
 371
 372
 373
 374 /**
 375  * Get the register class which shall be used to store a value of a given mode.
 376  * @param self The this pointer.
 377  * @param mode The mode in question.
 378  * @return A register class which can hold values of the given mode.
 379  */
 380 static const arch_register_class_t *amd64_get_reg_class_for_mode(const ir_mode *mode)
 381 {
 382         assert(!mode_is_float(mode));
 383         return &amd64_reg_classes[CLASS_amd64_gp];
 384 }
 385
 386
 387
 388 typedef struct {
 389         be_abi_call_flags_bits_t flags;
 390         ir_graph *irg;
 391 } amd64_abi_env_t;
 392
 393 static void *amd64_abi_init(const be_abi_call_t *call, ir_graph *irg)
 394 {
 395         amd64_abi_env_t *env = XMALLOC(amd64_abi_env_t);
 396         be_abi_call_flags_t fl = be_abi_call_get_flags(call);
 397         env->flags    = fl.bits;
 398         env->irg      = irg;
 399         return env;
 400 }
 401
 402 /**
 403  * Get the between type for that call.
 404  * @param self The callback object.
 405  * @return The between type of for that call.
 406  */
 407 static ir_type *amd64_get_between_type(void *self)
 408 {
 409         static ir_type *between_type = NULL;
 410         static ir_entity *old_bp_ent = NULL;
 411         (void) self;
 412
 413         if(!between_type) {
 414                 ir_entity *ret_addr_ent;
 415                 ir_type *ret_addr_type = new_type_primitive(mode_P);
 416                 ir_type *old_bp_type   = new_type_primitive(mode_P);
 417
 418                 between_type           = new_type_class(new_id_from_str("amd64_between_type"));
 419                 old_bp_ent             = new_entity(between_type, new_id_from_str("old_bp"), old_bp_type);
 420                 ret_addr_ent           = new_entity(between_type, new_id_from_str("old_bp"), ret_addr_type);
 421
 422                 set_entity_offset(old_bp_ent, 0);
 423                 set_entity_offset(ret_addr_ent, get_type_size_bytes(old_bp_type));
 424                 set_type_size_bytes(between_type, get_type_size_bytes(old_bp_type) + get_type_size_bytes(ret_addr_type));
 425         }
 426
 427         return between_type;
 428 }
 429
 430 /**
 431  * Build the prolog, return the BASE POINTER register
 432  */
 433 static const arch_register_t *amd64_abi_prologue(void *self, ir_node **mem,
 434                                                     pmap *reg_map, int *stack_bias)
 435 {
 436         amd64_abi_env_t  *env  = self;
 437         const arch_env_t *aenv = be_get_irg_arch_env(env->irg);
 438         (void) mem;
 439         (void) stack_bias;
 440         (void) aenv;
 441         (void) reg_map;
 442
 443         if (!env->flags.try_omit_fp) {
 444                 /* FIXME: maybe later here should be some code to generate
 445                  * the usual abi prologue */
 446                 return aenv->bp;
 447         }
 448
 449         return aenv->sp;
 450 }
 451
 452 /* Build the epilog */
 453 static void amd64_abi_epilogue(void *self, ir_node *bl, ir_node **mem,
 454                                pmap *reg_map)
 455 {
 456         amd64_abi_env_t  *env  = self;
 457         const arch_env_t *aenv = be_get_irg_arch_env(env->irg);
 458         ir_node          *curr_sp  = be_abi_reg_map_get(reg_map, aenv->sp);
 459         ir_node          *curr_bp  = be_abi_reg_map_get(reg_map, aenv->bp);
 460         (void) bl;
 461         (void) mem;
 462
 463         if (env->flags.try_omit_fp) {
 464                 curr_sp = be_new_IncSP(aenv->sp, bl, curr_sp, BE_STACK_FRAME_SIZE_SHRINK, 0);
 465         }
 466
 467         be_abi_reg_map_set(reg_map, aenv->sp, curr_sp);
 468         be_abi_reg_map_set(reg_map, aenv->bp, curr_bp);
 469 }
 470
 471 static const be_abi_callbacks_t amd64_abi_callbacks = {
 472         amd64_abi_init,
 473         free,
 474         amd64_get_between_type,
 475         amd64_abi_prologue,
 476         amd64_abi_epilogue,
 477 };
 478
 479 static const arch_register_t *gpreg_param_reg_std[] = {
 480         &amd64_gp_regs[REG_RDI],
 481         &amd64_gp_regs[REG_RSI],
 482         &amd64_gp_regs[REG_RDX],
 483         &amd64_gp_regs[REG_RCX],
 484         &amd64_gp_regs[REG_R8],
 485         &amd64_gp_regs[REG_R9],
 486 };
 487
 488 static const arch_register_t *amd64_get_RegParam_reg(int n)
 489 {
 490         assert(n < 6 && n >=0 && "register param > 6 requested");
 491         return gpreg_param_reg_std[n];
 492 }
 493
 494 /**
 495  * Get the ABI restrictions for procedure calls.
 496  * @param self        The this pointer.
 497  * @param method_type The type of the method (procedure) in question.
 498  * @param abi         The abi object to be modified
 499  */
 500 static void amd64_get_call_abi(const void *self, ir_type *method_type,
 501                            be_abi_call_t *abi)
 502 {
 503         ir_type  *tp;
 504         ir_mode  *mode;
 505         int       i, n = get_method_n_params(method_type);
 506         be_abi_call_flags_t call_flags;
 507         int no_reg = 0;
 508
 509         (void) self;
 510
 511         /* set abi flags for calls */
 512         call_flags.bits.left_to_right         = 0;
 513         call_flags.bits.store_args_sequential = 0;
 514         call_flags.bits.try_omit_fp           = 1;
 515         call_flags.bits.fp_free               = 0;
 516         call_flags.bits.call_has_imm          = 1;
 517
 518         /* set stack parameter passing style */
 519         be_abi_call_set_flags(abi, call_flags, &amd64_abi_callbacks);
 520
 521         for (i = 0; i < n; i++) {
 522                 tp   = get_method_param_type(method_type, i);
 523                 mode = get_type_mode(tp);
 524                 //d// printf ("MODE %p %p XX %d\n", mode, mode_Iu, i);
 525
 526                 if (!no_reg && i < 6 && mode_is_data (mode)) {
 527                         //d// printf("TEST%d\n", i);
 528                         be_abi_call_param_reg(abi, i, amd64_get_RegParam_reg (i),
 529                                               ABI_CONTEXT_BOTH);
 530                 /* default: all parameters on stack */
 531                 } else {
 532                         no_reg = 1;
 533                         be_abi_call_param_stack(abi, i, mode, 8, 0, 0, ABI_CONTEXT_BOTH);
 534                 }
 535         }
 536
 537         /* TODO: set correct return register */
 538         /* default: return value is in R0 resp. F0 */
 539         if (get_method_n_ress(method_type) > 0) {
 540                 tp   = get_method_res_type(method_type, 0);
 541                 mode = get_type_mode(tp);
 542
 543                 /* FIXME: No floating point yet */
 544                 /* be_abi_call_res_reg(abi, 0,
 545                         mode_is_float(mode) ? &amd64_fp_regs[REG_F0] : &amd64_gp_regs[REG_R0], ABI_CONTEXT_BOTH) */;
 546
 547                 be_abi_call_res_reg(abi, 0,
 548                         &amd64_gp_regs[REG_RAX], ABI_CONTEXT_BOTH);
 549         }
 550 }
 551
 552 static int amd64_to_appear_in_schedule(void *block_env, const ir_node *irn)
 553 {
 554         (void) block_env;
 555
 556         if(!is_amd64_irn(irn))
 557                 return -1;
 558
 559         return 1;
 560 }
 561
 562 /**
 563  * Initializes the code generator interface.
 564  */
 565 static const arch_code_generator_if_t *amd64_get_code_generator_if(
 566                 void *self)
 567 {
 568         (void) self;
 569         return &amd64_code_gen_if;
 570 }
 571
 572 list_sched_selector_t amd64_sched_selector;
 573
 574 /**
 575  * Returns the reg_pressure scheduler with to_appear_in_schedule() overloaded
 576  */
 577 static const list_sched_selector_t *amd64_get_list_sched_selector(
 578                 const void *self, list_sched_selector_t *selector)
 579 {
 580         (void) self;
 581         (void) selector;
 582
 583         amd64_sched_selector = trivial_selector;
 584         amd64_sched_selector.to_appear_in_schedule = amd64_to_appear_in_schedule;
 585         return &amd64_sched_selector;
 586 }
 587
 588 static const ilp_sched_selector_t *amd64_get_ilp_sched_selector(
 589                 const void *self)
 590 {
 591         (void) self;
 592         return NULL;
 593 }
 594
 595 /**
 596  * Returns the necessary byte alignment for storing a register of given class.
 597  */
 598 static int amd64_get_reg_class_alignment(const arch_register_class_t *cls)
 599 {
 600         ir_mode *mode = arch_register_class_mode(cls);
 601         return get_mode_size_bytes(mode);
 602 }
 603
 604 /**
 605  * Returns the libFirm configuration parameter for this backend.
 606  */
 607 static const backend_params *amd64_get_backend_params(void) {
 608         static backend_params p = {
 609                 0,     /* no dword lowering */
 610                 0,     /* no inline assembly */
 611                 NULL,  /* will be set later */
 612                 NULL,  /* no creator function */
 613                 NULL,  /* context for create_intrinsic_fkt */
 614                 NULL,  /* parameter for if conversion */
 615                 NULL,  /* float arithmetic mode */
 616                 0,     /* no trampoline support: size 0 */
 617                 0,     /* no trampoline support: align 0 */
 618                 NULL,  /* no trampoline support: no trampoline builder */
 619                 8      /* alignment of stack parameter: typically 4 (32bit) or 8 (64bit) */
 620         };
 621         return &p;
 622 }
 623
 624 static const be_execution_unit_t ***amd64_get_allowed_execution_units(
 625                 const ir_node *irn)
 626 {
 627         (void) irn;
 628         /* TODO */
 629         assert(0);
 630         return NULL;
 631 }
 632
 633 static const be_machine_t *amd64_get_machine(const void *self)
 634 {
 635         (void) self;
 636         /* TODO */
 637         assert(0);
 638         return NULL;
 639 }
 640
 641 static ir_graph **amd64_get_backend_irg_list(const void *self,
 642                                                 ir_graph ***irgs)
 643 {
 644         (void) self;
 645         (void) irgs;
 646         return NULL;
 647 }
 648
 649 static asm_constraint_flags_t amd64_parse_asm_constraint(const char **c)
 650 {
 651         (void) c;
 652         return ASM_CONSTRAINT_FLAG_INVALID;
 653 }
 654
 655 static int amd64_is_valid_clobber(const char *clobber)
 656 {
 657         (void) clobber;
 658         return 0;
 659 }
 660
 661 const arch_isa_if_t amd64_isa_if = {
 662         amd64_init,
 663         amd64_done,
 664         NULL,                /* handle intrinsics */
 665         amd64_get_n_reg_class,
 666         amd64_get_reg_class,
 667         amd64_get_reg_class_for_mode,
 668         amd64_get_call_abi,
 669         amd64_get_code_generator_if,
 670         amd64_get_list_sched_selector,
 671         amd64_get_ilp_sched_selector,
 672         amd64_get_reg_class_alignment,
 673     amd64_get_backend_params,
 674         amd64_get_allowed_execution_units,
 675         amd64_get_machine,
 676         amd64_get_backend_irg_list,
 677         NULL,                    /* mark remat */
 678         amd64_parse_asm_constraint,
 679         amd64_is_valid_clobber
 680 };
 681
 682 BE_REGISTER_MODULE_CONSTRUCTOR(be_init_arch_amd64);
 683 void be_init_arch_amd64(void)
 684 {
 685         be_register_isa_if("amd64", &amd64_isa_if);
 686         FIRM_DBG_REGISTER(dbg, "firm.be.amd64.cg");
 687         amd64_init_transform();
 688 }