2 * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
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.
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.
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
22 * @brief The codegenerator (transform FIRM into ppc FIRM)
23 * @author Moritz Kroll, Jens Mueller
31 #include "irgraph_t.h"
35 #include "iredges_t.h"
42 #include "../benode_t.h"
43 #include "bearch_ppc32_t.h"
45 #include "ppc32_nodes_attr.h"
47 #include "ppc32_transform.h"
48 #include "ppc32_new_nodes.h"
49 #include "ppc32_map_regs.h"
51 #include "gen_ppc32_regalloc_if.h"
53 extern ir_op *get_op_Mulh(void);
55 int is_direct_entity(ir_entity *ent);
57 ir_mode* ppc32_mode_Cond = NULL;
60 * Returns the proj of a given node with the given proj number
62 static INLINE ir_node *get_succ_Proj(ir_node *node, long proj)
64 const ir_edge_t *edge;
65 foreach_out_edge(node, edge)
67 if (is_Proj(edge->src) && get_Proj_proj(edge->src) == proj)
74 * Returns a singleton condition mode
76 ir_mode *get_ppc32_mode_Cond(void) {
78 return ppc32_mode_Cond;
80 ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_int_number, 4, 0, irma_none, 0);
81 return ppc32_mode_Cond;
86 * Calculates the ir_modecode with size, sort and signed attributes
88 ir_modecode get_nice_modecode(ir_mode *irmode)
90 ir_modecode mode = irm_max;
91 int sign = mode_is_signed(irmode);
92 int bits = get_mode_size_bits(irmode);
93 if(mode_is_int(irmode))
98 mode = sign ? irm_Bs : irm_Bu;
101 mode = sign ? irm_Hs : irm_Hu;
104 mode = sign ? irm_Is : irm_Iu;
108 else if(mode_is_float(irmode))
120 else if(mode_is_reference(irmode))
133 * Returns true, if the given node is a Const node and it's value fits into
134 * a signed 16-bit variable
136 int is_16bit_signed_const(ir_node *node)
140 if(!is_ppc32_Const(node)) return 0;
142 tv_const = get_ppc32_constant_tarval(node);
144 switch(get_nice_modecode(get_irn_mode(node)))
153 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
154 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
162 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
170 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
171 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
172 if(val2==0 && val3==0)
174 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
179 if(!(val2==0xff && val3==0xff))
181 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
189 fprintf(stderr, "is_16bit_signed_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
196 * Returns true, if the given node is a Const node and it's value fits into
197 * a unsigned 16-bit variable
199 int is_16bit_unsigned_const(ir_node *node)
203 if(!is_ppc32_Const(node)) return 0;
205 tv_const = get_ppc32_constant_tarval(node);
206 switch(get_nice_modecode(get_irn_mode(node)))
217 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
218 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
224 fprintf(stderr, "is_16bit_unsigned_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
231 /****************************************************************************************************
233 * | | | | / _| | | (_)
234 * _ __ ___ __| | ___ | |_ _ __ __ _ _ __ ___| |_ ___ _ __ _ __ ___ __ _| |_ _ ___ _ __
235 * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __| _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
236 * | | | | (_) | (_| | __/ | |_| | | (_| | | | \__ \ || (_) | | | | | | | | (_| | |_| | (_) | | | |
237 * |_| |_|\___/ \__,_|\___| \__|_| \__,_|_| |_|___/_| \___/|_| |_| |_| |_|\__,_|\__|_|\___/|_| |_|
239 ****************************************************************************************************/
242 * Creates an ppc Add.
244 * @param env The transformation environment
245 * @return the created ppc Add node
247 static ir_node *gen_Add(ppc32_transform_env_t *env) {
248 ir_node *op1 = get_Add_left(env->irn);
249 ir_node *op2 = get_Add_right(env->irn);
251 switch(get_nice_modecode(env->mode)){
253 return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode);
255 return new_rd_ppc32_fAdds(env->dbg, env->irg, env->block, op1, op2, env->mode);
263 if(is_16bit_signed_const(op1))
265 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op2, env->mode);
266 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op1));
267 set_ppc32_offset_mode(addnode, ppc32_ao_None);
270 if(is_16bit_signed_const(op2))
272 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op1, env->mode);
273 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op2));
274 set_ppc32_offset_mode(addnode, ppc32_ao_None);
278 return new_rd_ppc32_Add(env->dbg, env->irg, env->block, op1, op2, env->mode);
281 fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode));
288 * Creates an ppc Mul.
290 * @param env The transformation environment
291 * @return the created ppc Mul node
293 static ir_node *gen_Mul(ppc32_transform_env_t *env) {
294 ir_node *op1 = get_Mul_left(env->irn);
295 ir_node *op2 = get_Mul_right(env->irn);
297 switch(get_nice_modecode(env->mode)){
299 return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
301 return new_rd_ppc32_fMuls(env->dbg, env->irg, env->block, op1, op2, env->mode);
308 return new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, op1, op2, env->mode);
312 fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode));
319 * Creates an ppc Mulh.
321 * @param env The transformation environment
322 * @return the created ppc Mulh node
324 static ir_node *gen_Mulh(ppc32_transform_env_t *env) {
325 ir_node *op1 = get_irn_n(env->irn, 0);
326 ir_node *op2 = get_irn_n(env->irn, 1);
328 switch(get_nice_modecode(env->mode)){
332 return new_rd_ppc32_Mulhw(env->dbg, env->irg, env->block, op1, op2, env->mode);
337 return new_rd_ppc32_Mulhwu(env->dbg, env->irg, env->block, op1, op2, env->mode);
343 fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode));
350 * Creates an ppc And.
352 * @param env The transformation environment
353 * @return the created ppc And node
355 static ir_node *gen_And(ppc32_transform_env_t *env) {
356 ir_node *op1 = get_And_left(env->irn);
357 ir_node *op2 = get_And_right(env->irn);
359 return new_rd_ppc32_And(env->dbg, env->irg, env->block, op1, op2, env->mode);
365 * @param env The transformation environment
366 * @return the created ppc Or node
368 static ir_node *gen_Or(ppc32_transform_env_t *env) {
369 ir_node *op1 = get_Or_left(env->irn);
370 ir_node *op2 = get_Or_right(env->irn);
372 return new_rd_ppc32_Or(env->dbg, env->irg, env->block, op1, op2, env->mode);
376 * Creates an ppc Xor.
378 * @param env The transformation environment
379 * @return the created ppc Xor node
381 static ir_node *gen_Eor(ppc32_transform_env_t *env) {
382 ir_node *op1 = get_Eor_left(env->irn);
383 ir_node *op2 = get_Eor_right(env->irn);
385 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, op1, op2, env->mode);
389 * Creates an ppc Sub.
391 * @param env The transformation environment
392 * @return the created ppc Sub node
394 static ir_node *gen_Sub(ppc32_transform_env_t *env) {
395 ir_node *op1 = get_Sub_left(env->irn);
396 ir_node *op2 = get_Sub_right(env->irn);
398 switch(get_nice_modecode(env->mode)){
400 return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
402 return new_rd_ppc32_fSubs(env->dbg, env->irg, env->block, op1, op2, env->mode);
410 return new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, op2, env->mode);
413 fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode));
420 * Creates an ppc floating Div.
422 * @param env The transformation environment
423 * @return the created ppc fDiv node
425 static ir_node *gen_Quot(ppc32_transform_env_t *env) {
426 ir_node *op1 = get_Quot_left(env->irn);
427 ir_node *op2 = get_Quot_right(env->irn);
429 switch(get_nice_modecode(env->mode)){
431 return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
433 return new_rd_ppc32_fDivs(env->dbg, env->irg, env->block, op1, op2, env->mode);
436 fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode));
443 * Creates an ppc integer Div.
445 * @param env The transformation environment
446 * @return the created ppc Div node
448 static ir_node *gen_Div(ppc32_transform_env_t *env) {
449 ir_node *op1 = get_Div_left(env->irn);
450 ir_node *op2 = get_Div_right(env->irn);
452 switch(get_nice_modecode(get_irn_mode(op1))){
456 return new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
461 return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
464 fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(op1)));
471 * Creates an ppc integer Div and Mod.
473 * @param env The transformation environment
474 * @return the created ppc Div node
476 static ir_node *gen_DivMod(ppc32_transform_env_t *env) {
477 ir_node *op1 = get_DivMod_left(env->irn);
478 ir_node *op2 = get_DivMod_right(env->irn);
479 ir_node *proj_div = NULL, *proj_mod = NULL;
481 const ir_edge_t *edge;
484 foreach_out_edge(env->irn, edge)
486 if (is_Proj(edge->src))
488 switch(get_Proj_proj(edge->src)){
489 case pn_DivMod_res_div:
490 proj_div = edge->src;
492 case pn_DivMod_res_mod:
493 proj_mod = edge->src;
501 assert(proj_div!=NULL || proj_mod!=NULL);
503 res_mode = get_irn_mode(proj_div);
505 switch(get_nice_modecode(res_mode))
510 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
516 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
520 fprintf(stderr, "Mode for DivMod not supported: %s\n", get_mode_name(res_mode));
526 if (proj_div == NULL)
527 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, get_irn_mode(proj_mod), pn_DivMod_res_div);
533 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
534 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
536 exchange(proj_mod, mod_result);
543 * Creates an ppc integer Mod.
545 * @param env The transformation environment
546 * @return the created ppc Mod result node
548 static ir_node *gen_Mod(ppc32_transform_env_t *env) {
549 ir_node *op1 = get_Mod_left(env->irn);
550 ir_node *op2 = get_Mod_right(env->irn);
551 ir_node *proj_div = NULL, *proj_mod = NULL;
557 proj_mod = get_succ_Proj(env->irn, pn_Mod_res);
559 assert(proj_mod != NULL);
560 res_mode = get_irn_mode(proj_mod);
562 switch(get_nice_modecode(res_mode))
567 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
573 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
577 fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode));
583 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, res_mode, pn_DivMod_res_div);
585 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
586 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
588 exchange(proj_mod, mod_result);
594 * Creates an ppc Shl.
596 * @param env The transformation environment
597 * @return the created ppc Shl node
599 static ir_node *gen_Shl(ppc32_transform_env_t *env) {
600 ir_node *op1 = get_Shl_left(env->irn);
601 ir_node *op2 = get_Shl_right(env->irn);
603 if(is_ppc32_Const(op2))
605 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
606 tarval *tv_const = get_ppc32_constant_tarval(op2);
607 int sh = get_tarval_long(tv_const);
608 assert(0<=sh && sh<=31);
609 set_ppc32_rlwimi_const(shift, sh, 0, 31-sh);
612 return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode);
616 * Creates an ppc Srw.
618 * @param env The transformation environment
619 * @return the created ppc Shr node
621 static ir_node *gen_Shr(ppc32_transform_env_t *env) {
622 ir_node *op1 = get_Shr_left(env->irn);
623 ir_node *op2 = get_Shr_right(env->irn);
625 if(is_ppc32_Const(op2))
627 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
628 tarval *tv_const = get_ppc32_constant_tarval(op2);
629 int sh = get_tarval_long(tv_const);
630 assert(0<=sh && sh<=31);
631 set_ppc32_rlwimi_const(shift, 32-sh, sh, 31);
634 return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode);
638 * Creates an ppc Sraw.
640 * @param env The transformation environment
641 * @return the created ppc Sraw node
643 static ir_node *gen_Shrs(ppc32_transform_env_t *env) {
644 ir_node *op1 = get_Shrs_left(env->irn);
645 ir_node *op2 = get_Shrs_right(env->irn);
647 if(is_ppc32_Const(op2))
649 ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode);
650 tarval *tv_const = get_ppc32_constant_tarval(op2);
651 int sh = get_tarval_long(tv_const);
652 assert(0<=sh && sh<=31);
654 set_ppc32_constant_tarval(shift, tv_const);
655 set_ppc32_offset_mode(shift, ppc32_ao_None);
658 return new_rd_ppc32_Sraw(env->dbg, env->irg, env->block, op1, op2, env->mode);
662 * Creates an ppc Rotl.
664 * @param env The transformation environment
665 * @return the created ppc Rotl node
667 static ir_node *gen_Rotl(ppc32_transform_env_t *env) {
668 ir_node *op1 = get_Rotl_left(env->irn);
669 ir_node *op2 = get_Rotl_right(env->irn);
671 if(is_ppc32_Const(op2))
673 ir_node *rot = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
674 tarval *tv_const = get_ppc32_constant_tarval(op2);
675 int sh = get_tarval_long(tv_const);
676 assert(0<=sh && sh<=31);
677 set_ppc32_rlwimi_const(rot, sh, 0, 31);
680 return new_rd_ppc32_Rlwnm(env->dbg, env->irg, env->block, op1, op2, env->mode);
684 * Creates an ppc Cmp.
686 * @param env The transformation environment
687 * @return the created ppc Cmp node
689 static ir_node *gen_Cmp(ppc32_transform_env_t *env) {
690 ir_node *op1 = get_Cmp_left(env->irn);
691 ir_node *op2 = get_Cmp_right(env->irn);
693 const ir_edge_t *edge;
694 foreach_out_edge(env->irn, edge)
696 if (is_Proj(edge->src))
697 set_irn_mode(edge->src, get_ppc32_mode_Cond());
700 if(mode_is_float(env->mode))
701 return new_rd_ppc32_fCmpu(env->dbg, env->irg, env->block, op1, op2, env->mode);
702 else if(mode_is_signed(env->mode))
704 if(is_16bit_signed_const(op2))
706 ir_node *cmp = new_rd_ppc32_Cmpi(env->dbg, env->irg, env->block, op1, env->mode);
707 tarval *tv_const = get_ppc32_constant_tarval(op2);
708 set_ppc32_constant_tarval(cmp, tv_const);
709 set_ppc32_offset_mode(cmp, ppc32_ao_None);
714 return new_rd_ppc32_Cmp(env->dbg, env->irg, env->block, op1, op2, env->mode);
719 if(is_16bit_unsigned_const(op2))
721 ir_node *cmp = new_rd_ppc32_Cmpli(env->dbg, env->irg, env->block, op1, env->mode);
722 tarval *tv_const = get_ppc32_constant_tarval(op2);
723 set_ppc32_constant_tarval(cmp, tv_const);
724 set_ppc32_offset_mode(cmp, ppc32_ao_None);
730 return new_rd_ppc32_Cmpl(env->dbg, env->irg, env->block, op1, op2, env->mode);
736 * Transforms a Minus node.
738 * @param env The transformation environment
739 * @return the created ppc Minus node
741 static ir_node *gen_Minus(ppc32_transform_env_t *env) {
742 ir_node *op = get_Minus_op(env->irn);
744 switch(get_nice_modecode(env->mode)){
747 return new_rd_ppc32_fNeg(env->dbg, env->irg, env->block, op, env->mode);
755 return new_rd_ppc32_Neg(env->dbg, env->irg, env->block, op, env->mode);
758 fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode));
765 * Transforms a Not node.
767 * @param env The transformation environment
768 * @return the created ppc Not node
770 static ir_node *gen_Not(ppc32_transform_env_t *env) {
771 return new_rd_ppc32_Not(env->dbg, env->irg, env->block, get_Not_op(env->irn), env->mode);
775 static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, int mask)
777 ir_node *andi = new_rd_ppc32_Andi_dot(env->dbg, env->irg, env->block, op, mode_T);
779 set_ppc32_offset_mode(andi, ppc32_ao_Lo16);
780 set_ppc32_constant_tarval(andi, new_tarval_from_long(mask, mode_Is));
781 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,1);
782 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_condition], env->irg, env->block, 1, in);
783 return new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,0);
787 * Transforms a Conv node.
789 * @param env The transformation environment
790 * @return the created ppc Conv node
792 static ir_node *gen_Conv(ppc32_transform_env_t *env) {
793 ir_node *op = get_Conv_op(env->irn);
794 ir_modecode from_mode=get_nice_modecode(get_irn_mode(op));
795 ir_modecode to_mode=get_nice_modecode(env->mode);
797 #define SKIP return op
799 if(from_mode == to_mode) SKIP;
815 return new_rd_ppc32_fRsp(env->dbg, env->irg, env->block, op, env->mode);
826 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
828 return own_gen_Andi_dot_lo16(env, op, 0xffff);
830 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
832 return own_gen_Andi_dot_lo16(env, op, 0xff);
846 if(from_mode==irm_Hu)
848 return own_gen_Andi_dot_lo16(env, op, 0xffff);
852 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
854 return own_gen_Andi_dot_lo16(env, op, 0xff);
856 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
868 if(from_mode==irm_Bs)
870 return own_gen_Andi_dot_lo16(env, op, 0xff);
875 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
881 if(to_mode==irm_Is || to_mode==irm_Iu) SKIP;
887 fprintf(stderr, "Mode for Conv not supported: %s -> %s\n",
888 get_mode_name(get_irn_mode(get_irn_n(env->irn,0))),get_mode_name(env->mode));
896 * Transforms an Abs node.
898 * @param env The transformation environment
899 * @return the ppc node generating the absolute value
901 static ir_node *gen_Abs(ppc32_transform_env_t *env) {
902 ir_node *op = get_Abs_op(env->irn);
906 switch(get_nice_modecode(env->mode))
910 return new_rd_ppc32_fAbs(env->dbg, env->irg, env->block, op, env->mode);
916 n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode);
917 set_ppc32_constant_tarval(n1, new_tarval_from_long(shift, mode_Is));
918 set_ppc32_offset_mode(n1, ppc32_ao_None);
919 n2 = new_rd_ppc32_Add(env->dbg, env->irg, env->block, op, n1, env->mode);
920 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, n2, n1, env->mode);
924 fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode));
930 * Transforms an Cond node.
932 * @param env The transformation environment
933 * @return a ppc branch node
935 static ir_node *gen_Cond(ppc32_transform_env_t *env) {
936 ir_node *selector = get_Cond_selector(env->irn);
937 ir_mode *projmode = get_irn_mode(selector);
938 if(is_Proj(selector) && projmode==get_ppc32_mode_Cond())
940 int projnum = get_Proj_proj(selector);
941 ir_node *branch = new_rd_ppc32_Branch(env->dbg, env->irg, env->block, selector, env->mode);
942 set_ppc32_proj_nr(branch, projnum);
947 ir_node *unknown_gpr = new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, mode_Is);
948 ir_node *unknown_cond = new_rd_ppc32_cUnknown(env->dbg, env->irg, env->block, get_ppc32_mode_Cond());
950 ir_node *switch_node = new_rd_ppc32_Switch(env->dbg, env->irg, env->block, selector,
951 unknown_gpr, unknown_cond, env->mode);
952 set_ppc32_proj_nr(switch_node, get_Cond_defaultProj(env->irn));
959 * Transforms an Unknown node.
961 * @param env The transformation environment
962 * @return a ppc Unknown node
964 static ir_node *gen_Unknown(ppc32_transform_env_t *env) {
965 if(mode_is_float(env->mode))
966 return new_rd_ppc32_fUnknown(env->dbg, env->irg, env->block, env->mode);
967 else if (mode_is_int(env->mode))
968 return new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, env->mode);
971 fprintf(stderr, "Mode %s for unknown value not supported.\n", get_mode_name(env->mode));
977 static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32_transform_env_t *env) {
978 tarval *tv_const = NULL;
979 ident *id_symconst = NULL;
981 if(is_ppc32_Const(ptr))
983 tv_const = get_ppc32_constant_tarval(ptr);
984 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, tv_const, NULL);
986 else if(is_ppc32_SymConst(ptr))
988 ir_entity *ent = get_ppc32_frame_entity(ptr);
989 if(is_direct_entity(ent))
991 id_symconst = get_entity_ident(ent);
992 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, NULL, id_symconst);
1001 * Transforms a Load.
1003 * @param env The transformation environment
1004 * @return the created ppc Load node
1006 static ir_node *gen_Load(ppc32_transform_env_t *env) {
1007 ir_node *node = env->irn;
1008 ir_node *loadptr = get_Load_ptr(node);
1010 ir_mode *mode = get_Load_mode(node);
1011 tarval *tv_const = NULL;
1012 ident *id_symconst = NULL;
1014 loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env);
1015 switch(get_nice_modecode(mode)){
1017 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1022 ir_node *proj_load, *extsb_node;
1023 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1024 proj_load = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1025 extsb_node = new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, proj_load, mode);
1026 exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node);
1032 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1035 load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1040 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1044 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1047 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1051 fprintf(stderr, "Mode for Load not supported: %s\n", get_mode_name(env->mode));
1058 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1059 set_ppc32_constant_tarval(load, tv_const);
1061 else if(id_symconst)
1063 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1064 set_ppc32_symconst_ident(load, id_symconst);
1072 * Transforms a Store.
1074 * @param env The transformation environment
1075 * @return the created ppc Store node
1077 static ir_node *gen_Store(ppc32_transform_env_t *env) {
1078 ir_node *node = env->irn;
1079 ir_node *storeptr = get_Store_ptr(node);
1080 ir_node *valuenode = get_Store_value(node);
1081 ir_mode *mode = get_irn_mode(valuenode);
1083 tarval *tv_const = NULL;
1084 ident *id_symconst = NULL;
1086 storeptr = ldst_insert_const(storeptr, &tv_const, &id_symconst, env);
1088 switch(get_nice_modecode(mode)){
1091 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1096 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1101 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1105 store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1108 store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1112 fprintf(stderr, "Mode for Store not supported: %s\n", get_mode_name(env->mode));
1118 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1119 set_ppc32_constant_tarval(store, tv_const);
1121 else if(id_symconst)
1123 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1124 set_ppc32_symconst_ident(store, id_symconst);
1130 * Transforms a CopyB.
1132 * @param env The transformation environment
1133 * @return the created ppc CopyB node
1135 static ir_node *gen_CopyB(ppc32_transform_env_t *env) {
1136 ir_node *mem = get_CopyB_mem(env->irn);
1137 ir_node *src = get_CopyB_src(env->irn);
1138 ir_node *dest = get_CopyB_dst(env->irn);
1139 ir_type *type = get_CopyB_type(env->irn);
1140 int size = get_type_size_bytes(type);
1143 ir_node *load, *store = NULL;
1148 tarval *offset0 = new_tarval_from_long(0, mode_Is);
1149 tarval *offset4 = new_tarval_from_long(4, mode_Is);
1151 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1152 set_ppc32_constant_tarval(load, offset0);
1153 set_ppc32_offset_mode(load, ppc32_ao_None);
1154 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1155 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1157 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1158 set_ppc32_constant_tarval(store, offset0);
1159 set_ppc32_offset_mode(store, ppc32_ao_None);
1160 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1164 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1165 set_ppc32_constant_tarval(load, offset4);
1166 set_ppc32_offset_mode(load, ppc32_ao_None);
1167 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1168 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1170 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1171 set_ppc32_constant_tarval(store, offset4);
1172 set_ppc32_offset_mode(store, ppc32_ao_None);
1173 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1179 ir_node *ornode, *mtctrnode;
1181 assert(size/4-1<=0xffff);
1184 ornode = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1185 set_ppc32_offset_mode(ornode, ppc32_ao_None);
1189 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1190 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1191 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1192 ornode = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1193 set_ppc32_offset_mode(ornode, ppc32_ao_Lo16);
1196 set_ppc32_constant_tarval(ornode, new_tarval_from_long(size/4-1, mode_Is));
1197 mtctrnode = new_rd_ppc32_Mtctr(env->dbg, env->irg, env->block, ornode, mode_Is);
1198 store = new_rd_ppc32_LoopCopy(env->dbg, env->irg, env->block, src, dest, mtctrnode, mem, mode_T);
1200 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 1); // src
1201 in[1] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 2); // dest
1202 in[2] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 4); // temp
1203 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_gp], env->irg, env->block, 3, in);
1204 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 3); // ctr
1205 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_count], env->irg, env->block, 1, in);
1207 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, 0);
1216 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1217 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem);
1218 set_ppc32_constant_tarval(load, offset_tarval);
1219 set_ppc32_offset_mode(load, ppc32_ao_None);
1220 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1221 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1223 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem);
1224 set_ppc32_constant_tarval(store, offset_tarval);
1225 set_ppc32_offset_mode(store, ppc32_ao_None);
1226 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1234 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1235 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem);
1236 set_ppc32_constant_tarval(load, offset_tarval);
1237 set_ppc32_offset_mode(load, ppc32_ao_None);
1238 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1239 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1241 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem);
1242 set_ppc32_constant_tarval(store, offset_tarval);
1243 set_ppc32_offset_mode(store, ppc32_ao_None);
1244 // mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1251 * Transforms a FrameAddr into a ppc Add.
1253 * @param env The transformation environment
1255 static ir_node *gen_be_FrameAddr(ppc32_transform_env_t *env) {
1256 ir_node *op = get_irn_n(env->irn, 0);
1257 ir_node *add = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op, mode_P);
1258 set_ppc32_frame_entity(add, be_get_frame_entity(env->irn));
1263 /*********************************************************
1266 * _ __ ___ __ _ _ _ __ __| |_ __ ___ _____ _ __
1267 * | '_ ` _ \ / _` | | '_ \ / _` | '__| \ \ / / _ \ '__|
1268 * | | | | | | (_| | | | | | | (_| | | | |\ V / __/ |
1269 * |_| |_| |_|\__,_|_|_| |_| \__,_|_| |_| \_/ \___|_|
1271 *********************************************************/
1274 * the BAD transformer.
1276 static ir_node *bad_transform(ppc32_transform_env_t *env) {
1277 ir_fprintf(stderr, "Not implemented: %+F\n", env->irn);
1283 * Enters all transform functions into the generic pointer
1285 void ppc32_register_transformers(void) {
1286 ir_op *op_Max, *op_Min, *op_Mulh;
1288 /* first clear the generic function pointer for all ops */
1289 clear_irp_opcodes_generic_func();
1291 #define FIRM_OP(a) op_##a->ops.generic = (op_func)gen_##a
1292 #define BAD(a) op_##a->ops.generic = (op_func)bad_transform
1323 /* TODO: implement these nodes */
1326 /* You probably don't need to handle the following nodes */
1356 FIRM_OP(be_FrameAddr);
1357 op_Mulh = get_op_Mulh();
1360 op_Max = get_op_Max();
1363 op_Min = get_op_Min();
1368 typedef ir_node *(transform_func)(ppc32_transform_env_t *env);
1371 * Transforms the given firm node (and maybe some other related nodes)
1372 * into one or more assembler nodes.
1374 * @param node the firm node
1375 * @param env the debug module
1377 void ppc32_transform_node(ir_node *node, void *env) {
1378 ppc32_code_gen_t *cg = (ppc32_code_gen_t *)env;
1379 ir_op *op = get_irn_op(node);
1380 ir_node *asm_node = NULL;
1386 DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
1388 if (op->ops.generic) {
1389 ppc32_transform_env_t tenv;
1390 transform_func *transform = (transform_func *)op->ops.generic;
1392 tenv.block = get_nodes_block(node);
1393 tenv.dbg = get_irn_dbg_info(node);
1394 tenv.irg = current_ir_graph;
1396 tenv.mode = get_irn_mode(node);
1397 DEBUG_ONLY(tenv.mod = cg->mod;)
1399 asm_node = (*transform)(&tenv);
1403 exchange(node, asm_node);
1404 DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1407 DB((cg->mod, LEVEL_1, "ignored\n"));
1412 * Constant generating code
1420 /** Compares two (entity, tarval) combinations */
1421 static int cmp_tv_ent(const void *a, const void *b, size_t len) {
1422 const struct tv_ent *e1 = a;
1423 const struct tv_ent *e2 = b;
1426 return !(e1->tv == e2->tv);
1429 /** Generates a SymConst node for a known FP const */
1430 static ir_node *gen_fp_known_symconst(ppc32_transform_env_t *env, tarval *known_const) {
1431 static set *const_set = NULL;
1432 static ir_type *tp = NULL;
1434 struct tv_ent *entry;
1435 ir_node *cnst,*symcnst;
1437 ir_entity *ent = NULL;
1440 const_set = new_set(cmp_tv_ent, 10);
1442 tp = new_type_primitive(new_id_from_str("const_double_t"), env->mode);
1444 key.tv = known_const;
1447 entry = set_insert(const_set, &key, sizeof(key), HASH_PTR(key.tv));
1451 sprintf(buf, "const_%ld", get_irn_node_nr(env->irn));
1452 ent = new_entity(get_glob_type(), new_id_from_str(buf), tp);
1454 set_entity_ld_ident(ent, get_entity_ident(ent));
1455 set_entity_visibility(ent, visibility_local);
1456 set_entity_variability(ent, variability_constant);
1457 set_entity_allocation(ent, allocation_static);
1459 /* we create a new entity here: It's initialization must resist on the
1461 rem = current_ir_graph;
1462 current_ir_graph = get_const_code_irg();
1463 cnst = new_Const(env->mode, key.tv);
1464 current_ir_graph = rem;
1466 set_atomic_ent_value(ent, cnst);
1468 /* set the entry for hashmap */
1470 } // TODO: Wird nicht richtig in global type gesteckt, ppc32_gen_decls.c findet ihn nicht
1472 symcnst = new_rd_ppc32_SymConst(env->dbg, env->irg, env->block, env->mode);
1473 set_ppc32_frame_entity(symcnst, ent);
1477 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env);
1480 * Transforms a Const.
1482 * @param mod the debug module
1483 * @param block the block the new node should belong to
1484 * @param node the ir Const node
1485 * @param mode node mode
1486 * @return the created ppc Load immediate node
1488 static ir_node *gen_ppc32_Const(ppc32_transform_env_t *env) {
1489 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1492 switch(get_nice_modecode(env->mode)){
1495 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1498 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1499 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1500 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1501 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1502 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1509 node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1510 set_ppc32_offset_mode(node, ppc32_ao_None);
1516 unsigned char val2 = get_tarval_sub_bits(tv_const,2);
1517 unsigned char val3 = get_tarval_sub_bits(tv_const,3);
1520 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1523 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1524 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1525 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1526 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1527 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1531 node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1532 set_ppc32_offset_mode(node, ppc32_ao_None);
1537 unsigned char val0 = get_tarval_sub_bits(tv_const,0);
1538 unsigned char val1 = get_tarval_sub_bits(tv_const,1);
1539 node = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, tv_const, NULL);
1542 set_ppc32_constant_tarval(node, tv_const);
1543 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node, env->mode);
1544 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1551 fprintf(stderr, "Mode for Const not supported: %s\n", get_mode_name(env->mode));
1555 set_ppc32_constant_tarval(node, tv_const);
1560 * Transforms a fConst.
1562 * @param mod the debug module
1563 * @param block the block the new node should belong to
1564 * @param node the ir Const node
1565 * @param mode node mode
1566 * @return the created ppc float Load node
1568 static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) {
1569 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1571 switch(get_nice_modecode(env->mode)){
1575 ir_node *addr, *load;
1576 ir_mode *mode = env->mode;
1578 env->irn = gen_fp_known_symconst(env, tv_const);
1580 ent = get_ppc32_frame_entity(env->irn);
1581 if(is_direct_entity(ent))
1583 ident *id_symconst = get_entity_ident(ent);
1584 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1587 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1589 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1591 set_ppc32_symconst_ident(load, id_symconst);
1592 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1596 addr = gen_ppc32_SymConst (env);
1598 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem());
1600 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem());
1602 return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1606 fprintf(stderr, "Mode for fConst not supported: %s\n", get_mode_name(env->mode));
1610 assert(0 && "Dead end!");
1615 * Returns true, if the entity can be accessed directly,
1616 * or false, if the address must be loaded first
1618 int is_direct_entity(ir_entity *ent) {
1619 return get_entity_visibility(ent) != visibility_external_allocated;
1620 /* visibility vis = get_entity_visibility(ent);
1621 if(is_Method_type(get_entity_type(ent)))
1623 return (vis!=visibility_external_allocated);
1627 return (vis==visibility_local);
1632 * Transforms a SymConst.
1634 * @param mod the debug module
1635 * @param block the block the new node should belong to
1636 * @param node the ir Const node
1637 * @param mode node mode
1638 * @return the created ppc Load immediate node
1640 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) {
1641 ir_entity *ent = get_ppc32_frame_entity(env->irn);
1642 ident *id_symconst = get_entity_ident(ent);
1644 switch(get_nice_modecode(env->mode)){
1647 if (is_direct_entity(ent))
1649 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, NULL, id_symconst);
1650 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node_addis, env->mode);
1651 set_ppc32_symconst_ident(node, id_symconst);
1652 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1656 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1657 node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1658 set_ppc32_symconst_ident(node, id_symconst);
1659 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1660 node = new_rd_Proj(env->dbg, env->irg, env->block, node, env->mode, pn_Load_res);
1666 fprintf(stderr, "Mode for SymConst not supported: %s\n", get_mode_name(env->mode));
1674 * Transforms the given firm node (and maybe some other related nodes)
1675 * into one or more assembler nodes.
1677 * @param node the firm node
1678 * @param env the debug module
1680 void ppc32_transform_const(ir_node *node, void *env) {
1681 ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env;
1682 ir_node *asm_node = NULL;
1683 ppc32_transform_env_t tenv;
1689 tenv.block = get_nodes_block(node);
1690 tenv.dbg = get_irn_dbg_info(node);
1691 tenv.irg = current_ir_graph;
1693 DEBUG_ONLY(tenv.mod = cgenv->mod;)
1694 tenv.mode = get_irn_mode(node);
1696 #define OTHER_GEN(a) \
1697 if (get_irn_op(node) == get_op_##a()) { \
1698 asm_node = gen_##a(&tenv); \
1701 DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1703 OTHER_GEN(ppc32_Const)
1704 else OTHER_GEN(ppc32_fConst)
1705 else OTHER_GEN(ppc32_SymConst)
1708 exchange(node, asm_node);
1709 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1712 DB((tenv.mod, LEVEL_1, "ignored\n"));