nsz Git - libfirm/blob - ir/be/ppc32/ppc32_transform.c

   1 /* The codegenerator (transform FIRM into ppc FIRM) */
   2 /* $Id$ */
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include "config.h"
   6 #endif
   7
   8 #include "irnode_t.h"
   9 #include "irgraph_t.h"
  10 #include "irmode_t.h"
  11 #include "irgmod.h"
  12 #include "iredges.h"
  13 #include "iredges_t.h"
  14 #include "irvrfy.h"
  15 #include "ircons.h"
  16 #include "dbginfo.h"
  17 #include "iropt_t.h"
  18 #include "irprintf.h"
  19 #include "debug.h"
  20
  21 #include "../benode_t.h"
  22 #include "bearch_ppc32_t.h"
  23
  24 #include "ppc32_nodes_attr.h"
  25 #include "../arch/archop.h"     /* we need this for Min and Max nodes */
  26 #include "ppc32_transform.h"
  27 #include "ppc32_new_nodes.h"
  28 #include "ppc32_map_regs.h"
  29
  30 #include "gen_ppc32_regalloc_if.h"
  31
  32 extern pset *symbol_pset;
  33 extern ir_op *get_op_Mulh(void);
  34
  35 int is_direct_entity(ir_entity *ent);
  36
  37 ir_mode* ppc32_mode_Cond = NULL;
  38
  39 /**
  40  * Returns the proj of a given node with the given proj number
  41  */
  42 static INLINE ir_node *get_succ_Proj(ir_node *node, long proj)
  43 {
  44         const ir_edge_t *edge;
  45         foreach_out_edge(node, edge)
  46         {
  47                 if (is_Proj(edge->src) && get_Proj_proj(edge->src) == proj)
  48                         return edge->src;
  49         }
  50         return NULL;
  51 }
  52
  53 /**
  54  * Returns a singleton condition mode
  55  */
  56 ir_mode *get_ppc32_mode_Cond(void) {
  57         if (ppc32_mode_Cond)
  58                 return ppc32_mode_Cond;
  59         else {
  60                 ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_character, 4, 0, irma_none, 0);
  61                 return ppc32_mode_Cond;
  62         }
  63 }
  64
  65 /**
  66  * Calculates the modecode with size, sort and signed attributes
  67  */
  68 modecode get_nice_modecode(ir_mode *irmode)
  69 {
  70         modecode mode = irm_max;
  71         int sign = mode_is_signed(irmode);
  72         int bits = get_mode_size_bits(irmode);
  73         if(mode_is_int(irmode))
  74         {
  75                 switch(bits)
  76                 {
  77                         case 8:
  78                                 mode = sign ? irm_Bs : irm_Bu;
  79                                 break;
  80                         case 16:
  81                                 mode = sign ? irm_Hs : irm_Hu;
  82                                 break;
  83                         case 32:
  84                                 mode = sign ? irm_Is : irm_Iu;
  85                                 break;
  86                 }
  87         }
  88         else if(mode_is_float(irmode))
  89         {
  90                 switch(bits)
  91                 {
  92                         case 32:
  93                                 mode = irm_F;
  94                                 break;
  95                         case 64:
  96                                 mode = irm_D;
  97                                 break;
  98                 }
  99         }
 100         else if(mode_is_reference(irmode))
 101         {
 102                 switch(bits)
 103                 {
 104                         case 32:
 105                                 mode = irm_P;
 106                                 break;
 107                 }
 108         }
 109         return mode;
 110 }
 111
 112 /**
 113  * Returns true, if the given node is a Const node and it's value fits into
 114  * a signed 16-bit variable
 115  */
 116 int is_16bit_signed_const(ir_node *node)
 117 {
 118         tarval *tv_const;
 119
 120         if(!is_ppc32_Const(node)) return 0;
 121
 122         tv_const = get_ppc32_constant_tarval(node);
 123
 124         switch(get_nice_modecode(get_irn_mode(node)))
 125         {
 126                 case irm_Bu:
 127                 case irm_Bs:
 128                 case irm_Hs:
 129                         return 1;
 130                 case irm_Iu:
 131                 case irm_P:
 132                 {
 133                         unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
 134                         unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
 135                         if(val2 || val3)
 136                                 return 0;
 137
 138                         // fall through
 139                 }
 140                 case irm_Hu:
 141                 {
 142                         unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
 143                         if(val1&0x80)
 144                                 return 0;
 145                         return 1;
 146                 }
 147
 148                 case irm_Is:
 149                 {
 150                         unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
 151                         unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
 152                         if(val2==0 && val3==0)
 153                         {
 154                                 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
 155                                 if(val1&0x80)
 156                                         return 0;
 157                                 return 1;
 158                         }
 159                         if(!(val2==0xff && val3==0xff))
 160                         {
 161                                 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
 162                                 if(!(val1&0x80))
 163                                         return 0;
 164                                 return 1;
 165                         }
 166                         return 0;
 167                 }
 168                 default:
 169                         fprintf(stderr, "is_16bit_signed_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
 170                         assert(0);
 171                         return 0;
 172         }
 173 }
 174
 175 /**
 176  * Returns true, if the given node is a Const node and it's value fits into
 177  * a unsigned 16-bit variable
 178  */
 179 int is_16bit_unsigned_const(ir_node *node)
 180 {
 181         tarval *tv_const;
 182
 183         if(!is_ppc32_Const(node)) return 0;
 184
 185         tv_const = get_ppc32_constant_tarval(node);
 186         switch(get_nice_modecode(get_irn_mode(node)))
 187         {
 188                 case irm_Bu:
 189                 case irm_Bs:
 190                 case irm_Hs:
 191                 case irm_Hu:
 192                         return 1;
 193                 case irm_Iu:
 194                 case irm_P:
 195                 case irm_Is:
 196                 {
 197                         unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
 198                         unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
 199                         if(val2 || val3)
 200                                 return 0;
 201                         return 1;
 202                 }
 203                 default:
 204                         fprintf(stderr, "is_16bit_unsigned_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
 205                         assert(0);
 206                         return 0;
 207         }
 208 }
 209
 210
 211 /****************************************************************************************************
 212  *                  _        _                        __                           _   _
 213  *                 | |      | |                      / _|                         | | (_)
 214  *  _ __   ___   __| | ___  | |_ _ __ __ _ _ __  ___| |_ ___  _ __ _ __ ___   __ _| |_ _  ___  _ __
 215  * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __|  _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
 216  * | | | | (_) | (_| |  __/ | |_| | | (_| | | | \__ \ || (_) | |  | | | | | | (_| | |_| | (_) | | | |
 217  * |_| |_|\___/ \__,_|\___|  \__|_|  \__,_|_| |_|___/_| \___/|_|  |_| |_| |_|\__,_|\__|_|\___/|_| |_|
 218  *
 219  ****************************************************************************************************/
 220
 221 /**
 222  * Creates an ppc Add.
 223  *
 224  * @param env   The transformation environment
 225  * @return the created ppc Add node
 226  */
 227 static ir_node *gen_Add(ppc32_transform_env_t *env) {
 228         ir_node *op1 = get_Add_left(env->irn);
 229         ir_node *op2 = get_Add_right(env->irn);
 230
 231         switch(get_nice_modecode(env->mode)){
 232                 case irm_D:
 233                         return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode);
 234                 case irm_F:
 235                         return new_rd_ppc32_fAdds(env->dbg, env->irg, env->block, op1, op2, env->mode);
 236                 case irm_Is:
 237                 case irm_Iu:
 238                 case irm_Hs:
 239                 case irm_Hu:
 240                 case irm_Bs:
 241                 case irm_Bu:
 242                 case irm_P:
 243                         if(is_16bit_signed_const(op1))
 244                         {
 245                                 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op2, env->mode);
 246                                 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op1));
 247                                 set_ppc32_offset_mode(addnode, ppc32_ao_None);
 248                                 return addnode;
 249                         }
 250                         if(is_16bit_signed_const(op2))
 251                         {
 252                                 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op1, env->mode);
 253                                 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op2));
 254                                 set_ppc32_offset_mode(addnode, ppc32_ao_None);
 255                                 return addnode;
 256                         }
 257
 258                         return new_rd_ppc32_Add(env->dbg, env->irg, env->block, op1, op2, env->mode);
 259
 260                 default:
 261                         fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode));
 262                         assert(0);
 263                         return NULL;
 264         }
 265 }
 266
 267 /**
 268  * Creates an ppc Mul.
 269  *
 270  * @param env   The transformation environment
 271  * @return the created ppc Mul node
 272  */
 273 static ir_node *gen_Mul(ppc32_transform_env_t *env) {
 274         ir_node *op1 = get_Mul_left(env->irn);
 275         ir_node *op2 = get_Mul_right(env->irn);
 276
 277         switch(get_nice_modecode(env->mode)){
 278                 case irm_D:
 279                         return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
 280                 case irm_F:
 281                         return new_rd_ppc32_fMuls(env->dbg, env->irg, env->block, op1, op2, env->mode);
 282                 case irm_Is:
 283                 case irm_Iu:
 284                 case irm_Hs:
 285                 case irm_Hu:
 286                 case irm_Bs:
 287                 case irm_Bu:
 288                         return new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, op1, op2, env->mode);
 289
 290                 case irm_P:
 291                 default:
 292                         fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode));
 293                         assert(0);
 294                         return NULL;
 295         }
 296 }
 297
 298 /**
 299  * Creates an ppc Mulh.
 300  *
 301  * @param env   The transformation environment
 302  * @return the created ppc Mulh node
 303  */
 304 static ir_node *gen_Mulh(ppc32_transform_env_t *env) {
 305         ir_node *op1 = get_irn_n(env->irn, 0);
 306         ir_node *op2 = get_irn_n(env->irn, 1);
 307
 308         switch(get_nice_modecode(env->mode)){
 309                 case irm_Is:
 310                 case irm_Hs:
 311                 case irm_Bs:
 312                         return new_rd_ppc32_Mulhw(env->dbg, env->irg, env->block, op1, op2, env->mode);
 313
 314                 case irm_Iu:
 315                 case irm_Hu:
 316                 case irm_Bu:
 317                         return new_rd_ppc32_Mulhwu(env->dbg, env->irg, env->block, op1, op2, env->mode);
 318
 319                 case irm_D:
 320                 case irm_F:
 321                 case irm_P:
 322                 default:
 323                         fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode));
 324                         assert(0);
 325                         return NULL;
 326         }
 327 }
 328
 329 /**
 330  * Creates an ppc And.
 331  *
 332  * @param env   The transformation environment
 333  * @return the created ppc And node
 334  */
 335 static ir_node *gen_And(ppc32_transform_env_t *env) {
 336         ir_node *op1 = get_And_left(env->irn);
 337         ir_node *op2 = get_And_right(env->irn);
 338
 339         return new_rd_ppc32_And(env->dbg, env->irg, env->block, op1, op2, env->mode);
 340 }
 341
 342 /**
 343  * Creates an ppc Or.
 344  *
 345  * @param env   The transformation environment
 346  * @return the created ppc Or node
 347  */
 348 static ir_node *gen_Or(ppc32_transform_env_t *env) {
 349         ir_node *op1 = get_Or_left(env->irn);
 350         ir_node *op2 = get_Or_right(env->irn);
 351
 352         return new_rd_ppc32_Or(env->dbg, env->irg, env->block, op1, op2, env->mode);
 353 }
 354
 355 /**
 356  * Creates an ppc Xor.
 357  *
 358  * @param env   The transformation environment
 359  * @return the created ppc Xor node
 360  */
 361 static ir_node *gen_Eor(ppc32_transform_env_t *env) {
 362         ir_node *op1 = get_Eor_left(env->irn);
 363         ir_node *op2 = get_Eor_right(env->irn);
 364
 365         return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, op1, op2, env->mode);
 366 }
 367
 368 /**
 369  * Creates an ppc Sub.
 370  *
 371  * @param env   The transformation environment
 372  * @return the created ppc Sub node
 373  */
 374 static ir_node *gen_Sub(ppc32_transform_env_t *env) {
 375         ir_node *op1 = get_Sub_left(env->irn);
 376         ir_node *op2 = get_Sub_right(env->irn);
 377
 378         switch(get_nice_modecode(env->mode)){
 379                 case irm_D:
 380                         return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
 381                 case irm_F:
 382                         return new_rd_ppc32_fSubs(env->dbg, env->irg, env->block, op1, op2, env->mode);
 383                 case irm_Is:
 384                 case irm_Iu:
 385                 case irm_Hs:
 386                 case irm_Hu:
 387                 case irm_Bs:
 388                 case irm_Bu:
 389                 case irm_P:
 390                         return new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, op2, env->mode);
 391
 392                 default:
 393                         fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode));
 394                         assert(0);
 395                         return NULL;
 396         }
 397 }
 398
 399 /**
 400  * Creates an ppc floating Div.
 401  *
 402  * @param env   The transformation environment
 403  * @return the created ppc fDiv node
 404  */
 405 static ir_node *gen_Quot(ppc32_transform_env_t *env) {
 406         ir_node *op1 = get_Quot_left(env->irn);
 407         ir_node *op2 = get_Quot_right(env->irn);
 408
 409         switch(get_nice_modecode(env->mode)){
 410                 case irm_D:
 411                         return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
 412                 case irm_F:
 413                         return new_rd_ppc32_fDivs(env->dbg, env->irg, env->block, op1, op2, env->mode);
 414
 415                 default:
 416                         fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode));
 417                         assert(0);
 418                         return NULL;
 419         }
 420 }
 421
 422 /**
 423  * Creates an ppc integer Div.
 424  *
 425  * @param env   The transformation environment
 426  * @return the created ppc Div node
 427  */
 428 static ir_node *gen_Div(ppc32_transform_env_t *env) {
 429         ir_node *op1 = get_Div_left(env->irn);
 430         ir_node *op2 = get_Div_right(env->irn);
 431
 432         switch(get_nice_modecode(get_irn_mode(op1))){
 433                 case irm_Is:
 434                 case irm_Hs:
 435                 case irm_Bs:
 436                         return new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
 437
 438                 case irm_Iu:
 439                 case irm_Hu:
 440                 case irm_Bu:
 441                         return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
 442
 443                 default:
 444                         fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(op1)));
 445                         assert(0);
 446                         return NULL;
 447         }
 448 }
 449
 450 /**
 451  * Creates an ppc integer Div and Mod.
 452  *
 453  * @param env   The transformation environment
 454  * @return the created ppc Div node
 455  */
 456 static ir_node *gen_DivMod(ppc32_transform_env_t *env) {
 457         ir_node *op1 = get_DivMod_left(env->irn);
 458         ir_node *op2 = get_DivMod_right(env->irn);
 459         ir_node *proj_div = NULL, *proj_mod = NULL;
 460         ir_node *div_result;
 461         const ir_edge_t *edge;
 462         ir_mode *res_mode;
 463
 464         foreach_out_edge(env->irn, edge)
 465         {
 466                 if (is_Proj(edge->src))
 467                 {
 468                         switch(get_Proj_proj(edge->src)){
 469                                 case pn_DivMod_res_div:
 470                                         proj_div = edge->src;
 471                                         break;
 472                                 case pn_DivMod_res_mod:
 473                                         proj_mod = edge->src;
 474                                         break;
 475                                 default:
 476                                         break;
 477                         }
 478                 }
 479         }
 480
 481         assert(proj_div!=NULL || proj_mod!=NULL);
 482
 483         res_mode = get_irn_mode(proj_div);
 484
 485         switch(get_nice_modecode(res_mode))
 486         {
 487                 case irm_Is:
 488                 case irm_Hs:
 489                 case irm_Bs:
 490                         div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
 491                         break;
 492
 493                 case irm_Iu:
 494                 case irm_Hu:
 495                 case irm_Bu:
 496                         div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
 497                         break;
 498
 499                 default:
 500                         fprintf(stderr, "Mode for DivMod not supported: %s\n", get_mode_name(res_mode));
 501                         assert(0);
 502                         return 0;
 503
 504         }
 505
 506         if (proj_div == NULL)
 507                 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, get_irn_mode(proj_mod), pn_DivMod_res_div);
 508
 509         if (proj_mod!=NULL){
 510                 ir_node *mul_result;
 511                 ir_node *mod_result;
 512
 513                 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
 514                 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
 515
 516                 exchange(proj_mod, mod_result);
 517         }
 518
 519         return div_result;
 520 }
 521
 522 /**
 523  * Creates an ppc integer Mod.
 524  *
 525  * @param env   The transformation environment
 526  * @return the created ppc Mod result node
 527  */
 528 static ir_node *gen_Mod(ppc32_transform_env_t *env) {
 529         ir_node *op1 = get_Mod_left(env->irn);
 530         ir_node *op2 = get_Mod_right(env->irn);
 531         ir_node *proj_div = NULL, *proj_mod = NULL;
 532         ir_node *div_result;
 533         ir_mode *res_mode;
 534         ir_node *mul_result;
 535         ir_node *mod_result;
 536
 537         proj_mod = get_succ_Proj(env->irn, pn_Mod_res);
 538
 539         assert(proj_mod != NULL);
 540         res_mode = get_irn_mode(proj_mod);
 541
 542         switch(get_nice_modecode(res_mode))
 543         {
 544                 case irm_Is:
 545                 case irm_Hs:
 546                 case irm_Bs:
 547                         div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
 548                         break;
 549
 550                 case irm_Iu:
 551                 case irm_Hu:
 552                 case irm_Bu:
 553                         div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
 554                         break;
 555
 556                 default:
 557                         fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode));
 558                         assert(0);
 559                         return NULL;
 560
 561         }
 562
 563         proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, res_mode, pn_DivMod_res_div);
 564
 565         mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
 566         mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
 567
 568         exchange(proj_mod, mod_result);
 569
 570         return div_result;
 571 }
 572
 573 /**
 574  * Creates an ppc Shl.
 575  *
 576  * @param env   The transformation environment
 577  * @return the created ppc Shl node
 578  */
 579 static ir_node *gen_Shl(ppc32_transform_env_t *env) {
 580         ir_node *op1 = get_Shl_left(env->irn);
 581         ir_node *op2 = get_Shl_right(env->irn);
 582
 583         if(is_ppc32_Const(op2))
 584         {
 585                 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
 586                 tarval *tv_const = get_ppc32_constant_tarval(op2);
 587                 int sh = get_tarval_long(tv_const);
 588                 assert(0<=sh && sh<=31);
 589                 set_ppc32_rlwimi_const(shift, sh, 0, 31-sh);
 590                 return shift;
 591         }
 592         return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode);
 593 }
 594
 595 /**
 596  * Creates an ppc Srw.
 597  *
 598  * @param env   The transformation environment
 599  * @return the created ppc Shr node
 600  */
 601 static ir_node *gen_Shr(ppc32_transform_env_t *env) {
 602         ir_node *op1 = get_Shr_left(env->irn);
 603         ir_node *op2 = get_Shr_right(env->irn);
 604
 605         if(is_ppc32_Const(op2))
 606         {
 607                 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
 608                 tarval *tv_const = get_ppc32_constant_tarval(op2);
 609                 int sh = get_tarval_long(tv_const);
 610                 assert(0<=sh && sh<=31);
 611                 set_ppc32_rlwimi_const(shift, 32-sh, sh, 31);
 612                 return shift;
 613         }
 614         return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode);
 615 }
 616
 617 /**
 618  * Creates an ppc Sraw.
 619  *
 620  * @param env   The transformation environment
 621  * @return the created ppc Sraw node
 622  */
 623 static ir_node *gen_Shrs(ppc32_transform_env_t *env) {
 624         ir_node *op1 = get_Shrs_left(env->irn);
 625         ir_node *op2 = get_Shrs_right(env->irn);
 626
 627         if(is_ppc32_Const(op2))
 628         {
 629                 ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode);
 630                 tarval *tv_const = get_ppc32_constant_tarval(op2);
 631                 int sh = get_tarval_long(tv_const);
 632                 assert(0<=sh && sh<=31);
 633                 set_ppc32_constant_tarval(shift, tv_const);
 634                 set_ppc32_offset_mode(shift, ppc32_ao_None);
 635                 return shift;
 636         }
 637         return new_rd_ppc32_Sraw(env->dbg, env->irg, env->block, op1, op2, env->mode);
 638 }
 639
 640 /**
 641  * Creates an ppc RotL.
 642  *
 643  * @param env   The transformation environment
 644  * @return the created ppc RotL node
 645  */
 646 static ir_node *gen_Rot(ppc32_transform_env_t *env) {
 647         ir_node *op1 = get_Rot_left(env->irn);
 648         ir_node *op2 = get_Rot_right(env->irn);
 649
 650         if(is_ppc32_Const(op2))
 651         {
 652                 ir_node *rot = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
 653                 tarval *tv_const = get_ppc32_constant_tarval(op2);
 654                 int sh = get_tarval_long(tv_const);
 655                 assert(0<=sh && sh<=31);
 656                 set_ppc32_rlwimi_const(rot, sh, 0, 31);
 657                 return rot;
 658         }
 659         return new_rd_ppc32_Rlwnm(env->dbg, env->irg, env->block, op1, op2, env->mode);
 660 }
 661
 662 /**
 663  * Creates an ppc Cmp.
 664  *
 665  * @param env   The transformation environment
 666  * @return the created ppc Cmp node
 667  */
 668 static ir_node *gen_Cmp(ppc32_transform_env_t *env) {
 669         ir_node *op1 = get_Cmp_left(env->irn);
 670         ir_node *op2 = get_Cmp_right(env->irn);
 671
 672         const ir_edge_t *edge;
 673         foreach_out_edge(env->irn, edge)
 674         {
 675                 if (is_Proj(edge->src))
 676                         set_irn_mode(edge->src, get_ppc32_mode_Cond());
 677         }
 678
 679         if(mode_is_float(env->mode))
 680                 return new_rd_ppc32_fCmpu(env->dbg, env->irg, env->block, op1, op2, env->mode);
 681         else if(mode_is_signed(env->mode))
 682         {
 683                 if(is_16bit_signed_const(op2))
 684                 {
 685                         ir_node *cmp = new_rd_ppc32_Cmpi(env->dbg, env->irg, env->block, op1, env->mode);
 686                         tarval *tv_const = get_ppc32_constant_tarval(op2);
 687                         set_ppc32_constant_tarval(cmp, tv_const);
 688                         set_ppc32_offset_mode(cmp, ppc32_ao_None);
 689                         return cmp;
 690                 }
 691                 else
 692                 {
 693                         return new_rd_ppc32_Cmp(env->dbg, env->irg, env->block, op1, op2, env->mode);
 694                 }
 695         }
 696         else
 697         {
 698                 if(is_16bit_unsigned_const(op2))
 699                 {
 700                         ir_node *cmp = new_rd_ppc32_Cmpli(env->dbg, env->irg, env->block, op1, env->mode);
 701                         tarval *tv_const = get_ppc32_constant_tarval(op2);
 702                         set_ppc32_constant_tarval(cmp, tv_const);
 703                         set_ppc32_offset_mode(cmp, ppc32_ao_None);
 704
 705                         return cmp;
 706                 }
 707                 else
 708                 {
 709                         return new_rd_ppc32_Cmpl(env->dbg, env->irg, env->block, op1, op2, env->mode);
 710                 }
 711         }
 712 }
 713
 714 /**
 715  * Transforms a Minus node.
 716  *
 717  * @param env   The transformation environment
 718  * @return the created ppc Minus node
 719  */
 720 static ir_node *gen_Minus(ppc32_transform_env_t *env) {
 721         ir_node *op = get_Minus_op(env->irn);
 722
 723         switch(get_nice_modecode(env->mode)){
 724                 case irm_D:
 725                 case irm_F:
 726                         return new_rd_ppc32_fNeg(env->dbg, env->irg, env->block, op, env->mode);
 727                 case irm_Is:
 728                 case irm_Iu:
 729                 case irm_Hs:
 730                 case irm_Hu:
 731                 case irm_Bs:
 732                 case irm_Bu:
 733                 case irm_P:
 734                         return new_rd_ppc32_Neg(env->dbg, env->irg, env->block, op, env->mode);
 735
 736                 default:
 737                         fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode));
 738                         assert(0);
 739                         return NULL;
 740         }
 741 }
 742
 743 /**
 744  * Transforms a Not node.
 745  *
 746  * @param env   The transformation environment
 747  * @return the created ppc Not node
 748  */
 749 static ir_node *gen_Not(ppc32_transform_env_t *env) {
 750         return new_rd_ppc32_Not(env->dbg, env->irg, env->block, get_Not_op(env->irn), env->mode);
 751 }
 752
 753
 754 static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, int mask)
 755 {
 756         ir_node *andi = new_rd_ppc32_Andi_dot(env->dbg, env->irg, env->block, op, mode_T);
 757         ir_node* in[1];
 758         set_ppc32_offset_mode(andi, ppc32_ao_Lo16);
 759         set_ppc32_constant_tarval(andi, new_tarval_from_long(mask, mode_Is));
 760         in[0] = new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,1);
 761         be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_condition], env->irg, env->block, 1, in);
 762         return new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,0);
 763 }
 764
 765 /**
 766  * Transforms a Conv node.
 767  *
 768  * @param env   The transformation environment
 769  * @return the created ppc Conv node
 770  */
 771 static ir_node *gen_Conv(ppc32_transform_env_t *env) {
 772         ir_node *op = get_Conv_op(env->irn);
 773         modecode from_mode=get_nice_modecode(get_irn_mode(op));
 774         modecode to_mode=get_nice_modecode(env->mode);
 775
 776 #define SKIP return op
 777
 778         if(from_mode == to_mode) SKIP;
 779
 780         switch(from_mode){
 781                 case irm_F:
 782                         switch(to_mode)
 783                         {
 784                                 case irm_D: SKIP;
 785                                 default:
 786                                         break;
 787                         }
 788                         break;
 789
 790                 case irm_D:
 791                         switch(to_mode)
 792                         {
 793                                 case irm_F:
 794                                         return new_rd_ppc32_fRsp(env->dbg, env->irg, env->block, op, env->mode);
 795                                 default:
 796                                         break;
 797                         }
 798                         break;
 799
 800                 case irm_Is:
 801                 case irm_Iu:
 802                         switch(to_mode)
 803                         {
 804                                 case irm_Hs:
 805                                         return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
 806                                 case irm_Hu:
 807                                         return own_gen_Andi_dot_lo16(env, op, 0xffff);
 808                                 case irm_Bs:
 809                                         return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
 810                                 case irm_Bu:
 811                                         return own_gen_Andi_dot_lo16(env, op, 0xff);
 812                                 case irm_Is:
 813                                 case irm_Iu:
 814                                         SKIP;
 815                                 default:
 816                                         break;
 817                         }
 818                         break;
 819
 820                 case irm_Hs:
 821                 case irm_Hu:
 822                         switch(to_mode)
 823                         {
 824                                 case irm_Iu:
 825                                         if(from_mode==irm_Hu)
 826                                 case irm_Hu:
 827                                                 return own_gen_Andi_dot_lo16(env, op, 0xffff);
 828                                 case irm_Is:
 829                                         SKIP;
 830                                 case irm_Bs:
 831                                         return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
 832                                 case irm_Bu:
 833                                         return own_gen_Andi_dot_lo16(env, op, 0xff);
 834                                 case irm_Hs:
 835                                         return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
 836                                 default:
 837                                         break;
 838                         }
 839                         break;
 840
 841                 case irm_Bs:
 842                 case irm_Bu:
 843                         switch(to_mode)
 844                         {
 845                                 case irm_Iu:
 846                                 case irm_Hu:
 847                                         if(from_mode==irm_Bs)
 848                                 case irm_Bu:
 849                                                 return own_gen_Andi_dot_lo16(env, op, 0xff);
 850                                 case irm_Is:
 851                                 case irm_Hs:
 852                                         SKIP;
 853                                 case irm_Bs:
 854                                         return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
 855                                 default:
 856                                         break;
 857                         }
 858                         break;
 859                 case irm_P:
 860                         if(to_mode==irm_Is || to_mode==irm_Iu) SKIP;
 861                         break;
 862                 default:
 863                         break;
 864         }
 865
 866         fprintf(stderr, "Mode for Conv not supported: %s -> %s\n",
 867                 get_mode_name(get_irn_mode(get_irn_n(env->irn,0))),get_mode_name(env->mode));
 868         assert(0);
 869         return NULL;
 870
 871 #undef SKIP
 872 }
 873
 874 /**
 875  * Transforms an Abs node.
 876  *
 877  * @param env   The transformation environment
 878  * @return the ppc node generating the absolute value
 879  */
 880 static ir_node *gen_Abs(ppc32_transform_env_t *env) {
 881         ir_node *op = get_Abs_op(env->irn);
 882         int shift = 7;
 883         ir_node *n1,*n2;
 884
 885         switch(get_nice_modecode(env->mode))
 886         {
 887                 case irm_F:
 888                 case irm_D:
 889                         return new_rd_ppc32_fAbs(env->dbg, env->irg, env->block, op, env->mode);
 890                 case irm_Is:
 891                         shift += 16;
 892                 case irm_Hs:
 893                         shift += 8;
 894                 case irm_Bs:
 895                         n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode);
 896                         set_ppc32_constant_tarval(n1, new_tarval_from_long(shift, mode_Is));
 897                         set_ppc32_offset_mode(n1, ppc32_ao_None);
 898                         n2 = new_rd_ppc32_Add(env->dbg, env->irg, env->block, op, n1, env->mode);
 899                         return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, n2, n1, env->mode);
 900                 default:
 901                         break;
 902         }
 903         fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode));
 904         assert(0);
 905         return NULL;
 906 }
 907
 908 /**
 909  * Transforms an Cond node.
 910  *
 911  * @param env   The transformation environment
 912  * @return a ppc branch node
 913  */
 914 static ir_node *gen_Cond(ppc32_transform_env_t *env) {
 915         ir_node *selector = get_Cond_selector(env->irn);
 916         ir_mode *projmode = get_irn_mode(selector);
 917         if(is_Proj(selector) && projmode==get_ppc32_mode_Cond())
 918         {
 919                 int projnum = get_Proj_proj(selector);
 920                 ir_node *branch = new_rd_ppc32_Branch(env->dbg, env->irg, env->block, selector, env->mode);
 921                 set_ppc32_proj_nr(branch, projnum);
 922                 return branch;
 923         }
 924         else
 925         {
 926                 ir_node *unknown_gpr = new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, mode_Is);
 927                 ir_node *unknown_cond = new_rd_ppc32_cUnknown(env->dbg, env->irg, env->block, get_ppc32_mode_Cond());
 928
 929                 ir_node *switch_node = new_rd_ppc32_Switch(env->dbg, env->irg, env->block, selector,
 930                         unknown_gpr, unknown_cond, env->mode);
 931                 set_ppc32_proj_nr(switch_node, get_Cond_defaultProj(env->irn));
 932
 933                 return switch_node;
 934         }
 935 }
 936
 937 /**
 938  * Transforms an Unknown node.
 939  *
 940  * @param env   The transformation environment
 941  * @return a ppc Unknown node
 942  */
 943 static ir_node *gen_Unknown(ppc32_transform_env_t *env) {
 944         if(mode_is_float(env->mode))
 945                 return new_rd_ppc32_fUnknown(env->dbg, env->irg, env->block, env->mode);
 946         else if (mode_is_int(env->mode))
 947                 return new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, env->mode);
 948         else
 949         {
 950                 fprintf(stderr, "Mode %s for unknown value not supported.\n", get_mode_name(env->mode));
 951                 assert(0);
 952                 return 0;
 953         }
 954 }
 955
 956 static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32_transform_env_t *env) {
 957         tarval *tv_const = NULL;
 958         ident *id_symconst = NULL;
 959
 960         if(is_ppc32_Const(ptr))
 961         {
 962                 tv_const = get_ppc32_constant_tarval(ptr);
 963                 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, tv_const, NULL);
 964         }
 965         else if(is_ppc32_SymConst(ptr))
 966         {
 967                 ir_entity *ent = get_ppc32_frame_entity(ptr);
 968                 if(is_direct_entity(ent))
 969                 {
 970                         id_symconst = get_entity_ident(ent);
 971                         ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, NULL, id_symconst);
 972                 }
 973         }
 974         *ptv = tv_const;
 975         *pid = id_symconst;
 976         return ptr;
 977 }
 978
 979 /**
 980  * Transforms a Load.
 981  *
 982  * @param env   The transformation environment
 983  * @return the created ppc Load node
 984  */
 985 static ir_node *gen_Load(ppc32_transform_env_t *env) {
 986         ir_node *node = env->irn;
 987         ir_node *loadptr = get_Load_ptr(node);
 988         ir_node *load;
 989         ir_mode *mode = get_Load_mode(node);
 990         tarval *tv_const = NULL;
 991         ident *id_symconst = NULL;
 992
 993         loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env);
 994         switch(get_nice_modecode(mode)){
 995                 case irm_Bu:
 996                         load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
 997                         break;
 998
 999                 case irm_Bs:
1000                 {
1001                         ir_node *proj_load, *extsb_node;
1002                         load =  new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1003                         proj_load = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1004                         extsb_node = new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, proj_load, mode);
1005                         exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node);
1006                         break;
1007                 }
1008
1009
1010                 case irm_Hu:
1011                         load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1012                         break;
1013                 case irm_Hs:
1014                         load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1015                         break;
1016                 case irm_Is:
1017                 case irm_Iu:
1018                 case irm_P:
1019                         load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1020                         break;
1021
1022                 case irm_D:
1023                         load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1024                         break;
1025                 case irm_F:
1026                         load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1027                         break;
1028
1029                 default:
1030                         fprintf(stderr, "Mode for Load not supported: %s\n", get_mode_name(env->mode));
1031                         assert(0);
1032                         return 0;
1033         }
1034
1035         if(tv_const)
1036         {
1037                 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1038                 set_ppc32_constant_tarval(load, tv_const);
1039         }
1040         else if(id_symconst)
1041         {
1042                 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1043                 set_ppc32_symconst_ident(load, id_symconst);
1044         }
1045         return load;
1046 }
1047
1048
1049
1050 /**
1051  * Transforms a Store.
1052  *
1053  * @param env   The transformation environment
1054  * @return the created ppc Store node
1055  */
1056 static ir_node *gen_Store(ppc32_transform_env_t *env) {
1057         ir_node *node = env->irn;
1058         ir_node *storeptr = get_Store_ptr(node);
1059         ir_node *valuenode = get_Store_value(node);
1060         ir_mode *mode = get_irn_mode(valuenode);
1061         ir_node *store;
1062         tarval *tv_const = NULL;
1063         ident *id_symconst = NULL;
1064
1065         storeptr = ldst_insert_const(storeptr, &tv_const, &id_symconst, env);
1066
1067         switch(get_nice_modecode(mode)){
1068                 case irm_Bu:
1069                 case irm_Bs:
1070                         store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1071                         break;
1072
1073                 case irm_Hu:
1074                 case irm_Hs:
1075                         store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1076                         break;
1077                 case irm_Is:
1078                 case irm_Iu:
1079                 case irm_P:
1080                         store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1081                         break;
1082
1083                 case irm_D:
1084                         store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1085                         break;
1086                 case irm_F:
1087                         store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1088                         break;
1089
1090                 default:
1091                         fprintf(stderr, "Mode for Store not supported: %s\n", get_mode_name(env->mode));
1092                         assert(0);
1093                         return 0;
1094         }
1095         if(tv_const)
1096         {
1097                 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1098                 set_ppc32_constant_tarval(store, tv_const);
1099         }
1100         else if(id_symconst)
1101         {
1102                 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1103                 set_ppc32_symconst_ident(store, id_symconst);
1104         }
1105         return store;
1106 }
1107
1108 /**
1109  * Transforms a CopyB.
1110  *
1111  * @param env   The transformation environment
1112  * @return the created ppc CopyB node
1113  */
1114 static ir_node *gen_CopyB(ppc32_transform_env_t *env) {
1115         ir_node *mem = get_CopyB_mem(env->irn);
1116         ir_node *src = get_CopyB_src(env->irn);
1117         ir_node *dest = get_CopyB_dst(env->irn);
1118         ir_type *type = get_CopyB_type(env->irn);
1119         int size = get_type_size_bytes(type);
1120         int offset = 0;
1121
1122         ir_node *load, *store;
1123
1124         if(size/4>=1)
1125         {
1126                 ir_node *res;
1127                 tarval *offset0 = new_tarval_from_long(0, mode_Is);
1128                 tarval *offset4 = new_tarval_from_long(4, mode_Is);
1129
1130                 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1131                 set_ppc32_constant_tarval(load, offset0);
1132                 set_ppc32_offset_mode(load, ppc32_ao_None);
1133                 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1134                 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1135
1136                 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1137                 set_ppc32_constant_tarval(store, offset0);
1138                 set_ppc32_offset_mode(store, ppc32_ao_None);
1139                 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1140
1141                 if(size/4==2)
1142                 {
1143                         load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1144                         set_ppc32_constant_tarval(load, offset4);
1145                         set_ppc32_offset_mode(load, ppc32_ao_None);
1146                         mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1147                         res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1148
1149                         store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1150                         set_ppc32_constant_tarval(store, offset4);
1151                         set_ppc32_offset_mode(store, ppc32_ao_None);
1152                         mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1153
1154                         offset = 8;
1155                 }
1156                 else
1157                 {
1158                         ir_node *ornode, *mtctrnode;
1159                         ir_node* in[3];
1160                         assert(size/4-1<=0xffff);
1161                         if(size/4-1<0x8000)
1162                         {
1163                                 ornode = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1164                                 set_ppc32_offset_mode(ornode, ppc32_ao_None);
1165                         }
1166                         else
1167                         {
1168                                 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1169                                 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1170                                 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1171                                 ornode = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1172                                 set_ppc32_offset_mode(ornode, ppc32_ao_Lo16);
1173                         }
1174
1175                         set_ppc32_constant_tarval(ornode, new_tarval_from_long(size/4-1, mode_Is));
1176                         mtctrnode = new_rd_ppc32_Mtctr(env->dbg, env->irg, env->block, ornode, mode_Is);
1177                         store = new_rd_ppc32_LoopCopy(env->dbg, env->irg, env->block, src, dest, mtctrnode, mem, mode_T);
1178
1179                         in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 1); // src
1180                         in[1] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 2); // dest
1181                         in[2] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 4); // temp
1182                         be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_gp], env->irg, env->block, 3, in);
1183                         in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 3); // ctr
1184                         be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_count], env->irg, env->block, 1, in);
1185
1186                         mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, 0);
1187
1188                         offset = 4;
1189                 }
1190         }
1191
1192         if(size & 2)
1193         {
1194                 ir_node *res;
1195                 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1196                 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem);
1197                 set_ppc32_constant_tarval(load, offset_tarval);
1198                 set_ppc32_offset_mode(load, ppc32_ao_None);
1199                 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1200                 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1201
1202                 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem);
1203                 set_ppc32_constant_tarval(store, offset_tarval);
1204                 set_ppc32_offset_mode(store, ppc32_ao_None);
1205                 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1206
1207                 offset += 2;
1208         }
1209
1210         if(size & 1)
1211         {
1212                 ir_node *res;
1213                 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1214                 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem);
1215                 set_ppc32_constant_tarval(load, offset_tarval);
1216                 set_ppc32_offset_mode(load, ppc32_ao_None);
1217                 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1218                 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1219
1220                 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem);
1221                 set_ppc32_constant_tarval(store, offset_tarval);
1222                 set_ppc32_offset_mode(store, ppc32_ao_None);
1223                 // mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1224         }
1225
1226         return store;
1227 }
1228
1229 /**
1230  * Transforms a FrameAddr into a ppc Add.
1231  *
1232  * @param env   The transformation environment
1233  */
1234 static ir_node *gen_be_FrameAddr(ppc32_transform_env_t *env) {
1235         ir_node *op = get_irn_n(env->irn, 0);
1236         ir_node *add = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op, mode_P);
1237         set_ppc32_frame_entity(add, be_get_frame_entity(env->irn));
1238         return add;
1239 }
1240
1241 /**
1242  * Transforms a StackParam into a ppc Load
1243  *
1244  * @param env   The transformation environment
1245  */
1246 static ir_node *gen_be_StackParam(ppc32_transform_env_t *env) {
1247         ir_node *load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, get_irn_n(env->irn, 0), new_NoMem());
1248         ir_node *proj = new_rd_Proj(env->dbg, env->irg, env->block, load, env->mode, pn_Load_res);
1249         set_ppc32_frame_entity(load, be_get_frame_entity(env->irn));
1250         return proj;
1251 }
1252
1253
1254 /*********************************************************
1255  *                  _             _      _
1256  *                 (_)           | |    (_)
1257  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
1258  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
1259  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
1260  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
1261  *
1262  *********************************************************/
1263
1264 /**
1265  * the BAD transformer.
1266  */
1267 static ir_node *bad_transform(ppc32_transform_env_t *env) {
1268         ir_fprintf(stderr, "Not implemented: %+F\n", env->irn);
1269         assert(0);
1270         return NULL;
1271 }
1272
1273 /**
1274  * Enters all transform functions into the generic pointer
1275  */
1276 void ppc32_register_transformers(void) {
1277         ir_op *op_Max, *op_Min, *op_Mulh;
1278
1279         /* first clear the generic function pointer for all ops */
1280         clear_irp_opcodes_generic_func();
1281
1282 #define FIRM_OP(a)     op_##a->ops.generic = (op_func)gen_##a
1283 #define BAD(a)         op_##a->ops.generic = (op_func)bad_transform
1284 #define IGN(a)
1285
1286         FIRM_OP(Add);
1287         FIRM_OP(Mul);
1288         FIRM_OP(And);
1289         FIRM_OP(Or);
1290         FIRM_OP(Eor);
1291
1292         FIRM_OP(Sub);
1293         FIRM_OP(Shl);
1294         FIRM_OP(Shr);
1295         FIRM_OP(Shrs);
1296         FIRM_OP(Rot);
1297         FIRM_OP(Quot);
1298         FIRM_OP(Div);
1299         FIRM_OP(DivMod);
1300         FIRM_OP(Mod);
1301         FIRM_OP(Cmp);
1302
1303         FIRM_OP(Minus);
1304         FIRM_OP(Not);
1305         FIRM_OP(Conv);
1306         FIRM_OP(Abs);
1307
1308         FIRM_OP(Load);
1309         FIRM_OP(Store);
1310         FIRM_OP(Cond);
1311         FIRM_OP(Unknown);
1312         FIRM_OP(CopyB);
1313
1314         /* TODO: implement these nodes */
1315         BAD(Mux);
1316
1317         /* You probably don't need to handle the following nodes */
1318
1319         IGN(Call);
1320         IGN(Proj);
1321         IGN(Alloc);
1322
1323         IGN(Block);
1324         IGN(Start);
1325         IGN(End);
1326         IGN(NoMem);
1327         IGN(Phi);
1328         IGN(IJmp);
1329         IGN(Jmp);
1330         IGN(Break);
1331         IGN(Sync);
1332
1333         BAD(Raise);
1334         BAD(Sel);
1335         BAD(InstOf);
1336         BAD(Cast);
1337         BAD(Free);
1338         BAD(Tuple);
1339         BAD(Id);
1340         BAD(Bad);
1341         BAD(Confirm);
1342         BAD(Filter);
1343         BAD(CallBegin);
1344         BAD(EndReg);
1345         BAD(EndExcept);
1346
1347         FIRM_OP(be_FrameAddr);
1348         FIRM_OP(be_StackParam);
1349         op_Mulh = get_op_Mulh();
1350         if (op_Mulh)
1351                 FIRM_OP(Mulh);
1352         op_Max = get_op_Max();
1353         if (op_Max)
1354                 BAD(Max);
1355         op_Min = get_op_Min();
1356         if (op_Min)
1357                 BAD(Min);
1358 }
1359
1360 typedef ir_node *(transform_func)(ppc32_transform_env_t *env);
1361
1362 /**
1363  * Transforms the given firm node (and maybe some other related nodes)
1364  * into one or more assembler nodes.
1365  *
1366  * @param node    the firm node
1367  * @param env     the debug module
1368  */
1369 void ppc32_transform_node(ir_node *node, void *env) {
1370         ppc32_code_gen_t *cg = (ppc32_code_gen_t *)env;
1371         ir_op *op            = get_irn_op(node);
1372         ir_node *asm_node    = NULL;
1373
1374         if (op == op_Block)
1375                 return;
1376
1377         DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
1378
1379         if (op->ops.generic) {
1380                 ppc32_transform_env_t tenv;
1381                 transform_func *transform = (transform_func *)op->ops.generic;
1382
1383                 tenv.block    = get_nodes_block(node);
1384                 tenv.dbg      = get_irn_dbg_info(node);
1385                 tenv.irg      = current_ir_graph;
1386                 tenv.irn      = node;
1387                 tenv.mode     = get_irn_mode(node);
1388                 DEBUG_ONLY(tenv.mod = cg->mod;)
1389
1390                 asm_node = (*transform)(&tenv);
1391         }
1392
1393         if (asm_node) {
1394                 exchange(node, asm_node);
1395                 DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1396         }
1397         else {
1398                 DB((cg->mod, LEVEL_1, "ignored\n"));
1399         }
1400 }
1401
1402 /**
1403  * Constant generating code
1404  */
1405
1406 struct tv_ent {
1407         ir_entity *ent;
1408         tarval *tv;
1409 };
1410
1411 /** Compares two (entity, tarval) combinations */
1412 static int cmp_tv_ent(const void *a, const void *b, size_t len) {
1413         const struct tv_ent *e1 = a;
1414         const struct tv_ent *e2 = b;
1415
1416         return !(e1->tv == e2->tv);
1417 }
1418
1419 /** Generates a SymConst node for a known FP const */
1420 static ir_node *gen_fp_known_symconst(ppc32_transform_env_t *env, tarval *known_const) {
1421         static set    *const_set = NULL;
1422         static ir_type *tp = NULL;
1423         struct tv_ent  key;
1424         struct tv_ent *entry;
1425         ir_node       *cnst,*symcnst;
1426         ir_graph      *rem;
1427         ir_entity     *ent;
1428
1429         if(!const_set)
1430                 const_set = new_set(cmp_tv_ent, 10);
1431         if(!tp)
1432                 tp = new_type_primitive(new_id_from_str("const_double_t"), env->mode);
1433
1434         key.tv  = known_const;
1435         key.ent = NULL;
1436
1437         entry = set_insert(const_set, &key, sizeof(key), HASH_PTR(key.tv));
1438
1439         if(!entry->ent) {
1440                 char buf[80];
1441                 sprintf(buf, "const_%ld", get_irn_node_nr(env->irn));
1442                 ent = new_entity(get_glob_type(), new_id_from_str(buf), tp);
1443
1444                 set_entity_ld_ident(ent, get_entity_ident(ent));
1445                 set_entity_visibility(ent, visibility_local);
1446                 set_entity_variability(ent, variability_constant);
1447                 set_entity_allocation(ent, allocation_static);
1448
1449                 /* we create a new entity here: It's initialization must resist on the
1450                     const code irg */
1451                 rem = current_ir_graph;
1452                 current_ir_graph = get_const_code_irg();
1453                 cnst = new_Const(env->mode, key.tv);
1454                 current_ir_graph = rem;
1455
1456                 set_atomic_ent_value(ent, cnst);
1457
1458                 /* set the entry for hashmap */
1459                 entry->ent = ent;
1460         }                                // TODO: Wird nicht richtig in global type gesteckt, ppc32_gen_decls.c findet ihn nicht
1461
1462         symcnst = new_rd_ppc32_SymConst(env->dbg, env->irg, env->block, env->mode);
1463         set_ppc32_frame_entity(symcnst, ent);
1464         return symcnst;
1465 }
1466
1467 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env);
1468
1469 /**
1470  * Transforms a Const.
1471  *
1472  * @param mod     the debug module
1473  * @param block   the block the new node should belong to
1474  * @param node    the ir Const node
1475  * @param mode    node mode
1476  * @return the created ppc Load immediate node
1477  */
1478 static ir_node *gen_ppc32_Const(ppc32_transform_env_t *env) {
1479         tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1480         ir_node *node;
1481
1482         switch(get_nice_modecode(env->mode)){
1483                 case irm_Hu:
1484                 {
1485                         unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1486                         if(val1&0x80)
1487                         {
1488                                 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1489                                 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1490                                 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1491                                 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1492                                 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1493                                 break;
1494                         }
1495                 }
1496                 case irm_Bu:
1497                 case irm_Bs:
1498                 case irm_Hs:
1499                         node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1500                         set_ppc32_offset_mode(node, ppc32_ao_None);
1501                         break;
1502                 case irm_Is:
1503                 case irm_Iu:
1504                 case irm_P:
1505                 {
1506                         unsigned char val2 = get_tarval_sub_bits(tv_const,2);
1507                         unsigned char val3 = get_tarval_sub_bits(tv_const,3);
1508                         if(!val2 && !val3)
1509                         {
1510                                 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1511                                 if(val1&0x80)
1512                                 {
1513                                         ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1514                                         set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1515                                         set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1516                                         node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1517                                         set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1518                                 }
1519                                 else
1520                                 {
1521                                         node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1522                                         set_ppc32_offset_mode(node, ppc32_ao_None);
1523                                 }
1524                         }
1525                         else
1526                         {
1527                                 unsigned char val0 = get_tarval_sub_bits(tv_const,0);
1528                                 unsigned char val1 = get_tarval_sub_bits(tv_const,1);
1529                                 node = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, tv_const, NULL);
1530                                 if(val0 || val1)
1531                                 {
1532                                         set_ppc32_constant_tarval(node, tv_const);
1533                                         node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node, env->mode);
1534                                         set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1535                                 }
1536                         }
1537                         break;
1538                 }
1539
1540                 default:
1541                         fprintf(stderr, "Mode for Const not supported: %s\n", get_mode_name(env->mode));
1542                         assert(0);
1543                         return 0;
1544         }
1545         set_ppc32_constant_tarval(node, tv_const);
1546         return node;
1547 }
1548
1549 /**
1550  * Transforms a fConst.
1551  *
1552  * @param mod     the debug module
1553  * @param block   the block the new node should belong to
1554  * @param node    the ir Const node
1555  * @param mode    node mode
1556  * @return the created ppc float Load node
1557  */
1558 static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) {
1559         tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1560
1561         switch(get_nice_modecode(env->mode)){
1562                 case irm_D:
1563                 case irm_F:
1564                 {
1565                         ir_node *addr, *load;
1566                         ir_mode *mode = env->mode;
1567                         ir_entity *ent;
1568                         env->irn = gen_fp_known_symconst(env, tv_const);
1569                         env->mode = mode_P;
1570                         ent = get_ppc32_frame_entity(env->irn);
1571                         if(is_direct_entity(ent))
1572                         {
1573                                 ident *id_symconst = get_entity_ident(ent);
1574                                 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1575
1576                                 if(mode==mode_D)
1577                                         load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1578                                 else // mode_F
1579                                         load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1580
1581                                 set_ppc32_symconst_ident(load, id_symconst);
1582                                 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1583                         }
1584                         else
1585                         {
1586                                 addr = gen_ppc32_SymConst (env);
1587                                 if(mode==mode_D)
1588                                         load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem());
1589                                 else // mode_F
1590                                         load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem());
1591                         }
1592                         return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1593                 }
1594
1595                 default:
1596                         fprintf(stderr, "Mode for fConst not supported: %s\n", get_mode_name(env->mode));
1597                         assert(0);
1598                         return 0;
1599         }
1600         assert(0 && "Dead end!");
1601 }
1602
1603
1604 /**
1605  * Returns true, if the entity can be accessed directly,
1606  * or false, if the address must be loaded first
1607  */
1608 int is_direct_entity(ir_entity *ent) {
1609         return get_entity_visibility(ent)!=visibility_external_allocated;
1610 /*      visibility vis = get_entity_visibility(ent);
1611         if(is_Method_type(get_entity_type(ent)))
1612         {
1613                 return (vis!=visibility_external_allocated);
1614         }
1615         else
1616         {
1617                 return (vis==visibility_local);
1618         }*/
1619 }
1620
1621 /**
1622  * Transforms a SymConst.
1623  *
1624  * @param mod     the debug module
1625  * @param block   the block the new node should belong to
1626  * @param node    the ir Const node
1627  * @param mode    node mode
1628  * @return the created ppc Load immediate node
1629  */
1630 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) {
1631         ir_entity *ent = get_ppc32_frame_entity(env->irn);
1632         ident *id_symconst = get_entity_ident(ent);
1633         ir_node *node;
1634         switch(get_nice_modecode(env->mode)){
1635                 case irm_P:
1636                 {
1637                         if (is_direct_entity(ent))
1638                         {
1639                                 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, NULL, id_symconst);
1640                                 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node_addis, env->mode);
1641                                 set_ppc32_symconst_ident(node, id_symconst);
1642                                 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1643                         }
1644                         else
1645                         {
1646                                 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1647                                 node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1648                                 set_ppc32_symconst_ident(node, id_symconst);
1649                                 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1650                                 node = new_rd_Proj(env->dbg, env->irg, env->block, node, env->mode, pn_Load_res);
1651 //                              pset_insert_ptr(symbol_pset, ent);
1652                         }
1653                         break;
1654                 }
1655
1656                 default:
1657                         fprintf(stderr, "Mode for SymConst not supported: %s\n", get_mode_name(env->mode));
1658                         assert(0);
1659                         return 0;
1660         }
1661         return node;
1662 }
1663
1664 /**
1665  * Transforms the given firm node (and maybe some other related nodes)
1666  * into one or more assembler nodes.
1667  *
1668  * @param node    the firm node
1669  * @param env     the debug module
1670  */
1671 void ppc32_transform_const(ir_node *node, void *env) {
1672         ppc32_code_gen_t *cgenv    = (ppc32_code_gen_t *)env;
1673         ir_node          *asm_node = NULL;
1674         ppc32_transform_env_t tenv;
1675
1676         if (is_Block(node))
1677                 return;
1678
1679         tenv.block = get_nodes_block(node);
1680         tenv.dbg   = get_irn_dbg_info(node);
1681         tenv.irg   = current_ir_graph;
1682         tenv.irn   = node;
1683         DEBUG_ONLY(tenv.mod   = cgenv->mod;)
1684         tenv.mode  = get_irn_mode(node);
1685
1686 #define OTHER_GEN(a)                        \
1687         if (get_irn_op(node) == get_op_##a()) { \
1688                 asm_node = gen_##a(&tenv);          \
1689         }
1690
1691         DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1692
1693         OTHER_GEN(ppc32_Const)
1694         else OTHER_GEN(ppc32_fConst)
1695         else OTHER_GEN(ppc32_SymConst)
1696
1697         if (asm_node) {
1698                 exchange(node, asm_node);
1699                 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1700         }
1701         else {
1702                 DB((tenv.mod, LEVEL_1, "ignored\n"));
1703         }
1704 #undef OTHER_GEN
1705 }