1 /* The codegenerator (transform FIRM into ppc FIRM) */
13 #include "iredges_t.h"
20 #include "../benode_t.h"
21 #include "bearch_ppc32_t.h"
23 #include "ppc32_nodes_attr.h"
24 #include "../arch/archop.h" /* we need this for Min and Max nodes */
25 #include "ppc32_transform.h"
26 #include "ppc32_new_nodes.h"
27 #include "ppc32_map_regs.h"
29 #include "gen_ppc32_regalloc_if.h"
31 extern pset *symbol_pset;
32 extern ir_op *get_op_Mulh(void);
34 int is_direct_entity(entity *ent);
36 ir_mode* ppc32_mode_Cond = NULL;
39 * Returns the proj of a given node with the given proj number
41 static INLINE ir_node *get_succ_Proj(ir_node *node, long proj)
43 const ir_edge_t *edge;
44 foreach_out_edge(node, edge)
46 if (is_Proj(edge->src) && get_Proj_proj(edge->src) == proj)
53 * Returns a singleton condition mode
55 ir_mode *get_ppc32_mode_Cond(void) {
57 return ppc32_mode_Cond;
59 ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_character, 4, 0, irma_none, 0);
60 return ppc32_mode_Cond;
65 * Calculates the modecode with size, sort and signed attributes
67 modecode get_nice_modecode(ir_mode *irmode)
69 modecode mode = irm_max;
70 int sign = mode_is_signed(irmode);
71 int bits = get_mode_size_bits(irmode);
72 if(mode_is_int(irmode))
77 mode = sign ? irm_Bs : irm_Bu;
80 mode = sign ? irm_Hs : irm_Hu;
83 mode = sign ? irm_Is : irm_Iu;
87 else if(mode_is_float(irmode))
99 else if(mode_is_reference(irmode))
112 * Returns true, if the given node is a Const node and it's value fits into
113 * a signed 16-bit variable
115 int is_16bit_signed_const(ir_node *node)
119 if(!is_ppc32_Const(node)) return 0;
121 tv_const = get_ppc32_constant_tarval(node);
123 switch(get_nice_modecode(get_irn_mode(node)))
132 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
133 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
141 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
149 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
150 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
151 if(val2==0 && val3==0)
153 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
158 if(!(val2==0xff && val3==0xff))
160 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
168 fprintf(stderr, "is_16bit_signed_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
175 * Returns true, if the given node is a Const node and it's value fits into
176 * a unsigned 16-bit variable
178 int is_16bit_unsigned_const(ir_node *node)
182 if(!is_ppc32_Const(node)) return 0;
184 tv_const = get_ppc32_constant_tarval(node);
185 switch(get_nice_modecode(get_irn_mode(node)))
196 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
197 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
203 fprintf(stderr, "is_16bit_unsigned_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
210 /****************************************************************************************************
212 * | | | | / _| | | (_)
213 * _ __ ___ __| | ___ | |_ _ __ __ _ _ __ ___| |_ ___ _ __ _ __ ___ __ _| |_ _ ___ _ __
214 * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __| _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
215 * | | | | (_) | (_| | __/ | |_| | | (_| | | | \__ \ || (_) | | | | | | | | (_| | |_| | (_) | | | |
216 * |_| |_|\___/ \__,_|\___| \__|_| \__,_|_| |_|___/_| \___/|_| |_| |_| |_|\__,_|\__|_|\___/|_| |_|
218 ****************************************************************************************************/
221 * Creates an ppc Add.
223 * @param env The transformation environment
224 * @param op1 first operator
225 * @param op2 second operator
226 * @return the created ppc Add node
228 static ir_node *gen_Add(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
229 switch(get_nice_modecode(env->mode)){
231 return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode);
233 return new_rd_ppc32_fAdds(env->dbg, env->irg, env->block, op1, op2, env->mode);
241 if(is_16bit_signed_const(op1))
243 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op2, env->mode);
244 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op1));
245 set_ppc32_offset_mode(addnode, ppc32_ao_None);
248 if(is_16bit_signed_const(op2))
250 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op1, env->mode);
251 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op2));
252 set_ppc32_offset_mode(addnode, ppc32_ao_None);
256 return new_rd_ppc32_Add(env->dbg, env->irg, env->block, op1, op2, env->mode);
259 fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode));
268 * Creates an ppc Mul.
270 * @param dbg firm node dbg
271 * @param block the block the new node should belong to
272 * @param op1 first operator
273 * @param op2 second operator
274 * @param mode node mode
275 * @return the created ppc Mul node
277 static ir_node *gen_Mul(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
278 switch(get_nice_modecode(env->mode)){
280 return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
282 return new_rd_ppc32_fMuls(env->dbg, env->irg, env->block, op1, op2, env->mode);
289 return new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, op1, op2, env->mode);
293 fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode));
300 * Creates an ppc Mulh.
302 * @param dbg firm node dbg
303 * @param block the block the new node should belong to
304 * @param op1 first operator
305 * @param op2 second operator
306 * @param mode node mode
307 * @return the created ppc Mulh node
309 static ir_node *gen_Mulh(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
310 switch(get_nice_modecode(env->mode)){
314 return new_rd_ppc32_Mulhw(env->dbg, env->irg, env->block, op1, op2, env->mode);
319 return new_rd_ppc32_Mulhwu(env->dbg, env->irg, env->block, op1, op2, env->mode);
325 fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode));
333 * Creates an ppc And.
335 * @param dbg firm node dbg
336 * @param block the block the new node should belong to
337 * @param op1 first operator
338 * @param op2 second operator
339 * @param mode node mode
340 * @return the created ppc And node
342 static ir_node *gen_And(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
343 return new_rd_ppc32_And(env->dbg, env->irg, env->block, op1, op2, env->mode);
351 * @param dbg firm node dbg
352 * @param block the block the new node should belong to
353 * @param op1 first operator
354 * @param op2 second operator
355 * @param mode node mode
356 * @return the created ppc Or node
358 static ir_node *gen_Or(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
359 return new_rd_ppc32_Or(env->dbg, env->irg, env->block, op1, op2, env->mode);
365 * Creates an ppc Xor.
367 * @param dbg firm node dbg
368 * @param block the block the new node should belong to
369 * @param op1 first operator
370 * @param op2 second operator
371 * @param mode node mode
372 * @return the created ppc Xor node
374 static ir_node *gen_Eor(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
375 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, op1, op2, env->mode);
381 * Creates an ppc Sub.
383 * @param dbg firm node dbg
384 * @param block the block the new node should belong to
385 * @param op1 first operator
386 * @param op2 second operator
387 * @param mode node mode
388 * @return the created ppc Sub node
390 static ir_node *gen_Sub(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
391 switch(get_nice_modecode(env->mode)){
393 return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
395 return new_rd_ppc32_fSubs(env->dbg, env->irg, env->block, op1, op2, env->mode);
403 return new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, op2, env->mode);
406 fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode));
415 * Creates an ppc floating Div.
417 * @param dbg firm node dbg
418 * @param block the block the new node should belong to
419 * @param op1 first operator
420 * @param op2 second operator
421 * @param mode node mode
422 * @return the created ppc fDiv node
424 static ir_node *gen_Quot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
425 switch(get_nice_modecode(env->mode)){
427 return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
429 return new_rd_ppc32_fDivs(env->dbg, env->irg, env->block, op1, op2, env->mode);
432 fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode));
440 * Creates an ppc integer Div.
442 * @param dbg firm node dbg
443 * @param block the block the new node should belong to
444 * @param op1 first operator
445 * @param op2 second operator
446 * @param mode node mode
447 * @return the created ppc Div node
449 static ir_node *gen_Div(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
450 ir_node *proj_div = NULL;
451 const ir_edge_t *edge;
453 foreach_out_edge(env->irn, edge)
455 if (is_Proj(edge->src) && get_Proj_proj(edge->src) == pn_DivMod_res_div)
456 proj_div = edge->src;
459 switch(get_nice_modecode(get_irn_mode(proj_div))){
463 return new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
468 return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
471 fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(proj_div)));
478 * Creates an ppc integer Div and Mod.
480 * @param dbg firm node dbg
481 * @param block the block the new node should belong to
482 * @param op1 first operator
483 * @param op2 second operator
484 * @param mode node mode
485 * @return the created ppc Div node
487 static ir_node *gen_DivMod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
488 ir_node *proj_div = NULL, *proj_mod = NULL;
490 const ir_edge_t *edge;
493 foreach_out_edge(env->irn, edge)
495 if (is_Proj(edge->src))
497 switch(get_Proj_proj(edge->src)){
498 case pn_DivMod_res_div:
499 proj_div = edge->src;
501 case pn_DivMod_res_mod:
502 proj_mod = edge->src;
510 assert(proj_div!=NULL || proj_mod!=NULL);
512 res_mode = get_irn_mode(proj_div);
514 switch(get_nice_modecode(res_mode))
519 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
525 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
529 fprintf(stderr, "Mode for DivMod not supported: %s\n", get_mode_name(res_mode));
535 if (proj_div == NULL)
536 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, get_irn_mode(proj_mod), pn_DivMod_res_div);
542 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
543 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
545 exchange(proj_mod, mod_result);
552 * Creates an ppc integer Mod.
554 * @param dbg firm node dbg
555 * @param block the block the new node should belong to
556 * @param op1 first operator
557 * @param op2 second operator
558 * @param mode node mode
559 * @return the created ppc Mod result node
561 static ir_node *gen_Mod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
562 ir_node *proj_div = NULL, *proj_mod = NULL;
568 proj_mod = get_succ_Proj(env->irn, pn_Mod_res);
570 assert(proj_mod!=NULL);
571 res_mode = get_irn_mode(proj_mod);
573 switch(get_nice_modecode(res_mode))
578 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
584 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
588 fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode));
594 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, res_mode, pn_DivMod_res_div);
596 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
597 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
599 exchange(proj_mod, mod_result);
608 * Creates an ppc Shl.
610 * @param dbg firm node dbg
611 * @param block the block the new node should belong to
612 * @param op1 first operator
613 * @param op2 second operator
614 * @param mode node mode
615 * @return the created ppc Shl node
617 static ir_node *gen_Shl(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
618 if(is_ppc32_Const(op2))
620 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
621 tarval *tv_const = get_ppc32_constant_tarval(op2);
622 int sh = get_tarval_long(tv_const);
623 assert(0<=sh && sh<=31);
624 set_ppc32_rlwimi_const(shift, sh, 0, 31-sh);
627 return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode);
633 * Creates an ppc Srw.
635 * @param dbg firm node dbg
636 * @param block the block the new node should belong to
637 * @param op1 first operator
638 * @param op2 second operator
639 * @param mode node mode
640 * @return the created ppc Shr node
642 static ir_node *gen_Shr(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
643 if(is_ppc32_Const(op2))
645 ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
646 tarval *tv_const = get_ppc32_constant_tarval(op2);
647 int sh = get_tarval_long(tv_const);
648 assert(0<=sh && sh<=31);
649 set_ppc32_rlwimi_const(shift, 32-sh, sh, 31);
652 return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode);
657 * Creates an ppc Sraw.
659 * @param dbg firm node dbg
660 * @param block the block the new node should belong to
661 * @param op1 first operator
662 * @param op2 second operator
663 * @param mode node mode
664 * @return the created ppc Sraw node
666 static ir_node *gen_Shrs(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
667 if(is_ppc32_Const(op2))
669 ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode);
670 tarval *tv_const = get_ppc32_constant_tarval(op2);
671 int sh = get_tarval_long(tv_const);
672 assert(0<=sh && sh<=31);
673 set_ppc32_constant_tarval(shift, tv_const);
674 set_ppc32_offset_mode(shift, ppc32_ao_None);
677 return new_rd_ppc32_Sraw(env->dbg, env->irg, env->block, op1, op2, env->mode);
682 * Creates an ppc RotL.
684 * @param dbg firm node dbg
685 * @param block the block the new node should belong to
686 * @param op1 first operator
687 * @param op2 second operator
688 * @param mode node mode
689 * @return the created ppc RotL node
691 static ir_node *gen_Rot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
692 if(is_ppc32_Const(op2))
694 ir_node *rot = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
695 tarval *tv_const = get_ppc32_constant_tarval(op2);
696 int sh = get_tarval_long(tv_const);
697 assert(0<=sh && sh<=31);
698 set_ppc32_rlwimi_const(rot, sh, 0, 31);
701 return new_rd_ppc32_Rlwnm(env->dbg, env->irg, env->block, op1, op2, env->mode);
706 * Creates an ppc Cmp.
708 * @param dbg firm node dbg
709 * @param block the block the new node should belong to
710 * @param op1 first operator
711 * @param op2 second operator
712 * @param mode node mode
713 * @return the created ppc Cmp node
715 static ir_node *gen_Cmp(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
716 const ir_edge_t *edge;
717 foreach_out_edge(env->irn, edge)
719 if (is_Proj(edge->src))
720 set_irn_mode(edge->src, get_ppc32_mode_Cond());
723 if(mode_is_float(env->mode))
724 return new_rd_ppc32_fCmpu(env->dbg, env->irg, env->block, op1, op2, env->mode);
725 else if(mode_is_signed(env->mode))
727 if(is_16bit_signed_const(op2))
729 ir_node *cmp = new_rd_ppc32_Cmpi(env->dbg, env->irg, env->block, op1, env->mode);
730 tarval *tv_const = get_ppc32_constant_tarval(op2);
731 set_ppc32_constant_tarval(cmp, tv_const);
732 set_ppc32_offset_mode(cmp, ppc32_ao_None);
737 return new_rd_ppc32_Cmp(env->dbg, env->irg, env->block, op1, op2, env->mode);
742 if(is_16bit_unsigned_const(op2))
744 ir_node *cmp = new_rd_ppc32_Cmpli(env->dbg, env->irg, env->block, op1, env->mode);
745 tarval *tv_const = get_ppc32_constant_tarval(op2);
746 set_ppc32_constant_tarval(cmp, tv_const);
747 set_ppc32_offset_mode(cmp, ppc32_ao_None);
753 return new_rd_ppc32_Cmpl(env->dbg, env->irg, env->block, op1, op2, env->mode);
760 * Transforms a Minus node.
762 * @param mod the debug module
763 * @param block the block the new node should belong to
764 * @param node the ir Minus node
766 * @param mode node mode
767 * @return the created ppc Minus node
769 static ir_node *gen_Minus(ppc32_transform_env_t *env, ir_node *op) {
770 switch(get_nice_modecode(env->mode)){
773 return new_rd_ppc32_fNeg(env->dbg, env->irg, env->block, op, env->mode);
781 return new_rd_ppc32_Neg(env->dbg, env->irg, env->block, op, env->mode);
784 fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode));
793 * Transforms a Not node.
795 * @param mod the debug module
796 * @param block the block the new node should belong to
797 * @param node the ir Not node
799 * @param mode node mode
800 * @return the created ppc Not node
802 static ir_node *gen_Not(ppc32_transform_env_t *env, ir_node *op) {
803 return new_rd_ppc32_Not(env->dbg, env->irg, env->block, op, env->mode);
807 static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, int mask)
809 ir_node *andi = new_rd_ppc32_Andi_dot(env->dbg, env->irg, env->block, op, mode_T);
811 set_ppc32_offset_mode(andi, ppc32_ao_Lo16);
812 set_ppc32_constant_tarval(andi, new_tarval_from_long(mask, mode_Is));
813 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,1);
814 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_condition], env->irg, env->block, 1, in);
815 return new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,0);
819 * Transforms a Conv node.
821 * @param mod the debug module
822 * @param block the block the new node should belong to
823 * @param node the ir Conv node
825 * @param mode node mode
826 * @return the created ppc Conv node
828 static ir_node *gen_Conv(ppc32_transform_env_t *env, ir_node *op) {
829 modecode from_mode=get_nice_modecode(get_irn_mode(get_irn_n(env->irn,0)));
830 modecode to_mode=get_nice_modecode(env->mode);
832 #define SKIP return get_irn_n(env->irn, 0)
834 if(from_mode == to_mode) SKIP;
850 return new_rd_ppc32_fRsp(env->dbg, env->irg, env->block, op, env->mode);
861 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
863 return own_gen_Andi_dot_lo16(env, op, 0xffff);
865 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
867 return own_gen_Andi_dot_lo16(env, op, 0xff);
881 if(from_mode==irm_Hu)
883 return own_gen_Andi_dot_lo16(env, op, 0xffff);
887 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
889 return own_gen_Andi_dot_lo16(env, op, 0xff);
891 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
903 if(from_mode==irm_Bs)
905 return own_gen_Andi_dot_lo16(env, op, 0xff);
910 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
916 if(to_mode==irm_Is || to_mode==irm_Iu) SKIP;
922 fprintf(stderr, "Mode for Conv not supported: %s -> %s\n",
923 get_mode_name(get_irn_mode(get_irn_n(env->irn,0))),get_mode_name(env->mode));
932 * Transforms an Abs node.
934 * @param mod the debug module
935 * @param block the block the new node should belong to
936 * @param node the ir Not node
938 * @param mode node mode
939 * @return the ppc node generating the absolute value
941 static ir_node *gen_Abs(ppc32_transform_env_t *env, ir_node *op) {
945 switch(get_nice_modecode(env->mode))
949 return new_rd_ppc32_fAbs(env->dbg, env->irg, env->block, op, env->mode);
955 n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode);
956 set_ppc32_constant_tarval(n1, new_tarval_from_long(shift, mode_Is));
957 set_ppc32_offset_mode(n1, ppc32_ao_None);
958 n2 = new_rd_ppc32_Add(env->dbg, env->irg, env->block, op, n1, env->mode);
959 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, n2, n1, env->mode);
963 fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode));
969 * Transforms an Cond node.
971 * @param mod the debug module
972 * @param block the block the new node should belong to
973 * @param node the ir Not node
975 * @param mode node mode
976 * @return a ppc branch node
978 static ir_node *gen_Cond(ppc32_transform_env_t *env) {
979 ir_node *selector = get_Cond_selector(env->irn);
980 ir_mode *projmode = get_irn_mode(selector);
981 if(is_Proj(selector) && projmode==get_ppc32_mode_Cond())
983 int projnum = get_Proj_proj(selector);
984 ir_node *branch = new_rd_ppc32_Branch(env->dbg, env->irg, env->block, selector, env->mode);
985 set_ppc32_proj_nr(branch, projnum);
990 ir_node *unknown_gpr = new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, mode_Is);
991 ir_node *unknown_cond = new_rd_ppc32_cUnknown(env->dbg, env->irg, env->block, get_ppc32_mode_Cond());
993 ir_node *switch_node = new_rd_ppc32_Switch(env->dbg, env->irg, env->block, selector,
994 unknown_gpr, unknown_cond, env->mode);
995 set_ppc32_proj_nr(switch_node, get_Cond_defaultProj(env->irn));
1003 * Transforms an Unknown node.
1005 * @param mod the debug module
1006 * @param block the block the new node should belong to
1007 * @param node the ir Not node
1008 * @param op operator
1009 * @param mode node mode
1010 * @return a ppc Unknown node
1012 static ir_node *gen_Unknown(ppc32_transform_env_t *env) {
1013 if(mode_is_float(env->mode))
1014 return new_rd_ppc32_fUnknown(env->dbg, env->irg, env->block, env->mode);
1015 else if (mode_is_int(env->mode))
1016 return new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, env->mode);
1019 fprintf(stderr, "Mode %s for unknown value not supported.\n", get_mode_name(env->mode));
1025 static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32_transform_env_t *env) {
1026 tarval *tv_const = NULL;
1027 ident *id_symconst = NULL;
1029 if(is_ppc32_Const(ptr))
1031 tv_const = get_ppc32_constant_tarval(ptr);
1032 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, tv_const, NULL);
1034 else if(is_ppc32_SymConst(ptr))
1036 entity *ent = get_ppc32_frame_entity(ptr);
1037 if(is_direct_entity(ent))
1039 id_symconst = get_entity_ident(ent);
1040 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, NULL, id_symconst);
1049 * Transforms a Load.
1051 * @param mod the debug module
1052 * @param block the block the new node should belong to
1053 * @param node the ir Load node
1054 * @param mode node mode
1055 * @return the created ppc Load node
1057 static ir_node *gen_Load(ppc32_transform_env_t *env) {
1058 ir_node *node = env->irn;
1059 ir_node *loadptr = get_Load_ptr(node);
1061 ir_mode *mode = get_Load_mode(node);
1062 tarval *tv_const = NULL;
1063 ident *id_symconst = NULL;
1065 loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env);
1066 switch(get_nice_modecode(mode)){
1068 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
1073 ir_node *proj_load, *extsb_node;
1074 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
1075 proj_load = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1076 extsb_node = new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, proj_load, mode);
1077 exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node);
1083 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
1086 load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
1091 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
1095 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
1098 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
1102 fprintf(stderr, "Mode for Load not supported: %s\n", get_mode_name(env->mode));
1109 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1110 set_ppc32_constant_tarval(load, tv_const);
1112 else if(id_symconst)
1114 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1115 set_ppc32_symconst_ident(load, id_symconst);
1123 * Transforms a Store.
1125 * @param mod the debug module
1126 * @param block the block the new node should belong to
1127 * @param node the ir Store node
1128 * @param mode node mode
1129 * @return the created ppc Store node
1131 static ir_node *gen_Store(ppc32_transform_env_t *env) {
1132 ir_node *node = env->irn;
1133 ir_node *storeptr = get_Store_ptr(node);
1134 ir_node *valuenode = get_Store_value(node);
1135 ir_mode *mode = get_irn_mode(valuenode);
1137 tarval *tv_const = NULL;
1138 ident *id_symconst = NULL;
1140 storeptr = ldst_insert_const(storeptr, &tv_const, &id_symconst, env);
1142 switch(get_nice_modecode(mode)){
1145 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
1150 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
1155 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
1159 store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
1162 store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
1166 fprintf(stderr, "Mode for Store not supported: %s\n", get_mode_name(env->mode));
1172 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1173 set_ppc32_constant_tarval(store, tv_const);
1175 else if(id_symconst)
1177 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1178 set_ppc32_symconst_ident(store, id_symconst);
1184 * Transforms a CopyB.
1186 * @param mod the debug module
1187 * @param block the block the new node should belong to
1188 * @param node the ir Store node
1189 * @param mode node mode
1190 * @return the created ppc CopyB node
1192 static ir_node *gen_CopyB(ppc32_transform_env_t *env) {
1193 ir_node *mem = get_CopyB_mem(env->irn);
1194 ir_node *src = get_CopyB_src(env->irn);
1195 ir_node *dest = get_CopyB_dst(env->irn);
1196 ir_type *type = get_CopyB_type(env->irn);
1197 int size = get_type_size_bytes(type);
1200 ir_node *load, *store;
1205 tarval *offset0 = new_tarval_from_long(0, mode_Is);
1206 tarval *offset4 = new_tarval_from_long(4, mode_Is);
1208 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem, mode_T);
1209 set_ppc32_constant_tarval(load, offset0);
1210 set_ppc32_offset_mode(load, ppc32_ao_None);
1211 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1212 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1214 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
1215 set_ppc32_constant_tarval(store, offset0);
1216 set_ppc32_offset_mode(store, ppc32_ao_None);
1217 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1221 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem, mode_T);
1222 set_ppc32_constant_tarval(load, offset4);
1223 set_ppc32_offset_mode(load, ppc32_ao_None);
1224 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1225 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1227 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
1228 set_ppc32_constant_tarval(store, offset4);
1229 set_ppc32_offset_mode(store, ppc32_ao_None);
1230 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1236 ir_node *ornode, *mtctrnode;
1238 assert(size/4-1<=0xffff);
1241 ornode = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1242 set_ppc32_offset_mode(ornode, ppc32_ao_None);
1246 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1247 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1248 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1249 ornode = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1250 set_ppc32_offset_mode(ornode, ppc32_ao_Lo16);
1253 set_ppc32_constant_tarval(ornode, new_tarval_from_long(size/4-1, mode_Is));
1254 mtctrnode = new_rd_ppc32_Mtctr(env->dbg, env->irg, env->block, ornode, mode_Is);
1255 store = new_rd_ppc32_LoopCopy(env->dbg, env->irg, env->block, src, dest, mtctrnode, mem, mode_T);
1257 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 1); // src
1258 in[1] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 2); // dest
1259 in[2] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 4); // temp
1260 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_general_purpose], env->irg, env->block, 3, in);
1261 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 3); // ctr
1262 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_count], env->irg, env->block, 1, in);
1264 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, 0);
1273 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1274 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem, mode_T);
1275 set_ppc32_constant_tarval(load, offset_tarval);
1276 set_ppc32_offset_mode(load, ppc32_ao_None);
1277 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1278 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1280 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
1281 set_ppc32_constant_tarval(store, offset_tarval);
1282 set_ppc32_offset_mode(store, ppc32_ao_None);
1283 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1291 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1292 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem, mode_T);
1293 set_ppc32_constant_tarval(load, offset_tarval);
1294 set_ppc32_offset_mode(load, ppc32_ao_None);
1295 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1296 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1298 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
1299 set_ppc32_constant_tarval(store, offset_tarval);
1300 set_ppc32_offset_mode(store, ppc32_ao_None);
1301 // mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1308 * Transforms a FrameAddr into a ppc Add.
1310 static ir_node *gen_FrameAddr(ppc32_transform_env_t *env) {
1311 ir_node *op = get_irn_n(env->irn, 0);
1312 ir_node *add = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op, mode_P);
1313 set_ppc32_frame_entity(add, be_get_frame_entity(env->irn));
1318 * Transforms a StackParam into a ppc Load
1320 static ir_node *gen_StackParam(ppc32_transform_env_t *env) {
1321 ir_node *load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, get_irn_n(env->irn, 0), new_NoMem(), mode_T);
1322 ir_node *proj = new_rd_Proj(env->dbg, env->irg, env->block, load, env->mode, pn_Load_res);
1323 set_ppc32_frame_entity(load, be_get_frame_entity(env->irn));
1328 /*********************************************************
1331 * _ __ ___ __ _ _ _ __ __| |_ __ ___ _____ _ __
1332 * | '_ ` _ \ / _` | | '_ \ / _` | '__| \ \ / / _ \ '__|
1333 * | | | | | | (_| | | | | | | (_| | | | |\ V / __/ |
1334 * |_| |_| |_|\__,_|_|_| |_| \__,_|_| |_| \_/ \___|_|
1336 *********************************************************/
1341 * Transforms the given firm node (and maybe some other related nodes)
1342 * into one or more assembler nodes.
1344 * @param node the firm node
1345 * @param env the debug module
1347 void ppc32_transform_node(ir_node *node, void *env) {
1348 ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env;
1349 opcode code = get_irn_opcode(node);
1350 ir_node *asm_node = NULL;
1351 ppc32_transform_env_t tenv;
1356 tenv.block = get_nodes_block(node);
1357 tenv.dbg = get_irn_dbg_info(node);
1358 tenv.irg = current_ir_graph;
1360 DEBUG_ONLY(tenv.mod = cgenv->mod;)
1361 tenv.mode = get_irn_mode(node);
1363 #define UNOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_op(node)); break
1364 #define BINOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_left(node), get_##a##_right(node)); break
1365 #define GEN(a) case iro_##a: asm_node = gen_##a(&tenv); break
1366 #define IGN(a) case iro_##a: break
1367 #define BAD(a) case iro_##a: goto bad
1368 #define OTHER_BIN(a) \
1369 if (get_irn_op(node) == get_op_##a()) { \
1370 asm_node = gen_##a(&tenv, get_irn_n(node, 0), get_irn_n(node, 1)); \
1374 if (be_is_##a(node)) { \
1375 asm_node = gen_##a(&tenv); \
1379 DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1410 /* TODO: implement these nodes */
1413 /* You probably don't need to handle the following nodes */
1447 if (get_irn_op(node) == get_op_Max() ||
1448 get_irn_op(node) == get_op_Min())
1450 /* TODO: implement */
1451 /* ignore for now */
1455 fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node));
1460 exchange(node, asm_node);
1461 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1464 DB((tenv.mod, LEVEL_1, "ignored\n"));
1469 * Constant generating code
1477 /** Compares two (entity, tarval) combinations */
1478 static int cmp_tv_ent(const void *a, const void *b, size_t len) {
1479 const struct tv_ent *e1 = a;
1480 const struct tv_ent *e2 = b;
1482 return !(e1->tv == e2->tv);
1485 /** Generates a SymConst node for a known FP const */
1486 static ir_node *gen_fp_known_symconst(ppc32_transform_env_t *env, tarval *known_const) {
1487 static set *const_set = NULL;
1488 static ir_type *tp = NULL;
1490 struct tv_ent *entry;
1491 ir_node *cnst,*symcnst;
1496 const_set = new_set(cmp_tv_ent, 10);
1498 tp = new_type_primitive(new_id_from_str("const_double_t"), env->mode);
1500 key.tv = known_const;
1503 entry = set_insert(const_set, &key, sizeof(key), HASH_PTR(key.tv));
1507 sprintf(buf, "const_%ld", get_irn_node_nr(env->irn));
1508 ent = new_entity(get_glob_type(), new_id_from_str(buf), tp);
1510 set_entity_ld_ident(ent, get_entity_ident(ent));
1511 set_entity_visibility(ent, visibility_local);
1512 set_entity_variability(ent, variability_constant);
1513 set_entity_allocation(ent, allocation_static);
1515 /* we create a new entity here: It's initialization must resist on the
1517 rem = current_ir_graph;
1518 current_ir_graph = get_const_code_irg();
1519 cnst = new_Const(env->mode, key.tv);
1520 current_ir_graph = rem;
1522 set_atomic_ent_value(ent, cnst);
1524 /* set the entry for hashmap */
1526 } // TODO: Wird nicht richtig in global type gesteckt, ppc32_gen_decls.c findet ihn nicht
1528 symcnst = new_rd_ppc32_SymConst(env->dbg, env->irg, env->block, env->mode);
1529 set_ppc32_frame_entity(symcnst, ent);
1533 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env);
1536 * Transforms a Const.
1538 * @param mod the debug module
1539 * @param block the block the new node should belong to
1540 * @param node the ir Const node
1541 * @param mode node mode
1542 * @return the created ppc Load immediate node
1544 static ir_node *gen_ppc32_Const(ppc32_transform_env_t *env) {
1545 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1548 switch(get_nice_modecode(env->mode)){
1551 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1554 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1555 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1556 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1557 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1558 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1565 node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1566 set_ppc32_offset_mode(node, ppc32_ao_None);
1572 unsigned char val2 = get_tarval_sub_bits(tv_const,2);
1573 unsigned char val3 = get_tarval_sub_bits(tv_const,3);
1576 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1579 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1580 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1581 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1582 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1583 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1587 node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1588 set_ppc32_offset_mode(node, ppc32_ao_None);
1593 unsigned char val0 = get_tarval_sub_bits(tv_const,0);
1594 unsigned char val1 = get_tarval_sub_bits(tv_const,1);
1595 node = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, tv_const, NULL);
1598 set_ppc32_constant_tarval(node, tv_const);
1599 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node, env->mode);
1600 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1607 fprintf(stderr, "Mode for Const not supported: %s\n", get_mode_name(env->mode));
1611 set_ppc32_constant_tarval(node, tv_const);
1616 * Transforms a fConst.
1618 * @param mod the debug module
1619 * @param block the block the new node should belong to
1620 * @param node the ir Const node
1621 * @param mode node mode
1622 * @return the created ppc float Load node
1624 static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) {
1625 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1627 switch(get_nice_modecode(env->mode)){
1631 ir_node *addr, *load;
1632 ir_mode *mode = env->mode;
1634 env->irn = gen_fp_known_symconst(env, tv_const);
1636 ent = get_ppc32_frame_entity(env->irn);
1637 if(is_direct_entity(ent))
1639 ident *id_symconst = get_entity_ident(ent);
1640 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1643 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T);
1645 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T);
1647 set_ppc32_symconst_ident(load, id_symconst);
1648 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1652 addr = gen_ppc32_SymConst (env);
1654 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem(), mode_T);
1656 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem(), mode_T);
1658 return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1662 fprintf(stderr, "Mode for fConst not supported: %s\n", get_mode_name(env->mode));
1666 assert(0 && "Dead end!");
1671 * Returns true, if the entity can be accessed directly,
1672 * or false, if the address must be loaded first
1674 int is_direct_entity(entity *ent) {
1675 return get_entity_visibility(ent)!=visibility_external_allocated;
1676 /* visibility vis = get_entity_visibility(ent);
1677 if(is_Method_type(get_entity_type(ent)))
1679 return (vis!=visibility_external_allocated);
1683 return (vis==visibility_local);
1688 * Transforms a SymConst.
1690 * @param mod the debug module
1691 * @param block the block the new node should belong to
1692 * @param node the ir Const node
1693 * @param mode node mode
1694 * @return the created ppc Load immediate node
1696 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) {
1697 entity *ent = get_ppc32_frame_entity(env->irn);
1698 ident *id_symconst = get_entity_ident(ent);
1700 switch(get_nice_modecode(env->mode)){
1703 if (is_direct_entity(ent))
1705 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, NULL, id_symconst);
1706 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node_addis, env->mode);
1707 set_ppc32_symconst_ident(node, id_symconst);
1708 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1712 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1713 node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T);
1714 set_ppc32_symconst_ident(node, id_symconst);
1715 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1716 node = new_rd_Proj(env->dbg, env->irg, env->block, node, env->mode, pn_Load_res);
1717 // pset_insert_ptr(symbol_pset, ent);
1723 fprintf(stderr, "Mode for SymConst not supported: %s\n", get_mode_name(env->mode));
1731 * Transforms the given firm node (and maybe some other related nodes)
1732 * into one or more assembler nodes.
1734 * @param node the firm node
1735 * @param env the debug module
1737 void ppc32_transform_const(ir_node *node, void *env) {
1738 ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env;
1739 ir_node *asm_node = NULL;
1740 ppc32_transform_env_t tenv;
1745 tenv.block = get_nodes_block(node);
1746 tenv.dbg = get_irn_dbg_info(node);
1747 tenv.irg = current_ir_graph;
1749 DEBUG_ONLY(tenv.mod = cgenv->mod;)
1750 tenv.mode = get_irn_mode(node);
1752 #define OTHER_GEN(a) \
1753 if (get_irn_op(node) == get_op_##a()) { \
1754 asm_node = gen_##a(&tenv); \
1757 DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1759 OTHER_GEN(ppc32_Const)
1760 else OTHER_GEN(ppc32_fConst)
1761 else OTHER_GEN(ppc32_SymConst)
1764 exchange(node, asm_node);
1765 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1768 DB((tenv.mod, LEVEL_1, "ignored\n"));