nsz Git - libfirm/blob - ir/be/firm/bearch_firm.c

   1
   2 /**
   3  * ISA implementation for Firm IR nodes.
   4  */
   5 #ifdef HAVE_CONFIG_H
   6 #include "config.h"
   7 #endif
   8
   9 #ifdef WITH_LIBCORE
  10 #include <libcore/lc_opts.h>
  11 #endif
  12
  13 #include "bitset.h"
  14 #include "obst.h"
  15
  16 #include "irmode_t.h"
  17 #include "irnode_t.h"
  18 #include "iredges_t.h"
  19 #include "irgmod.h"
  20 #include "ircons_t.h"
  21 #include "irgwalk.h"
  22 #include "type.h"
  23 #include "irtools.h"
  24
  25 #include "../be_t.h"
  26 #include "../bearch.h"
  27 #include "../besched.h"
  28 #include "../beutil.h"
  29 #include "../beabi.h"
  30
  31 #define N_REGS 3
  32
  33 typedef struct {
  34   enum  { imm_Const, imm_SymConst } tp;
  35   union {
  36     const_attr    cnst_attr;
  37     symconst_attr symc_attr;
  38   } data;
  39 } imm_attr_t;
  40
  41 static arch_register_t datab_regs[N_REGS];
  42
  43 static arch_register_class_t reg_classes[] = {
  44   { "datab", N_REGS, NULL, datab_regs },
  45 };
  46
  47 static ir_op *op_push;
  48 static ir_op *op_imm;
  49
  50 const arch_isa_if_t firm_isa;
  51
  52 #define N_CLASSES \
  53   (sizeof(reg_classes) / sizeof(reg_classes[0]))
  54
  55 #define CLS_DATAB 0
  56
  57 tarval *get_Imm_tv(ir_node *n) {
  58   imm_attr_t *attr = (imm_attr_t *)get_irn_generic_attr(n);
  59   return attr->tp == imm_Const ? attr->data.cnst_attr.tv : NULL;
  60 }
  61
  62 int is_Imm(const ir_node *irn) {
  63   return get_irn_op(irn) == op_imm;
  64 }
  65
  66 static int dump_node_Imm(ir_node *n, FILE *F, dump_reason_t reason) {
  67   ir_mode    *mode;
  68   int        bad = 0;
  69   char       buf[1024];
  70   tarval     *tv;
  71   imm_attr_t *attr;
  72
  73   switch (reason) {
  74     case dump_node_opcode_txt:
  75       tv = get_Imm_tv(n);
  76
  77       if (tv) {
  78         tarval_snprintf(buf, sizeof(buf), tv);
  79         fprintf(F, "%s", buf);
  80       }
  81       else {
  82         fprintf(F, "immSymC");
  83       }
  84       break;
  85
  86     case dump_node_mode_txt:
  87       mode = get_irn_mode(n);
  88
  89       if (mode && mode != mode_BB && mode != mode_ANY && mode != mode_BAD && mode != mode_T) {
  90         fprintf(F, "[%s]", get_mode_name(mode));
  91       }
  92       break;
  93
  94     case dump_node_nodeattr_txt:
  95       attr = (imm_attr_t *)get_irn_generic_attr(n);
  96
  97       if (is_Imm(n) && attr->tp == imm_SymConst) {
  98         const char *name    = NULL;
  99         symconst_attr *sc_attr = &attr->data.symc_attr;
 100
 101         switch (sc_attr->num) {
 102           case symconst_addr_name:
 103             name = get_id_str(sc_attr->sym.ident_p);
 104             break;
 105
 106           case symconst_addr_ent:
 107             name = get_entity_ld_name(sc_attr->sym.entity_p);
 108             break;
 109
 110           default:
 111             assert(!"Unsupported SymConst");
 112         }
 113
 114         fprintf(F, "&%s ", name);
 115       }
 116
 117       break;
 118
 119     case dump_node_info_txt:
 120       break;
 121   }
 122
 123   return bad;
 124 }
 125
 126 static void *firm_init(FILE *outfile)
 127 {
 128   static struct obstack obst;
 129   static int inited = 0;
 130   arch_isa_t *isa = xmalloc(sizeof(*isa));
 131   int k;
 132
 133   isa->impl = &firm_isa;
 134
 135   if(inited)
 136     return NULL;
 137
 138   inited = 1;
 139   obstack_init(&obst);
 140
 141   for(k = 0; k < N_CLASSES; ++k) {
 142     arch_register_class_t *cls = &reg_classes[k];
 143     int i;
 144
 145     cls->mode = mode_Is;
 146     for(i = 0; i < cls->n_regs; ++i) {
 147       int n;
 148       char buf[8];
 149       char *name;
 150       arch_register_t *reg = (arch_register_t *) &cls->regs[i];
 151
 152       n = snprintf(buf, sizeof(buf), "r%d", i);
 153       name = obstack_copy0(&obst, buf, n);
 154
 155       reg->name = name;
 156       reg->reg_class = cls;
 157       reg->index = i;
 158       reg->type = 0;
 159     }
 160   }
 161
 162         /*
 163          * Create some opcodes and types to let firm look a little
 164          * bit more like real machines.
 165          */
 166         if(!op_push) {
 167                 int push_opc = get_next_ir_opcode();
 168
 169                 op_push = new_ir_op(push_opc, "Push",
 170                                 op_pin_state_pinned, 0, oparity_binary, 0, 0, NULL);
 171         }
 172
 173         if(!op_imm) {
 174                 int imm_opc = get_next_ir_opcode();
 175                 ir_op_ops ops;
 176
 177                 memset(&ops, 0, sizeof(ops));
 178                 ops.dump_node = dump_node_Imm;
 179
 180                 op_imm = new_ir_op(imm_opc, "Imm",
 181                                 op_pin_state_pinned, 0, oparity_zero, 0, sizeof(imm_attr_t), &ops);
 182         }
 183
 184         return isa;
 185 }
 186
 187 static void firm_done(void *self)
 188 {
 189         free(self);
 190 }
 191
 192 static int firm_get_n_reg_class(const void *self)
 193 {
 194   return N_CLASSES;
 195 }
 196
 197 static const arch_register_class_t *firm_get_reg_class(const void *self, int i)
 198 {
 199   assert(i >= 0 && i < N_CLASSES);
 200   return &reg_classes[i];
 201 }
 202
 203 static const arch_register_class_t *firm_get_reg_class_for_mode(const void *self, const ir_mode *irm)
 204 {
 205         return mode_is_datab(irm) ? &reg_classes[CLS_DATAB] : NULL;
 206 }
 207
 208 static ir_type *firm_abi_get_between_type(void *self) {
 209         static ir_type *between_type = NULL;
 210
 211         if(!between_type) {
 212                 between_type = new_type_class(new_id_from_str("firm_be_between"));
 213                 set_type_size_bytes(between_type, 0);
 214         }
 215
 216         return between_type;
 217 }
 218
 219 static const be_abi_callbacks_t firm_abi_callbacks = {
 220         NULL,
 221         NULL,
 222         firm_abi_get_between_type,
 223         NULL,
 224         NULL,
 225         NULL,
 226 };
 227
 228 static void firm_get_call_abi(const void *self, ir_type *method_type, be_abi_call_t *abi)
 229 {
 230         const arch_register_class_t *cls = &reg_classes[CLS_DATAB];
 231         int i, n;
 232         be_abi_call_flags_t flags = { { 0, 0, 0, 0, 0 } };
 233
 234
 235         for(i = 0, n = get_method_n_params(method_type); i < n; ++i) {
 236                 ir_type *t = get_method_param_type(method_type, i);
 237                 if(is_Primitive_type(t))
 238                         be_abi_call_param_reg(abi, i, &cls->regs[i]);
 239                 else
 240                         be_abi_call_param_stack(abi, i, 1, 0, 0);
 241         }
 242
 243         for(i = 0, n = get_method_n_ress(method_type); i < n; ++i) {
 244                 ir_type *t = get_method_res_type(method_type, i);
 245                 if(is_Primitive_type(t))
 246                         be_abi_call_res_reg(abi, i, &cls->regs[i]);
 247         }
 248
 249         flags.val = 0;
 250         be_abi_call_set_flags(abi, flags, &firm_abi_callbacks);
 251 }
 252
 253
 254 static const arch_register_req_t firm_std_reg_req = {
 255   arch_register_req_type_normal,
 256   &reg_classes[CLS_DATAB],
 257   NULL,
 258   NULL
 259 };
 260
 261 static const arch_register_req_t *
 262 firm_get_irn_reg_req(const void *self,
 263     arch_register_req_t *req, const ir_node *irn, int pos)
 264 {
 265   if(is_firm_be_mode(get_irn_mode(irn)))
 266     memcpy(req, &firm_std_reg_req, sizeof(*req));
 267   else
 268     req = NULL;
 269
 270   return req;
 271 }
 272
 273 struct irn_reg_assoc {
 274   const ir_node *irn;
 275   const arch_register_t *reg;
 276 };
 277
 278 static int cmp_irn_reg_assoc(const void *a, const void *b, size_t len)
 279 {
 280   const struct irn_reg_assoc *x = a;
 281   const struct irn_reg_assoc *y = b;
 282
 283   return x->irn != y->irn;
 284 }
 285
 286 static struct irn_reg_assoc *get_irn_reg_assoc(const ir_node *irn)
 287 {
 288   static set *reg_set = NULL;
 289   struct irn_reg_assoc templ;
 290
 291   if(!reg_set)
 292     reg_set = new_set(cmp_irn_reg_assoc, 1024);
 293
 294   templ.irn = irn;
 295   templ.reg = NULL;
 296
 297   return set_insert(reg_set, &templ, sizeof(templ), HASH_PTR(irn));
 298 }
 299
 300 static void firm_set_irn_reg(const void *self, ir_node *irn, const arch_register_t *reg)
 301 {
 302   struct irn_reg_assoc *assoc = get_irn_reg_assoc(irn);
 303   assoc->reg = reg;
 304 }
 305
 306 static const arch_register_t *firm_get_irn_reg(const void *self, const ir_node *irn)
 307 {
 308   struct irn_reg_assoc *assoc = get_irn_reg_assoc(irn);
 309   return assoc->reg;
 310 }
 311
 312 static arch_irn_class_t firm_classify(const void *self, const ir_node *irn)
 313 {
 314     arch_irn_class_t res;
 315
 316     switch(get_irn_opcode(irn)) {
 317         case iro_Cond:
 318         case iro_Jmp:
 319             res = arch_irn_class_branch;
 320             break;
 321                 case iro_Call:
 322                         res = arch_irn_class_call;
 323                         break;
 324         default:
 325             res = arch_irn_class_normal;
 326     }
 327
 328         return res;
 329 }
 330
 331 static arch_irn_flags_t firm_get_flags(const void *self, const ir_node *irn)
 332 {
 333         arch_irn_flags_t res = 0;
 334
 335         if(get_irn_op(irn) == op_imm)
 336                 res |= arch_irn_flags_rematerializable;
 337
 338         switch(get_irn_opcode(irn)) {
 339                 case iro_Add:
 340                 case iro_Sub:
 341                 case iro_Shl:
 342                 case iro_Shr:
 343                 case iro_Shrs:
 344                 case iro_And:
 345                 case iro_Or:
 346                 case iro_Eor:
 347                 case iro_Not:
 348                         res |= arch_irn_flags_rematerializable;
 349                 default:
 350                         res = res;
 351         }
 352
 353         return res;
 354 }
 355
 356 static void firm_set_stack_bias(const void *self, ir_node *irn, int bias)
 357 {
 358 }
 359
 360 static entity *firm_get_frame_entity(const void *self, const ir_node *irn)
 361 {
 362         return NULL;
 363 }
 364
 365 static const arch_irn_ops_if_t firm_irn_ops_if = {
 366         firm_get_irn_reg_req,
 367         firm_set_irn_reg,
 368         firm_get_irn_reg,
 369         firm_classify,
 370         firm_get_flags,
 371         firm_get_frame_entity,
 372         firm_set_stack_bias
 373 };
 374
 375 static const arch_irn_ops_t firm_irn_ops = {
 376         &firm_irn_ops_if
 377 };
 378
 379 static const void *firm_get_irn_ops(const arch_irn_handler_t *self,
 380         const ir_node *irn)
 381 {
 382         return &firm_irn_ops;
 383 }
 384
 385 const arch_irn_handler_t firm_irn_handler = {
 386         firm_get_irn_ops,
 387 };
 388
 389 static ir_node *new_Push(ir_graph *irg, ir_node *bl, ir_node *push, ir_node *arg)
 390 {
 391         ir_node *ins[2];
 392         ins[0] = push;
 393         ins[1] = arg;
 394         return new_ir_node(NULL, irg, bl, op_push, mode_M, 2, ins);
 395 }
 396
 397 /**
 398  * Creates an op_Imm node from an op_Const.
 399  */
 400 static ir_node *new_Imm(ir_graph *irg, ir_node *bl, ir_node *cnst) {
 401   ir_node    *ins[1];
 402   ir_node    *res;
 403   imm_attr_t *attr;
 404
 405   res = new_ir_node(NULL, irg, bl, op_imm, get_irn_mode(cnst), 0, ins);
 406   attr = (imm_attr_t *) &res->attr;
 407
 408   switch (get_irn_opcode(cnst)) {
 409     case iro_Const:
 410       attr->tp      = imm_Const;
 411       attr->data.cnst_attr = get_irn_const_attr(cnst);
 412       break;
 413     case iro_SymConst:
 414       attr->tp             = imm_SymConst;
 415       attr->data.symc_attr = get_irn_symconst_attr(cnst);
 416       break;
 417     case iro_Unknown:
 418       break;
 419     default:
 420       assert(0 && "Cannot create Imm for this opcode");
 421   }
 422
 423   return res;
 424 }
 425
 426 static void prepare_walker(ir_node *irn, void *data)
 427 {
 428         opcode opc = get_irn_opcode(irn);
 429
 430         /* A replacement for this node has already been computed. */
 431         if(get_irn_link(irn))
 432                 return;
 433
 434         if(opc == iro_Call) {
 435                 ir_node *bl   = get_nodes_block(irn);
 436                 ir_graph *irg = get_irn_irg(bl);
 437
 438                 ir_node *store   = get_Call_mem(irn);
 439                 ir_node *ptr     = get_Call_ptr(irn);
 440                 ir_type *ct      = get_Call_type(irn);
 441                 int np           = get_Call_n_params(irn) > 0 ? 1 : 0;
 442
 443                 if(np > 0) {
 444                         ir_node *ins[1];
 445                         char buf[128];
 446                         ir_node *nc;
 447                         int i, n = get_Call_n_params(irn);
 448                         ir_type *nt;
 449       unsigned cc = get_method_calling_convention(get_Call_type(irn));
 450
 451       if (cc & cc_last_on_top) {
 452                           store = new_Push(irg, bl, store, get_Call_param(irn, 0));
 453
 454                           for (i = 1; i < n; ++i)
 455                                   store = new_Push(irg, bl, store, get_Call_param(irn, i));
 456       }
 457       else {
 458         store = new_Push(irg, bl, store, get_Call_param(irn, n - 1));
 459
 460         for (i = n - 2; i >= 0; --i)
 461           store = new_Push(irg, bl, store, get_Call_param(irn, i));
 462       }
 463
 464                         snprintf(buf, sizeof(buf), "push_%s", get_type_name(ct));
 465
 466                         n = get_method_n_ress(ct);
 467                         nt = new_type_method(new_id_from_str(buf), 0, n);
 468                         for(i = 0; i < n; ++i)
 469                                 set_method_res_type(nt, i, get_method_res_type(ct, i));
 470
 471                         nc = new_r_Call(irg, bl, store, ptr, 0, ins, nt);
 472                         exchange(irn, nc);
 473                         set_irn_link(nc, nc);
 474                 }
 475         }
 476 }
 477
 478 static void localize_const_walker(ir_node *irn, void *data)
 479 {
 480         if(!is_Block(irn)) {
 481                 int i, n;
 482                 ir_node *bl = get_nodes_block(irn);
 483
 484                 for(i = 0, n = get_irn_arity(irn); i < n; ++i) {
 485                         ir_node *op    = get_irn_n(irn, i);
 486                         opcode opc     = get_irn_opcode(op);
 487
 488                         if(opc == iro_Const
 489                         || opc == iro_Unknown
 490                         || (opc == iro_SymConst /*&& get_SymConst_kind(op) == symconst_addr_ent*/)) {
 491                                 ir_graph *irg   = get_irn_irg(bl);
 492                                 ir_node *imm_bl = is_Phi(irn) ? get_Block_cfgpred_block(bl, i) : bl;
 493
 494                                 ir_node *imm = new_Imm(irg, imm_bl, op);
 495                                 set_irn_n(irn, i, imm);
 496                         }
 497                 }
 498         }
 499 }
 500
 501 static const arch_irn_handler_t *firm_get_irn_handler(const void *self)
 502 {
 503         return &firm_irn_handler;
 504 }
 505
 506 typedef struct _firm_code_gen_t {
 507         const arch_code_generator_if_t *impl;
 508         ir_graph *irg;
 509 } firm_code_gen_t;
 510
 511
 512 static void firm_prepare_graph(void *self)
 513 {
 514         firm_code_gen_t *cg = self;
 515
 516         irg_walk_graph(cg->irg, firm_clear_link, localize_const_walker, NULL);
 517         irg_walk_graph(cg->irg, NULL, prepare_walker, NULL);
 518 }
 519
 520 static void firm_before_sched(void *self)
 521 {
 522 }
 523
 524 static void imm_scheduler(ir_node *irn, void *env) {
 525         if(is_Imm(irn)) {
 526                 const ir_edge_t *e;
 527                 ir_node *user, *user_block, *before, *tgt_block;
 528
 529                 if (1 != get_irn_n_edges(irn)) {
 530                         printf("Out edges: %d\n", get_irn_n_edges(irn));
 531                         assert(1 == get_irn_n_edges(irn));
 532                 }
 533
 534                 e = get_irn_out_edge_first(irn);
 535                 user = e->src;
 536                 user_block = get_nodes_block(user);
 537                 if (is_Phi(user)) {
 538                         before = get_Block_cfgpred_block(user_block, e->pos);
 539                         tgt_block = before;
 540                 } else {
 541                         before = user;
 542                         tgt_block = user_block;
 543                 }
 544
 545                 sched_remove(irn);
 546                 set_nodes_block(irn, tgt_block);
 547                 sched_add_before(before, irn);
 548         }
 549 }
 550
 551 static void firm_before_ra(void *self)
 552 {
 553         firm_code_gen_t *cg = self;
 554         irg_walk_graph(cg->irg, imm_scheduler, NULL, NULL);
 555 }
 556
 557 static void firm_after_ra(void *self)
 558 {
 559 }
 560
 561 static void firm_codegen_done(void *self)
 562 {
 563         free(self);
 564 }
 565
 566 static void *firm_cg_init(const be_irg_t *birg);
 567
 568 static const arch_code_generator_if_t firm_code_gen_if = {
 569         firm_cg_init,
 570         NULL,
 571         firm_prepare_graph,
 572         firm_before_sched,
 573         firm_before_ra,
 574         firm_after_ra,
 575         firm_codegen_done
 576 };
 577
 578 static void *firm_cg_init(const be_irg_t *birg)
 579 {
 580         firm_code_gen_t *cg = xmalloc(sizeof(*cg));
 581         cg->impl = &firm_code_gen_if;
 582         cg->irg  = birg->irg;
 583         return cg;
 584 }
 585
 586
 587 static const arch_code_generator_if_t *firm_get_code_generator_if(void *self)
 588 {
 589         return &firm_code_gen_if;
 590 }
 591
 592 static const list_sched_selector_t *firm_get_list_sched_selector(const void *self) {
 593         return trivial_selector;
 594 }
 595
 596 /**
 597  * Returns the necessary byte alignment for storing a register of given class.
 598  */
 599 static int firm_get_reg_class_alignment(const void *self, const arch_register_class_t *cls) {
 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 *firm_get_libfirm_params(void) {
 608         static arch_dep_params_t ad = {
 609                 1,  /* allow subs */
 610                 0,      /* Muls are fast enough on Firm */
 611                 31, /* shift would be ok */
 612                 0,  /* no Mulhs */
 613                 0,  /* no Mulhu */
 614                 0,  /* no Mulh */
 615         };
 616         static backend_params p = {
 617                 NULL,  /* no additional opcodes */
 618                 NULL,  /* will be set later */
 619                 0,     /* no dword lowering */
 620                 NULL,  /* no creator function */
 621         };
 622
 623         p.dep_param = &ad;
 624         return &p;
 625 }
 626
 627 #ifdef WITH_LIBCORE
 628 static void firm_register_options(lc_opt_entry_t *ent)
 629 {
 630 }
 631 #endif
 632
 633 const arch_isa_if_t firm_isa = {
 634         firm_init,
 635         firm_done,
 636         firm_get_n_reg_class,
 637         firm_get_reg_class,
 638         firm_get_reg_class_for_mode,
 639         firm_get_call_abi,
 640         firm_get_irn_handler,
 641         firm_get_code_generator_if,
 642         firm_get_list_sched_selector,
 643         firm_get_reg_class_alignment,
 644         firm_get_libfirm_params,
 645 #ifdef WITH_LIBCORE
 646         firm_register_options,
 647 #endif
 648 };