1 /* The codegenerator (transform FIRM into ppc FIRM) */
13 #include "iredges_t.h"
21 #include "../benode_t.h"
22 #include "bearch_ppc32_t.h"
24 #include "ppc32_nodes_attr.h"
25 #include "../arch/archop.h" /* we need this for Min and Max nodes */
26 #include "ppc32_transform.h"
27 #include "ppc32_new_nodes.h"
28 #include "ppc32_map_regs.h"
30 #include "gen_ppc32_regalloc_if.h"
32 extern pset *symbol_pset;
33 extern ir_op *get_op_Mulh(void);
35 int is_direct_entity(entity *ent);
37 ir_mode* ppc32_mode_Cond = NULL;
40 * Returns the proj of a given node with the given proj number
42 static INLINE ir_node *get_succ_Proj(ir_node *node, long proj)
44 const ir_edge_t *edge;
45 foreach_out_edge(node, edge)
47 if (is_Proj(edge->src) && get_Proj_proj(edge->src) == proj)
54 * Returns a singleton condition mode
56 ir_mode *get_ppc32_mode_Cond(void) {
58 return ppc32_mode_Cond;
60 ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_character, 4, 0, irma_none, 0);
61 return ppc32_mode_Cond;
66 * Calculates the modecode with size, sort and signed attributes
68 modecode get_nice_modecode(ir_mode *irmode)
70 modecode mode = irm_max;
71 int sign = mode_is_signed(irmode);
72 int bits = get_mode_size_bits(irmode);
73 if(mode_is_int(irmode))
78 mode = sign ? irm_Bs : irm_Bu;
81 mode = sign ? irm_Hs : irm_Hu;
84 mode = sign ? irm_Is : irm_Iu;
88 else if(mode_is_float(irmode))
100 else if(mode_is_reference(irmode))
113 * Returns true, if the given node is a Const node and it's value fits into
114 * a signed 16-bit variable
116 int is_16bit_signed_const(ir_node *node)
120 if(!is_ppc32_Const(node)) return 0;
122 tv_const = get_ppc32_constant_tarval(node);
124 switch(get_nice_modecode(get_irn_mode(node)))
133 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
134 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
142 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
150 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
151 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
152 if(val2==0 && val3==0)
154 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
159 if(!(val2==0xff && val3==0xff))
161 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
169 fprintf(stderr, "is_16bit_signed_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
176 * Returns true, if the given node is a Const node and it's value fits into
177 * a unsigned 16-bit variable
179 int is_16bit_unsigned_const(ir_node *node)
183 if(!is_ppc32_Const(node)) return 0;
185 tv_const = get_ppc32_constant_tarval(node);
186 switch(get_nice_modecode(get_irn_mode(node)))
197 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
198 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
204 fprintf(stderr, "is_16bit_unsigned_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
211 /****************************************************************************************************
213 * | | | | / _| | | (_)
214 * _ __ ___ __| | ___ | |_ _ __ __ _ _ __ ___| |_ ___ _ __ _ __ ___ __ _| |_ _ ___ _ __
215 * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __| _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
216 * | | | | (_) | (_| | __/ | |_| | | (_| | | | \__ \ || (_) | | | | | | | | (_| | |_| | (_) | | | |
217 * |_| |_|\___/ \__,_|\___| \__|_| \__,_|_| |_|___/_| \___/|_| |_| |_| |_|\__,_|\__|_|\___/|_| |_|
219 ****************************************************************************************************/
222 * Creates an ppc Add.
224 * @param env The transformation environment
225 * @return the created ppc Add node
227 static ir_node *gen_Add(ppc32_transform_env_t *env) {
228 ir_node *op1 = get_Add_left(env->irn);
229 ir_node *op2 = get_Add_right(env->irn);
231 switch(get_nice_modecode(env->mode)){
233 return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode);
235 return new_rd_ppc32_fAdds(env->dbg, env->irg, env->block, op1, op2, env->mode);
243 if(is_16bit_signed_const(op1))
245 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op2, env->mode);
246 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op1));
247 set_ppc32_offset_mode(addnode, ppc32_ao_None);
250 if(is_16bit_signed_const(op2))
252 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op1, env->mode);
253 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op2));
254 set_ppc32_offset_mode(addnode, ppc32_ao_None);
258 return new_rd_ppc32_Add(env->dbg, env->irg, env->block, op1, op2, env->mode);
261 fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode));
268 * Creates an ppc Mul.
270 * @param env The transformation environment
271 * @return the created ppc Mul node
273 static ir_node *gen_Mul(ppc32_transform_env_t *env) {
274 ir_node *op1 = get_Mul_left(env->irn);
275 ir_node *op2 = get_Mul_right(env->irn);
277 switch(get_nice_modecode(env->mode)){
279 return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
281 return new_rd_ppc32_fMuls(env->dbg, env->irg, env->block, op1, op2, env->mode);
288 return new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, op1, op2, env->mode);
292 fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode));
299 * Creates an ppc Mulh.
301 * @param env The transformation environment
302 * @return the created ppc Mulh node
304 static ir_node *gen_Mulh(ppc32_transform_env_t *env) {
305 ir_node *op1 = get_irn_n(env->irn, 0);
306 ir_node *op2 = get_irn_n(env->irn, 1);
308 switch(get_nice_modecode(env->mode)){
312 return new_rd_ppc32_Mulhw(env->dbg, env->irg, env->block, op1, op2, env->mode);
317 return new_rd_ppc32_Mulhwu(env->dbg, env->irg, env->block, op1, op2, env->mode);
323 fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode));
330 * Creates an ppc And.
332 * @param env The transformation environment
333 * @return the created ppc And node
335 static ir_node *gen_And(ppc32_transform_env_t *env) {
336 ir_node *op1 = get_And_left(env->irn);
337 ir_node *op2 = get_And_right(env->irn);
339 return new_rd_ppc32_And(env->dbg, env->irg, env->block, op1, op2, env->mode);
345 * @param env The transformation environment
346 * @return the created ppc Or node
348 static ir_node *gen_Or(ppc32_transform_env_t *env) {
349 ir_node *op1 = get_Or_left(env->irn);
350 ir_node *op2 = get_Or_right(env->irn);
352 return new_rd_ppc32_Or(env->dbg, env->irg, env->block, op1, op2, env->mode);
356 * Creates an ppc Xor.
358 * @param env The transformation environment
359 * @return the created ppc Xor node
361 static ir_node *gen_Eor(ppc32_transform_env_t *env) {
362 ir_node *op1 = get_Eor_left(env->irn);
363 ir_node *op2 = get_Eor_right(env->irn);
365 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, op1, op2, env->mode);
369 * Creates an ppc Sub.
371 * @param env The transformation environment
372 * @return the created ppc Sub node
374 static ir_node *gen_Sub(ppc32_transform_env_t *env) {
375 ir_node *op1 = get_Sub_left(env->irn);
376 ir_node *op2 = get_Sub_right(env->irn);
378 switch(get_nice_modecode(env->mode)){
380 return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
382 return new_rd_ppc32_fSubs(env->dbg, env->irg, env->block, op1, op2, env->mode);
390 return new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, op2, env->mode);
393 fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode));
400 * Creates an ppc floating Div.
402 * @param env The transformation environment
403 * @return the created ppc fDiv node
405 static ir_node *gen_Quot(ppc32_transform_env_t *env) {
406 ir_node *op1 = get_Quot_left(env->irn);
407 ir_node *op2 = get_Quot_right(env->irn);
409 switch(get_nice_modecode(env->mode)){
411 return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
413 return new_rd_ppc32_fDivs(env->dbg, env->irg, env->block, op1, op2, env->mode);
416 fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode));
423 * Creates an ppc integer Div.
425 * @param env The transformation environment
426 * @return the created ppc Div node
428 static ir_node *gen_Div(ppc32_transform_env_t *env) {
429 ir_node *op1 = get_Div_left(env->irn);
430 ir_node *op2 = get_Div_right(env->irn);
432 switch(get_nice_modecode(get_irn_mode(op1))){
436 return new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
441 return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
444 fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(op1)));
451 * Creates an ppc integer Div and Mod.
453 * @param env The transformation environment
454 * @return the created ppc Div node
456 static ir_node *gen_DivMod(ppc32_transform_env_t *env) {
457 ir_node *op1 = get_DivMod_left(env->irn);
458 ir_node *op2 = get_DivMod_right(env->irn);
459 ir_node *proj_div = NULL, *proj_mod = NULL;
461 const ir_edge_t *edge;
464 foreach_out_edge(env->irn, edge)
466 if (is_Proj(edge->src))
468 switch(get_Proj_proj(edge->src)){
469 case pn_DivMod_res_div:
470 proj_div = edge->src;
472 case pn_DivMod_res_mod:
473 proj_mod = edge->src;
481 assert(proj_div!=NULL || proj_mod!=NULL);
483 res_mode = get_irn_mode(proj_div);
485 switch(get_nice_modecode(res_mode))
490 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
496 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
500 fprintf(stderr, "Mode for DivMod not supported: %s\n", get_mode_name(res_mode));
506 if (proj_div == NULL)
507 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, get_irn_mode(proj_mod), pn_DivMod_res_div);
513 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
514 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
516 exchange(proj_mod, mod_result);
523 * Creates an ppc integer Mod.
525 * @param env The transformation environment
526 * @return the created ppc Mod result node
528 static ir_node *gen_Mod(ppc32_transform_env_t *env) {
529 ir_node *op1 = get_Mod_left(env->irn);
530 ir_node *op2 = get_Mod_right(env->irn);
531 ir_node *proj_div = NULL, *proj_mod = NULL;
537 proj_mod = get_succ_Proj(env->irn, pn_Mod_res);
539 assert(proj_mod != NULL);
540 res_mode = get_irn_mode(proj_mod);
542 switch(get_nice_modecode(res_mode))
547 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
553 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
557 fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode));
563 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, res_mode, pn_DivMod_res_div);
565 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
566 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
568 exchange(proj_mod, mod_result);
574 * Creates an ppc Shl.
576 * @param env The transformation environment
577 * @return the created ppc Shl node
579 static ir_node *gen_Shl(ppc32_transform_env_t *env) {
580 ir_node *op1 = get_Shl_left(env->irn);
581 ir_node *op2 = get_Shl_right(env->irn);
583 if(is_ppc32_Const(op2))
585 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
586 tarval *tv_const = get_ppc32_constant_tarval(op2);
587 int sh = get_tarval_long(tv_const);
588 assert(0<=sh && sh<=31);
589 set_ppc32_rlwimi_const(shift, sh, 0, 31-sh);
592 return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode);
596 * Creates an ppc Srw.
598 * @param env The transformation environment
599 * @return the created ppc Shr node
601 static ir_node *gen_Shr(ppc32_transform_env_t *env) {
602 ir_node *op1 = get_Shr_left(env->irn);
603 ir_node *op2 = get_Shr_right(env->irn);
605 if(is_ppc32_Const(op2))
607 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
608 tarval *tv_const = get_ppc32_constant_tarval(op2);
609 int sh = get_tarval_long(tv_const);
610 assert(0<=sh && sh<=31);
611 set_ppc32_rlwimi_const(shift, 32-sh, sh, 31);
614 return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode);
618 * Creates an ppc Sraw.
620 * @param env The transformation environment
621 * @return the created ppc Sraw node
623 static ir_node *gen_Shrs(ppc32_transform_env_t *env) {
624 ir_node *op1 = get_Shrs_left(env->irn);
625 ir_node *op2 = get_Shrs_right(env->irn);
627 if(is_ppc32_Const(op2))
629 ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode);
630 tarval *tv_const = get_ppc32_constant_tarval(op2);
631 int sh = get_tarval_long(tv_const);
632 assert(0<=sh && sh<=31);
633 set_ppc32_constant_tarval(shift, tv_const);
634 set_ppc32_offset_mode(shift, ppc32_ao_None);
637 return new_rd_ppc32_Sraw(env->dbg, env->irg, 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_Rot(ppc32_transform_env_t *env) {
647 ir_node *op1 = get_Rot_left(env->irn);
648 ir_node *op2 = get_Rot_right(env->irn);
650 if(is_ppc32_Const(op2))
652 ir_node *rot = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
653 tarval *tv_const = get_ppc32_constant_tarval(op2);
654 int sh = get_tarval_long(tv_const);
655 assert(0<=sh && sh<=31);
656 set_ppc32_rlwimi_const(rot, sh, 0, 31);
659 return new_rd_ppc32_Rlwnm(env->dbg, env->irg, 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_rd_ppc32_fCmpu(env->dbg, env->irg, 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_rd_ppc32_Cmpi(env->dbg, env->irg, env->block, op1, env->mode);
686 tarval *tv_const = get_ppc32_constant_tarval(op2);
687 set_ppc32_constant_tarval(cmp, tv_const);
688 set_ppc32_offset_mode(cmp, ppc32_ao_None);
693 return new_rd_ppc32_Cmp(env->dbg, env->irg, env->block, op1, op2, env->mode);
698 if(is_16bit_unsigned_const(op2))
700 ir_node *cmp = new_rd_ppc32_Cmpli(env->dbg, env->irg, env->block, op1, env->mode);
701 tarval *tv_const = get_ppc32_constant_tarval(op2);
702 set_ppc32_constant_tarval(cmp, tv_const);
703 set_ppc32_offset_mode(cmp, ppc32_ao_None);
709 return new_rd_ppc32_Cmpl(env->dbg, env->irg, 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_rd_ppc32_fNeg(env->dbg, env->irg, env->block, op, env->mode);
734 return new_rd_ppc32_Neg(env->dbg, env->irg, env->block, op, env->mode);
737 fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode));
744 * Transforms a Not node.
746 * @param env The transformation environment
747 * @return the created ppc Not node
749 static ir_node *gen_Not(ppc32_transform_env_t *env) {
750 return new_rd_ppc32_Not(env->dbg, env->irg, env->block, get_Not_op(env->irn), env->mode);
754 static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, int mask)
756 ir_node *andi = new_rd_ppc32_Andi_dot(env->dbg, env->irg, env->block, op, mode_T);
758 set_ppc32_offset_mode(andi, ppc32_ao_Lo16);
759 set_ppc32_constant_tarval(andi, new_tarval_from_long(mask, mode_Is));
760 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,1);
761 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_condition], env->irg, env->block, 1, in);
762 return new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,0);
766 * Transforms a Conv node.
768 * @param env The transformation environment
769 * @return the created ppc Conv node
771 static ir_node *gen_Conv(ppc32_transform_env_t *env) {
772 ir_node *op = get_Conv_op(env->irn);
773 modecode from_mode=get_nice_modecode(get_irn_mode(op));
774 modecode to_mode=get_nice_modecode(env->mode);
776 #define SKIP return op
778 if(from_mode == to_mode) SKIP;
794 return new_rd_ppc32_fRsp(env->dbg, env->irg, env->block, op, env->mode);
805 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
807 return own_gen_Andi_dot_lo16(env, op, 0xffff);
809 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
811 return own_gen_Andi_dot_lo16(env, op, 0xff);
825 if(from_mode==irm_Hu)
827 return own_gen_Andi_dot_lo16(env, op, 0xffff);
831 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
833 return own_gen_Andi_dot_lo16(env, op, 0xff);
835 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
847 if(from_mode==irm_Bs)
849 return own_gen_Andi_dot_lo16(env, op, 0xff);
854 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
860 if(to_mode==irm_Is || to_mode==irm_Iu) SKIP;
866 fprintf(stderr, "Mode for Conv not supported: %s -> %s\n",
867 get_mode_name(get_irn_mode(get_irn_n(env->irn,0))),get_mode_name(env->mode));
875 * Transforms an Abs node.
877 * @param env The transformation environment
878 * @return the ppc node generating the absolute value
880 static ir_node *gen_Abs(ppc32_transform_env_t *env) {
881 ir_node *op = get_Abs_op(env->irn);
885 switch(get_nice_modecode(env->mode))
889 return new_rd_ppc32_fAbs(env->dbg, env->irg, env->block, op, env->mode);
895 n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode);
896 set_ppc32_constant_tarval(n1, new_tarval_from_long(shift, mode_Is));
897 set_ppc32_offset_mode(n1, ppc32_ao_None);
898 n2 = new_rd_ppc32_Add(env->dbg, env->irg, env->block, op, n1, env->mode);
899 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, n2, n1, env->mode);
903 fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode));
909 * Transforms an Cond node.
911 * @param env The transformation environment
912 * @return a ppc branch node
914 static ir_node *gen_Cond(ppc32_transform_env_t *env) {
915 ir_node *selector = get_Cond_selector(env->irn);
916 ir_mode *projmode = get_irn_mode(selector);
917 if(is_Proj(selector) && projmode==get_ppc32_mode_Cond())
919 int projnum = get_Proj_proj(selector);
920 ir_node *branch = new_rd_ppc32_Branch(env->dbg, env->irg, env->block, selector, env->mode);
921 set_ppc32_proj_nr(branch, projnum);
926 ir_node *unknown_gpr = new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, mode_Is);
927 ir_node *unknown_cond = new_rd_ppc32_cUnknown(env->dbg, env->irg, env->block, get_ppc32_mode_Cond());
929 ir_node *switch_node = new_rd_ppc32_Switch(env->dbg, env->irg, env->block, selector,
930 unknown_gpr, unknown_cond, env->mode);
931 set_ppc32_proj_nr(switch_node, get_Cond_defaultProj(env->irn));
938 * Transforms an Unknown node.
940 * @param env The transformation environment
941 * @return a ppc Unknown node
943 static ir_node *gen_Unknown(ppc32_transform_env_t *env) {
944 if(mode_is_float(env->mode))
945 return new_rd_ppc32_fUnknown(env->dbg, env->irg, env->block, env->mode);
946 else if (mode_is_int(env->mode))
947 return new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, env->mode);
950 fprintf(stderr, "Mode %s for unknown value not supported.\n", get_mode_name(env->mode));
956 static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32_transform_env_t *env) {
957 tarval *tv_const = NULL;
958 ident *id_symconst = NULL;
960 if(is_ppc32_Const(ptr))
962 tv_const = get_ppc32_constant_tarval(ptr);
963 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, tv_const, NULL);
965 else if(is_ppc32_SymConst(ptr))
967 entity *ent = get_ppc32_frame_entity(ptr);
968 if(is_direct_entity(ent))
970 id_symconst = get_entity_ident(ent);
971 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, NULL, id_symconst);
982 * @param env The transformation environment
983 * @return the created ppc Load node
985 static ir_node *gen_Load(ppc32_transform_env_t *env) {
986 ir_node *node = env->irn;
987 ir_node *loadptr = get_Load_ptr(node);
989 ir_mode *mode = get_Load_mode(node);
990 tarval *tv_const = NULL;
991 ident *id_symconst = NULL;
993 loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env);
994 switch(get_nice_modecode(mode)){
996 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1001 ir_node *proj_load, *extsb_node;
1002 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1003 proj_load = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1004 extsb_node = new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, proj_load, mode);
1005 exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node);
1011 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1014 load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1019 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1023 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1026 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1030 fprintf(stderr, "Mode for Load not supported: %s\n", get_mode_name(env->mode));
1037 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1038 set_ppc32_constant_tarval(load, tv_const);
1040 else if(id_symconst)
1042 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1043 set_ppc32_symconst_ident(load, id_symconst);
1051 * Transforms a Store.
1053 * @param env The transformation environment
1054 * @return the created ppc Store node
1056 static ir_node *gen_Store(ppc32_transform_env_t *env) {
1057 ir_node *node = env->irn;
1058 ir_node *storeptr = get_Store_ptr(node);
1059 ir_node *valuenode = get_Store_value(node);
1060 ir_mode *mode = get_irn_mode(valuenode);
1062 tarval *tv_const = NULL;
1063 ident *id_symconst = NULL;
1065 storeptr = ldst_insert_const(storeptr, &tv_const, &id_symconst, env);
1067 switch(get_nice_modecode(mode)){
1070 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1075 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1080 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1084 store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1087 store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1091 fprintf(stderr, "Mode for Store not supported: %s\n", get_mode_name(env->mode));
1097 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1098 set_ppc32_constant_tarval(store, tv_const);
1100 else if(id_symconst)
1102 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1103 set_ppc32_symconst_ident(store, id_symconst);
1109 * Transforms a CopyB.
1111 * @param env The transformation environment
1112 * @return the created ppc CopyB node
1114 static ir_node *gen_CopyB(ppc32_transform_env_t *env) {
1115 ir_node *mem = get_CopyB_mem(env->irn);
1116 ir_node *src = get_CopyB_src(env->irn);
1117 ir_node *dest = get_CopyB_dst(env->irn);
1118 ir_type *type = get_CopyB_type(env->irn);
1119 int size = get_type_size_bytes(type);
1122 ir_node *load, *store;
1127 tarval *offset0 = new_tarval_from_long(0, mode_Is);
1128 tarval *offset4 = new_tarval_from_long(4, mode_Is);
1130 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1131 set_ppc32_constant_tarval(load, offset0);
1132 set_ppc32_offset_mode(load, ppc32_ao_None);
1133 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1134 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1136 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1137 set_ppc32_constant_tarval(store, offset0);
1138 set_ppc32_offset_mode(store, ppc32_ao_None);
1139 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1143 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1144 set_ppc32_constant_tarval(load, offset4);
1145 set_ppc32_offset_mode(load, ppc32_ao_None);
1146 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1147 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1149 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1150 set_ppc32_constant_tarval(store, offset4);
1151 set_ppc32_offset_mode(store, ppc32_ao_None);
1152 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1158 ir_node *ornode, *mtctrnode;
1160 assert(size/4-1<=0xffff);
1163 ornode = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1164 set_ppc32_offset_mode(ornode, ppc32_ao_None);
1168 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1169 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1170 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1171 ornode = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1172 set_ppc32_offset_mode(ornode, ppc32_ao_Lo16);
1175 set_ppc32_constant_tarval(ornode, new_tarval_from_long(size/4-1, mode_Is));
1176 mtctrnode = new_rd_ppc32_Mtctr(env->dbg, env->irg, env->block, ornode, mode_Is);
1177 store = new_rd_ppc32_LoopCopy(env->dbg, env->irg, env->block, src, dest, mtctrnode, mem, mode_T);
1179 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 1); // src
1180 in[1] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 2); // dest
1181 in[2] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 4); // temp
1182 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_gp], env->irg, env->block, 3, in);
1183 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 3); // ctr
1184 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_count], env->irg, env->block, 1, in);
1186 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, 0);
1195 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1196 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem);
1197 set_ppc32_constant_tarval(load, offset_tarval);
1198 set_ppc32_offset_mode(load, ppc32_ao_None);
1199 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1200 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1202 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem);
1203 set_ppc32_constant_tarval(store, offset_tarval);
1204 set_ppc32_offset_mode(store, ppc32_ao_None);
1205 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1213 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1214 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem);
1215 set_ppc32_constant_tarval(load, offset_tarval);
1216 set_ppc32_offset_mode(load, ppc32_ao_None);
1217 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1218 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1220 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem);
1221 set_ppc32_constant_tarval(store, offset_tarval);
1222 set_ppc32_offset_mode(store, ppc32_ao_None);
1223 // mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1230 * Transforms a FrameAddr into a ppc Add.
1232 * @param env The transformation environment
1234 static ir_node *gen_be_FrameAddr(ppc32_transform_env_t *env) {
1235 ir_node *op = get_irn_n(env->irn, 0);
1236 ir_node *add = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op, mode_P);
1237 set_ppc32_frame_entity(add, be_get_frame_entity(env->irn));
1242 * Transforms a StackParam into a ppc Load
1244 * @param env The transformation environment
1246 static ir_node *gen_be_StackParam(ppc32_transform_env_t *env) {
1247 ir_node *load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, get_irn_n(env->irn, 0), new_NoMem());
1248 ir_node *proj = new_rd_Proj(env->dbg, env->irg, env->block, load, env->mode, pn_Load_res);
1249 set_ppc32_frame_entity(load, be_get_frame_entity(env->irn));
1254 /*********************************************************
1257 * _ __ ___ __ _ _ _ __ __| |_ __ ___ _____ _ __
1258 * | '_ ` _ \ / _` | | '_ \ / _` | '__| \ \ / / _ \ '__|
1259 * | | | | | | (_| | | | | | | (_| | | | |\ V / __/ |
1260 * |_| |_| |_|\__,_|_|_| |_| \__,_|_| |_| \_/ \___|_|
1262 *********************************************************/
1265 * the BAD transformer.
1267 static ir_node *bad_transform(ppc32_transform_env_t *env) {
1268 ir_fprintf(stderr, "Not implemented: %+F\n", env->irn);
1274 * Enters all transform functions into the generic pointer
1276 void ppc32_register_transformers(void) {
1277 ir_op *op_Max, *op_Min, *op_Mulh;
1279 /* first clear the generic function pointer for all ops */
1280 clear_irp_opcodes_generic_func();
1282 #define FIRM_OP(a) op_##a->ops.generic = (op_func)gen_##a
1283 #define BAD(a) op_##a->ops.generic = (op_func)bad_transform
1314 /* TODO: implement these nodes */
1317 /* You probably don't need to handle the following nodes */
1347 FIRM_OP(be_FrameAddr);
1348 FIRM_OP(be_StackParam);
1349 op_Mulh = get_op_Mulh();
1352 op_Max = get_op_Max();
1355 op_Min = get_op_Min();
1360 typedef ir_node *(transform_func)(ppc32_transform_env_t *env);
1363 * Transforms the given firm node (and maybe some other related nodes)
1364 * into one or more assembler nodes.
1366 * @param node the firm node
1367 * @param env the debug module
1369 void ppc32_transform_node(ir_node *node, void *env) {
1370 ppc32_code_gen_t *cg = (ppc32_code_gen_t *)env;
1371 ir_op *op = get_irn_op(node);
1372 ir_node *asm_node = NULL;
1377 DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
1379 if (op->ops.generic) {
1380 ppc32_transform_env_t tenv;
1381 transform_func *transform = (transform_func *)op->ops.generic;
1383 tenv.block = get_nodes_block(node);
1384 tenv.dbg = get_irn_dbg_info(node);
1385 tenv.irg = current_ir_graph;
1387 tenv.mode = get_irn_mode(node);
1388 DEBUG_ONLY(tenv.mod = cg->mod;)
1390 asm_node = (*transform)(&tenv);
1394 exchange(node, asm_node);
1395 DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1398 DB((cg->mod, LEVEL_1, "ignored\n"));
1403 * Constant generating code
1411 /** Compares two (entity, tarval) combinations */
1412 static int cmp_tv_ent(const void *a, const void *b, size_t len) {
1413 const struct tv_ent *e1 = a;
1414 const struct tv_ent *e2 = b;
1416 return !(e1->tv == e2->tv);
1419 /** Generates a SymConst node for a known FP const */
1420 static ir_node *gen_fp_known_symconst(ppc32_transform_env_t *env, tarval *known_const) {
1421 static set *const_set = NULL;
1422 static ir_type *tp = NULL;
1424 struct tv_ent *entry;
1425 ir_node *cnst,*symcnst;
1430 const_set = new_set(cmp_tv_ent, 10);
1432 tp = new_type_primitive(new_id_from_str("const_double_t"), env->mode);
1434 key.tv = known_const;
1437 entry = set_insert(const_set, &key, sizeof(key), HASH_PTR(key.tv));
1441 sprintf(buf, "const_%ld", get_irn_node_nr(env->irn));
1442 ent = new_entity(get_glob_type(), new_id_from_str(buf), tp);
1444 set_entity_ld_ident(ent, get_entity_ident(ent));
1445 set_entity_visibility(ent, visibility_local);
1446 set_entity_variability(ent, variability_constant);
1447 set_entity_allocation(ent, allocation_static);
1449 /* we create a new entity here: It's initialization must resist on the
1451 rem = current_ir_graph;
1452 current_ir_graph = get_const_code_irg();
1453 cnst = new_Const(env->mode, key.tv);
1454 current_ir_graph = rem;
1456 set_atomic_ent_value(ent, cnst);
1458 /* set the entry for hashmap */
1460 } // TODO: Wird nicht richtig in global type gesteckt, ppc32_gen_decls.c findet ihn nicht
1462 symcnst = new_rd_ppc32_SymConst(env->dbg, env->irg, env->block, env->mode);
1463 set_ppc32_frame_entity(symcnst, ent);
1467 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env);
1470 * Transforms a Const.
1472 * @param mod the debug module
1473 * @param block the block the new node should belong to
1474 * @param node the ir Const node
1475 * @param mode node mode
1476 * @return the created ppc Load immediate node
1478 static ir_node *gen_ppc32_Const(ppc32_transform_env_t *env) {
1479 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1482 switch(get_nice_modecode(env->mode)){
1485 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1488 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1489 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1490 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1491 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1492 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1499 node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1500 set_ppc32_offset_mode(node, ppc32_ao_None);
1506 unsigned char val2 = get_tarval_sub_bits(tv_const,2);
1507 unsigned char val3 = get_tarval_sub_bits(tv_const,3);
1510 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1513 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1514 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1515 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1516 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1517 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1521 node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1522 set_ppc32_offset_mode(node, ppc32_ao_None);
1527 unsigned char val0 = get_tarval_sub_bits(tv_const,0);
1528 unsigned char val1 = get_tarval_sub_bits(tv_const,1);
1529 node = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, tv_const, NULL);
1532 set_ppc32_constant_tarval(node, tv_const);
1533 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node, env->mode);
1534 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1541 fprintf(stderr, "Mode for Const not supported: %s\n", get_mode_name(env->mode));
1545 set_ppc32_constant_tarval(node, tv_const);
1550 * Transforms a fConst.
1552 * @param mod the debug module
1553 * @param block the block the new node should belong to
1554 * @param node the ir Const node
1555 * @param mode node mode
1556 * @return the created ppc float Load node
1558 static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) {
1559 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1561 switch(get_nice_modecode(env->mode)){
1565 ir_node *addr, *load;
1566 ir_mode *mode = env->mode;
1568 env->irn = gen_fp_known_symconst(env, tv_const);
1570 ent = get_ppc32_frame_entity(env->irn);
1571 if(is_direct_entity(ent))
1573 ident *id_symconst = get_entity_ident(ent);
1574 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1577 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1579 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1581 set_ppc32_symconst_ident(load, id_symconst);
1582 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1586 addr = gen_ppc32_SymConst (env);
1588 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem());
1590 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem());
1592 return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1596 fprintf(stderr, "Mode for fConst not supported: %s\n", get_mode_name(env->mode));
1600 assert(0 && "Dead end!");
1605 * Returns true, if the entity can be accessed directly,
1606 * or false, if the address must be loaded first
1608 int is_direct_entity(entity *ent) {
1609 return get_entity_visibility(ent)!=visibility_external_allocated;
1610 /* visibility vis = get_entity_visibility(ent);
1611 if(is_Method_type(get_entity_type(ent)))
1613 return (vis!=visibility_external_allocated);
1617 return (vis==visibility_local);
1622 * Transforms a SymConst.
1624 * @param mod the debug module
1625 * @param block the block the new node should belong to
1626 * @param node the ir Const node
1627 * @param mode node mode
1628 * @return the created ppc Load immediate node
1630 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) {
1631 entity *ent = get_ppc32_frame_entity(env->irn);
1632 ident *id_symconst = get_entity_ident(ent);
1634 switch(get_nice_modecode(env->mode)){
1637 if (is_direct_entity(ent))
1639 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, NULL, id_symconst);
1640 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node_addis, env->mode);
1641 set_ppc32_symconst_ident(node, id_symconst);
1642 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1646 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1647 node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1648 set_ppc32_symconst_ident(node, id_symconst);
1649 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1650 node = new_rd_Proj(env->dbg, env->irg, env->block, node, env->mode, pn_Load_res);
1651 // pset_insert_ptr(symbol_pset, ent);
1657 fprintf(stderr, "Mode for SymConst not supported: %s\n", get_mode_name(env->mode));
1665 * Transforms the given firm node (and maybe some other related nodes)
1666 * into one or more assembler nodes.
1668 * @param node the firm node
1669 * @param env the debug module
1671 void ppc32_transform_const(ir_node *node, void *env) {
1672 ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env;
1673 ir_node *asm_node = NULL;
1674 ppc32_transform_env_t tenv;
1679 tenv.block = get_nodes_block(node);
1680 tenv.dbg = get_irn_dbg_info(node);
1681 tenv.irg = current_ir_graph;
1683 DEBUG_ONLY(tenv.mod = cgenv->mod;)
1684 tenv.mode = get_irn_mode(node);
1686 #define OTHER_GEN(a) \
1687 if (get_irn_op(node) == get_op_##a()) { \
1688 asm_node = gen_##a(&tenv); \
1691 DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1693 OTHER_GEN(ppc32_Const)
1694 else OTHER_GEN(ppc32_fConst)
1695 else OTHER_GEN(ppc32_SymConst)
1698 exchange(node, asm_node);
1699 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1702 DB((tenv.mod, LEVEL_1, "ignored\n"));