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

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