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
29 #include "irgraph_t.h"
33 #include "iredges_t.h"
41 #include "../benode.h"
42 #include "bearch_ppc32_t.h"
44 #include "ppc32_nodes_attr.h"
45 #include "ppc32_transform.h"
46 #include "ppc32_new_nodes.h"
47 #include "ppc32_map_regs.h"
49 #include "gen_ppc32_regalloc_if.h"
51 extern ir_op *get_op_Mulh(void);
53 int is_direct_entity(ir_entity *ent);
55 ir_mode* ppc32_mode_Cond = NULL;
58 * Returns the proj of a given node with the given proj number
60 static inline ir_node *get_succ_Proj(ir_node *node, long proj)
62 const ir_edge_t *edge;
63 foreach_out_edge(node, edge)
65 if (is_Proj(edge->src) && get_Proj_proj(edge->src) == proj)
72 * Returns a singleton condition mode
74 ir_mode *get_ppc32_mode_Cond(void) {
76 return ppc32_mode_Cond;
78 ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_int_number, 4, 0, irma_none, 0);
79 return ppc32_mode_Cond;
84 * Calculates the ppc32_modecode with size, sort and signed attributes
86 ppc32_modecode get_nice_modecode(ir_mode *irmode)
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))
96 mode = sign ? irm_Bs : irm_Bu;
99 mode = sign ? irm_Hs : irm_Hu;
102 mode = sign ? irm_Is : irm_Iu;
106 else if(mode_is_float(irmode))
118 else if(mode_is_reference(irmode))
131 * Returns true, if the given node is a Const node and it's value fits into
132 * a signed 16-bit variable
134 int is_16bit_signed_const(ir_node *node)
138 if(!is_ppc32_Const(node)) return 0;
140 tv_const = get_ppc32_constant_tarval(node);
142 switch(get_nice_modecode(get_irn_mode(node)))
151 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
152 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
160 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
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)
172 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
177 if(!(val2==0xff && val3==0xff))
179 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
187 panic("is_16bit_signed_const(): Mode not supported: %F", get_irn_mode(node));
192 * Returns true, if the given node is a Const node and it's value fits into
193 * a unsigned 16-bit variable
195 int is_16bit_unsigned_const(ir_node *node)
199 if(!is_ppc32_Const(node)) return 0;
201 tv_const = get_ppc32_constant_tarval(node);
202 switch(get_nice_modecode(get_irn_mode(node)))
213 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
214 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
220 panic("is_16bit_unsigned_const(): Mode not supported: %F", get_irn_mode(node));
225 /****************************************************************************************************
227 * | | | | / _| | | (_)
228 * _ __ ___ __| | ___ | |_ _ __ __ _ _ __ ___| |_ ___ _ __ _ __ ___ __ _| |_ _ ___ _ __
229 * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __| _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
230 * | | | | (_) | (_| | __/ | |_| | | (_| | | | \__ \ || (_) | | | | | | | | (_| | |_| | (_) | | | |
231 * |_| |_|\___/ \__,_|\___| \__|_| \__,_|_| |_|___/_| \___/|_| |_| |_| |_|\__,_|\__|_|\___/|_| |_|
233 ****************************************************************************************************/
236 * Creates an ppc Add.
238 * @param env The transformation environment
239 * @return the created ppc Add node
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);
245 switch(get_nice_modecode(env->mode)){
247 return new_bd_ppc32_fAdd(env->dbg, env->block, op1, op2, env->mode);
249 return new_bd_ppc32_fAdds(env->dbg, env->block, op1, op2, env->mode);
257 if(is_16bit_signed_const(op1))
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);
264 if(is_16bit_signed_const(op2))
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);
272 return new_bd_ppc32_Add(env->dbg, env->block, op1, op2, env->mode);
275 panic("Mode for Add not supported: %F", env->mode);
280 * Creates an ppc Mul.
282 * @param env The transformation environment
283 * @return the created ppc Mul node
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);
289 switch(get_nice_modecode(env->mode)){
291 return new_bd_ppc32_fMul(env->dbg, env->block, op1, op2, env->mode);
293 return new_bd_ppc32_fMuls(env->dbg, env->block, op1, op2, env->mode);
300 return new_bd_ppc32_Mullw(env->dbg, env->block, op1, op2, env->mode);
304 panic("Mode for Mul not supported: %F", env->mode);
309 * Creates an ppc Mulh.
311 * @param env The transformation environment
312 * @return the created ppc Mulh node
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);
318 switch(get_nice_modecode(env->mode)){
322 return new_bd_ppc32_Mulhw(env->dbg, env->block, op1, op2, env->mode);
327 return new_bd_ppc32_Mulhwu(env->dbg, env->block, op1, op2, env->mode);
333 panic("Mode for Mulh not supported: %F", env->mode);
338 * Creates an ppc And.
340 * @param env The transformation environment
341 * @return the created ppc And node
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);
347 return new_bd_ppc32_And(env->dbg, env->block, op1, op2, env->mode);
353 * @param env The transformation environment
354 * @return the created ppc Or node
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);
360 return new_bd_ppc32_Or(env->dbg, env->block, op1, op2, env->mode);
364 * Creates an ppc Xor.
366 * @param env The transformation environment
367 * @return the created ppc Xor node
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);
373 return new_bd_ppc32_Xor(env->dbg, env->block, op1, op2, env->mode);
377 * Creates an ppc Sub.
379 * @param env The transformation environment
380 * @return the created ppc Sub node
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);
386 switch(get_nice_modecode(env->mode)){
388 return new_bd_ppc32_fSub(env->dbg, env->block, op1, op2, env->mode);
390 return new_bd_ppc32_fSubs(env->dbg, env->block, op1, op2, env->mode);
398 return new_bd_ppc32_Sub(env->dbg, env->block, op1, op2, env->mode);
401 panic("Mode for Sub not supported: %F", env->mode);
406 * Creates an ppc floating Div.
408 * @param env The transformation environment
409 * @return the created ppc fDiv node
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);
415 switch(get_nice_modecode(env->mode)){
417 return new_bd_ppc32_fDiv(env->dbg, env->block, op1, op2, env->mode);
419 return new_bd_ppc32_fDivs(env->dbg, env->block, op1, op2, env->mode);
422 panic("Mode for Quot not supported: %F", env->mode);
427 * Creates an ppc integer Div.
429 * @param env The transformation environment
430 * @return the created ppc Div node
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);
436 switch(get_nice_modecode(get_irn_mode(op1))){
440 return new_bd_ppc32_Divw(env->dbg, env->block, op1, op2, mode_T);
445 return new_bd_ppc32_Divwu(env->dbg, env->block, op1, op2, mode_T);
448 panic("Mode for Div not supported: %F", get_irn_mode(op1));
453 * Creates an ppc integer Div and Mod.
455 * @param env The transformation environment
456 * @return the created ppc Div node
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;
463 const ir_edge_t *edge;
466 foreach_out_edge(env->irn, edge)
468 if (is_Proj(edge->src))
470 switch(get_Proj_proj(edge->src)){
471 case pn_DivMod_res_div:
472 proj_div = edge->src;
474 case pn_DivMod_res_mod:
475 proj_mod = edge->src;
483 assert(proj_div!=NULL || proj_mod!=NULL);
485 res_mode = get_irn_mode(proj_div);
487 switch(get_nice_modecode(res_mode))
492 div_result = new_bd_ppc32_Divw(env->dbg, env->block, op1, op2, mode_T);
498 div_result = new_bd_ppc32_Divwu(env->dbg, env->block, op1, op2, mode_T);
502 panic("Mode for DivMod not supported: %F", res_mode);
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);
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);
515 exchange(proj_mod, mod_result);
522 * Creates an ppc integer Mod.
524 * @param env The transformation environment
525 * @return the created ppc Mod result node
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;
536 proj_mod = get_succ_Proj(env->irn, pn_Mod_res);
538 assert(proj_mod != NULL);
539 res_mode = get_irn_mode(proj_mod);
541 switch(get_nice_modecode(res_mode))
546 div_result = new_bd_ppc32_Divw(env->dbg, env->block, op1, op2, mode_T);
552 div_result = new_bd_ppc32_Divwu(env->dbg, env->block, op1, op2, mode_T);
556 fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode));
562 proj_div = new_rd_Proj(env->dbg, env->block, div_result, res_mode, pn_DivMod_res_div);
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);
567 exchange(proj_mod, mod_result);
573 * Creates an ppc Shl.
575 * @param env The transformation environment
576 * @return the created ppc Shl node
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);
582 if(is_ppc32_Const(op2))
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);
591 return new_bd_ppc32_Slw(env->dbg, env->block, op1, op2, env->mode);
595 * Creates an ppc Srw.
597 * @param env The transformation environment
598 * @return the created ppc Shr node
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);
604 if(is_ppc32_Const(op2))
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);
613 return new_bd_ppc32_Srw(env->dbg, env->block, op1, op2, env->mode);
617 * Creates an ppc Sraw.
619 * @param env The transformation environment
620 * @return the created ppc Sraw node
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);
626 if(is_ppc32_Const(op2))
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);
633 set_ppc32_constant_tarval(shift, tv_const);
634 set_ppc32_offset_mode(shift, ppc32_ao_None);
637 return new_bd_ppc32_Sraw(env->dbg, env->block, op1, op2, env->mode);
641 * Creates an ppc Rotl.
643 * @param env The transformation environment
644 * @return the created ppc Rotl node
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);
650 if(is_ppc32_Const(op2))
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);
659 return new_bd_ppc32_Rlwnm(env->dbg, env->block, op1, op2, env->mode);
663 * Creates an ppc Cmp.
665 * @param env The transformation environment
666 * @return the created ppc Cmp node
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);
672 const ir_edge_t *edge;
673 foreach_out_edge(env->irn, edge)
675 if (is_Proj(edge->src))
676 set_irn_mode(edge->src, get_ppc32_mode_Cond());
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))
683 if(is_16bit_signed_const(op2))
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);
693 return new_bd_ppc32_Cmp(env->dbg, env->block, op1, op2, env->mode);
698 if(is_16bit_unsigned_const(op2))
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);
709 return new_bd_ppc32_Cmpl(env->dbg, env->block, op1, op2, env->mode);
715 * Transforms a Minus node.
717 * @param env The transformation environment
718 * @return the created ppc Minus node
720 static ir_node *gen_Minus(ppc32_transform_env_t *env) {
721 ir_node *op = get_Minus_op(env->irn);
723 switch(get_nice_modecode(env->mode)){
726 return new_bd_ppc32_fNeg(env->dbg, env->block, op, env->mode);
734 return new_bd_ppc32_Neg(env->dbg, env->block, op, env->mode);
737 panic("Mode for Neg not supported: %F", env->mode);
742 * Transforms a Not node.
744 * @param env The transformation environment
745 * @return the created ppc Not node
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);
752 static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, int mask)
754 ir_node *andi = new_bd_ppc32_Andi_dot(env->dbg, env->block, op, mode_T);
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);
764 * Transforms a Conv node.
766 * @param env The transformation environment
767 * @return the created ppc Conv node
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);
774 #define SKIP return op
776 if(from_mode == to_mode) SKIP;
792 return new_bd_ppc32_fRsp(env->dbg, env->block, op, env->mode);
803 return new_bd_ppc32_Extsh(env->dbg, env->block, op, env->mode);
805 return own_gen_Andi_dot_lo16(env, op, 0xffff);
807 return new_bd_ppc32_Extsb(env->dbg, env->block, op, env->mode);
809 return own_gen_Andi_dot_lo16(env, op, 0xff);
823 if(from_mode==irm_Hu)
825 return own_gen_Andi_dot_lo16(env, op, 0xffff);
829 return new_bd_ppc32_Extsb(env->dbg, env->block, op, env->mode);
831 return own_gen_Andi_dot_lo16(env, op, 0xff);
833 return new_bd_ppc32_Extsh(env->dbg, env->block, op, env->mode);
845 if(from_mode==irm_Bs)
847 return own_gen_Andi_dot_lo16(env, op, 0xff);
852 return new_bd_ppc32_Extsb(env->dbg, env->block, op, env->mode);
858 if(to_mode==irm_Is || to_mode==irm_Iu) SKIP;
864 panic("Mode for Conv not supported: %F -> %F", get_irn_mode(op), env->mode);
869 * Transforms an Abs node.
871 * @param env The transformation environment
872 * @return the ppc node generating the absolute value
874 static ir_node *gen_Abs(ppc32_transform_env_t *env) {
875 ir_node *op = get_Abs_op(env->irn);
879 switch(get_nice_modecode(env->mode))
883 return new_bd_ppc32_fAbs(env->dbg, env->block, op, env->mode);
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);
897 panic("Mode for Abs not supported: %F", env->mode);
902 * Transforms an Cond node.
904 * @param env The transformation environment
905 * @return a ppc branch node
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())
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);
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());
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));
931 * Transforms an Unknown node.
933 * @param env The transformation environment
934 * @return a ppc Unknown node
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);
942 panic("Mode %F for unknown value not supported.", env->mode);
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;
949 if(is_ppc32_Const(ptr))
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);
954 else if(is_ppc32_SymConst(ptr))
956 ir_entity *ent = get_ppc32_frame_entity(ptr);
957 if(is_direct_entity(ent))
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);
971 * @param env The transformation environment
972 * @return the created ppc Load node
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);
978 ir_mode *mode = get_Load_mode(node);
979 tarval *tv_const = NULL;
980 ident *id_symconst = NULL;
982 loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env);
983 switch(get_nice_modecode(mode)){
985 load = new_bd_ppc32_Lbz(env->dbg, env->block, loadptr, get_Load_mem(node));
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);
1000 load = new_bd_ppc32_Lhz(env->dbg, env->block, loadptr, get_Load_mem(node));
1003 load =new_bd_ppc32_Lha(env->dbg, env->block, loadptr, get_Load_mem(node));
1008 load = new_bd_ppc32_Lwz(env->dbg, env->block, loadptr, get_Load_mem(node));
1012 load = new_bd_ppc32_Lfd(env->dbg, env->block, loadptr, get_Load_mem(node));
1015 load = new_bd_ppc32_Lfs(env->dbg, env->block, loadptr, get_Load_mem(node));
1019 panic("Mode for Load not supported: %F", env->mode);
1024 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1025 set_ppc32_constant_tarval(load, tv_const);
1027 else if(id_symconst)
1029 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1030 set_ppc32_symconst_ident(load, id_symconst);
1038 * Transforms a Store.
1040 * @param env The transformation environment
1041 * @return the created ppc Store node
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);
1049 tarval *tv_const = NULL;
1050 ident *id_symconst = NULL;
1052 storeptr = ldst_insert_const(storeptr, &tv_const, &id_symconst, env);
1054 switch(get_nice_modecode(mode)){
1057 store = new_bd_ppc32_Stb(env->dbg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1062 store = new_bd_ppc32_Sth(env->dbg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1067 store = new_bd_ppc32_Stw(env->dbg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1071 store = new_bd_ppc32_Stfd(env->dbg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1074 store = new_bd_ppc32_Stfs(env->dbg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1078 panic("Mode for Store not supported: %F", env->mode);
1082 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1083 set_ppc32_constant_tarval(store, tv_const);
1085 else if(id_symconst)
1087 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1088 set_ppc32_symconst_ident(store, id_symconst);
1094 * Transforms a CopyB.
1096 * @param env The transformation environment
1097 * @return the created ppc CopyB node
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);
1107 ir_node *load, *store = NULL;
1112 tarval *offset0 = new_tarval_from_long(0, mode_Is);
1113 tarval *offset4 = new_tarval_from_long(4, mode_Is);
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);
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);
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);
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);
1143 ir_node *ornode, *mtctrnode;
1145 assert(size/4-1<=0xffff);
1148 ornode = new_bd_ppc32_Addi_zero(env->dbg, env->block, mode_Is);
1149 set_ppc32_offset_mode(ornode, ppc32_ao_None);
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);
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);
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);
1171 mem = new_rd_Proj(env->dbg, env->block, store, mode_M, 0);
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);
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);
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);
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);
1215 * Transforms a FrameAddr into a ppc Add.
1217 * @param env The transformation environment
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));
1227 /*********************************************************
1230 * _ __ ___ __ _ _ _ __ __| |_ __ ___ _____ _ __
1231 * | '_ ` _ \ / _` | | '_ \ / _` | '__| \ \ / / _ \ '__|
1232 * | | | | | | (_| | | | | | | (_| | | | |\ V / __/ |
1233 * |_| |_| |_|\__,_|_|_| |_| \__,_|_| |_| \_/ \___|_|
1235 *********************************************************/
1238 * the BAD transformer.
1240 static ir_node *bad_transform(ppc32_transform_env_t *env) {
1241 panic("Transformation not implemented: %+F\n", env->irn);
1245 * Enters all transform functions into the generic pointer
1247 void ppc32_register_transformers(void) {
1248 /* first clear the generic function pointer for all ops */
1249 clear_irp_opcodes_generic_func();
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
1284 /* TODO: implement these nodes */
1287 /* You probably don't need to handle the following nodes */
1317 /* handle builtins */
1320 /* handle generic backend nodes */
1321 FIRM_OP(be_FrameAddr);
1324 typedef ir_node *(transform_func)(ppc32_transform_env_t *env);
1327 * Transforms the given firm node (and maybe some other related nodes)
1328 * into one or more assembler nodes.
1330 * @param node the firm node
1331 * @param env the debug module
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;
1342 DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
1344 if (op->ops.generic) {
1345 ppc32_transform_env_t tenv;
1346 transform_func *transform = (transform_func *)op->ops.generic;
1348 tenv.block = get_nodes_block(node);
1349 tenv.dbg = get_irn_dbg_info(node);
1350 tenv.irg = current_ir_graph;
1352 tenv.mode = get_irn_mode(node);
1353 DEBUG_ONLY(tenv.mod = cg->mod;)
1355 asm_node = (*transform)(&tenv);
1359 exchange(node, asm_node);
1360 DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1363 DB((cg->mod, LEVEL_1, "ignored\n"));
1368 * Constant generating code
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;
1382 return !(e1->tv == e2->tv);
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;
1390 struct tv_ent *entry;
1391 ir_node *cnst,*symcnst;
1393 ir_entity *ent = NULL;
1396 const_set = new_set(cmp_tv_ent, 10);
1398 tp = new_type_primitive(env->mode);
1400 key.tv = known_const;
1403 entry = set_insert(const_set, &key, sizeof(key), HASH_PTR(key.tv));
1407 sprintf(buf, "const_%ld", get_irn_node_nr(env->irn));
1408 ent = new_entity(get_glob_type(), new_id_from_str(buf), tp);
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);
1415 /* we create a new entity here: It's initialization must resist on the
1417 rem = current_ir_graph;
1418 current_ir_graph = get_const_code_irg();
1419 cnst = new_Const(key.tv);
1420 current_ir_graph = rem;
1422 set_atomic_ent_value(ent, cnst);
1424 /* set the entry for hashmap */
1426 } // TODO: Wird nicht richtig in global type gesteckt, ppc32_gen_decls.c findet ihn nicht
1428 symcnst = new_bd_ppc32_SymConst(env->dbg, env->block, env->mode);
1429 set_ppc32_frame_entity(symcnst, ent);
1433 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env);
1436 * Transforms a Const.
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
1444 static ir_node *gen_ppc32_Const(ppc32_transform_env_t *env) {
1445 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1448 switch(get_nice_modecode(env->mode)){
1451 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
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);
1465 node = new_bd_ppc32_Addi_zero(env->dbg, env->block, env->mode);
1466 set_ppc32_offset_mode(node, ppc32_ao_None);
1472 unsigned char val2 = get_tarval_sub_bits(tv_const,2);
1473 unsigned char val3 = get_tarval_sub_bits(tv_const,3);
1476 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
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);
1487 node = new_bd_ppc32_Addi_zero(env->dbg, env->block, env->mode);
1488 set_ppc32_offset_mode(node, ppc32_ao_None);
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);
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);
1507 panic("Mode for Const not supported: %F", env->mode);
1509 set_ppc32_constant_tarval(node, tv_const);
1514 * Transforms a fConst.
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
1522 static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) {
1523 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1525 switch(get_nice_modecode(env->mode)){
1529 ir_node *addr, *load;
1530 ir_mode *mode = env->mode;
1532 env->irn = gen_fp_known_symconst(env, tv_const);
1534 ent = get_ppc32_frame_entity(env->irn);
1535 if(is_direct_entity(ent))
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);
1541 load = new_bd_ppc32_Lfd(env->dbg, env->block, node_addis, new_NoMem());
1543 load = new_bd_ppc32_Lfs(env->dbg, env->block, node_addis, new_NoMem());
1545 set_ppc32_symconst_ident(load, id_symconst);
1546 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1550 addr = gen_ppc32_SymConst (env);
1552 load = new_bd_ppc32_Lfd(env->dbg, env->block, addr, new_NoMem());
1554 load = new_bd_ppc32_Lfs(env->dbg, env->block, addr, new_NoMem());
1556 return new_rd_Proj(env->dbg, env->block, load, mode, pn_Load_res);
1560 panic("Mode for fConst not supported: %F", env->mode);
1566 * Returns true, if the entity can be accessed directly,
1567 * or false, if the address must be loaded first
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)))
1574 return (vis!=visibility_external_allocated);
1578 return (vis==visibility_local);
1583 * Transforms a SymConst.
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
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);
1595 switch(get_nice_modecode(env->mode)){
1598 if (is_direct_entity(ent))
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);
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);
1617 panic("Mode for SymConst not supported: %F", env->mode);
1623 * Transforms the given firm node (and maybe some other related nodes)
1624 * into one or more assembler nodes.
1626 * @param node the firm node
1627 * @param env the debug module
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;
1638 tenv.block = get_nodes_block(node);
1639 tenv.dbg = get_irn_dbg_info(node);
1640 tenv.irg = current_ir_graph;
1642 DEBUG_ONLY(tenv.mod = cgenv->mod;)
1643 tenv.mode = get_irn_mode(node);
1645 #define OTHER_GEN(a) \
1646 if (get_irn_op(node) == get_op_##a()) { \
1647 asm_node = gen_##a(&tenv); \
1650 DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1652 OTHER_GEN(ppc32_Const)
1653 else OTHER_GEN(ppc32_fConst)
1654 else OTHER_GEN(ppc32_SymConst)
1657 exchange(node, asm_node);
1658 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1661 DB((tenv.mod, LEVEL_1, "ignored\n"));