2 * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief The codegenerator (transform FIRM into ppc FIRM)
23 * @author Moritz Kroll, Jens Mueller
31 #include "irgraph_t.h"
35 #include "iredges_t.h"
43 #include "../benode_t.h"
44 #include "bearch_ppc32_t.h"
46 #include "ppc32_nodes_attr.h"
47 #include "../arch/archop.h" /* we need this for Min and Max nodes */
48 #include "ppc32_transform.h"
49 #include "ppc32_new_nodes.h"
50 #include "ppc32_map_regs.h"
52 #include "gen_ppc32_regalloc_if.h"
54 extern pset *symbol_pset;
55 extern ir_op *get_op_Mulh(void);
57 int is_direct_entity(ir_entity *ent);
59 ir_mode* ppc32_mode_Cond = NULL;
62 * Returns the proj of a given node with the given proj number
64 static INLINE ir_node *get_succ_Proj(ir_node *node, long proj)
66 const ir_edge_t *edge;
67 foreach_out_edge(node, edge)
69 if (is_Proj(edge->src) && get_Proj_proj(edge->src) == proj)
76 * Returns a singleton condition mode
78 ir_mode *get_ppc32_mode_Cond(void) {
80 return ppc32_mode_Cond;
82 ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_character, 4, 0, irma_none, 0);
83 return ppc32_mode_Cond;
88 * Calculates the modecode with size, sort and signed attributes
90 modecode get_nice_modecode(ir_mode *irmode)
92 modecode mode = irm_max;
93 int sign = mode_is_signed(irmode);
94 int bits = get_mode_size_bits(irmode);
95 if(mode_is_int(irmode))
100 mode = sign ? irm_Bs : irm_Bu;
103 mode = sign ? irm_Hs : irm_Hu;
106 mode = sign ? irm_Is : irm_Iu;
110 else if(mode_is_float(irmode))
122 else if(mode_is_reference(irmode))
135 * Returns true, if the given node is a Const node and it's value fits into
136 * a signed 16-bit variable
138 int is_16bit_signed_const(ir_node *node)
142 if(!is_ppc32_Const(node)) return 0;
144 tv_const = get_ppc32_constant_tarval(node);
146 switch(get_nice_modecode(get_irn_mode(node)))
155 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
156 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
164 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
172 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
173 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
174 if(val2==0 && val3==0)
176 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
181 if(!(val2==0xff && val3==0xff))
183 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
191 fprintf(stderr, "is_16bit_signed_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
198 * Returns true, if the given node is a Const node and it's value fits into
199 * a unsigned 16-bit variable
201 int is_16bit_unsigned_const(ir_node *node)
205 if(!is_ppc32_Const(node)) return 0;
207 tv_const = get_ppc32_constant_tarval(node);
208 switch(get_nice_modecode(get_irn_mode(node)))
219 unsigned char val2 = get_tarval_sub_bits(tv_const, 2);
220 unsigned char val3 = get_tarval_sub_bits(tv_const, 3);
226 fprintf(stderr, "is_16bit_unsigned_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
233 /****************************************************************************************************
235 * | | | | / _| | | (_)
236 * _ __ ___ __| | ___ | |_ _ __ __ _ _ __ ___| |_ ___ _ __ _ __ ___ __ _| |_ _ ___ _ __
237 * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __| _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
238 * | | | | (_) | (_| | __/ | |_| | | (_| | | | \__ \ || (_) | | | | | | | | (_| | |_| | (_) | | | |
239 * |_| |_|\___/ \__,_|\___| \__|_| \__,_|_| |_|___/_| \___/|_| |_| |_| |_|\__,_|\__|_|\___/|_| |_|
241 ****************************************************************************************************/
244 * Creates an ppc Add.
246 * @param env The transformation environment
247 * @return the created ppc Add node
249 static ir_node *gen_Add(ppc32_transform_env_t *env) {
250 ir_node *op1 = get_Add_left(env->irn);
251 ir_node *op2 = get_Add_right(env->irn);
253 switch(get_nice_modecode(env->mode)){
255 return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode);
257 return new_rd_ppc32_fAdds(env->dbg, env->irg, env->block, op1, op2, env->mode);
265 if(is_16bit_signed_const(op1))
267 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op2, env->mode);
268 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op1));
269 set_ppc32_offset_mode(addnode, ppc32_ao_None);
272 if(is_16bit_signed_const(op2))
274 ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op1, env->mode);
275 set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op2));
276 set_ppc32_offset_mode(addnode, ppc32_ao_None);
280 return new_rd_ppc32_Add(env->dbg, env->irg, env->block, op1, op2, env->mode);
283 fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode));
290 * Creates an ppc Mul.
292 * @param env The transformation environment
293 * @return the created ppc Mul node
295 static ir_node *gen_Mul(ppc32_transform_env_t *env) {
296 ir_node *op1 = get_Mul_left(env->irn);
297 ir_node *op2 = get_Mul_right(env->irn);
299 switch(get_nice_modecode(env->mode)){
301 return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
303 return new_rd_ppc32_fMuls(env->dbg, env->irg, env->block, op1, op2, env->mode);
310 return new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, op1, op2, env->mode);
314 fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode));
321 * Creates an ppc Mulh.
323 * @param env The transformation environment
324 * @return the created ppc Mulh node
326 static ir_node *gen_Mulh(ppc32_transform_env_t *env) {
327 ir_node *op1 = get_irn_n(env->irn, 0);
328 ir_node *op2 = get_irn_n(env->irn, 1);
330 switch(get_nice_modecode(env->mode)){
334 return new_rd_ppc32_Mulhw(env->dbg, env->irg, env->block, op1, op2, env->mode);
339 return new_rd_ppc32_Mulhwu(env->dbg, env->irg, env->block, op1, op2, env->mode);
345 fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode));
352 * Creates an ppc And.
354 * @param env The transformation environment
355 * @return the created ppc And node
357 static ir_node *gen_And(ppc32_transform_env_t *env) {
358 ir_node *op1 = get_And_left(env->irn);
359 ir_node *op2 = get_And_right(env->irn);
361 return new_rd_ppc32_And(env->dbg, env->irg, env->block, op1, op2, env->mode);
367 * @param env The transformation environment
368 * @return the created ppc Or node
370 static ir_node *gen_Or(ppc32_transform_env_t *env) {
371 ir_node *op1 = get_Or_left(env->irn);
372 ir_node *op2 = get_Or_right(env->irn);
374 return new_rd_ppc32_Or(env->dbg, env->irg, env->block, op1, op2, env->mode);
378 * Creates an ppc Xor.
380 * @param env The transformation environment
381 * @return the created ppc Xor node
383 static ir_node *gen_Eor(ppc32_transform_env_t *env) {
384 ir_node *op1 = get_Eor_left(env->irn);
385 ir_node *op2 = get_Eor_right(env->irn);
387 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, op1, op2, env->mode);
391 * Creates an ppc Sub.
393 * @param env The transformation environment
394 * @return the created ppc Sub node
396 static ir_node *gen_Sub(ppc32_transform_env_t *env) {
397 ir_node *op1 = get_Sub_left(env->irn);
398 ir_node *op2 = get_Sub_right(env->irn);
400 switch(get_nice_modecode(env->mode)){
402 return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
404 return new_rd_ppc32_fSubs(env->dbg, env->irg, env->block, op1, op2, env->mode);
412 return new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, op2, env->mode);
415 fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode));
422 * Creates an ppc floating Div.
424 * @param env The transformation environment
425 * @return the created ppc fDiv node
427 static ir_node *gen_Quot(ppc32_transform_env_t *env) {
428 ir_node *op1 = get_Quot_left(env->irn);
429 ir_node *op2 = get_Quot_right(env->irn);
431 switch(get_nice_modecode(env->mode)){
433 return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
435 return new_rd_ppc32_fDivs(env->dbg, env->irg, env->block, op1, op2, env->mode);
438 fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode));
445 * Creates an ppc integer Div.
447 * @param env The transformation environment
448 * @return the created ppc Div node
450 static ir_node *gen_Div(ppc32_transform_env_t *env) {
451 ir_node *op1 = get_Div_left(env->irn);
452 ir_node *op2 = get_Div_right(env->irn);
454 switch(get_nice_modecode(get_irn_mode(op1))){
458 return new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
463 return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
466 fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(op1)));
473 * Creates an ppc integer Div and Mod.
475 * @param env The transformation environment
476 * @return the created ppc Div node
478 static ir_node *gen_DivMod(ppc32_transform_env_t *env) {
479 ir_node *op1 = get_DivMod_left(env->irn);
480 ir_node *op2 = get_DivMod_right(env->irn);
481 ir_node *proj_div = NULL, *proj_mod = NULL;
483 const ir_edge_t *edge;
486 foreach_out_edge(env->irn, edge)
488 if (is_Proj(edge->src))
490 switch(get_Proj_proj(edge->src)){
491 case pn_DivMod_res_div:
492 proj_div = edge->src;
494 case pn_DivMod_res_mod:
495 proj_mod = edge->src;
503 assert(proj_div!=NULL || proj_mod!=NULL);
505 res_mode = get_irn_mode(proj_div);
507 switch(get_nice_modecode(res_mode))
512 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
518 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
522 fprintf(stderr, "Mode for DivMod not supported: %s\n", get_mode_name(res_mode));
528 if (proj_div == NULL)
529 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, get_irn_mode(proj_mod), pn_DivMod_res_div);
535 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
536 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
538 exchange(proj_mod, mod_result);
545 * Creates an ppc integer Mod.
547 * @param env The transformation environment
548 * @return the created ppc Mod result node
550 static ir_node *gen_Mod(ppc32_transform_env_t *env) {
551 ir_node *op1 = get_Mod_left(env->irn);
552 ir_node *op2 = get_Mod_right(env->irn);
553 ir_node *proj_div = NULL, *proj_mod = NULL;
559 proj_mod = get_succ_Proj(env->irn, pn_Mod_res);
561 assert(proj_mod != NULL);
562 res_mode = get_irn_mode(proj_mod);
564 switch(get_nice_modecode(res_mode))
569 div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
575 div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
579 fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode));
585 proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, res_mode, pn_DivMod_res_div);
587 mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
588 mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
590 exchange(proj_mod, mod_result);
596 * Creates an ppc Shl.
598 * @param env The transformation environment
599 * @return the created ppc Shl node
601 static ir_node *gen_Shl(ppc32_transform_env_t *env) {
602 ir_node *op1 = get_Shl_left(env->irn);
603 ir_node *op2 = get_Shl_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, sh, 0, 31-sh);
614 return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode);
618 * Creates an ppc Srw.
620 * @param env The transformation environment
621 * @return the created ppc Shr node
623 static ir_node *gen_Shr(ppc32_transform_env_t *env) {
624 ir_node *op1 = get_Shr_left(env->irn);
625 ir_node *op2 = get_Shr_right(env->irn);
627 if(is_ppc32_Const(op2))
629 ir_node *shift = new_rd_ppc32_Rlwinm(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_rlwimi_const(shift, 32-sh, sh, 31);
636 return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode);
640 * Creates an ppc Sraw.
642 * @param env The transformation environment
643 * @return the created ppc Sraw node
645 static ir_node *gen_Shrs(ppc32_transform_env_t *env) {
646 ir_node *op1 = get_Shrs_left(env->irn);
647 ir_node *op2 = get_Shrs_right(env->irn);
649 if(is_ppc32_Const(op2))
651 ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode);
652 tarval *tv_const = get_ppc32_constant_tarval(op2);
653 int sh = get_tarval_long(tv_const);
654 assert(0<=sh && sh<=31);
655 set_ppc32_constant_tarval(shift, tv_const);
656 set_ppc32_offset_mode(shift, ppc32_ao_None);
659 return new_rd_ppc32_Sraw(env->dbg, env->irg, env->block, op1, op2, env->mode);
663 * Creates an ppc RotL.
665 * @param env The transformation environment
666 * @return the created ppc RotL node
668 static ir_node *gen_Rot(ppc32_transform_env_t *env) {
669 ir_node *op1 = get_Rot_left(env->irn);
670 ir_node *op2 = get_Rot_right(env->irn);
672 if(is_ppc32_Const(op2))
674 ir_node *rot = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
675 tarval *tv_const = get_ppc32_constant_tarval(op2);
676 int sh = get_tarval_long(tv_const);
677 assert(0<=sh && sh<=31);
678 set_ppc32_rlwimi_const(rot, sh, 0, 31);
681 return new_rd_ppc32_Rlwnm(env->dbg, env->irg, env->block, op1, op2, env->mode);
685 * Creates an ppc Cmp.
687 * @param env The transformation environment
688 * @return the created ppc Cmp node
690 static ir_node *gen_Cmp(ppc32_transform_env_t *env) {
691 ir_node *op1 = get_Cmp_left(env->irn);
692 ir_node *op2 = get_Cmp_right(env->irn);
694 const ir_edge_t *edge;
695 foreach_out_edge(env->irn, edge)
697 if (is_Proj(edge->src))
698 set_irn_mode(edge->src, get_ppc32_mode_Cond());
701 if(mode_is_float(env->mode))
702 return new_rd_ppc32_fCmpu(env->dbg, env->irg, env->block, op1, op2, env->mode);
703 else if(mode_is_signed(env->mode))
705 if(is_16bit_signed_const(op2))
707 ir_node *cmp = new_rd_ppc32_Cmpi(env->dbg, env->irg, env->block, op1, env->mode);
708 tarval *tv_const = get_ppc32_constant_tarval(op2);
709 set_ppc32_constant_tarval(cmp, tv_const);
710 set_ppc32_offset_mode(cmp, ppc32_ao_None);
715 return new_rd_ppc32_Cmp(env->dbg, env->irg, env->block, op1, op2, env->mode);
720 if(is_16bit_unsigned_const(op2))
722 ir_node *cmp = new_rd_ppc32_Cmpli(env->dbg, env->irg, env->block, op1, env->mode);
723 tarval *tv_const = get_ppc32_constant_tarval(op2);
724 set_ppc32_constant_tarval(cmp, tv_const);
725 set_ppc32_offset_mode(cmp, ppc32_ao_None);
731 return new_rd_ppc32_Cmpl(env->dbg, env->irg, env->block, op1, op2, env->mode);
737 * Transforms a Minus node.
739 * @param env The transformation environment
740 * @return the created ppc Minus node
742 static ir_node *gen_Minus(ppc32_transform_env_t *env) {
743 ir_node *op = get_Minus_op(env->irn);
745 switch(get_nice_modecode(env->mode)){
748 return new_rd_ppc32_fNeg(env->dbg, env->irg, env->block, op, env->mode);
756 return new_rd_ppc32_Neg(env->dbg, env->irg, env->block, op, env->mode);
759 fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode));
766 * Transforms a Not node.
768 * @param env The transformation environment
769 * @return the created ppc Not node
771 static ir_node *gen_Not(ppc32_transform_env_t *env) {
772 return new_rd_ppc32_Not(env->dbg, env->irg, env->block, get_Not_op(env->irn), env->mode);
776 static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, int mask)
778 ir_node *andi = new_rd_ppc32_Andi_dot(env->dbg, env->irg, env->block, op, mode_T);
780 set_ppc32_offset_mode(andi, ppc32_ao_Lo16);
781 set_ppc32_constant_tarval(andi, new_tarval_from_long(mask, mode_Is));
782 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,1);
783 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_condition], env->irg, env->block, 1, in);
784 return new_rd_Proj(env->dbg, env->irg, env->block, andi, env->mode,0);
788 * Transforms a Conv node.
790 * @param env The transformation environment
791 * @return the created ppc Conv node
793 static ir_node *gen_Conv(ppc32_transform_env_t *env) {
794 ir_node *op = get_Conv_op(env->irn);
795 modecode from_mode=get_nice_modecode(get_irn_mode(op));
796 modecode to_mode=get_nice_modecode(env->mode);
798 #define SKIP return op
800 if(from_mode == to_mode) SKIP;
816 return new_rd_ppc32_fRsp(env->dbg, env->irg, env->block, op, env->mode);
827 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
829 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);
847 if(from_mode==irm_Hu)
849 return own_gen_Andi_dot_lo16(env, op, 0xffff);
853 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
855 return own_gen_Andi_dot_lo16(env, op, 0xff);
857 return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
869 if(from_mode==irm_Bs)
871 return own_gen_Andi_dot_lo16(env, op, 0xff);
876 return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
882 if(to_mode==irm_Is || to_mode==irm_Iu) SKIP;
888 fprintf(stderr, "Mode for Conv not supported: %s -> %s\n",
889 get_mode_name(get_irn_mode(get_irn_n(env->irn,0))),get_mode_name(env->mode));
897 * Transforms an Abs node.
899 * @param env The transformation environment
900 * @return the ppc node generating the absolute value
902 static ir_node *gen_Abs(ppc32_transform_env_t *env) {
903 ir_node *op = get_Abs_op(env->irn);
907 switch(get_nice_modecode(env->mode))
911 return new_rd_ppc32_fAbs(env->dbg, env->irg, env->block, op, env->mode);
917 n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode);
918 set_ppc32_constant_tarval(n1, new_tarval_from_long(shift, mode_Is));
919 set_ppc32_offset_mode(n1, ppc32_ao_None);
920 n2 = new_rd_ppc32_Add(env->dbg, env->irg, env->block, op, n1, env->mode);
921 return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, n2, n1, env->mode);
925 fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode));
931 * Transforms an Cond node.
933 * @param env The transformation environment
934 * @return a ppc branch node
936 static ir_node *gen_Cond(ppc32_transform_env_t *env) {
937 ir_node *selector = get_Cond_selector(env->irn);
938 ir_mode *projmode = get_irn_mode(selector);
939 if(is_Proj(selector) && projmode==get_ppc32_mode_Cond())
941 int projnum = get_Proj_proj(selector);
942 ir_node *branch = new_rd_ppc32_Branch(env->dbg, env->irg, env->block, selector, env->mode);
943 set_ppc32_proj_nr(branch, projnum);
948 ir_node *unknown_gpr = new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, mode_Is);
949 ir_node *unknown_cond = new_rd_ppc32_cUnknown(env->dbg, env->irg, env->block, get_ppc32_mode_Cond());
951 ir_node *switch_node = new_rd_ppc32_Switch(env->dbg, env->irg, env->block, selector,
952 unknown_gpr, unknown_cond, env->mode);
953 set_ppc32_proj_nr(switch_node, get_Cond_defaultProj(env->irn));
960 * Transforms an Unknown node.
962 * @param env The transformation environment
963 * @return a ppc Unknown node
965 static ir_node *gen_Unknown(ppc32_transform_env_t *env) {
966 if(mode_is_float(env->mode))
967 return new_rd_ppc32_fUnknown(env->dbg, env->irg, env->block, env->mode);
968 else if (mode_is_int(env->mode))
969 return new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, env->mode);
972 fprintf(stderr, "Mode %s for unknown value not supported.\n", get_mode_name(env->mode));
978 static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32_transform_env_t *env) {
979 tarval *tv_const = NULL;
980 ident *id_symconst = NULL;
982 if(is_ppc32_Const(ptr))
984 tv_const = get_ppc32_constant_tarval(ptr);
985 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, tv_const, NULL);
987 else if(is_ppc32_SymConst(ptr))
989 ir_entity *ent = get_ppc32_frame_entity(ptr);
990 if(is_direct_entity(ent))
992 id_symconst = get_entity_ident(ent);
993 ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, NULL, id_symconst);
1002 * Transforms a Load.
1004 * @param env The transformation environment
1005 * @return the created ppc Load node
1007 static ir_node *gen_Load(ppc32_transform_env_t *env) {
1008 ir_node *node = env->irn;
1009 ir_node *loadptr = get_Load_ptr(node);
1011 ir_mode *mode = get_Load_mode(node);
1012 tarval *tv_const = NULL;
1013 ident *id_symconst = NULL;
1015 loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env);
1016 switch(get_nice_modecode(mode)){
1018 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1023 ir_node *proj_load, *extsb_node;
1024 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1025 proj_load = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1026 extsb_node = new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, proj_load, mode);
1027 exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node);
1033 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1036 load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1041 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1045 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1048 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
1052 fprintf(stderr, "Mode for Load not supported: %s\n", get_mode_name(env->mode));
1059 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1060 set_ppc32_constant_tarval(load, tv_const);
1062 else if(id_symconst)
1064 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1065 set_ppc32_symconst_ident(load, id_symconst);
1073 * Transforms a Store.
1075 * @param env The transformation environment
1076 * @return the created ppc Store node
1078 static ir_node *gen_Store(ppc32_transform_env_t *env) {
1079 ir_node *node = env->irn;
1080 ir_node *storeptr = get_Store_ptr(node);
1081 ir_node *valuenode = get_Store_value(node);
1082 ir_mode *mode = get_irn_mode(valuenode);
1084 tarval *tv_const = NULL;
1085 ident *id_symconst = NULL;
1087 storeptr = ldst_insert_const(storeptr, &tv_const, &id_symconst, env);
1089 switch(get_nice_modecode(mode)){
1092 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1097 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1102 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1106 store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1109 store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
1113 fprintf(stderr, "Mode for Store not supported: %s\n", get_mode_name(env->mode));
1119 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1120 set_ppc32_constant_tarval(store, tv_const);
1122 else if(id_symconst)
1124 set_ppc32_offset_mode(store, ppc32_ao_Lo16);
1125 set_ppc32_symconst_ident(store, id_symconst);
1131 * Transforms a CopyB.
1133 * @param env The transformation environment
1134 * @return the created ppc CopyB node
1136 static ir_node *gen_CopyB(ppc32_transform_env_t *env) {
1137 ir_node *mem = get_CopyB_mem(env->irn);
1138 ir_node *src = get_CopyB_src(env->irn);
1139 ir_node *dest = get_CopyB_dst(env->irn);
1140 ir_type *type = get_CopyB_type(env->irn);
1141 int size = get_type_size_bytes(type);
1144 ir_node *load, *store = NULL;
1149 tarval *offset0 = new_tarval_from_long(0, mode_Is);
1150 tarval *offset4 = new_tarval_from_long(4, mode_Is);
1152 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1153 set_ppc32_constant_tarval(load, offset0);
1154 set_ppc32_offset_mode(load, ppc32_ao_None);
1155 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1156 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1158 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1159 set_ppc32_constant_tarval(store, offset0);
1160 set_ppc32_offset_mode(store, ppc32_ao_None);
1161 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1165 load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
1166 set_ppc32_constant_tarval(load, offset4);
1167 set_ppc32_offset_mode(load, ppc32_ao_None);
1168 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1169 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1171 store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
1172 set_ppc32_constant_tarval(store, offset4);
1173 set_ppc32_offset_mode(store, ppc32_ao_None);
1174 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1180 ir_node *ornode, *mtctrnode;
1182 assert(size/4-1<=0xffff);
1185 ornode = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1186 set_ppc32_offset_mode(ornode, ppc32_ao_None);
1190 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1191 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1192 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1193 ornode = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1194 set_ppc32_offset_mode(ornode, ppc32_ao_Lo16);
1197 set_ppc32_constant_tarval(ornode, new_tarval_from_long(size/4-1, mode_Is));
1198 mtctrnode = new_rd_ppc32_Mtctr(env->dbg, env->irg, env->block, ornode, mode_Is);
1199 store = new_rd_ppc32_LoopCopy(env->dbg, env->irg, env->block, src, dest, mtctrnode, mem, mode_T);
1201 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 1); // src
1202 in[1] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 2); // dest
1203 in[2] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 4); // temp
1204 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_gp], env->irg, env->block, 3, in);
1205 in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 3); // ctr
1206 be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_count], env->irg, env->block, 1, in);
1208 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, 0);
1217 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1218 load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem);
1219 set_ppc32_constant_tarval(load, offset_tarval);
1220 set_ppc32_offset_mode(load, ppc32_ao_None);
1221 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1222 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1224 store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem);
1225 set_ppc32_constant_tarval(store, offset_tarval);
1226 set_ppc32_offset_mode(store, ppc32_ao_None);
1227 mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1235 tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
1236 load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem);
1237 set_ppc32_constant_tarval(load, offset_tarval);
1238 set_ppc32_offset_mode(load, ppc32_ao_None);
1239 mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
1240 res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
1242 store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem);
1243 set_ppc32_constant_tarval(store, offset_tarval);
1244 set_ppc32_offset_mode(store, ppc32_ao_None);
1245 // mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
1252 * Transforms a FrameAddr into a ppc Add.
1254 * @param env The transformation environment
1256 static ir_node *gen_be_FrameAddr(ppc32_transform_env_t *env) {
1257 ir_node *op = get_irn_n(env->irn, 0);
1258 ir_node *add = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op, mode_P);
1259 set_ppc32_frame_entity(add, be_get_frame_entity(env->irn));
1264 * Transforms a StackParam into a ppc Load
1266 * @param env The transformation environment
1268 static ir_node *gen_be_StackParam(ppc32_transform_env_t *env) {
1269 ir_node *load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, get_irn_n(env->irn, 0), new_NoMem());
1270 ir_node *proj = new_rd_Proj(env->dbg, env->irg, env->block, load, env->mode, pn_Load_res);
1271 set_ppc32_frame_entity(load, be_get_frame_entity(env->irn));
1276 /*********************************************************
1279 * _ __ ___ __ _ _ _ __ __| |_ __ ___ _____ _ __
1280 * | '_ ` _ \ / _` | | '_ \ / _` | '__| \ \ / / _ \ '__|
1281 * | | | | | | (_| | | | | | | (_| | | | |\ V / __/ |
1282 * |_| |_| |_|\__,_|_|_| |_| \__,_|_| |_| \_/ \___|_|
1284 *********************************************************/
1287 * the BAD transformer.
1289 static ir_node *bad_transform(ppc32_transform_env_t *env) {
1290 ir_fprintf(stderr, "Not implemented: %+F\n", env->irn);
1296 * Enters all transform functions into the generic pointer
1298 void ppc32_register_transformers(void) {
1299 ir_op *op_Max, *op_Min, *op_Mulh;
1301 /* first clear the generic function pointer for all ops */
1302 clear_irp_opcodes_generic_func();
1304 #define FIRM_OP(a) op_##a->ops.generic = (op_func)gen_##a
1305 #define BAD(a) op_##a->ops.generic = (op_func)bad_transform
1336 /* TODO: implement these nodes */
1339 /* You probably don't need to handle the following nodes */
1369 FIRM_OP(be_FrameAddr);
1370 FIRM_OP(be_StackParam);
1371 op_Mulh = get_op_Mulh();
1374 op_Max = get_op_Max();
1377 op_Min = get_op_Min();
1382 typedef ir_node *(transform_func)(ppc32_transform_env_t *env);
1385 * Transforms the given firm node (and maybe some other related nodes)
1386 * into one or more assembler nodes.
1388 * @param node the firm node
1389 * @param env the debug module
1391 void ppc32_transform_node(ir_node *node, void *env) {
1392 ppc32_code_gen_t *cg = (ppc32_code_gen_t *)env;
1393 ir_op *op = get_irn_op(node);
1394 ir_node *asm_node = NULL;
1399 DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
1401 if (op->ops.generic) {
1402 ppc32_transform_env_t tenv;
1403 transform_func *transform = (transform_func *)op->ops.generic;
1405 tenv.block = get_nodes_block(node);
1406 tenv.dbg = get_irn_dbg_info(node);
1407 tenv.irg = current_ir_graph;
1409 tenv.mode = get_irn_mode(node);
1410 DEBUG_ONLY(tenv.mod = cg->mod;)
1412 asm_node = (*transform)(&tenv);
1416 exchange(node, asm_node);
1417 DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1420 DB((cg->mod, LEVEL_1, "ignored\n"));
1425 * Constant generating code
1433 /** Compares two (entity, tarval) combinations */
1434 static int cmp_tv_ent(const void *a, const void *b, size_t len) {
1435 const struct tv_ent *e1 = a;
1436 const struct tv_ent *e2 = b;
1438 return !(e1->tv == e2->tv);
1441 /** Generates a SymConst node for a known FP const */
1442 static ir_node *gen_fp_known_symconst(ppc32_transform_env_t *env, tarval *known_const) {
1443 static set *const_set = NULL;
1444 static ir_type *tp = NULL;
1446 struct tv_ent *entry;
1447 ir_node *cnst,*symcnst;
1449 ir_entity *ent = NULL;
1452 const_set = new_set(cmp_tv_ent, 10);
1454 tp = new_type_primitive(new_id_from_str("const_double_t"), env->mode);
1456 key.tv = known_const;
1459 entry = set_insert(const_set, &key, sizeof(key), HASH_PTR(key.tv));
1463 sprintf(buf, "const_%ld", get_irn_node_nr(env->irn));
1464 ent = new_entity(get_glob_type(), new_id_from_str(buf), tp);
1466 set_entity_ld_ident(ent, get_entity_ident(ent));
1467 set_entity_visibility(ent, visibility_local);
1468 set_entity_variability(ent, variability_constant);
1469 set_entity_allocation(ent, allocation_static);
1471 /* we create a new entity here: It's initialization must resist on the
1473 rem = current_ir_graph;
1474 current_ir_graph = get_const_code_irg();
1475 cnst = new_Const(env->mode, key.tv);
1476 current_ir_graph = rem;
1478 set_atomic_ent_value(ent, cnst);
1480 /* set the entry for hashmap */
1482 } // TODO: Wird nicht richtig in global type gesteckt, ppc32_gen_decls.c findet ihn nicht
1484 symcnst = new_rd_ppc32_SymConst(env->dbg, env->irg, env->block, env->mode);
1485 set_ppc32_frame_entity(symcnst, ent);
1489 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env);
1492 * Transforms a Const.
1494 * @param mod the debug module
1495 * @param block the block the new node should belong to
1496 * @param node the ir Const node
1497 * @param mode node mode
1498 * @return the created ppc Load immediate node
1500 static ir_node *gen_ppc32_Const(ppc32_transform_env_t *env) {
1501 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1504 switch(get_nice_modecode(env->mode)){
1507 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1510 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1511 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1512 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1513 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1514 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);
1528 unsigned char val2 = get_tarval_sub_bits(tv_const,2);
1529 unsigned char val3 = get_tarval_sub_bits(tv_const,3);
1532 unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
1535 ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
1536 set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
1537 set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
1538 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
1539 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1543 node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
1544 set_ppc32_offset_mode(node, ppc32_ao_None);
1549 unsigned char val0 = get_tarval_sub_bits(tv_const,0);
1550 unsigned char val1 = get_tarval_sub_bits(tv_const,1);
1551 node = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, tv_const, NULL);
1554 set_ppc32_constant_tarval(node, tv_const);
1555 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node, env->mode);
1556 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1563 fprintf(stderr, "Mode for Const not supported: %s\n", get_mode_name(env->mode));
1567 set_ppc32_constant_tarval(node, tv_const);
1572 * Transforms a fConst.
1574 * @param mod the debug module
1575 * @param block the block the new node should belong to
1576 * @param node the ir Const node
1577 * @param mode node mode
1578 * @return the created ppc float Load node
1580 static ir_node *gen_ppc32_fConst(ppc32_transform_env_t *env) {
1581 tarval *tv_const = get_ppc32_constant_tarval(env->irn);
1583 switch(get_nice_modecode(env->mode)){
1587 ir_node *addr, *load;
1588 ir_mode *mode = env->mode;
1590 env->irn = gen_fp_known_symconst(env, tv_const);
1592 ent = get_ppc32_frame_entity(env->irn);
1593 if(is_direct_entity(ent))
1595 ident *id_symconst = get_entity_ident(ent);
1596 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1599 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1601 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1603 set_ppc32_symconst_ident(load, id_symconst);
1604 set_ppc32_offset_mode(load, ppc32_ao_Lo16);
1608 addr = gen_ppc32_SymConst (env);
1610 load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem());
1612 load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem());
1614 return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
1618 fprintf(stderr, "Mode for fConst not supported: %s\n", get_mode_name(env->mode));
1622 assert(0 && "Dead end!");
1627 * Returns true, if the entity can be accessed directly,
1628 * or false, if the address must be loaded first
1630 int is_direct_entity(ir_entity *ent) {
1631 return get_entity_visibility(ent)!=visibility_external_allocated;
1632 /* visibility vis = get_entity_visibility(ent);
1633 if(is_Method_type(get_entity_type(ent)))
1635 return (vis!=visibility_external_allocated);
1639 return (vis==visibility_local);
1644 * Transforms a SymConst.
1646 * @param mod the debug module
1647 * @param block the block the new node should belong to
1648 * @param node the ir Const node
1649 * @param mode node mode
1650 * @return the created ppc Load immediate node
1652 static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) {
1653 ir_entity *ent = get_ppc32_frame_entity(env->irn);
1654 ident *id_symconst = get_entity_ident(ent);
1656 switch(get_nice_modecode(env->mode)){
1659 if (is_direct_entity(ent))
1661 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, NULL, id_symconst);
1662 node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node_addis, env->mode);
1663 set_ppc32_symconst_ident(node, id_symconst);
1664 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1668 ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
1669 node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem());
1670 set_ppc32_symconst_ident(node, id_symconst);
1671 set_ppc32_offset_mode(node, ppc32_ao_Lo16);
1672 node = new_rd_Proj(env->dbg, env->irg, env->block, node, env->mode, pn_Load_res);
1673 // pset_insert_ptr(symbol_pset, ent);
1679 fprintf(stderr, "Mode for SymConst not supported: %s\n", get_mode_name(env->mode));
1687 * Transforms the given firm node (and maybe some other related nodes)
1688 * into one or more assembler nodes.
1690 * @param node the firm node
1691 * @param env the debug module
1693 void ppc32_transform_const(ir_node *node, void *env) {
1694 ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env;
1695 ir_node *asm_node = NULL;
1696 ppc32_transform_env_t tenv;
1701 tenv.block = get_nodes_block(node);
1702 tenv.dbg = get_irn_dbg_info(node);
1703 tenv.irg = current_ir_graph;
1705 DEBUG_ONLY(tenv.mod = cgenv->mod;)
1706 tenv.mode = get_irn_mode(node);
1708 #define OTHER_GEN(a) \
1709 if (get_irn_op(node) == get_op_##a()) { \
1710 asm_node = gen_##a(&tenv); \
1713 DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1715 OTHER_GEN(ppc32_Const)
1716 else OTHER_GEN(ppc32_fConst)
1717 else OTHER_GEN(ppc32_SymConst)
1720 exchange(node, asm_node);
1721 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1724 DB((tenv.mod, LEVEL_1, "ignored\n"));