1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
11 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
12 "Gt", "Ge", "Lg", "Leg", "Uo",
13 "Ue", "Ul", "Ule", "Ug", "Uge",
16 inline char *get_pnc_string(int pnc) {
17 return pnc_name_arr[pnc];
22 get_negated_pnc(int pnc) {
24 case False: return True; break;
25 case Eq: return Ne; break;
26 case Lt: return Uge; break;
27 case Le: return Ug; break;
28 case Gt: return Ule; break;
29 case Ge: return Ul; break;
30 case Lg: return Ue; break;
31 case Leg: return Uo; break;
32 case Uo: return Leg; break;
33 case Ue: return Lg; break;
34 case Ul: return Ge; break;
35 case Ule: return Gt; break;
36 case Ug: return Le; break;
37 case Uge: return Lt; break;
38 case Ne: return Eq; break;
39 case True: return False; break;
41 return 99; /* to shut up gcc */
44 static char *pns_name_arr [] = {"initial_exec", "global_store",
45 "frame_base", "globals", "args"};
47 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
54 /* irnode constructor */
55 /* create a new irnode in irg, with an op, mode, arity and */
56 /* some incoming irnodes */
57 /* this constructor is used in every specified irnode constructor */
59 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
60 int arity, ir_node **in)
63 int node_size = offsetof (ir_node, attr) + op->attr_size;
65 res = (ir_node *) obstack_alloc (irg->obst, node_size);
67 res->kind = k_ir_node;
73 res->in = NEW_ARR_F (ir_node *, 1);
75 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
76 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
81 res->node_nr = get_irp_new_node_nr();
88 /* IR-Nodes with attributes */
90 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
93 ir_node *np = XP_GETARG (ir_node *, 0);
96 XPS ("<null ir_node>");
100 XPF1 ("%I", get_irn_opname(np));
102 switch (get_irn_opcode (np)) { /* node label */
104 XPF1 ("%I", get_irn_mode(np)->name);
106 XPF1 ("%v", get_irn_const_attr);
109 if (get_irn_modecode (np) == irm_b) {
111 XP (pnc_name_arr[get_irn_proj_attr(np)]);
112 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
114 XP (pns_name_arr[get_irn_proj_attr(np)]);
116 XPF1 ("%I", get_irn_mode(np)->name);
118 XPF1 ("%d", get_irn_proj_attr(np));
122 XPF1 ("%I", get_irn_mode(np)->name);
124 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
125 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
127 case iro_Start: /* don't dump mode of these */
136 XPF1 ("%I", get_irn_mode(np)->name);
143 /** getting some parameters from ir_nodes **/
145 /* returns the number of predecessors without the block predecessor. */
147 get_irn_arity (ir_node *node)
150 return (ARR_LEN((node)->in)-1);
153 /* Returns the array with ins. This array is shifted with respect to the
154 array accessed by get_irn_n: The block operand is at position 0 not -1.
155 (@@@ This should be changed.)
156 The order of the predecessors in this array is not guaranteed, except that
157 lists of operands as predecessors of Block or arguments of a Call are
160 get_irn_in (ir_node *node)
166 /* to iterate through the predecessors without touching the array */
167 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
168 to iterate includind the Block predecessor iterate from i = -1 to
170 If it is a block, the entry -1 is NULL. */
173 get_irn_n (ir_node *node, int n)
176 /* GL commented the assert in, 12.7.00, let's see whether it works */
177 assert (get_irn_arity (node) > n);
178 return skip_nop(node->in[n+1]);
182 set_irn_n (ir_node *node, int n, ir_node *in)
185 assert (get_irn_arity (node) > n);
190 get_irn_mode (ir_node *node)
197 get_irn_modecode (ir_node *node)
200 return node->mode->code;
205 get_irn_modename (ir_node *node)
208 return node->mode->name;
212 get_irn_op (ir_node *node)
218 /* should be private to the library: */
220 set_irn_op (ir_node *node, ir_op *op)
227 get_irn_opcode (ir_node *node)
230 return node->op->code;
234 get_irn_opname (ir_node *node)
237 return node->op->name;
241 get_irn_visited (ir_node *node)
244 return node->visited;
248 set_irn_visited (ir_node *node, unsigned long visited)
251 node->visited = visited;
254 set_irn_link (ir_node *node, ir_node *link) {
260 get_irn_link (ir_node *node) {
266 /* Outputs a unique number for this node */
268 get_irn_node_nr(ir_node *node) {
270 return node->node_nr;
275 get_irn_const_attr (ir_node *node)
277 assert (node->op == op_Const);
278 return node->attr.con;
282 get_irn_proj_attr (ir_node *node)
284 assert (node->op == op_Proj);
285 return node->attr.proj;
289 get_irn_alloc_attr (ir_node *node)
291 assert (node->op == op_Alloc);
296 get_irn_free_attr (ir_node *node)
298 assert (node->op == op_Free);
303 get_irn_symconst_attr (ir_node *node)
305 assert (node->op == op_SymConst);
310 get_irn_call_attr (ir_node *node)
312 assert (node->op == op_Call);
313 return node->attr.call;
317 get_irn_sel_attr (ir_node *node)
319 assert (node->op == op_Sel);
324 get_irn_phi_attr (ir_node *node)
326 assert (node->op == op_Phi);
327 return node->attr.phi0_pos;
331 get_irn_block_attr (ir_node *node)
333 assert (node->op == op_Block);
334 return node->attr.block;
337 /** manipulate fields of individual nodes **/
339 /* this works for all except Block */
341 get_nodes_Block (ir_node *node) {
342 assert (!(node->op == op_Block));
343 return get_irn_n(node, -1);
347 set_nodes_Block (ir_node *node, ir_node *block) {
348 assert (!(node->op == op_Block));
349 set_irn_n(node, -1, block);
352 /* Returns an array with the predecessors of the Block. Depending on
353 the implementation of the graph datastructure this can be a copy of
354 the internal representation of predecessors as well as the internal
355 array itself. Therefore writing to this array might obstruct the ir. */
357 get_Block_cfgpred_arr (ir_node *node)
359 assert ((node->op == op_Block));
360 return (ir_node **)get_Block_cfgpred(node, 0);
365 get_Block_n_cfgpreds (ir_node *node) {
366 assert ((node->op == op_Block));
367 return (get_irn_arity(node));
372 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
373 assert ((node->op == op_Block));
378 get_Block_cfgpred (ir_node *node, int pos) {
379 assert (node->op == op_Block);
380 return get_irn_n(node, pos);
384 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
385 assert (node->op == op_Block);
386 set_irn_n(node, pos, pred);
390 get_Block_matured (ir_node *node) {
391 assert (node->op == op_Block);
392 return node->attr.block.matured;
396 set_Block_matured (ir_node *node, bool matured) {
397 assert (node->op == op_Block);
398 node->attr.block.matured = matured;
401 get_Block_block_visited (ir_node *node) {
402 assert (node->op == op_Block);
403 return node->attr.block.block_visited;
407 set_Block_block_visited (ir_node *node, unsigned long visit) {
408 assert (node->op == op_Block);
409 node->attr.block.block_visited = visit;
413 get_Block_graph_arr (ir_node *node, int pos) {
414 assert (node->op == op_Block);
415 return node->attr.block.graph_arr[pos+1];
419 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
420 assert (node->op == op_Block);
421 node->attr.block.graph_arr[pos+1] = value;
425 get_Cond_selector (ir_node *node) {
426 assert (node->op == op_Cond);
427 return get_irn_n(node, 0);
431 set_Cond_selector (ir_node *node, ir_node *selector) {
432 assert (node->op == op_Cond);
433 set_irn_n(node, 0, selector);
437 get_Return_mem (ir_node *node) {
438 assert (node->op == op_Return);
439 return get_irn_n(node, 0);
443 set_Return_mem (ir_node *node, ir_node *mem) {
444 assert (node->op == op_Return);
445 set_irn_n(node, 0, mem);
449 get_Return_res_arr (ir_node *node)
451 assert ((node->op == op_Return));
452 if (get_Return_n_res(node) > 0)
453 return ((ir_node **)get_Return_res(node, 0));
459 get_Return_n_res (ir_node *node) {
460 assert (node->op == op_Return);
461 return (get_irn_arity(node) - 1);
466 set_Return_n_res (ir_node *node, int results) {
467 assert (node->op == op_Return);
472 get_Return_res (ir_node *node, int pos) {
473 assert (node->op == op_Return);
474 assert (get_Return_n_res(node) > pos);
475 return get_irn_n(node, pos+1);
479 set_Return_res (ir_node *node, int pos, ir_node *res){
480 assert (node->op == op_Return);
481 set_irn_n(node, pos+1, res);
485 get_Raise_mem (ir_node *node) {
486 assert (node->op == op_Return);
487 return get_irn_n(node, 0);
491 set_Raise_mem (ir_node *node, ir_node *mem) {
492 assert (node->op == op_Raise);
493 set_irn_n(node, 0, mem);
497 get_Raise_exo_ptr (ir_node *node) {
498 assert (node->op == op_Raise);
499 return get_irn_n(node, 1);
503 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
504 assert (node->op == op_Raise);
505 set_irn_n(node, 1, exo_ptr);
508 inline tarval *get_Const_tarval (ir_node *node) {
509 assert (node->op == op_Const);
510 return get_irn_const_attr(node);
514 set_Const_tarval (ir_node *node, tarval *con) {
515 assert (node->op == op_Const);
516 node->attr.con = con;
520 get_SymConst_kind (ir_node *node) {
521 assert (node->op == op_SymConst);
522 return node->attr.i.num;
526 set_SymConst_kind (ir_node *node, symconst_kind num) {
527 assert (node->op == op_SymConst);
528 node->attr.i.num = num;
532 get_SymConst_type (ir_node *node) {
533 assert ( (node->op == op_SymConst)
534 && ( get_SymConst_kind(node) == type_tag
535 || get_SymConst_kind(node) == size));
536 return node->attr.i.tori.typ;
540 set_SymConst_type (ir_node *node, type *type) {
541 assert ( (node->op == op_SymConst)
542 && ( get_SymConst_kind(node) == type_tag
543 || get_SymConst_kind(node) == size));
544 node->attr.i.tori.typ = type;
548 get_SymConst_ptrinfo (ir_node *node) {
549 assert ( (node->op == op_SymConst)
550 && (get_SymConst_kind(node) == linkage_ptr_info));
551 return node->attr.i.tori.ptrinfo;
557 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
558 assert ( (node->op == op_SymConst)
559 && (get_SymConst_kind(node) == linkage_ptr_info));
560 node->attr.i.tori.ptrinfo = ptrinfo;
564 get_Sel_mem (ir_node *node) {
565 assert (node->op == op_Sel);
566 return get_irn_n(node, 0);
570 set_Sel_mem (ir_node *node, ir_node *mem) {
571 assert (node->op == op_Sel);
572 set_irn_n(node, 0, mem);
576 get_Sel_ptr (ir_node *node) {
577 assert (node->op == op_Sel);
578 return get_irn_n(node, 1);
582 set_Sel_ptr (ir_node *node, ir_node *ptr) {
583 assert (node->op == op_Sel);
584 set_irn_n(node, 1, ptr);
588 get_Sel_index_arr (ir_node *node)
590 assert ((node->op == op_Sel));
591 if (get_Sel_n_index(node) > 0)
592 return (ir_node **)get_Sel_index(node, 0);
598 get_Sel_n_index (ir_node *node) {
599 assert (node->op == op_Sel);
600 return (get_irn_arity(node) - 2);
605 set_Sel_n_index (ir_node *node, int n_index) {
606 assert (node->op == op_Sel);
611 get_Sel_index (ir_node *node, int pos) {
612 assert (node->op == op_Sel);
613 return get_irn_n(node, pos+2);
617 set_Sel_index (ir_node *node, int pos, ir_node *index) {
618 assert (node->op == op_Sel);
619 set_irn_n(node, pos+2, index);
623 get_Sel_entity (ir_node *node) {
624 assert (node->op == op_Sel);
625 return node->attr.s.ent;
629 set_Sel_entity (ir_node *node, entity *ent) {
630 assert (node->op == op_Sel);
631 node->attr.s.ent = ent;
635 get_Sel_linkage_type (ir_node *node) {
636 assert (node->op == op_Sel);
637 return node->attr.s.ltyp;
641 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
642 assert (node->op == op_Sel);
643 node->attr.s.ltyp = lt;
647 get_Call_mem (ir_node *node) {
648 assert (node->op == op_Call);
649 return get_irn_n(node, 0);
653 set_Call_mem (ir_node *node, ir_node *mem) {
654 assert (node->op == op_Call);
655 set_irn_n(node, 0, mem);
659 get_Call_ptr (ir_node *node) {
660 assert (node->op == op_Call);
661 return get_irn_n(node, 1);
665 set_Call_ptr (ir_node *node, ir_node *ptr) {
666 assert (node->op == op_Call);
667 set_irn_n(node, 1, ptr);
671 get_Call_param_arr (ir_node *node) {
672 assert (node->op == op_Call);
673 if (get_Call_arity(node) > 0)
674 return ((ir_node **)get_Call_param (node, 0));
680 get_Call_arity (ir_node *node) {
681 assert (node->op == op_Call);
682 return (get_irn_arity(node) - 2);
686 set_Call_arity (ir_node *node, ir_node *arity) {
687 assert (node->op == op_Call);
692 get_Call_param (ir_node *node, int pos) {
693 assert (node->op == op_Call);
694 return get_irn_n(node, pos+1);
698 set_Call_param (ir_node *node, int pos, ir_node *param) {
699 assert (node->op == op_Call);
700 set_irn_n(node, pos+1, param);
704 get_Call_type (ir_node *node) {
705 assert (node->op == op_Call);
706 return node->attr.call;
710 set_Call_type (ir_node *node, type_method *type) {
711 assert (node->op == op_Call);
712 node->attr.call = type;
715 /* For unary and binary arithmetic operations the access to the
716 operands can be factored out. Left is the first, right the
717 second arithmetic value as listed in tech report 0999-33.
718 unops are: Minus, Abs, Not, Conv
719 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
720 Shr, Shrs, Rotate, Cmp */
723 is_unop (ir_node *node) {
724 return ( node->op == op_Minus ||
725 node->op == op_Abs ||
726 node->op == op_Not ||
727 node->op == op_Conv );
731 get_unop_op (ir_node *node) {
732 assert ( node->op == op_Minus ||
733 node->op == op_Abs ||
734 node->op == op_Not ||
735 node->op == op_Conv );
736 switch (get_irn_opcode (node)) {
737 case iro_Minus: return get_Minus_op(node); break;
738 case iro_Abs: return get_Abs_op(node); break;
739 case iro_Not: return get_Not_op(node); break;
740 case iro_Conv: return get_Conv_op(node); break;
741 default: return NULL;
746 set_unop_op (ir_node *node, ir_node *op) {
747 assert (node->op == op_Minus ||
748 node->op == op_Abs ||
749 node->op == op_Not ||
750 node->op == op_Conv );
751 switch (get_irn_opcode (node)) {
752 case iro_Minus: set_Minus_op(node, op); break;
753 case iro_Abs: set_Abs_op(node, op); break;
754 case iro_Not: set_Not_op(node, op); break;
755 case iro_Conv: set_Conv_op(node, op); break;
762 is_binop (ir_node *node) {
763 return (node->op == op_Add ||
764 node->op == op_Sub ||
765 node->op == op_Mul ||
766 node->op == op_Quot ||
767 node->op == op_DivMod ||
768 node->op == op_Div ||
769 node->op == op_Mod ||
770 node->op == op_And ||
772 node->op == op_Eor ||
773 node->op == op_Shl ||
774 node->op == op_Shr ||
775 node->op == op_Shrs ||
776 node->op == op_Rot ||
777 node->op == op_Cmp );
781 get_binop_left (ir_node *node) {
782 assert (node->op == op_Add ||
783 node->op == op_Sub ||
784 node->op == op_Mul ||
785 node->op == op_Quot ||
786 node->op == op_DivMod ||
787 node->op == op_Div ||
788 node->op == op_Mod ||
789 node->op == op_And ||
791 node->op == op_Eor ||
792 node->op == op_Shl ||
793 node->op == op_Shr ||
794 node->op == op_Shrs ||
795 node->op == op_Rot ||
796 node->op == op_Cmp );
798 switch (get_irn_opcode (node)) {
799 case iro_Add : return get_Add_left(node); break;
800 case iro_Sub : return get_Sub_left(node); break;
801 case iro_Mul : return get_Mul_left(node); break;
802 case iro_Quot : return get_Quot_left(node); break;
803 case iro_DivMod: return get_DivMod_left(node); break;
804 case iro_Div : return get_Div_left(node); break;
805 case iro_Mod : return get_Mod_left(node); break;
806 case iro_And : return get_And_left(node); break;
807 case iro_Or : return get_Or_left(node); break;
808 case iro_Eor : return get_Eor_left(node); break;
809 case iro_Shl : return get_Shl_left(node); break;
810 case iro_Shr : return get_Shr_left(node); break;
811 case iro_Shrs : return get_Shrs_left(node); break;
812 case iro_Rot : return get_Rot_left(node); break;
813 case iro_Cmp : return get_Cmp_left(node); break;
814 default: return NULL;
819 set_binop_left (ir_node *node, ir_node *left) {
820 assert (node->op == op_Add ||
821 node->op == op_Sub ||
822 node->op == op_Mul ||
823 node->op == op_Quot ||
824 node->op == op_DivMod ||
825 node->op == op_Div ||
826 node->op == op_Mod ||
827 node->op == op_And ||
829 node->op == op_Eor ||
830 node->op == op_Shl ||
831 node->op == op_Shr ||
832 node->op == op_Shrs ||
833 node->op == op_Rot ||
834 node->op == op_Cmp );
836 switch (get_irn_opcode (node)) {
837 case iro_Add : set_Add_left(node, left); break;
838 case iro_Sub : set_Sub_left(node, left); break;
839 case iro_Mul : set_Mul_left(node, left); break;
840 case iro_Quot : set_Quot_left(node, left); break;
841 case iro_DivMod: set_DivMod_left(node, left); break;
842 case iro_Div : set_Div_left(node, left); break;
843 case iro_Mod : set_Mod_left(node, left); break;
844 case iro_And : set_And_left(node, left); break;
845 case iro_Or : set_Or_left(node, left); break;
846 case iro_Eor : set_Eor_left(node, left); break;
847 case iro_Shl : set_Shl_left(node, left); break;
848 case iro_Shr : set_Shr_left(node, left); break;
849 case iro_Shrs : set_Shrs_left(node, left); break;
850 case iro_Rot : set_Rot_left(node, left); break;
851 case iro_Cmp : set_Cmp_left(node, left); break;
857 get_binop_right (ir_node *node) {
858 assert (node->op == op_Add ||
859 node->op == op_Sub ||
860 node->op == op_Mul ||
861 node->op == op_Quot ||
862 node->op == op_DivMod ||
863 node->op == op_Div ||
864 node->op == op_Mod ||
865 node->op == op_And ||
867 node->op == op_Eor ||
868 node->op == op_Shl ||
869 node->op == op_Shr ||
870 node->op == op_Shrs ||
871 node->op == op_Rot ||
872 node->op == op_Cmp );
874 switch (get_irn_opcode (node)) {
875 case iro_Add : return get_Add_right(node); break;
876 case iro_Sub : return get_Sub_right(node); break;
877 case iro_Mul : return get_Mul_right(node); break;
878 case iro_Quot : return get_Quot_right(node); break;
879 case iro_DivMod: return get_DivMod_right(node); break;
880 case iro_Div : return get_Div_right(node); break;
881 case iro_Mod : return get_Mod_right(node); break;
882 case iro_And : return get_And_right(node); break;
883 case iro_Or : return get_Or_right(node); break;
884 case iro_Eor : return get_Eor_right(node); break;
885 case iro_Shl : return get_Shl_right(node); break;
886 case iro_Shr : return get_Shr_right(node); break;
887 case iro_Shrs : return get_Shrs_right(node); break;
888 case iro_Rot : return get_Rot_right(node); break;
889 case iro_Cmp : return get_Cmp_right(node); break;
890 default: return NULL;
895 set_binop_right (ir_node *node, ir_node *right) {
896 assert (node->op == op_Add ||
897 node->op == op_Sub ||
898 node->op == op_Mul ||
899 node->op == op_Quot ||
900 node->op == op_DivMod ||
901 node->op == op_Div ||
902 node->op == op_Mod ||
903 node->op == op_And ||
905 node->op == op_Eor ||
906 node->op == op_Shl ||
907 node->op == op_Shr ||
908 node->op == op_Shrs ||
909 node->op == op_Rot ||
910 node->op == op_Cmp );
912 switch (get_irn_opcode (node)) {
913 case iro_Add : set_Add_right(node, right); break;
914 case iro_Sub : set_Sub_right(node, right); break;
915 case iro_Mul : set_Mul_right(node, right); break;
916 case iro_Quot : set_Quot_right(node, right); break;
917 case iro_DivMod: set_DivMod_right(node, right); break;
918 case iro_Div : set_Div_right(node, right); break;
919 case iro_Mod : set_Mod_right(node, right); break;
920 case iro_And : set_And_right(node, right); break;
921 case iro_Or : set_Or_right(node, right); break;
922 case iro_Eor : set_Eor_right(node, right); break;
923 case iro_Shl : set_Shl_right(node, right); break;
924 case iro_Shr : set_Shr_right(node, right); break;
925 case iro_Shrs : set_Shrs_right(node, right); break;
926 case iro_Rot : set_Rot_right(node, right); break;
927 case iro_Cmp : set_Cmp_right(node, right); break;
933 get_Add_left (ir_node *node) {
934 assert (node->op == op_Add);
935 return get_irn_n(node, 0);
939 set_Add_left (ir_node *node, ir_node *left) {
940 assert (node->op == op_Add);
941 set_irn_n(node, 0, left);
945 get_Add_right (ir_node *node) {
946 assert (node->op == op_Add);
947 return get_irn_n(node, 1);
951 set_Add_right (ir_node *node, ir_node *right) {
952 assert (node->op == op_Add);
953 set_irn_n(node, 1, right);
957 get_Sub_left (ir_node *node) {
958 assert (node->op == op_Sub);
959 return get_irn_n(node, 0);
963 set_Sub_left (ir_node *node, ir_node *left) {
964 assert (node->op == op_Sub);
965 set_irn_n(node, 0, left);
969 get_Sub_right (ir_node *node) {
970 assert (node->op == op_Sub);
971 return get_irn_n(node, 1);
975 set_Sub_right (ir_node *node, ir_node *right) {
976 assert (node->op == op_Sub);
977 set_irn_n(node, 1, right);
982 get_Minus_op (ir_node *node) {
983 assert (node->op == op_Minus);
984 return get_irn_n(node, 0);
988 set_Minus_op (ir_node *node, ir_node *op) {
989 assert (node->op == op_Minus);
990 set_irn_n(node, 0, op);
995 get_Mul_left (ir_node *node) {
996 assert (node->op == op_Mul);
997 return get_irn_n(node, 0);
1001 set_Mul_left (ir_node *node, ir_node *left) {
1002 assert (node->op == op_Mul);
1003 set_irn_n(node, 0, left);
1007 get_Mul_right (ir_node *node) {
1008 assert (node->op == op_Mul);
1009 return get_irn_n(node, 1);
1013 set_Mul_right (ir_node *node, ir_node *right) {
1014 assert (node->op == op_Mul);
1015 set_irn_n(node, 1, right);
1019 get_Quot_left (ir_node *node) {
1020 assert (node->op == op_Quot);
1021 return get_irn_n(node, 1);
1025 set_Quot_left (ir_node *node, ir_node *left) {
1026 assert (node->op == op_Quot);
1027 set_irn_n(node, 1, left);
1031 get_Quot_right (ir_node *node) {
1032 assert (node->op == op_Quot);
1033 return get_irn_n(node, 2);
1037 set_Quot_right (ir_node *node, ir_node *right) {
1038 assert (node->op == op_Quot);
1039 set_irn_n(node, 2, right);
1043 get_Quot_mem (ir_node *node) {
1044 assert (node->op == op_Quot);
1045 return get_irn_n(node, 0);
1049 set_Quot_mem (ir_node *node, ir_node *mem) {
1050 assert (node->op == op_Quot);
1051 set_irn_n(node, 0, mem);
1055 get_DivMod_left (ir_node *node) {
1056 assert (node->op == op_DivMod);
1057 return get_irn_n(node, 1);
1061 set_DivMod_left (ir_node *node, ir_node *left) {
1062 assert (node->op == op_DivMod);
1063 set_irn_n(node, 1, left);
1067 get_DivMod_right (ir_node *node) {
1068 assert (node->op == op_DivMod);
1069 return get_irn_n(node, 2);
1073 set_DivMod_right (ir_node *node, ir_node *right) {
1074 assert (node->op == op_DivMod);
1075 set_irn_n(node, 2, right);
1079 get_DivMod_mem (ir_node *node) {
1080 assert (node->op == op_DivMod);
1081 return get_irn_n(node, 0);
1085 set_DivMod_mem (ir_node *node, ir_node *mem) {
1086 assert (node->op == op_DivMod);
1087 set_irn_n(node, 0, mem);
1091 get_Div_left (ir_node *node) {
1092 assert (node->op == op_Div);
1093 return get_irn_n(node, 1);
1097 set_Div_left (ir_node *node, ir_node *left) {
1098 assert (node->op == op_Div);
1099 set_irn_n(node, 1, left);
1103 get_Div_right (ir_node *node) {
1104 assert (node->op == op_Div);
1105 return get_irn_n(node, 2);
1109 set_Div_right (ir_node *node, ir_node *right) {
1110 assert (node->op == op_Div);
1111 set_irn_n(node, 2, right);
1115 get_Div_mem (ir_node *node) {
1116 assert (node->op == op_Div);
1117 return get_irn_n(node, 0);
1121 set_Div_mem (ir_node *node, ir_node *mem) {
1122 assert (node->op == op_Div);
1123 set_irn_n(node, 0, mem);
1127 get_Mod_left (ir_node *node) {
1128 assert (node->op == op_Mod);
1129 return get_irn_n(node, 1);
1133 set_Mod_left (ir_node *node, ir_node *left) {
1134 assert (node->op == op_Mod);
1135 set_irn_n(node, 1, left);
1139 get_Mod_right (ir_node *node) {
1140 assert (node->op == op_Mod);
1141 return get_irn_n(node, 2);
1145 set_Mod_right (ir_node *node, ir_node *right) {
1146 assert (node->op == op_Mod);
1147 set_irn_n(node, 2, right);
1151 get_Mod_mem (ir_node *node) {
1152 assert (node->op == op_Mod);
1153 return get_irn_n(node, 0);
1157 set_Mod_mem (ir_node *node, ir_node *mem) {
1158 assert (node->op == op_Mod);
1159 set_irn_n(node, 0, mem);
1163 get_Abs_op (ir_node *node) {
1164 assert (node->op == op_Abs);
1165 return get_irn_n(node, 0);
1169 set_Abs_op (ir_node *node, ir_node *op) {
1170 assert (node->op == op_Abs);
1171 set_irn_n(node, 0, op);
1175 get_And_left (ir_node *node) {
1176 assert (node->op == op_And);
1177 return get_irn_n(node, 0);
1181 set_And_left (ir_node *node, ir_node *left) {
1182 assert (node->op == op_And);
1183 set_irn_n(node, 0, left);
1187 get_And_right (ir_node *node) {
1188 assert (node->op == op_And);
1189 return get_irn_n(node, 1);
1193 set_And_right (ir_node *node, ir_node *right) {
1194 assert (node->op == op_And);
1195 set_irn_n(node, 1, right);
1199 get_Or_left (ir_node *node) {
1200 assert (node->op == op_Or);
1201 return get_irn_n(node, 0);
1205 set_Or_left (ir_node *node, ir_node *left) {
1206 assert (node->op == op_Or);
1207 set_irn_n(node, 0, left);
1211 get_Or_right (ir_node *node) {
1212 assert (node->op == op_Or);
1213 return get_irn_n(node, 1);
1217 set_Or_right (ir_node *node, ir_node *right) {
1218 assert (node->op == op_Or);
1219 set_irn_n(node, 1, right);
1223 get_Eor_left (ir_node *node) {
1224 assert (node->op == op_Eor);
1225 return get_irn_n(node, 0);
1229 set_Eor_left (ir_node *node, ir_node *left) {
1230 assert (node->op == op_Eor);
1231 set_irn_n(node, 0, left);
1235 get_Eor_right (ir_node *node) {
1236 assert (node->op == op_Eor);
1237 return get_irn_n(node, 1);
1241 set_Eor_right (ir_node *node, ir_node *right) {
1242 assert (node->op == op_Eor);
1243 set_irn_n(node, 1, right);
1248 get_Not_op (ir_node *node) {
1249 assert (node->op == op_Not);
1250 return get_irn_n(node, 0);
1254 set_Not_op (ir_node *node, ir_node *op) {
1255 assert (node->op == op_Not);
1256 set_irn_n(node, 0, op);
1261 get_Shl_left (ir_node *node) {
1262 assert (node->op == op_Shl);
1263 return get_irn_n(node, 0);
1267 set_Shl_left (ir_node *node, ir_node *left) {
1268 assert (node->op == op_Shl);
1269 set_irn_n(node, 0, left);
1273 get_Shl_right (ir_node *node) {
1274 assert (node->op == op_Shl);
1275 return get_irn_n(node, 1);
1279 set_Shl_right (ir_node *node, ir_node *right) {
1280 assert (node->op == op_Shl);
1281 set_irn_n(node, 1, right);
1285 get_Shr_left (ir_node *node) {
1286 assert (node->op == op_Shr);
1287 return get_irn_n(node, 0);
1291 set_Shr_left (ir_node *node, ir_node *left) {
1292 assert (node->op == op_Shr);
1293 set_irn_n(node, 0, left);
1297 get_Shr_right (ir_node *node) {
1298 assert (node->op == op_Shr);
1299 return get_irn_n(node, 1);
1303 set_Shr_right (ir_node *node, ir_node *right) {
1304 assert (node->op == op_Shr);
1305 set_irn_n(node, 1, right);
1309 get_Shrs_left (ir_node *node) {
1310 assert (node->op == op_Shrs);
1311 return get_irn_n(node, 0);
1315 set_Shrs_left (ir_node *node, ir_node *left) {
1316 assert (node->op == op_Shrs);
1317 set_irn_n(node, 0, left);
1321 get_Shrs_right (ir_node *node) {
1322 assert (node->op == op_Shrs);
1323 return get_irn_n(node, 1);
1327 set_Shrs_right (ir_node *node, ir_node *right) {
1328 assert (node->op == op_Shrs);
1329 set_irn_n(node, 1, right);
1333 get_Rot_left (ir_node *node) {
1334 assert (node->op == op_Rot);
1335 return get_irn_n(node, 0);
1339 set_Rot_left (ir_node *node, ir_node *left) {
1340 assert (node->op == op_Rot);
1341 set_irn_n(node, 0, left);
1345 get_Rot_right (ir_node *node) {
1346 assert (node->op == op_Rot);
1347 return get_irn_n(node, 1);
1351 set_Rot_right (ir_node *node, ir_node *right) {
1352 assert (node->op == op_Rot);
1353 set_irn_n(node, 1, right);
1357 get_Cmp_left (ir_node *node) {
1358 assert (node->op == op_Cmp);
1359 return get_irn_n(node, 0);
1363 set_Cmp_left (ir_node *node, ir_node *left) {
1364 assert (node->op == op_Cmp);
1365 set_irn_n(node, 0, left);
1369 get_Cmp_right (ir_node *node) {
1370 assert (node->op == op_Cmp);
1371 return get_irn_n(node, 1);
1375 set_Cmp_right (ir_node *node, ir_node *right) {
1376 assert (node->op == op_Cmp);
1377 set_irn_n(node, 1, right);
1381 get_Conv_op (ir_node *node) {
1382 assert (node->op == op_Conv);
1383 return get_irn_n(node, 0);
1387 set_Conv_op (ir_node *node, ir_node *op) {
1388 assert (node->op == op_Conv);
1389 set_irn_n(node, 0, op);
1393 get_Phi_preds_arr (ir_node *node) {
1394 assert (node->op == op_Phi);
1395 return ((ir_node **)get_Phi_pred(node, 0));
1399 get_Phi_n_preds (ir_node *node) {
1400 assert (node->op == op_Phi);
1401 return (get_irn_arity(node));
1405 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1406 assert (node->op == op_Phi);
1411 get_Phi_pred (ir_node *node, int pos) {
1412 assert (node->op == op_Phi);
1413 return get_irn_n(node, pos);
1417 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1418 assert (node->op == op_Phi);
1419 set_irn_n(node, pos, pred);
1423 get_Load_mem (ir_node *node) {
1424 assert (node->op == op_Load);
1425 return get_irn_n(node, 0);
1429 set_Load_mem (ir_node *node, ir_node *mem) {
1430 assert (node->op == op_Load);
1431 set_irn_n(node, 0, mem);
1435 get_Load_ptr (ir_node *node) {
1436 assert (node->op == op_Load);
1437 return get_irn_n(node, 1);
1441 set_Load_ptr (ir_node *node, ir_node *ptr) {
1442 assert (node->op == op_Load);
1443 set_irn_n(node, 1, ptr);
1448 get_Store_mem (ir_node *node) {
1449 assert (node->op == op_Store);
1450 return get_irn_n(node, 0);
1454 set_Store_mem (ir_node *node, ir_node *mem) {
1455 assert (node->op == op_Store);
1456 set_irn_n(node, 0, mem);
1460 get_Store_ptr (ir_node *node) {
1461 assert (node->op == op_Store);
1462 return get_irn_n(node, 1);
1466 set_Store_ptr (ir_node *node, ir_node *ptr) {
1467 assert (node->op == op_Store);
1468 set_irn_n(node, 1, ptr);
1472 get_Store_value (ir_node *node) {
1473 assert (node->op == op_Store);
1474 return get_irn_n(node, 2);
1478 set_Store_value (ir_node *node, ir_node *value) {
1479 assert (node->op == op_Store);
1480 set_irn_n(node, 2, value);
1484 get_Alloc_mem (ir_node *node) {
1485 assert (node->op == op_Alloc);
1486 return get_irn_n(node, 0);
1490 set_Alloc_mem (ir_node *node, ir_node *mem) {
1491 assert (node->op == op_Alloc);
1492 set_irn_n(node, 0, mem);
1496 get_Alloc_size (ir_node *node) {
1497 assert (node->op == op_Alloc);
1498 return get_irn_n(node, 1);
1502 set_Allco_size (ir_node *node, ir_node *size) {
1503 assert (node->op == op_Alloc);
1504 set_irn_n(node, 1, size);
1508 get_Alloc_type (ir_node *node) {
1509 assert (node->op == op_Alloc);
1510 return node->attr.a.type;
1514 set_Alloc_type (ir_node *node, type *type) {
1515 assert (node->op == op_Alloc);
1516 node->attr.a.type = type;
1520 get_Alloc_where (ir_node *node) {
1521 assert (node->op == op_Alloc);
1522 return node->attr.a.where;
1526 set_Alloc_where (ir_node *node, where_alloc where) {
1527 assert (node->op == op_Alloc);
1528 node->attr.a.where = where;
1533 get_Free_mem (ir_node *node) {
1534 assert (node->op == op_Free);
1535 return get_irn_n(node, 0);
1539 set_Free_mem (ir_node *node, ir_node *mem) {
1540 assert (node->op == op_Free);
1541 set_irn_n(node, 0, mem);
1545 get_Free_ptr (ir_node *node) {
1546 assert (node->op == op_Free);
1547 return get_irn_n(node, 1);
1551 set_Free_ptr (ir_node *node, ir_node *ptr) {
1552 assert (node->op == op_Free);
1553 set_irn_n(node, 1, ptr);
1557 get_Free_size (ir_node *node) {
1558 assert (node->op == op_Free);
1559 return get_irn_n(node, 2);
1563 set_Free_size (ir_node *node, ir_node *size) {
1564 assert (node->op == op_Free);
1565 set_irn_n(node, 2, size);
1569 get_Free_type (ir_node *node) {
1570 assert (node->op == op_Free);
1571 return node->attr.f;
1575 set_Free_type (ir_node *node, type *type) {
1576 assert (node->op == op_Free);
1577 node->attr.f = type;
1581 get_Sync_preds_arr (ir_node *node) {
1582 assert (node->op == op_Sync);
1583 return ((ir_node **)get_Sync_pred(node, 0));
1587 get_Sync_n_preds (ir_node *node) {
1588 assert (node->op == op_Sync);
1589 return (get_irn_arity(node));
1594 set_Sync_n_preds (ir_node *node, int n_preds) {
1595 assert (node->op == op_Sync);
1600 get_Sync_pred (ir_node *node, int pos) {
1601 assert (node->op == op_Sync);
1602 return get_irn_n(node, pos);
1606 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1607 assert (node->op == op_Sync);
1608 set_irn_n(node, pos, pred);
1612 get_Proj_pred (ir_node *node) {
1613 assert (node->op == op_Proj);
1614 return get_irn_n(node, 0);
1618 set_Proj_pred (ir_node *node, ir_node *pred) {
1619 assert (node->op == op_Proj);
1620 set_irn_n(node, 0, pred);
1624 get_Proj_proj (ir_node *node) {
1625 assert (node->op == op_Proj);
1626 return node->attr.proj;
1630 set_Proj_proj (ir_node *node, long proj) {
1631 assert (node->op == op_Proj);
1632 node->attr.proj = proj;
1636 get_Tuple_preds_arr (ir_node *node) {
1637 assert (node->op == op_Tuple);
1638 return ((ir_node **)get_Tuple_pred(node, 0));
1642 get_Tuple_n_preds (ir_node *node) {
1643 assert (node->op == op_Tuple);
1644 return (get_irn_arity(node));
1649 set_Tuple_n_preds (ir_node *node, int n_preds) {
1650 assert (node->op == op_Tuple);
1655 get_Tuple_pred (ir_node *node, int pos) {
1656 assert (node->op == op_Tuple);
1657 return get_irn_n(node, pos);
1661 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1662 assert (node->op == op_Tuple);
1663 set_irn_n(node, pos, pred);
1667 get_Id_pred (ir_node *node) {
1668 assert (node->op == op_Id);
1669 return get_irn_n(node, 0);
1673 set_Id_pred (ir_node *node, ir_node *pred) {
1674 assert (node->op == op_Id);
1675 set_irn_n(node, 0, pred);
1678 /******************************************************************/
1679 /* Auxiliary routines */
1680 /******************************************************************/
1683 skip_Proj (ir_node *node) {
1684 /* don't assert node !!! */
1685 if (node && (node->op == op_Proj)) {
1686 return get_Proj_pred(node);
1693 skip_nop (ir_node *node) {
1694 /* don't assert node !!! */
1695 if (node && (node->op == op_Id)) {
1696 return get_Id_pred(node);
1703 is_Bad (ir_node *node) {
1705 if ((node) && get_irn_opcode(node) == iro_Bad)
1711 is_no_Block (ir_node *node) {
1713 return (get_irn_opcode(node) != iro_Block);
1716 /* Returns true if the operation manipulates control flow. */
1718 is_cfop(ir_node *node) {
1719 return ( (get_irn_opcode(node) == iro_Start)
1720 || (get_irn_opcode(node) == iro_Jmp)
1721 || (get_irn_opcode(node) == iro_Cond)
1722 || (get_irn_opcode(node) == iro_Return)
1723 || (get_irn_opcode(node) == iro_Raise)
1724 || (get_irn_opcode(node) == iro_Bad));
1727 /* Returns true if the operation can change the control flow because
1730 is_fragile_op(ir_node *node) {
1731 return ( (get_irn_opcode(node) == iro_Call)
1732 || (get_irn_opcode(node) == iro_Quot)
1733 || (get_irn_opcode(node) == iro_DivMod)
1734 || (get_irn_opcode(node) == iro_Div)
1735 || (get_irn_opcode(node) == iro_Mod)
1736 || (get_irn_opcode(node) == iro_Load)
1737 || (get_irn_opcode(node) == iro_Store)
1738 || (get_irn_opcode(node) == iro_Alloc)
1739 || (get_irn_opcode(node) == iro_Bad));