1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
12 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
13 "Gt", "Ge", "Lg", "Leg", "Uo",
14 "Ue", "Ul", "Ule", "Ug", "Uge",
17 inline char *get_pnc_string(int pnc) {
18 return pnc_name_arr[pnc];
23 get_negated_pnc(int pnc) {
25 case False: return True; break;
26 case Eq: return Ne; break;
27 case Lt: return Uge; break;
28 case Le: return Ug; break;
29 case Gt: return Ule; break;
30 case Ge: return Ul; break;
31 case Lg: return Ue; break;
32 case Leg: return Uo; break;
33 case Uo: return Leg; break;
34 case Ue: return Lg; break;
35 case Ul: return Ge; break;
36 case Ule: return Gt; break;
37 case Ug: return Le; break;
38 case Uge: return Lt; break;
39 case Ne: return Eq; break;
40 case True: return False; break;
42 return 99; /* to shut up gcc */
45 static char *pns_name_arr [] = {"initial_exec", "global_store",
46 "frame_base", "globals", "args"};
48 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
57 /* irnode constructor */
58 /* create a new irnode in irg, with an op, mode, arity and */
59 /* some incoming irnodes */
60 /* this constructor is used in every specified irnode constructor */
62 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
63 int arity, ir_node **in)
66 int node_size = offsetof (ir_node, attr) + op->attr_size;
68 res = (ir_node *) obstack_alloc (irg->obst, node_size);
70 res->kind = k_ir_node;
76 res->in = NEW_ARR_F (ir_node *, 1);
78 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
79 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
86 /* IR-Nodes with attributes */
88 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
91 ir_node *np = XP_GETARG (ir_node *, 0);
94 XPS ("<null ir_node>");
98 XPF1 ("%I", get_irn_op(np)->name);
100 switch (get_irn_opcode (np)) { /* node label */
102 XPF1 ("%I", get_irn_mode(np)->name);
104 XPF1 ("%v", get_irn_const_attr);
107 if (get_irn_modecode (np) == irm_b) {
109 XP (pnc_name_arr[get_irn_proj_attr(np)]);
110 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
112 XP (pns_name_arr[get_irn_proj_attr(np)]);
114 XPF1 ("%I", get_irn_mode(np)->name);
116 XPF1 ("%d", get_irn_proj_attr(np));
120 XPF1 ("%I", get_irn_mode(np)->name);
122 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
123 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
125 case iro_Start: /* don't dump mode of these */
134 XPF1 ("%I", get_irn_mode(np)->name);
141 /** getting some parameters from ir_nodes **/
143 /* returns the number of predecessors without the block predecessor. */
145 get_irn_arity (ir_node *node)
148 return (ARR_LEN((node)->in)-1);
151 /* returns the array with ins */
153 get_irn_in (ir_node *node)
159 /* to iterate through the predecessors without touching the array */
160 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
161 to iterate includind the Block predecessor iterate from i = -1 to
162 i < get_irn_arity. */
164 get_irn_n (ir_node *node, int n)
167 // assert (get_irn_arity (node) > n);
168 return skip_nop(node->in[n+1]);
172 set_irn_n (ir_node *node, int n, ir_node *in)
175 assert (get_irn_arity (node) > n);
180 get_irn_mode (ir_node *node)
187 get_irn_modecode (ir_node *node)
190 return node->mode->code;
194 get_irn_op (ir_node *node)
200 /* should be private to the library: */
202 set_irn_op (ir_node *node, ir_op *op)
209 get_irn_opcode (ir_node *node)
212 return node->op->code;
216 set_irn_link (ir_node *node, ir_node *link) {
222 get_irn_link (ir_node *node) {
228 get_irn_const_attr (ir_node *node)
230 assert (node->op == op_Const);
231 return node->attr.con;
235 get_irn_proj_attr (ir_node *node)
237 assert (node->op == op_Proj);
238 return node->attr.proj;
242 get_irn_alloc_attr (ir_node *node)
244 assert (node->op == op_Alloc);
249 get_irn_free_attr (ir_node *node)
251 assert (node->op == op_Free);
256 get_irn_symconst_attr (ir_node *node)
258 assert (node->op == op_SymConst);
263 get_irn_call_attr (ir_node *node)
265 assert (node->op == op_Call);
266 return node->attr.call;
270 get_irn_sel_attr (ir_node *node)
272 assert (node->op == op_Sel);
277 get_irn_phi_attr (ir_node *node)
279 assert (node->op == op_Phi);
280 return node->attr.phi0_pos;
284 get_irn_block_attr (ir_node *node)
286 assert (node->op == op_Block);
287 return node->attr.block;
290 /** manipulate fields of individual nodes **/
292 /* this works for all except Block */
294 get_nodes_Block (ir_node *node) {
295 assert (!(node->op == op_Block));
296 return get_irn_n(node, -1);
300 set_nodes_Block (ir_node *node, ir_node *block) {
301 assert (!(node->op == op_Block));
302 set_irn_n(node, -1, block);
306 get_Block_n_cfgpreds (ir_node *node) {
307 assert ((node->op == op_Block));
308 return (get_irn_arity(node));
313 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
314 assert ((node->op == op_Block));
319 get_Block_cfgpred (ir_node *node, int pos) {
320 assert (node->op == op_Block);
321 return get_irn_n(node, pos);
325 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
326 assert (node->op == op_Block);
327 set_irn_n(node, pos, pred);
331 get_Block_matured (ir_node *node) {
332 assert (node->op == op_Block);
333 return node->attr.block.matured;
337 set_Block_matured (ir_node *node, bool matured) {
338 assert (node->op == op_Block);
339 node->attr.block.matured = matured;
342 get_Block_block_visit (ir_node *node) {
343 assert (node->op == op_Block);
344 return node->attr.block.block_visit;
348 set_Block_block_visit (ir_node *node, unsigned long visit) {
349 assert (node->op == op_Block);
350 node->attr.block.block_visit = visit;
354 get_Block_graph_arr (ir_node *node, int pos) {
355 assert (node->op == op_Block);
356 return node->attr.block.graph_arr[pos+1];
360 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
361 assert (node->op == op_Block);
362 node->attr.block.graph_arr[pos+1] = value;
366 get_Cond_selector (ir_node *node) {
367 assert (node->op == op_Cond);
368 return get_irn_n(node, 0);
372 set_Cond_selector (ir_node *node, ir_node *selector) {
373 assert (node->op == op_Cond);
374 set_irn_n(node, 0, selector);
378 get_Return_mem (ir_node *node) {
379 assert (node->op == op_Cond);
380 return get_irn_n(node, 0);
384 set_Return_mem (ir_node *node, ir_node *mem) {
385 assert (node->op == op_Return);
386 set_irn_n(node, 0, mem);
390 get_Return_n_res (ir_node *node) {
391 assert (node->op == op_Return);
392 return (get_irn_arity(node) - 1);
397 set_Return_n_res (ir_node *node, int results) {
398 assert (node->op == op_Return);
403 get_Return_res (ir_node *node, int pos) {
404 assert (node->op == op_Return);
405 return get_irn_n(node, pos+1);
409 set_Return_res (ir_node *node, int pos, ir_node *res){
410 assert (node->op == op_Raise);
411 set_irn_n(node, pos+1, res);
415 get_Raise_mem (ir_node *node) {
416 assert (node->op == op_Return);
417 return get_irn_n(node, 0);
421 set_Raise_mem (ir_node *node, ir_node *mem) {
422 assert (node->op == op_Raise);
423 set_irn_n(node, 0, mem);
427 get_Raise_exo_ptr (ir_node *node) {
428 assert (node->op == op_Raise);
429 return get_irn_n(node, 1);
433 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
434 assert (node->op == op_Raise);
435 set_irn_n(node, 1, exo_ptr);
438 inline tarval *get_Const_tarval (ir_node *node) {
439 assert (node->op == op_Const);
440 return get_irn_const_attr(node);
444 set_Const_tarval (ir_node *node, tarval *con) {
445 assert (node->op == op_Const);
446 node->attr.con = con;
450 get_SymConst_kind (ir_node *node) {
451 assert (node->op == op_SymConst);
452 return node->attr.i.num;
456 set_SymConst_kind (ir_node *node, symconst_kind num) {
457 assert (node->op == op_SymConst);
458 node->attr.i.num = num;
462 get_SymConst_type (ir_node *node) {
463 assert ( (node->op == op_SymConst)
464 && ( get_SymConst_kind(node) == type_tag
465 || get_SymConst_kind(node) == size));
466 return node->attr.i.tori.typ;
470 set_SymConst_type (ir_node *node, type *type) {
471 assert ( (node->op == op_SymConst)
472 && ( get_SymConst_kind(node) == type_tag
473 || get_SymConst_kind(node) == size));
474 node->attr.i.tori.typ = type;
478 get_SymConst_ptrinfo (ir_node *node) {
479 assert ( (node->op == op_SymConst)
480 && (get_SymConst_kind(node) == linkage_ptr_info));
481 return node->attr.i.tori.ptrinfo;
487 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
488 assert ( (node->op == op_SymConst)
489 && (get_SymConst_kind(node) == linkage_ptr_info));
490 node->attr.i.tori.ptrinfo = ptrinfo;
494 get_Sel_mem (ir_node *node) {
495 assert (node->op == op_Sel);
496 return get_irn_n(node, 0);
500 set_Sel_mem (ir_node *node, ir_node *mem) {
501 assert (node->op == op_Sel);
502 set_irn_n(node, 0, mem);
506 get_Sel_ptr (ir_node *node) {
507 assert (node->op == op_Sel);
508 return get_irn_n(node, 1);
512 set_Sel_ptr (ir_node *node, ir_node *ptr) {
513 assert (node->op == op_Sel);
514 set_irn_n(node, 1, ptr);
518 get_Sel_n_index (ir_node *node) {
519 assert (node->op == op_Sel);
520 return (get_irn_arity(node) - 2);
525 set_Sel_n_index (ir_node *node, int n_index) {
526 assert (node->op == op_Sel);
531 get_Sel_index (ir_node *node, int pos) {
532 assert (node->op == op_Sel);
533 return get_irn_n(node, pos+2);
537 set_Sel_index (ir_node *node, int pos, ir_node *index) {
538 assert (node->op == op_Sel);
539 set_irn_n(node, pos+2, index);
543 get_Sel_entity (ir_node *node) {
544 assert (node->op == op_Sel);
545 return node->attr.s.ent;
549 set_Sel_entity (ir_node *node, entity *ent) {
550 assert (node->op == op_Sel);
551 node->attr.s.ent = ent;
555 get_Sel_linkage_type (ir_node *node) {
556 assert (node->op == op_Sel);
557 return node->attr.s.ltyp;
561 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
562 assert (node->op == op_Sel);
563 node->attr.s.ltyp = lt;
567 get_Call_mem (ir_node *node) {
568 assert (node->op == op_Call);
569 return get_irn_n(node, 0);
573 set_Call_mem (ir_node *node, ir_node *mem) {
574 assert (node->op == op_Call);
575 set_irn_n(node, 0, mem);
579 get_Call_ptr (ir_node *node) {
580 assert (node->op == op_Call);
581 return get_irn_n(node, 1);
585 set_Call_ptr (ir_node *node, ir_node *ptr) {
586 assert (node->op == op_Call);
587 set_irn_n(node, 1, ptr);
591 get_Call_arity (ir_node *node) {
592 assert (node->op == op_Call);
593 return (get_irn_arity(node) - 2);
597 set_Call_arity (ir_node *node, ir_node *arity) {
598 assert (node->op == op_Call);
603 get_Call_param (ir_node *node, int pos) {
604 assert (node->op == op_Call);
605 return get_irn_n(node, pos+1);
609 set_Call_param (ir_node *node, int pos, ir_node *param) {
610 assert (node->op == op_Call);
611 set_irn_n(node, pos+1, param);
615 get_Call_type (ir_node *node) {
616 assert (node->op == op_Call);
617 return node->attr.call;
621 set_Call_type (ir_node *node, type_method *type) {
622 assert (node->op == op_Call);
623 node->attr.call = type;
626 /* For unary and binary arithmetic operations the access to the
627 operands can be factored out. Left is the first, right the
628 second arithmetic value as listed in tech report 0999-33.
629 unops are: Minus, Abs, Not, Conv
630 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
631 Shr, Shrs, Rotate, Cmp */
634 is_unop (ir_node *node) {
635 return ( node->op == op_Minus ||
636 node->op == op_Abs ||
637 node->op == op_Not ||
638 node->op == op_Conv );
642 get_unop_op (ir_node *node) {
643 assert ( node->op == op_Minus ||
644 node->op == op_Abs ||
645 node->op == op_Not ||
646 node->op == op_Conv );
647 switch (get_irn_opcode (node)) {
648 case iro_Minus: return get_Minus_op(node); break;
649 case iro_Abs: return get_Abs_op(node); break;
650 case iro_Not: return get_Not_op(node); break;
651 case iro_Conv: return get_Conv_op(node); break;
652 default: return NULL;
657 set_unop_op (ir_node *node, ir_node *op) {
658 assert (node->op == op_Minus ||
659 node->op == op_Abs ||
660 node->op == op_Not ||
661 node->op == op_Conv );
662 switch (get_irn_opcode (node)) {
663 case iro_Minus: set_Minus_op(node, op); break;
664 case iro_Abs: set_Abs_op(node, op); break;
665 case iro_Not: set_Not_op(node, op); break;
666 case iro_Conv: set_Conv_op(node, op); break;
673 is_binop (ir_node *node) {
674 return (node->op == op_Add ||
675 node->op == op_Sub ||
676 node->op == op_Mul ||
677 node->op == op_Quot ||
678 node->op == op_DivMod ||
679 node->op == op_Div ||
680 node->op == op_Mod ||
681 node->op == op_And ||
683 node->op == op_Eor ||
684 node->op == op_Shl ||
685 node->op == op_Shr ||
686 node->op == op_Shrs ||
687 node->op == op_Rot ||
688 node->op == op_Cmp );
692 get_binop_left (ir_node *node) {
693 assert (node->op == op_Add ||
694 node->op == op_Sub ||
695 node->op == op_Mul ||
696 node->op == op_Quot ||
697 node->op == op_DivMod ||
698 node->op == op_Div ||
699 node->op == op_Mod ||
700 node->op == op_And ||
702 node->op == op_Eor ||
703 node->op == op_Shl ||
704 node->op == op_Shr ||
705 node->op == op_Shrs ||
706 node->op == op_Rot ||
707 node->op == op_Cmp );
709 switch (get_irn_opcode (node)) {
710 case iro_Add : return get_Add_left(node); break;
711 case iro_Sub : return get_Sub_left(node); break;
712 case iro_Mul : return get_Mul_left(node); break;
713 case iro_Quot : return get_Quot_left(node); break;
714 case iro_DivMod: return get_DivMod_left(node); break;
715 case iro_Div : return get_Div_left(node); break;
716 case iro_Mod : return get_Mod_left(node); break;
717 case iro_And : return get_And_left(node); break;
718 case iro_Or : return get_Or_left(node); break;
719 case iro_Eor : return get_Eor_left(node); break;
720 case iro_Shl : return get_Shl_left(node); break;
721 case iro_Shr : return get_Shr_left(node); break;
722 case iro_Shrs : return get_Shrs_left(node); break;
723 case iro_Rot : return get_Rot_left(node); break;
724 case iro_Cmp : return get_Cmp_left(node); break;
725 default: return NULL;
730 set_binop_left (ir_node *node, ir_node *left) {
731 assert (node->op == op_Add ||
732 node->op == op_Sub ||
733 node->op == op_Mul ||
734 node->op == op_Quot ||
735 node->op == op_DivMod ||
736 node->op == op_Div ||
737 node->op == op_Mod ||
738 node->op == op_And ||
740 node->op == op_Eor ||
741 node->op == op_Shl ||
742 node->op == op_Shr ||
743 node->op == op_Shrs ||
744 node->op == op_Rot ||
745 node->op == op_Cmp );
747 switch (get_irn_opcode (node)) {
748 case iro_Add : set_Add_left(node, left); break;
749 case iro_Sub : set_Sub_left(node, left); break;
750 case iro_Mul : set_Mul_left(node, left); break;
751 case iro_Quot : set_Quot_left(node, left); break;
752 case iro_DivMod: set_DivMod_left(node, left); break;
753 case iro_Div : set_Div_left(node, left); break;
754 case iro_Mod : set_Mod_left(node, left); break;
755 case iro_And : set_And_left(node, left); break;
756 case iro_Or : set_Or_left(node, left); break;
757 case iro_Eor : set_Eor_left(node, left); break;
758 case iro_Shl : set_Shl_left(node, left); break;
759 case iro_Shr : set_Shr_left(node, left); break;
760 case iro_Shrs : set_Shrs_left(node, left); break;
761 case iro_Rot : set_Rot_left(node, left); break;
762 case iro_Cmp : set_Cmp_left(node, left); break;
768 get_binop_right (ir_node *node) {
769 assert (node->op == op_Add ||
770 node->op == op_Sub ||
771 node->op == op_Mul ||
772 node->op == op_Quot ||
773 node->op == op_DivMod ||
774 node->op == op_Div ||
775 node->op == op_Mod ||
776 node->op == op_And ||
778 node->op == op_Eor ||
779 node->op == op_Shl ||
780 node->op == op_Shr ||
781 node->op == op_Shrs ||
782 node->op == op_Rot ||
783 node->op == op_Cmp );
785 switch (get_irn_opcode (node)) {
786 case iro_Add : return get_Add_right(node); break;
787 case iro_Sub : return get_Sub_right(node); break;
788 case iro_Mul : return get_Mul_right(node); break;
789 case iro_Quot : return get_Quot_right(node); break;
790 case iro_DivMod: return get_DivMod_right(node); break;
791 case iro_Div : return get_Div_right(node); break;
792 case iro_Mod : return get_Mod_right(node); break;
793 case iro_And : return get_And_right(node); break;
794 case iro_Or : return get_Or_right(node); break;
795 case iro_Eor : return get_Eor_right(node); break;
796 case iro_Shl : return get_Shl_right(node); break;
797 case iro_Shr : return get_Shr_right(node); break;
798 case iro_Shrs : return get_Shrs_right(node); break;
799 case iro_Rot : return get_Rot_right(node); break;
800 case iro_Cmp : return get_Cmp_right(node); break;
801 default: return NULL;
806 set_binop_right (ir_node *node, ir_node *right) {
807 assert (node->op == op_Add ||
808 node->op == op_Sub ||
809 node->op == op_Mul ||
810 node->op == op_Quot ||
811 node->op == op_DivMod ||
812 node->op == op_Div ||
813 node->op == op_Mod ||
814 node->op == op_And ||
816 node->op == op_Eor ||
817 node->op == op_Shl ||
818 node->op == op_Shr ||
819 node->op == op_Shrs ||
820 node->op == op_Rot ||
821 node->op == op_Cmp );
823 switch (get_irn_opcode (node)) {
824 case iro_Add : set_Add_right(node, right); break;
825 case iro_Sub : set_Sub_right(node, right); break;
826 case iro_Mul : set_Mul_right(node, right); break;
827 case iro_Quot : set_Quot_right(node, right); break;
828 case iro_DivMod: set_DivMod_right(node, right); break;
829 case iro_Div : set_Div_right(node, right); break;
830 case iro_Mod : set_Mod_right(node, right); break;
831 case iro_And : set_And_right(node, right); break;
832 case iro_Or : set_Or_right(node, right); break;
833 case iro_Eor : set_Eor_right(node, right); break;
834 case iro_Shl : set_Shl_right(node, right); break;
835 case iro_Shr : set_Shr_right(node, right); break;
836 case iro_Shrs : set_Shrs_right(node, right); break;
837 case iro_Rot : set_Rot_right(node, right); break;
838 case iro_Cmp : set_Cmp_right(node, right); break;
844 get_Add_left (ir_node *node) {
845 assert (node->op == op_Add);
846 return get_irn_n(node, 0);
850 set_Add_left (ir_node *node, ir_node *left) {
851 assert (node->op == op_Add);
852 set_irn_n(node, 0, left);
856 get_Add_right (ir_node *node) {
857 assert (node->op == op_Add);
858 return get_irn_n(node, 1);
862 set_Add_right (ir_node *node, ir_node *right) {
863 assert (node->op == op_Add);
864 set_irn_n(node, 1, right);
868 get_Sub_left (ir_node *node) {
869 assert (node->op == op_Sub);
870 return get_irn_n(node, 0);
874 set_Sub_left (ir_node *node, ir_node *left) {
875 assert (node->op == op_Sub);
876 set_irn_n(node, 0, left);
880 get_Sub_right (ir_node *node) {
881 assert (node->op == op_Sub);
882 return get_irn_n(node, 1);
886 set_Sub_right (ir_node *node, ir_node *right) {
887 assert (node->op == op_Sub);
888 set_irn_n(node, 1, right);
893 get_Minus_op (ir_node *node) {
894 assert (node->op == op_Minus);
895 return get_irn_n(node, 0);
899 set_Minus_op (ir_node *node, ir_node *op) {
900 assert (node->op == op_Minus);
901 set_irn_n(node, 0, op);
906 get_Mul_left (ir_node *node) {
907 assert (node->op == op_Mul);
908 return get_irn_n(node, 0);
912 set_Mul_left (ir_node *node, ir_node *left) {
913 assert (node->op == op_Mul);
914 set_irn_n(node, 0, left);
918 get_Mul_right (ir_node *node) {
919 assert (node->op == op_Mul);
920 return get_irn_n(node, 1);
924 set_Mul_right (ir_node *node, ir_node *right) {
925 assert (node->op == op_Mul);
926 set_irn_n(node, 1, right);
930 get_Quot_left (ir_node *node) {
931 assert (node->op == op_Quot);
932 return get_irn_n(node, 1);
936 set_Quot_left (ir_node *node, ir_node *left) {
937 assert (node->op == op_Quot);
938 set_irn_n(node, 1, left);
942 get_Quot_right (ir_node *node) {
943 assert (node->op == op_Quot);
944 return get_irn_n(node, 2);
948 set_Quot_right (ir_node *node, ir_node *right) {
949 assert (node->op == op_Quot);
950 set_irn_n(node, 2, right);
954 get_Quot_mem (ir_node *node) {
955 assert (node->op == op_Quot);
956 return get_irn_n(node, 0);
960 set_Quot_mem (ir_node *node, ir_node *mem) {
961 assert (node->op == op_Quot);
962 set_irn_n(node, 0, mem);
966 get_DivMod_left (ir_node *node) {
967 assert (node->op == op_DivMod);
968 return get_irn_n(node, 1);
972 set_DivMod_left (ir_node *node, ir_node *left) {
973 assert (node->op == op_DivMod);
974 set_irn_n(node, 1, left);
978 get_DivMod_right (ir_node *node) {
979 assert (node->op == op_DivMod);
980 return get_irn_n(node, 2);
984 set_DivMod_right (ir_node *node, ir_node *right) {
985 assert (node->op == op_DivMod);
986 set_irn_n(node, 2, right);
990 get_DivMod_mem (ir_node *node) {
991 assert (node->op == op_DivMod);
992 return get_irn_n(node, 0);
996 set_DivMod_mem (ir_node *node, ir_node *mem) {
997 assert (node->op == op_DivMod);
998 set_irn_n(node, 0, mem);
1002 get_Div_left (ir_node *node) {
1003 assert (node->op == op_Div);
1004 return get_irn_n(node, 1);
1008 set_Div_left (ir_node *node, ir_node *left) {
1009 assert (node->op == op_Div);
1010 set_irn_n(node, 1, left);
1014 get_Div_right (ir_node *node) {
1015 assert (node->op == op_Div);
1016 return get_irn_n(node, 2);
1020 set_Div_right (ir_node *node, ir_node *right) {
1021 assert (node->op == op_Div);
1022 set_irn_n(node, 2, right);
1026 get_Div_mem (ir_node *node) {
1027 assert (node->op == op_Div);
1028 return get_irn_n(node, 0);
1032 set_Div_mem (ir_node *node, ir_node *mem) {
1033 assert (node->op == op_Div);
1034 set_irn_n(node, 0, mem);
1038 get_Mod_left (ir_node *node) {
1039 assert (node->op == op_Mod);
1040 return get_irn_n(node, 1);
1044 set_Mod_left (ir_node *node, ir_node *left) {
1045 assert (node->op == op_Mod);
1046 set_irn_n(node, 1, left);
1050 get_Mod_right (ir_node *node) {
1051 assert (node->op == op_Mod);
1052 return get_irn_n(node, 2);
1056 set_Mod_right (ir_node *node, ir_node *right) {
1057 assert (node->op == op_Mod);
1058 set_irn_n(node, 2, right);
1062 get_Mod_mem (ir_node *node) {
1063 assert (node->op == op_Mod);
1064 return get_irn_n(node, 0);
1068 set_Mod_mem (ir_node *node, ir_node *mem) {
1069 assert (node->op == op_Mod);
1070 set_irn_n(node, 0, mem);
1074 get_Abs_op (ir_node *node) {
1075 assert (node->op == op_Abs);
1076 return get_irn_n(node, 0);
1080 set_Abs_op (ir_node *node, ir_node *op) {
1081 assert (node->op == op_Abs);
1082 set_irn_n(node, 0, op);
1086 get_And_left (ir_node *node) {
1087 assert (node->op == op_And);
1088 return get_irn_n(node, 0);
1092 set_And_left (ir_node *node, ir_node *left) {
1093 assert (node->op == op_And);
1094 set_irn_n(node, 0, left);
1098 get_And_right (ir_node *node) {
1099 assert (node->op == op_And);
1100 return get_irn_n(node, 1);
1104 set_And_right (ir_node *node, ir_node *right) {
1105 assert (node->op == op_And);
1106 set_irn_n(node, 1, right);
1110 get_Or_left (ir_node *node) {
1111 assert (node->op == op_Or);
1112 return get_irn_n(node, 0);
1116 set_Or_left (ir_node *node, ir_node *left) {
1117 assert (node->op == op_Or);
1118 set_irn_n(node, 0, left);
1122 get_Or_right (ir_node *node) {
1123 assert (node->op == op_Or);
1124 return get_irn_n(node, 1);
1128 set_Or_right (ir_node *node, ir_node *right) {
1129 assert (node->op == op_Or);
1130 set_irn_n(node, 1, right);
1134 get_Eor_left (ir_node *node) {
1135 assert (node->op == op_Eor);
1136 return get_irn_n(node, 0);
1140 set_Eor_left (ir_node *node, ir_node *left) {
1141 assert (node->op == op_Eor);
1142 set_irn_n(node, 0, left);
1146 get_Eor_right (ir_node *node) {
1147 assert (node->op == op_Eor);
1148 return get_irn_n(node, 1);
1152 set_Eor_right (ir_node *node, ir_node *right) {
1153 assert (node->op == op_Eor);
1154 set_irn_n(node, 1, right);
1159 get_Not_op (ir_node *node) {
1160 assert (node->op == op_Not);
1161 return get_irn_n(node, 0);
1165 set_Not_op (ir_node *node, ir_node *op) {
1166 assert (node->op == op_Not);
1167 set_irn_n(node, 0, op);
1172 get_Shl_left (ir_node *node) {
1173 assert (node->op == op_Shl);
1174 return get_irn_n(node, 0);
1178 set_Shl_left (ir_node *node, ir_node *left) {
1179 assert (node->op == op_Shl);
1180 set_irn_n(node, 0, left);
1184 get_Shl_right (ir_node *node) {
1185 assert (node->op == op_Shl);
1186 return get_irn_n(node, 1);
1190 set_Shl_right (ir_node *node, ir_node *right) {
1191 assert (node->op == op_Shl);
1192 set_irn_n(node, 1, right);
1196 get_Shr_left (ir_node *node) {
1197 assert (node->op == op_Shr);
1198 return get_irn_n(node, 0);
1202 set_Shr_left (ir_node *node, ir_node *left) {
1203 assert (node->op == op_Shr);
1204 set_irn_n(node, 0, left);
1208 get_Shr_right (ir_node *node) {
1209 assert (node->op == op_Shr);
1210 return get_irn_n(node, 1);
1214 set_Shr_right (ir_node *node, ir_node *right) {
1215 assert (node->op == op_Shr);
1216 set_irn_n(node, 1, right);
1220 get_Shrs_left (ir_node *node) {
1221 assert (node->op == op_Shrs);
1222 return get_irn_n(node, 0);
1226 set_Shrs_left (ir_node *node, ir_node *left) {
1227 assert (node->op == op_Shrs);
1228 set_irn_n(node, 0, left);
1232 get_Shrs_right (ir_node *node) {
1233 assert (node->op == op_Shrs);
1234 return get_irn_n(node, 1);
1238 set_Shrs_right (ir_node *node, ir_node *right) {
1239 assert (node->op == op_Shrs);
1240 set_irn_n(node, 1, right);
1244 get_Rot_left (ir_node *node) {
1245 assert (node->op == op_Rot);
1246 return get_irn_n(node, 0);
1250 set_Rot_left (ir_node *node, ir_node *left) {
1251 assert (node->op == op_Rot);
1252 set_irn_n(node, 0, left);
1256 get_Rot_right (ir_node *node) {
1257 assert (node->op == op_Rot);
1258 return get_irn_n(node, 1);
1262 set_Rot_right (ir_node *node, ir_node *right) {
1263 assert (node->op == op_Rot);
1264 set_irn_n(node, 1, right);
1268 get_Cmp_left (ir_node *node) {
1269 assert (node->op == op_Cmp);
1270 return get_irn_n(node, 0);
1274 set_Cmp_left (ir_node *node, ir_node *left) {
1275 assert (node->op == op_Cmp);
1276 set_irn_n(node, 0, left);
1280 get_Cmp_right (ir_node *node) {
1281 assert (node->op == op_Cmp);
1282 return get_irn_n(node, 1);
1286 set_Cmp_right (ir_node *node, ir_node *right) {
1287 assert (node->op == op_Cmp);
1288 set_irn_n(node, 1, right);
1292 get_Conv_op (ir_node *node) {
1293 assert (node->op == op_Conv);
1294 return get_irn_n(node, 0);
1298 set_Conv_op (ir_node *node, ir_node *op) {
1299 assert (node->op == op_Conv);
1300 set_irn_n(node, 0, op);
1304 get_Phi_n_preds (ir_node *node) {
1305 assert (node->op == op_Phi);
1306 return (get_irn_arity(node));
1310 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1311 assert (node->op == op_Phi);
1316 get_Phi_pred (ir_node *node, int pos) {
1317 assert (node->op == op_Phi);
1318 return get_irn_n(node, pos);
1322 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1323 assert (node->op == op_Phi);
1324 set_irn_n(node, pos, pred);
1328 get_Load_mem (ir_node *node) {
1329 assert (node->op == op_Load);
1330 return get_irn_n(node, 0);
1334 set_Load_mem (ir_node *node, ir_node *mem) {
1335 assert (node->op == op_Load);
1336 set_irn_n(node, 0, mem);
1340 get_Load_ptr (ir_node *node) {
1341 assert (node->op == op_Load);
1342 return get_irn_n(node, 1);
1346 set_Load_ptr (ir_node *node, ir_node *ptr) {
1347 assert (node->op == op_Load);
1348 set_irn_n(node, 1, ptr);
1353 get_Store_mem (ir_node *node) {
1354 assert (node->op == op_Store);
1355 return get_irn_n(node, 0);
1359 set_Store_mem (ir_node *node, ir_node *mem) {
1360 assert (node->op == op_Store);
1361 set_irn_n(node, 0, mem);
1365 get_Store_ptr (ir_node *node) {
1366 assert (node->op == op_Store);
1367 return get_irn_n(node, 1);
1371 set_Store_ptr (ir_node *node, ir_node *ptr) {
1372 assert (node->op == op_Store);
1373 set_irn_n(node, 1, ptr);
1377 get_Store_value (ir_node *node) {
1378 assert (node->op == op_Store);
1379 return get_irn_n(node, 2);
1383 set_Store_value (ir_node *node, ir_node *value) {
1384 assert (node->op == op_Store);
1385 set_irn_n(node, 2, value);
1389 get_Alloc_mem (ir_node *node) {
1390 assert (node->op == op_Alloc);
1391 return get_irn_n(node, 0);
1395 set_Alloc_mem (ir_node *node, ir_node *mem) {
1396 assert (node->op == op_Alloc);
1397 set_irn_n(node, 0, mem);
1401 get_Alloc_size (ir_node *node) {
1402 assert (node->op == op_Alloc);
1403 return get_irn_n(node, 1);
1407 set_Allco_size (ir_node *node, ir_node *size) {
1408 assert (node->op == op_Alloc);
1409 set_irn_n(node, 1, size);
1413 get_Alloc_type (ir_node *node) {
1414 assert (node->op == op_Alloc);
1415 return node->attr.a.type;
1419 set_Alloc_type (ir_node *node, type *type) {
1420 assert (node->op == op_Alloc);
1421 node->attr.a.type = type;
1425 get_Alloc_where (ir_node *node) {
1426 assert (node->op == op_Alloc);
1427 return node->attr.a.where;
1431 set_Alloc_where (ir_node *node, where_alloc where) {
1432 assert (node->op == op_Alloc);
1433 node->attr.a.where = where;
1438 get_Free_mem (ir_node *node) {
1439 assert (node->op == op_Free);
1440 return get_irn_n(node, 0);
1444 set_Free_mem (ir_node *node, ir_node *mem) {
1445 assert (node->op == op_Free);
1446 set_irn_n(node, 0, mem);
1450 get_Free_ptr (ir_node *node) {
1451 assert (node->op == op_Free);
1452 return get_irn_n(node, 1);
1456 set_Free_ptr (ir_node *node, ir_node *ptr) {
1457 assert (node->op == op_Free);
1458 set_irn_n(node, 1, ptr);
1462 get_Free_size (ir_node *node) {
1463 assert (node->op == op_Free);
1464 return get_irn_n(node, 2);
1468 set_Free_size (ir_node *node, ir_node *size) {
1469 assert (node->op == op_Free);
1470 set_irn_n(node, 2, size);
1474 get_Free_type (ir_node *node) {
1475 assert (node->op == op_Free);
1476 return node->attr.f;
1480 set_Free_type (ir_node *node, type *type) {
1481 assert (node->op == op_Free);
1482 node->attr.f = type;
1486 get_Sync_n_preds (ir_node *node) {
1487 assert (node->op == op_Sync);
1488 return (get_irn_arity(node));
1493 set_Sync_n_preds (ir_node *node, int n_preds) {
1494 assert (node->op == op_Sync);
1499 get_Sync_pred (ir_node *node, int pos) {
1500 assert (node->op == op_Sync);
1501 return get_irn_n(node, pos);
1505 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1506 assert (node->op == op_Sync);
1507 set_irn_n(node, pos, pred);
1511 get_Proj_pred (ir_node *node) {
1512 assert (node->op == op_Proj);
1513 return get_irn_n(node, 0);
1517 set_Proj_pred (ir_node *node, ir_node *pred) {
1518 assert (node->op == op_Proj);
1519 set_irn_n(node, 0, pred);
1523 get_Proj_proj (ir_node *node) {
1524 assert (node->op == op_Proj);
1525 return node->attr.proj;
1529 set_Proj_proj (ir_node *node, long proj) {
1530 assert (node->op == op_Proj);
1531 node->attr.proj = proj;
1535 get_Tuple_n_preds (ir_node *node) {
1536 assert (node->op == op_Tuple);
1537 return (get_irn_arity(node));
1542 set_Tuple_n_preds (ir_node *node, int n_preds) {
1543 assert (node->op == op_Tuple);
1548 get_Tuple_pred (ir_node *node, int pos) {
1549 assert (node->op == op_Tuple);
1550 return get_irn_n(node, pos);
1554 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1555 assert (node->op == op_Tuple);
1556 set_irn_n(node, pos, pred);
1560 get_Id_pred (ir_node *node) {
1561 assert (node->op == op_Id);
1562 return get_irn_n(node, 0);
1566 set_Id_pred (ir_node *node, ir_node *pred) {
1567 assert (node->op == op_Id);
1568 set_irn_n(node, 0, pred);
1571 /******************************************************************/
1572 /* Auxiliary routines */
1573 /******************************************************************/
1576 skip_Proj (ir_node *node) {
1577 /* don't assert node !!! */
1578 if (node && (node->op == op_Proj)) {
1579 return get_Proj_pred(node);
1586 skip_nop (ir_node *node) {
1587 /* don't assert node !!! */
1588 if (node && (node->op == op_Id)) {
1589 return get_Id_pred(node);
1596 is_Bad (ir_node *node) {
1598 if ((node) && get_irn_opcode(node) == iro_Bad)
1604 is_no_Block (ir_node *node) {
1606 return (get_irn_opcode(node) != iro_Block);
1609 /* Returns true if the operation manipulates control flow. */
1611 is_cfop(ir_node *node) {
1612 return ( (get_irn_opcode(node) == iro_Start)
1613 || (get_irn_opcode(node) == iro_Jmp)
1614 || (get_irn_opcode(node) == iro_Cond)
1615 || (get_irn_opcode(node) == iro_Return)
1616 || (get_irn_opcode(node) == iro_Raise)
1617 || (get_irn_opcode(node) == iro_Bad));
1620 /* Returns true if the operation can change the control flow because
1623 is_fragile_op(ir_node *node) {
1624 return ( (get_irn_opcode(node) == iro_Call)
1625 || (get_irn_opcode(node) == iro_Quot)
1626 || (get_irn_opcode(node) == iro_DivMod)
1627 || (get_irn_opcode(node) == iro_Div)
1628 || (get_irn_opcode(node) == iro_Mod)
1629 || (get_irn_opcode(node) == iro_Load)
1630 || (get_irn_opcode(node) == iro_Store)
1631 || (get_irn_opcode(node) == iro_Alloc)
1632 || (get_irn_opcode(node) == iro_Bad));