nsz Git - libfirm/blob - ir/be/sparc/gen_sparc_new_nodes.c.inl

   1 #include "gen_sparc_regalloc_if.h"
   2
   3
   4 ir_op *op_sparc_SubSP = NULL;
   5 ir_op *op_sparc_Add = NULL;
   6 ir_op *op_sparc_FrameAddr = NULL;
   7 ir_op *op_sparc_Store = NULL;
   8 ir_op *op_sparc_Branch = NULL;
   9 ir_op *op_sparc_Mov = NULL;
  10 ir_op *op_sparc_Tst = NULL;
  11 ir_op *op_sparc_SwitchJmp = NULL;
  12 ir_op *op_sparc_Cmp = NULL;
  13 ir_op *op_sparc_SymConst = NULL;
  14 ir_op *op_sparc_Sub = NULL;
  15 ir_op *op_sparc_Load = NULL;
  16 ir_op *op_sparc_AddSP = NULL;
  17
  18 ir_op *get_op_sparc_SubSP(void)         { return op_sparc_SubSP; }
  19 int    is_sparc_SubSP(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_SubSP; }
  20
  21 ir_op *get_op_sparc_Add(void)         { return op_sparc_Add; }
  22 int    is_sparc_Add(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Add; }
  23
  24 ir_op *get_op_sparc_FrameAddr(void)         { return op_sparc_FrameAddr; }
  25 int    is_sparc_FrameAddr(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_FrameAddr; }
  26
  27 ir_op *get_op_sparc_Store(void)         { return op_sparc_Store; }
  28 int    is_sparc_Store(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Store; }
  29
  30 ir_op *get_op_sparc_Branch(void)         { return op_sparc_Branch; }
  31 int    is_sparc_Branch(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Branch; }
  32
  33 ir_op *get_op_sparc_Mov(void)         { return op_sparc_Mov; }
  34 int    is_sparc_Mov(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Mov; }
  35
  36 ir_op *get_op_sparc_Tst(void)         { return op_sparc_Tst; }
  37 int    is_sparc_Tst(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Tst; }
  38
  39 ir_op *get_op_sparc_SwitchJmp(void)         { return op_sparc_SwitchJmp; }
  40 int    is_sparc_SwitchJmp(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_SwitchJmp; }
  41
  42 ir_op *get_op_sparc_Cmp(void)         { return op_sparc_Cmp; }
  43 int    is_sparc_Cmp(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Cmp; }
  44
  45 ir_op *get_op_sparc_SymConst(void)         { return op_sparc_SymConst; }
  46 int    is_sparc_SymConst(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_SymConst; }
  47
  48 ir_op *get_op_sparc_Sub(void)         { return op_sparc_Sub; }
  49 int    is_sparc_Sub(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Sub; }
  50
  51 ir_op *get_op_sparc_Load(void)         { return op_sparc_Load; }
  52 int    is_sparc_Load(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_Load; }
  53
  54 ir_op *get_op_sparc_AddSP(void)         { return op_sparc_AddSP; }
  55 int    is_sparc_AddSP(const ir_node *n) { return get_sparc_irn_opcode(n) == iro_sparc_AddSP; }
  56
  57
  58
  59 static int sparc_opcode_start = -1;
  60 static int sparc_opcode_end   = -1;
  61
  62
  63 /** A tag for the sparc opcodes. Note that the address is used as a tag value, NOT the FOURCC code. */
  64 #define sparc_op_tag FOURCC('S', 'P', 'A', 'R')
  65
  66 /** Return the opcode number of the first sparc opcode. */
  67 int get_sparc_opcode_first(void) {
  68         return sparc_opcode_start;
  69 }
  70
  71 /** Return the opcode number of the last sparc opcode + 1. */
  72 int get_sparc_opcode_last(void) {
  73         return sparc_opcode_end;
  74 }
  75
  76 /** Return 1 if the given opcode is a sparc machine op, 0 otherwise */
  77 int is_sparc_op(const ir_op *op) {
  78         return get_op_tag(op) == sparc_op_tag;
  79 }
  80
  81 /** Return 1 if the given node is a sparc machine node, 0 otherwise */
  82 int is_sparc_irn(const ir_node *node) {
  83         return is_sparc_op(get_irn_op(node));
  84 }
  85
  86 int get_sparc_irn_opcode(const ir_node *node) {
  87         if (is_sparc_irn(node))
  88                 return get_irn_opcode(node) - sparc_opcode_start;
  89         return -1;
  90 }
  91
  92 #ifdef BIT
  93 #undef BIT
  94 #endif
  95 #define BIT(x)  (1 << (x % 32))
  96
  97 static const unsigned sparc_limit_gp_sp[] = { BIT(REG_SP), 0 };
  98
  99 static const arch_register_req_t sparc_requirements_gp_sp = {
 100         arch_register_req_type_limited,
 101         & sparc_reg_classes[CLASS_sparc_gp],
 102         sparc_limit_gp_sp,
 103         0,        /* same pos */
 104         0        /* different pos */
 105 };
 106
 107
 108 static const arch_register_req_t sparc_requirements_gp_gp = {
 109         arch_register_req_type_normal,
 110         & sparc_reg_classes[CLASS_sparc_gp],
 111         NULL,        /* limit bitset */
 112         0,           /* same pos */
 113         0            /* different pos */
 114 };
 115
 116
 117 static const arch_register_req_t sparc_requirements_gp_sp_I_S = {
 118         arch_register_req_type_ignore | arch_register_req_type_produces_sp | arch_register_req_type_limited,
 119         & sparc_reg_classes[CLASS_sparc_gp],
 120         sparc_limit_gp_sp,
 121         0,        /* same pos */
 122         0        /* different pos */
 123 };
 124
 125
 126 static const arch_register_req_t sparc_requirements__none = {
 127         arch_register_req_type_none,
 128         NULL,                         /* regclass */
 129         NULL,                         /* limit bitset */
 130         0,                            /* same pos */
 131         0                             /* different pos */
 132 };
 133
 134
 135 static const arch_register_req_t sparc_requirements_flags_flags = {
 136         arch_register_req_type_normal,
 137         & sparc_reg_classes[CLASS_sparc_flags],
 138         NULL,        /* limit bitset */
 139         0,           /* same pos */
 140         0            /* different pos */
 141 };
 142
 143
 144
 145 /**
 146  * free stack space
 147  */
 148 ir_node *new_bd_sparc_SubSP(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *size, ir_node *mem)
 149 {
 150         ir_node        *res;
 151         ir_op          *op      = op_sparc_SubSP;
 152         int             flags   = 0;
 153         backend_info_t *info;
 154         int             arity   = 3;
 155         ir_node        *in[3];
 156         int             n_res   = 2;
 157         ir_mode        *mode    = mode_T;
 158         static const be_execution_unit_t ***exec_units = NULL;
 159         static const arch_register_req_t *in_reqs[] =
 160         {
 161                 & sparc_requirements_gp_sp,
 162                 & sparc_requirements_gp_gp,
 163                 & sparc_requirements__none,
 164         };
 165
 166         /* construct in array */
 167         in[0] = stack;
 168         in[1] = size;
 169         in[2] = mem;
 170
 171         /* create node */
 172         assert(op != NULL);
 173         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 174
 175         /* init node attributes */
 176                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 177
 178         info = be_get_info(res);
 179         info->out_infos[0].req = &sparc_requirements_gp_sp_I_S;
 180 info->out_infos[1].req = &sparc_requirements__none;
 181
 182
 183         /* optimize node */
 184         res = optimize_node(res);
 185         irn_vrfy_irg(res, current_ir_graph);
 186
 187         return res;
 188 }
 189
 190 /**
 191  * construct Add node
 192  */
 193 ir_node *new_bd_sparc_Add_imm(dbg_info *dbgi, ir_node *block, ir_node *left, int immediate_value)
 194 {
 195         ir_node        *res;
 196         ir_op          *op      = op_sparc_Add;
 197         int             flags   = 0;
 198         backend_info_t *info;
 199         int             arity   = 1;
 200         ir_node        *in[1];
 201         int             n_res   = 1;
 202         ir_mode        *mode    = mode_Iu;
 203         static const be_execution_unit_t ***exec_units = NULL;
 204         static const arch_register_req_t *in_reqs[] =
 205         {
 206                 & sparc_requirements_gp_gp,
 207         };
 208
 209         /* construct in array */
 210         in[0] = left;
 211
 212         /* flags */
 213         flags |= arch_irn_flags_rematerializable;
 214
 215         /* create node */
 216         assert(op != NULL);
 217         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 218
 219         /* init node attributes */
 220                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 221         sparc_set_attr_imm(res, immediate_value);
 222         info = be_get_info(res);
 223         info->out_infos[0].req = &sparc_requirements_gp_gp;
 224
 225
 226         /* optimize node */
 227         res = optimize_node(res);
 228         irn_vrfy_irg(res, current_ir_graph);
 229
 230         return res;
 231 }
 232
 233 /**
 234  * construct Add node
 235  */
 236 ir_node *new_bd_sparc_Add_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
 237 {
 238         ir_node        *res;
 239         ir_op          *op      = op_sparc_Add;
 240         int             flags   = 0;
 241         backend_info_t *info;
 242         int             arity   = 2;
 243         ir_node        *in[2];
 244         int             n_res   = 1;
 245         ir_mode        *mode    = mode_Iu;
 246         static const be_execution_unit_t ***exec_units = NULL;
 247         static const arch_register_req_t *in_reqs[] =
 248         {
 249                 & sparc_requirements_gp_gp,
 250                 & sparc_requirements_gp_gp,
 251         };
 252
 253         /* construct in array */
 254         in[0] = left;
 255         in[1] = right;
 256
 257         /* flags */
 258         flags |= arch_irn_flags_rematerializable;
 259
 260         /* create node */
 261         assert(op != NULL);
 262         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 263
 264         /* init node attributes */
 265                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 266
 267         info = be_get_info(res);
 268         info->out_infos[0].req = &sparc_requirements_gp_gp;
 269
 270
 271         /* optimize node */
 272         res = optimize_node(res);
 273         irn_vrfy_irg(res, current_ir_graph);
 274
 275         return res;
 276 }
 277
 278 /**
 279  * construct FrameAddr node
 280  */
 281 ir_node *new_bd_sparc_FrameAddr(dbg_info *dbgi, ir_node *block, ir_node *base, ir_entity *entity)
 282 {
 283         ir_node        *res;
 284         ir_op          *op      = op_sparc_FrameAddr;
 285         int             flags   = 0;
 286         backend_info_t *info;
 287         int             arity   = 1;
 288         ir_node        *in[1];
 289         int             n_res   = 1;
 290         ir_mode        *mode    = mode_Iu;
 291         static const be_execution_unit_t ***exec_units = NULL;
 292         static const arch_register_req_t *in_reqs[] =
 293         {
 294                 & sparc_requirements_gp_gp,
 295         };
 296
 297         /* construct in array */
 298         in[0] = base;
 299
 300         /* flags */
 301         flags |= arch_irn_flags_rematerializable;
 302
 303         /* create node */
 304         assert(op != NULL);
 305         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 306
 307         /* init node attributes */
 308                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 309         init_sparc_symconst_attributes(res, entity);
 310
 311         info = be_get_info(res);
 312         info->out_infos[0].req = &sparc_requirements_gp_gp;
 313
 314
 315         /* optimize node */
 316         res = optimize_node(res);
 317         irn_vrfy_irg(res, current_ir_graph);
 318
 319         return res;
 320 }
 321
 322 /**
 323  * construct Store: Store(ptr, val, mem) = ST ptr,val
 324  */
 325 ir_node *new_bd_sparc_Store(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *val, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity)
 326 {
 327         ir_node        *res;
 328         ir_op          *op      = op_sparc_Store;
 329         int             flags   = 0;
 330         backend_info_t *info;
 331         int             arity   = 3;
 332         ir_node        *in[3];
 333         int             n_res   = 1;
 334         ir_mode        *mode    = mode_M;
 335         static const be_execution_unit_t ***exec_units = NULL;
 336         static const arch_register_req_t *in_reqs[] =
 337         {
 338                 & sparc_requirements_gp_gp,
 339                 & sparc_requirements_gp_gp,
 340                 & sparc_requirements__none,
 341         };
 342
 343         /* construct in array */
 344         in[0] = ptr;
 345         in[1] = val;
 346         in[2] = mem;
 347
 348         /* create node */
 349         assert(op != NULL);
 350         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 351
 352         /* init node attributes */
 353                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 354         init_sparc_load_store_attributes(res, ls_mode, entity, entity_sign, offset, is_frame_entity);
 355
 356         info = be_get_info(res);
 357         info->out_infos[0].req = &sparc_requirements__none;
 358
 359
 360         /* optimize node */
 361         res = optimize_node(res);
 362         irn_vrfy_irg(res, current_ir_graph);
 363
 364         return res;
 365 }
 366
 367 /**
 368  * construct Branch node
 369  */
 370 ir_node *new_bd_sparc_Branch(dbg_info *dbgi, ir_node *block, ir_node *op0, int proj_num)
 371 {
 372         ir_node        *res;
 373         ir_op          *op      = op_sparc_Branch;
 374         int             flags   = 0;
 375         backend_info_t *info;
 376         int             arity   = 1;
 377         ir_node        *in[1];
 378         int             n_res   = 2;
 379         ir_mode        *mode    = mode_T;
 380         static const be_execution_unit_t ***exec_units = NULL;
 381         static const arch_register_req_t *in_reqs[] =
 382         {
 383                 & sparc_requirements_flags_flags,
 384         };
 385         sparc_jmp_cond_attr_t *attr;
 386
 387         /* construct in array */
 388         in[0] = op0;
 389
 390         /* create node */
 391         assert(op != NULL);
 392         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 393
 394         /* init node attributes */
 395                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 396
 397         info = be_get_info(res);
 398         info->out_infos[0].req = &sparc_requirements__none;
 399 info->out_infos[1].req = &sparc_requirements__none;
 400
 401
 402         attr = get_irn_generic_attr(res);
 403                 set_sparc_jmp_cond_proj_num(res, proj_num);
 404         /* optimize node */
 405         res = optimize_node(res);
 406         irn_vrfy_irg(res, current_ir_graph);
 407
 408         return res;
 409 }
 410
 411 /**
 412  * construct Mov node
 413  */
 414 ir_node *new_bd_sparc_Mov_imm(dbg_info *dbgi, ir_node *block, int immediate_value)
 415 {
 416         ir_node        *res;
 417         ir_op          *op      = op_sparc_Mov;
 418         int             flags   = 0;
 419         backend_info_t *info;
 420         int             arity   = 0;
 421         ir_node       **in      = NULL;
 422         int             n_res   = 1;
 423         ir_mode        *mode    = mode_Iu;
 424         static const be_execution_unit_t ***exec_units = NULL;
 425         static const arch_register_req_t **in_reqs = NULL;
 426
 427         /* flags */
 428         flags |= arch_irn_flags_rematerializable;
 429
 430         /* create node */
 431         assert(op != NULL);
 432         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 433
 434         /* init node attributes */
 435                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 436         sparc_set_attr_imm(res, immediate_value);
 437         info = be_get_info(res);
 438         info->out_infos[0].req = &sparc_requirements_gp_gp;
 439
 440
 441         /* optimize node */
 442         res = optimize_node(res);
 443         irn_vrfy_irg(res, current_ir_graph);
 444
 445         return res;
 446 }
 447
 448 /**
 449  * construct Mov node
 450  */
 451 ir_node *new_bd_sparc_Mov_reg(dbg_info *dbgi, ir_node *block, ir_node *op0)
 452 {
 453         ir_node        *res;
 454         ir_op          *op      = op_sparc_Mov;
 455         int             flags   = 0;
 456         backend_info_t *info;
 457         int             arity   = 1;
 458         ir_node        *in[1];
 459         int             n_res   = 1;
 460         ir_mode        *mode    = mode_Iu;
 461         static const be_execution_unit_t ***exec_units = NULL;
 462         static const arch_register_req_t *in_reqs[] =
 463         {
 464                 & sparc_requirements_gp_gp,
 465         };
 466
 467         /* construct in array */
 468         in[0] = op0;
 469
 470         /* flags */
 471         flags |= arch_irn_flags_rematerializable;
 472
 473         /* create node */
 474         assert(op != NULL);
 475         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 476
 477         /* init node attributes */
 478                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 479
 480         info = be_get_info(res);
 481         info->out_infos[0].req = &sparc_requirements_gp_gp;
 482
 483
 484         /* optimize node */
 485         res = optimize_node(res);
 486         irn_vrfy_irg(res, current_ir_graph);
 487
 488         return res;
 489 }
 490
 491 /**
 492  * construct Tst node
 493  */
 494 ir_node *new_bd_sparc_Tst(dbg_info *dbgi, ir_node *block, ir_node *left, bool ins_permuted, bool is_unsigned)
 495 {
 496         ir_node        *res;
 497         ir_op          *op      = op_sparc_Tst;
 498         int             flags   = 0;
 499         backend_info_t *info;
 500         int             arity   = 1;
 501         ir_node        *in[1];
 502         int             n_res   = 1;
 503         ir_mode        *mode    = mode_Bu;
 504         static const be_execution_unit_t ***exec_units = NULL;
 505         static const arch_register_req_t *in_reqs[] =
 506         {
 507                 & sparc_requirements_gp_gp,
 508         };
 509
 510         /* construct in array */
 511         in[0] = left;
 512
 513         /* flags */
 514         flags |= arch_irn_flags_rematerializable;
 515         flags |= arch_irn_flags_modify_flags;
 516
 517         /* create node */
 518         assert(op != NULL);
 519         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 520
 521         /* init node attributes */
 522                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 523
 524         init_sparc_cmp_attr(res, ins_permuted, is_unsigned);
 525         info = be_get_info(res);
 526         info->out_infos[0].req = &sparc_requirements_flags_flags;
 527
 528
 529         /* optimize node */
 530         res = optimize_node(res);
 531         irn_vrfy_irg(res, current_ir_graph);
 532
 533         return res;
 534 }
 535
 536 /**
 537  * construct SwitchJmp node
 538  */
 539 ir_node *new_bd_sparc_SwitchJmp(dbg_info *dbgi, ir_node *block, ir_node *op0, int n_projs, long def_proj_num)
 540 {
 541         ir_node        *res;
 542         ir_op          *op      = op_sparc_SwitchJmp;
 543         int             flags   = 0;
 544         backend_info_t *info;
 545         int             arity   = 1;
 546         ir_node        *in[1];
 547         int             n_res   = 1;
 548         ir_mode        *mode    = mode_T;
 549         static const be_execution_unit_t ***exec_units = NULL;
 550         static const arch_register_req_t *in_reqs[] =
 551         {
 552                 & sparc_requirements_gp_gp,
 553         };
 554         sparc_jmp_switch_attr_t *attr;
 555
 556         /* construct in array */
 557         in[0] = op0;
 558
 559         /* create node */
 560         assert(op != NULL);
 561         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 562
 563         /* init node attributes */
 564                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 565
 566         info = be_get_info(res);
 567         info->out_infos[0].req = &sparc_requirements__none;
 568
 569
 570         attr = get_irn_generic_attr(res);
 571                 set_sparc_jmp_switch_n_projs(res, n_projs);
 572         set_sparc_jmp_switch_default_proj_num(res, def_proj_num);
 573         /* optimize node */
 574         res = optimize_node(res);
 575         irn_vrfy_irg(res, current_ir_graph);
 576
 577         return res;
 578 }
 579
 580 /**
 581  * construct Cmp node
 582  */
 583 ir_node *new_bd_sparc_Cmp_imm(dbg_info *dbgi, ir_node *block, ir_node *left, int immediate_value, bool ins_permuted, bool is_unsigned)
 584 {
 585         ir_node        *res;
 586         ir_op          *op      = op_sparc_Cmp;
 587         int             flags   = 0;
 588         backend_info_t *info;
 589         int             arity   = 1;
 590         ir_node        *in[1];
 591         int             n_res   = 1;
 592         ir_mode        *mode    = mode_Bu;
 593         static const be_execution_unit_t ***exec_units = NULL;
 594         static const arch_register_req_t *in_reqs[] =
 595         {
 596                 & sparc_requirements_gp_gp,
 597         };
 598
 599         /* construct in array */
 600         in[0] = left;
 601
 602         /* flags */
 603         flags |= arch_irn_flags_rematerializable;
 604         flags |= arch_irn_flags_modify_flags;
 605
 606         /* create node */
 607         assert(op != NULL);
 608         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 609
 610         /* init node attributes */
 611                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 612
 613         sparc_set_attr_imm(res, immediate_value);       init_sparc_cmp_attr(res, ins_permuted, is_unsigned);
 614         info = be_get_info(res);
 615         info->out_infos[0].req = &sparc_requirements_flags_flags;
 616
 617
 618         /* optimize node */
 619         res = optimize_node(res);
 620         irn_vrfy_irg(res, current_ir_graph);
 621
 622         return res;
 623 }
 624
 625 /**
 626  * construct Cmp node
 627  */
 628 ir_node *new_bd_sparc_Cmp_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right, bool ins_permuted, bool is_unsigned)
 629 {
 630         ir_node        *res;
 631         ir_op          *op      = op_sparc_Cmp;
 632         int             flags   = 0;
 633         backend_info_t *info;
 634         int             arity   = 2;
 635         ir_node        *in[2];
 636         int             n_res   = 1;
 637         ir_mode        *mode    = mode_Bu;
 638         static const be_execution_unit_t ***exec_units = NULL;
 639         static const arch_register_req_t *in_reqs[] =
 640         {
 641                 & sparc_requirements_gp_gp,
 642                 & sparc_requirements_gp_gp,
 643         };
 644
 645         /* construct in array */
 646         in[0] = left;
 647         in[1] = right;
 648
 649         /* flags */
 650         flags |= arch_irn_flags_rematerializable;
 651         flags |= arch_irn_flags_modify_flags;
 652
 653         /* create node */
 654         assert(op != NULL);
 655         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 656
 657         /* init node attributes */
 658                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 659
 660         init_sparc_cmp_attr(res, ins_permuted, is_unsigned);
 661         info = be_get_info(res);
 662         info->out_infos[0].req = &sparc_requirements_flags_flags;
 663
 664
 665         /* optimize node */
 666         res = optimize_node(res);
 667         irn_vrfy_irg(res, current_ir_graph);
 668
 669         return res;
 670 }
 671
 672 /**
 673  * construct SymConst node
 674  */
 675 ir_node *new_bd_sparc_SymConst(dbg_info *dbgi, ir_node *block, ir_entity *entity)
 676 {
 677         ir_node        *res;
 678         ir_op          *op      = op_sparc_SymConst;
 679         int             flags   = 0;
 680         backend_info_t *info;
 681         int             arity   = 0;
 682         ir_node       **in      = NULL;
 683         int             n_res   = 1;
 684         ir_mode        *mode    = mode_Iu;
 685         static const be_execution_unit_t ***exec_units = NULL;
 686         static const arch_register_req_t **in_reqs = NULL;
 687
 688         /* flags */
 689         flags |= arch_irn_flags_rematerializable;
 690
 691         /* create node */
 692         assert(op != NULL);
 693         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 694
 695         /* init node attributes */
 696                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 697         init_sparc_symconst_attributes(res, entity);
 698
 699         info = be_get_info(res);
 700         info->out_infos[0].req = &sparc_requirements_gp_gp;
 701
 702
 703         /* optimize node */
 704         res = optimize_node(res);
 705         irn_vrfy_irg(res, current_ir_graph);
 706
 707         return res;
 708 }
 709
 710 /**
 711  * construct Sub node
 712  */
 713 ir_node *new_bd_sparc_Sub_imm(dbg_info *dbgi, ir_node *block, ir_node *left, int immediate_value)
 714 {
 715         ir_node        *res;
 716         ir_op          *op      = op_sparc_Sub;
 717         int             flags   = 0;
 718         backend_info_t *info;
 719         int             arity   = 1;
 720         ir_node        *in[1];
 721         int             n_res   = 1;
 722         ir_mode        *mode    = mode_Iu;
 723         static const be_execution_unit_t ***exec_units = NULL;
 724         static const arch_register_req_t *in_reqs[] =
 725         {
 726                 & sparc_requirements_gp_gp,
 727         };
 728
 729         /* construct in array */
 730         in[0] = left;
 731
 732         /* flags */
 733         flags |= arch_irn_flags_rematerializable;
 734
 735         /* create node */
 736         assert(op != NULL);
 737         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 738
 739         /* init node attributes */
 740                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 741         sparc_set_attr_imm(res, immediate_value);
 742         info = be_get_info(res);
 743         info->out_infos[0].req = &sparc_requirements_gp_gp;
 744
 745
 746         /* optimize node */
 747         res = optimize_node(res);
 748         irn_vrfy_irg(res, current_ir_graph);
 749
 750         return res;
 751 }
 752
 753 /**
 754  * construct Sub node
 755  */
 756 ir_node *new_bd_sparc_Sub_reg(dbg_info *dbgi, ir_node *block, ir_node *left, ir_node *right)
 757 {
 758         ir_node        *res;
 759         ir_op          *op      = op_sparc_Sub;
 760         int             flags   = 0;
 761         backend_info_t *info;
 762         int             arity   = 2;
 763         ir_node        *in[2];
 764         int             n_res   = 1;
 765         ir_mode        *mode    = mode_Iu;
 766         static const be_execution_unit_t ***exec_units = NULL;
 767         static const arch_register_req_t *in_reqs[] =
 768         {
 769                 & sparc_requirements_gp_gp,
 770                 & sparc_requirements_gp_gp,
 771         };
 772
 773         /* construct in array */
 774         in[0] = left;
 775         in[1] = right;
 776
 777         /* flags */
 778         flags |= arch_irn_flags_rematerializable;
 779
 780         /* create node */
 781         assert(op != NULL);
 782         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 783
 784         /* init node attributes */
 785                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 786
 787         info = be_get_info(res);
 788         info->out_infos[0].req = &sparc_requirements_gp_gp;
 789
 790
 791         /* optimize node */
 792         res = optimize_node(res);
 793         irn_vrfy_irg(res, current_ir_graph);
 794
 795         return res;
 796 }
 797
 798 /**
 799  * construct Load: Load(ptr, mem) = LD ptr -> reg
 800  */
 801 ir_node *new_bd_sparc_Load(dbg_info *dbgi, ir_node *block, ir_node *ptr, ir_node *mem, ir_mode *ls_mode, ir_entity *entity, int entity_sign, long offset, bool is_frame_entity)
 802 {
 803         ir_node        *res;
 804         ir_op          *op      = op_sparc_Load;
 805         int             flags   = 0;
 806         backend_info_t *info;
 807         int             arity   = 2;
 808         ir_node        *in[2];
 809         int             n_res   = 2;
 810         ir_mode        *mode    = mode_T;
 811         static const be_execution_unit_t ***exec_units = NULL;
 812         static const arch_register_req_t *in_reqs[] =
 813         {
 814                 & sparc_requirements_gp_gp,
 815                 & sparc_requirements__none,
 816         };
 817
 818         /* construct in array */
 819         in[0] = ptr;
 820         in[1] = mem;
 821
 822         /* create node */
 823         assert(op != NULL);
 824         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 825
 826         /* init node attributes */
 827                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 828         init_sparc_load_store_attributes(res, ls_mode, entity, entity_sign, offset, is_frame_entity);
 829
 830         info = be_get_info(res);
 831         info->out_infos[0].req = &sparc_requirements_gp_gp;
 832 info->out_infos[1].req = &sparc_requirements__none;
 833
 834
 835         /* optimize node */
 836         res = optimize_node(res);
 837         irn_vrfy_irg(res, current_ir_graph);
 838
 839         return res;
 840 }
 841
 842 /**
 843  * alloc stack space
 844  */
 845 ir_node *new_bd_sparc_AddSP(dbg_info *dbgi, ir_node *block, ir_node *stack, ir_node *size, ir_node *mem)
 846 {
 847         ir_node        *res;
 848         ir_op          *op      = op_sparc_AddSP;
 849         int             flags   = 0;
 850         backend_info_t *info;
 851         int             arity   = 3;
 852         ir_node        *in[3];
 853         int             n_res   = 3;
 854         ir_mode        *mode    = mode_T;
 855         static const be_execution_unit_t ***exec_units = NULL;
 856         static const arch_register_req_t *in_reqs[] =
 857         {
 858                 & sparc_requirements_gp_sp,
 859                 & sparc_requirements_gp_gp,
 860                 & sparc_requirements__none,
 861         };
 862
 863         /* construct in array */
 864         in[0] = stack;
 865         in[1] = size;
 866         in[2] = mem;
 867
 868         /* create node */
 869         assert(op != NULL);
 870         res = new_ir_node(dbgi, current_ir_graph, block, op, mode, arity, in);
 871
 872         /* init node attributes */
 873                 init_sparc_attributes(res, flags, in_reqs, exec_units, n_res);
 874
 875         info = be_get_info(res);
 876         info->out_infos[0].req = &sparc_requirements_gp_sp_I_S;
 877 info->out_infos[1].req = &sparc_requirements_gp_gp;
 878 info->out_infos[2].req = &sparc_requirements__none;
 879
 880
 881         /* optimize node */
 882         res = optimize_node(res);
 883         irn_vrfy_irg(res, current_ir_graph);
 884
 885         return res;
 886 }
 887
 888
 889
 890 /**
 891  * Creates the sparc specific Firm machine operations
 892  * needed for the assembler irgs.
 893  */
 894 void sparc_create_opcodes(const arch_irn_ops_t *be_ops) {
 895 #define N   irop_flag_none
 896 #define L   irop_flag_labeled
 897 #define C   irop_flag_commutative
 898 #define X   irop_flag_cfopcode
 899 #define I   irop_flag_ip_cfopcode
 900 #define F   irop_flag_fragile
 901 #define Y   irop_flag_forking
 902 #define H   irop_flag_highlevel
 903 #define c   irop_flag_constlike
 904 #define K   irop_flag_keep
 905 #define M   irop_flag_machine
 906 #define O   irop_flag_machine_op
 907 #define NB  irop_flag_dump_noblock
 908 #define NI  irop_flag_dump_noinput
 909 #define R   (irop_flag_user << 0)
 910
 911         ir_op_ops  ops;
 912         int        cur_opcode;
 913         static int run_once = 0;
 914
 915         if (run_once)
 916                 return;
 917         run_once = 1;
 918
 919         cur_opcode = get_next_ir_opcodes(iro_sparc_last);
 920
 921         sparc_opcode_start = cur_opcode;
 922
 923         memset(&ops, 0, sizeof(ops));
 924         ops.be_ops        = be_ops;
 925         ops.dump_node     = sparc_dump_node;
 926         ops.node_cmp_attr = cmp_attr_sparc;
 927         ops.copy_attr = sparc_copy_attr;
 928         op_sparc_SubSP = new_ir_op(cur_opcode + iro_sparc_SubSP, "sparc_SubSP", op_pin_state_floats, N|M, oparity_trinary, 0, sizeof(sparc_attr_t), &ops);
 929         set_op_tag(op_sparc_SubSP, sparc_op_tag);
 930
 931         memset(&ops, 0, sizeof(ops));
 932         ops.be_ops        = be_ops;
 933         ops.dump_node     = sparc_dump_node;
 934         ops.node_cmp_attr = cmp_attr_sparc;
 935         ops.copy_attr = sparc_copy_attr;
 936         op_sparc_Add = new_ir_op(cur_opcode + iro_sparc_Add, "sparc_Add", op_pin_state_floats, C|M, oparity_zero, 0, sizeof(sparc_attr_t), &ops);
 937         set_op_tag(op_sparc_Add, sparc_op_tag);
 938
 939         memset(&ops, 0, sizeof(ops));
 940         ops.be_ops        = be_ops;
 941         ops.dump_node     = sparc_dump_node;
 942         ops.node_cmp_attr = cmp_attr_sparc_symconst;
 943         ops.copy_attr = sparc_copy_attr;
 944         op_sparc_FrameAddr = new_ir_op(cur_opcode + iro_sparc_FrameAddr, "sparc_FrameAddr", op_pin_state_floats, c|M, oparity_unary, 0, sizeof(sparc_symconst_attr_t), &ops);
 945         set_op_tag(op_sparc_FrameAddr, sparc_op_tag);
 946
 947         memset(&ops, 0, sizeof(ops));
 948         ops.be_ops        = be_ops;
 949         ops.dump_node     = sparc_dump_node;
 950         ops.node_cmp_attr = cmp_attr_sparc_load_store;
 951         ops.copy_attr = sparc_copy_attr;
 952         op_sparc_Store = new_ir_op(cur_opcode + iro_sparc_Store, "sparc_Store", op_pin_state_exc_pinned, L|F|M, oparity_trinary, 0, sizeof(sparc_load_store_attr_t), &ops);
 953         set_op_tag(op_sparc_Store, sparc_op_tag);
 954
 955         memset(&ops, 0, sizeof(ops));
 956         ops.be_ops        = be_ops;
 957         ops.dump_node     = sparc_dump_node;
 958         ops.node_cmp_attr = cmp_attr_sparc_jmp_cond;
 959         ops.copy_attr = sparc_copy_attr;
 960         op_sparc_Branch = new_ir_op(cur_opcode + iro_sparc_Branch, "sparc_Branch", op_pin_state_pinned, L|X|Y|M, oparity_unary, 0, sizeof(sparc_jmp_cond_attr_t), &ops);
 961         set_op_tag(op_sparc_Branch, sparc_op_tag);
 962
 963         memset(&ops, 0, sizeof(ops));
 964         ops.be_ops        = be_ops;
 965         ops.dump_node     = sparc_dump_node;
 966         ops.node_cmp_attr = cmp_attr_sparc;
 967         ops.copy_attr = sparc_copy_attr;
 968         op_sparc_Mov = new_ir_op(cur_opcode + iro_sparc_Mov, "sparc_Mov", op_pin_state_floats, N|M, oparity_variable, 0, sizeof(sparc_attr_t), &ops);
 969         set_op_tag(op_sparc_Mov, sparc_op_tag);
 970
 971         memset(&ops, 0, sizeof(ops));
 972         ops.be_ops        = be_ops;
 973         ops.dump_node     = sparc_dump_node;
 974         ops.node_cmp_attr = cmp_attr_sparc_cmp;
 975         ops.copy_attr = sparc_copy_attr;
 976         op_sparc_Tst = new_ir_op(cur_opcode + iro_sparc_Tst, "sparc_Tst", op_pin_state_floats, N|M, oparity_unary, 0, sizeof(sparc_cmp_attr_t), &ops);
 977         set_op_tag(op_sparc_Tst, sparc_op_tag);
 978
 979         memset(&ops, 0, sizeof(ops));
 980         ops.be_ops        = be_ops;
 981         ops.dump_node     = sparc_dump_node;
 982         ops.node_cmp_attr = cmp_attr_sparc_jmp_switch;
 983         ops.copy_attr = sparc_copy_attr;
 984         op_sparc_SwitchJmp = new_ir_op(cur_opcode + iro_sparc_SwitchJmp, "sparc_SwitchJmp", op_pin_state_pinned, L|X|Y|M, oparity_unary, 0, sizeof(sparc_jmp_switch_attr_t), &ops);
 985         set_op_tag(op_sparc_SwitchJmp, sparc_op_tag);
 986
 987         memset(&ops, 0, sizeof(ops));
 988         ops.be_ops        = be_ops;
 989         ops.dump_node     = sparc_dump_node;
 990         ops.node_cmp_attr = cmp_attr_sparc_cmp;
 991         ops.copy_attr = sparc_copy_attr;
 992         op_sparc_Cmp = new_ir_op(cur_opcode + iro_sparc_Cmp, "sparc_Cmp", op_pin_state_floats, N|M, oparity_zero, 0, sizeof(sparc_cmp_attr_t), &ops);
 993         set_op_tag(op_sparc_Cmp, sparc_op_tag);
 994
 995         memset(&ops, 0, sizeof(ops));
 996         ops.be_ops        = be_ops;
 997         ops.dump_node     = sparc_dump_node;
 998         ops.node_cmp_attr = cmp_attr_sparc_symconst;
 999         ops.copy_attr = sparc_copy_attr;
1000         op_sparc_SymConst = new_ir_op(cur_opcode + iro_sparc_SymConst, "sparc_SymConst", op_pin_state_floats, c|M, oparity_zero, 0, sizeof(sparc_symconst_attr_t), &ops);
1001         set_op_tag(op_sparc_SymConst, sparc_op_tag);
1002
1003         memset(&ops, 0, sizeof(ops));
1004         ops.be_ops        = be_ops;
1005         ops.dump_node     = sparc_dump_node;
1006         ops.node_cmp_attr = cmp_attr_sparc;
1007         ops.copy_attr = sparc_copy_attr;
1008         op_sparc_Sub = new_ir_op(cur_opcode + iro_sparc_Sub, "sparc_Sub", op_pin_state_floats, N|M, oparity_binary, 0, sizeof(sparc_attr_t), &ops);
1009         set_op_tag(op_sparc_Sub, sparc_op_tag);
1010
1011         memset(&ops, 0, sizeof(ops));
1012         ops.be_ops        = be_ops;
1013         ops.dump_node     = sparc_dump_node;
1014         ops.node_cmp_attr = cmp_attr_sparc_load_store;
1015         ops.copy_attr = sparc_copy_attr;
1016         op_sparc_Load = new_ir_op(cur_opcode + iro_sparc_Load, "sparc_Load", op_pin_state_exc_pinned, L|F|M, oparity_binary, 0, sizeof(sparc_load_store_attr_t), &ops);
1017         set_op_tag(op_sparc_Load, sparc_op_tag);
1018
1019         memset(&ops, 0, sizeof(ops));
1020         ops.be_ops        = be_ops;
1021         ops.dump_node     = sparc_dump_node;
1022         ops.node_cmp_attr = cmp_attr_sparc;
1023         ops.copy_attr = sparc_copy_attr;
1024         op_sparc_AddSP = new_ir_op(cur_opcode + iro_sparc_AddSP, "sparc_AddSP", op_pin_state_floats, N|M, oparity_trinary, 0, sizeof(sparc_attr_t), &ops);
1025         set_op_tag(op_sparc_AddSP, sparc_op_tag);
1026
1027         sparc_opcode_end = cur_opcode + iro_sparc_last;
1028 }