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);
83 /* IR-Nodes with attributes */
85 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
88 ir_node *np = XP_GETARG (ir_node *, 0);
91 XPS ("<null ir_node>");
95 XPF1 ("%I", get_irn_op(np)->name);
97 switch (get_irn_opcode (np)) { /* node label */
99 XPF1 ("%I", get_irn_mode(np)->name);
101 XPF1 ("%v", get_irn_const_attr);
104 if (get_irn_modecode (np) == irm_b) {
106 XP (pnc_name_arr[get_irn_proj_attr(np)]);
107 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
109 XP (pns_name_arr[get_irn_proj_attr(np)]);
111 XPF1 ("%I", get_irn_mode(np)->name);
113 XPF1 ("%d", get_irn_proj_attr(np));
117 XPF1 ("%I", get_irn_mode(np)->name);
119 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
120 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
122 case iro_Start: /* don't dump mode of these */
131 XPF1 ("%I", get_irn_mode(np)->name);
138 /** getting some parameters from ir_nodes **/
140 /* returns the number of predecessors without the block predecessor. */
142 get_irn_arity (ir_node *node)
145 return (ARR_LEN((node)->in)-1);
148 /* Returns the array with ins. This array is shifted with respect to the
149 array accessed by get_irn_n: The block operand is at position 0 not -1.
150 (@@@ This should be changed.)
151 The order of the predecessors in this array is not guaranteed, except that
152 lists of operands as predecessors of Block or arguments of a Call are
155 get_irn_in (ir_node *node)
161 /* to iterate through the predecessors without touching the array */
162 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
163 to iterate includind the Block predecessor iterate from i = -1 to
165 If it is a block, the entry -1 is NULL. */
168 get_irn_n (ir_node *node, int n)
171 // assert (get_irn_arity (node) > n);
172 return skip_nop(node->in[n+1]);
176 set_irn_n (ir_node *node, int n, ir_node *in)
179 assert (get_irn_arity (node) > n);
184 get_irn_mode (ir_node *node)
191 get_irn_modecode (ir_node *node)
194 return node->mode->code;
198 get_irn_op (ir_node *node)
204 /* should be private to the library: */
206 set_irn_op (ir_node *node, ir_op *op)
213 set_irn_visited (ir_node *node, unsigned long visited)
216 node->visited = visited;
220 get_irn_visited (ir_node *node)
223 return node->visited;
227 get_irn_opcode (ir_node *node)
230 return node->op->code;
234 set_irn_link (ir_node *node, ir_node *link) {
240 get_irn_link (ir_node *node) {
246 get_irn_const_attr (ir_node *node)
248 assert (node->op == op_Const);
249 return node->attr.con;
253 get_irn_proj_attr (ir_node *node)
255 assert (node->op == op_Proj);
256 return node->attr.proj;
260 get_irn_alloc_attr (ir_node *node)
262 assert (node->op == op_Alloc);
267 get_irn_free_attr (ir_node *node)
269 assert (node->op == op_Free);
274 get_irn_symconst_attr (ir_node *node)
276 assert (node->op == op_SymConst);
281 get_irn_call_attr (ir_node *node)
283 assert (node->op == op_Call);
284 return node->attr.call;
288 get_irn_sel_attr (ir_node *node)
290 assert (node->op == op_Sel);
295 get_irn_phi_attr (ir_node *node)
297 assert (node->op == op_Phi);
298 return node->attr.phi0_pos;
302 get_irn_block_attr (ir_node *node)
304 assert (node->op == op_Block);
305 return node->attr.block;
308 /** manipulate fields of individual nodes **/
310 /* this works for all except Block */
312 get_nodes_Block (ir_node *node) {
313 assert (!(node->op == op_Block));
314 return get_irn_n(node, -1);
318 set_nodes_Block (ir_node *node, ir_node *block) {
319 assert (!(node->op == op_Block));
320 set_irn_n(node, -1, block);
323 /* Returns an array with the predecessors of the Block. Depending on
324 the implementation of the graph datastructure this can be a copy of
325 the internal representation of predecessors as well as the internal
326 array itself. Therefore writing to this array might obstruct the ir. */
328 get_Block_cfgpred_arr (ir_node *node)
330 assert ((node->op == op_Block));
331 return (ir_node **)get_Block_cfgpred(node, 0);
336 get_Block_n_cfgpreds (ir_node *node) {
337 assert ((node->op == op_Block));
338 return (get_irn_arity(node));
343 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
344 assert ((node->op == op_Block));
349 get_Block_cfgpred (ir_node *node, int pos) {
350 assert (node->op == op_Block);
351 return get_irn_n(node, pos);
355 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
356 assert (node->op == op_Block);
357 set_irn_n(node, pos, pred);
361 get_Block_matured (ir_node *node) {
362 assert (node->op == op_Block);
363 return node->attr.block.matured;
367 set_Block_matured (ir_node *node, bool matured) {
368 assert (node->op == op_Block);
369 node->attr.block.matured = matured;
372 get_Block_block_visited (ir_node *node) {
373 assert (node->op == op_Block);
374 return node->attr.block.block_visited;
378 set_Block_block_visited (ir_node *node, unsigned long visit) {
379 assert (node->op == op_Block);
380 node->attr.block.block_visited = visit;
384 get_Block_graph_arr (ir_node *node, int pos) {
385 assert (node->op == op_Block);
386 return node->attr.block.graph_arr[pos+1];
390 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
391 assert (node->op == op_Block);
392 node->attr.block.graph_arr[pos+1] = value;
396 get_Cond_selector (ir_node *node) {
397 assert (node->op == op_Cond);
398 return get_irn_n(node, 0);
402 set_Cond_selector (ir_node *node, ir_node *selector) {
403 assert (node->op == op_Cond);
404 set_irn_n(node, 0, selector);
408 get_Return_mem (ir_node *node) {
409 assert (node->op == op_Return);
410 return get_irn_n(node, 0);
414 set_Return_mem (ir_node *node, ir_node *mem) {
415 assert (node->op == op_Return);
416 set_irn_n(node, 0, mem);
420 get_Return_res_arr (ir_node *node)
422 assert ((node->op == op_Return));
423 return ((ir_node **)get_Return_res(node, 0));
427 get_Return_n_res (ir_node *node) {
428 assert (node->op == op_Return);
429 return (get_irn_arity(node) - 1);
434 set_Return_n_res (ir_node *node, int results) {
435 assert (node->op == op_Return);
440 get_Return_res (ir_node *node, int pos) {
441 assert (node->op == op_Return);
442 return get_irn_n(node, pos+1);
446 set_Return_res (ir_node *node, int pos, ir_node *res){
447 assert (node->op == op_Return);
448 set_irn_n(node, pos+1, res);
452 get_Raise_mem (ir_node *node) {
453 assert (node->op == op_Return);
454 return get_irn_n(node, 0);
458 set_Raise_mem (ir_node *node, ir_node *mem) {
459 assert (node->op == op_Raise);
460 set_irn_n(node, 0, mem);
464 get_Raise_exo_ptr (ir_node *node) {
465 assert (node->op == op_Raise);
466 return get_irn_n(node, 1);
470 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
471 assert (node->op == op_Raise);
472 set_irn_n(node, 1, exo_ptr);
475 inline tarval *get_Const_tarval (ir_node *node) {
476 assert (node->op == op_Const);
477 return get_irn_const_attr(node);
481 set_Const_tarval (ir_node *node, tarval *con) {
482 assert (node->op == op_Const);
483 node->attr.con = con;
487 get_SymConst_kind (ir_node *node) {
488 assert (node->op == op_SymConst);
489 return node->attr.i.num;
493 set_SymConst_kind (ir_node *node, symconst_kind num) {
494 assert (node->op == op_SymConst);
495 node->attr.i.num = num;
499 get_SymConst_type (ir_node *node) {
500 assert ( (node->op == op_SymConst)
501 && ( get_SymConst_kind(node) == type_tag
502 || get_SymConst_kind(node) == size));
503 return node->attr.i.tori.typ;
507 set_SymConst_type (ir_node *node, type *type) {
508 assert ( (node->op == op_SymConst)
509 && ( get_SymConst_kind(node) == type_tag
510 || get_SymConst_kind(node) == size));
511 node->attr.i.tori.typ = type;
515 get_SymConst_ptrinfo (ir_node *node) {
516 assert ( (node->op == op_SymConst)
517 && (get_SymConst_kind(node) == linkage_ptr_info));
518 return node->attr.i.tori.ptrinfo;
524 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
525 assert ( (node->op == op_SymConst)
526 && (get_SymConst_kind(node) == linkage_ptr_info));
527 node->attr.i.tori.ptrinfo = ptrinfo;
531 get_Sel_mem (ir_node *node) {
532 assert (node->op == op_Sel);
533 return get_irn_n(node, 0);
537 set_Sel_mem (ir_node *node, ir_node *mem) {
538 assert (node->op == op_Sel);
539 set_irn_n(node, 0, mem);
543 get_Sel_ptr (ir_node *node) {
544 assert (node->op == op_Sel);
545 return get_irn_n(node, 1);
549 set_Sel_ptr (ir_node *node, ir_node *ptr) {
550 assert (node->op == op_Sel);
551 set_irn_n(node, 1, ptr);
555 get_Sel_index_arr (ir_node *node)
557 assert ((node->op == op_Sel));
558 return (ir_node **)get_Sel_index(node, 0);
562 get_Sel_n_index (ir_node *node) {
563 assert (node->op == op_Sel);
564 return (get_irn_arity(node) - 2);
569 set_Sel_n_index (ir_node *node, int n_index) {
570 assert (node->op == op_Sel);
575 get_Sel_index (ir_node *node, int pos) {
576 assert (node->op == op_Sel);
577 return get_irn_n(node, pos+2);
581 set_Sel_index (ir_node *node, int pos, ir_node *index) {
582 assert (node->op == op_Sel);
583 set_irn_n(node, pos+2, index);
587 get_Sel_entity (ir_node *node) {
588 assert (node->op == op_Sel);
589 return node->attr.s.ent;
593 set_Sel_entity (ir_node *node, entity *ent) {
594 assert (node->op == op_Sel);
595 node->attr.s.ent = ent;
599 get_Sel_linkage_type (ir_node *node) {
600 assert (node->op == op_Sel);
601 return node->attr.s.ltyp;
605 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
606 assert (node->op == op_Sel);
607 node->attr.s.ltyp = lt;
611 get_Call_mem (ir_node *node) {
612 assert (node->op == op_Call);
613 return get_irn_n(node, 0);
617 set_Call_mem (ir_node *node, ir_node *mem) {
618 assert (node->op == op_Call);
619 set_irn_n(node, 0, mem);
623 get_Call_ptr (ir_node *node) {
624 assert (node->op == op_Call);
625 return get_irn_n(node, 1);
629 set_Call_ptr (ir_node *node, ir_node *ptr) {
630 assert (node->op == op_Call);
631 set_irn_n(node, 1, ptr);
635 get_Call_param_arr (ir_node *node) {
636 assert (node->op == op_Call);
637 return ((ir_node **)get_Call_param (node, 0));
641 get_Call_arity (ir_node *node) {
642 assert (node->op == op_Call);
643 return (get_irn_arity(node) - 2);
647 set_Call_arity (ir_node *node, ir_node *arity) {
648 assert (node->op == op_Call);
653 get_Call_param (ir_node *node, int pos) {
654 assert (node->op == op_Call);
655 return get_irn_n(node, pos+1);
659 set_Call_param (ir_node *node, int pos, ir_node *param) {
660 assert (node->op == op_Call);
661 set_irn_n(node, pos+1, param);
665 get_Call_type (ir_node *node) {
666 assert (node->op == op_Call);
667 return node->attr.call;
671 set_Call_type (ir_node *node, type_method *type) {
672 assert (node->op == op_Call);
673 node->attr.call = type;
676 /* For unary and binary arithmetic operations the access to the
677 operands can be factored out. Left is the first, right the
678 second arithmetic value as listed in tech report 0999-33.
679 unops are: Minus, Abs, Not, Conv
680 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
681 Shr, Shrs, Rotate, Cmp */
684 is_unop (ir_node *node) {
685 return ( node->op == op_Minus ||
686 node->op == op_Abs ||
687 node->op == op_Not ||
688 node->op == op_Conv );
692 get_unop_op (ir_node *node) {
693 assert ( node->op == op_Minus ||
694 node->op == op_Abs ||
695 node->op == op_Not ||
696 node->op == op_Conv );
697 switch (get_irn_opcode (node)) {
698 case iro_Minus: return get_Minus_op(node); break;
699 case iro_Abs: return get_Abs_op(node); break;
700 case iro_Not: return get_Not_op(node); break;
701 case iro_Conv: return get_Conv_op(node); break;
702 default: return NULL;
707 set_unop_op (ir_node *node, ir_node *op) {
708 assert (node->op == op_Minus ||
709 node->op == op_Abs ||
710 node->op == op_Not ||
711 node->op == op_Conv );
712 switch (get_irn_opcode (node)) {
713 case iro_Minus: set_Minus_op(node, op); break;
714 case iro_Abs: set_Abs_op(node, op); break;
715 case iro_Not: set_Not_op(node, op); break;
716 case iro_Conv: set_Conv_op(node, op); break;
723 is_binop (ir_node *node) {
724 return (node->op == op_Add ||
725 node->op == op_Sub ||
726 node->op == op_Mul ||
727 node->op == op_Quot ||
728 node->op == op_DivMod ||
729 node->op == op_Div ||
730 node->op == op_Mod ||
731 node->op == op_And ||
733 node->op == op_Eor ||
734 node->op == op_Shl ||
735 node->op == op_Shr ||
736 node->op == op_Shrs ||
737 node->op == op_Rot ||
738 node->op == op_Cmp );
742 get_binop_left (ir_node *node) {
743 assert (node->op == op_Add ||
744 node->op == op_Sub ||
745 node->op == op_Mul ||
746 node->op == op_Quot ||
747 node->op == op_DivMod ||
748 node->op == op_Div ||
749 node->op == op_Mod ||
750 node->op == op_And ||
752 node->op == op_Eor ||
753 node->op == op_Shl ||
754 node->op == op_Shr ||
755 node->op == op_Shrs ||
756 node->op == op_Rot ||
757 node->op == op_Cmp );
759 switch (get_irn_opcode (node)) {
760 case iro_Add : return get_Add_left(node); break;
761 case iro_Sub : return get_Sub_left(node); break;
762 case iro_Mul : return get_Mul_left(node); break;
763 case iro_Quot : return get_Quot_left(node); break;
764 case iro_DivMod: return get_DivMod_left(node); break;
765 case iro_Div : return get_Div_left(node); break;
766 case iro_Mod : return get_Mod_left(node); break;
767 case iro_And : return get_And_left(node); break;
768 case iro_Or : return get_Or_left(node); break;
769 case iro_Eor : return get_Eor_left(node); break;
770 case iro_Shl : return get_Shl_left(node); break;
771 case iro_Shr : return get_Shr_left(node); break;
772 case iro_Shrs : return get_Shrs_left(node); break;
773 case iro_Rot : return get_Rot_left(node); break;
774 case iro_Cmp : return get_Cmp_left(node); break;
775 default: return NULL;
780 set_binop_left (ir_node *node, ir_node *left) {
781 assert (node->op == op_Add ||
782 node->op == op_Sub ||
783 node->op == op_Mul ||
784 node->op == op_Quot ||
785 node->op == op_DivMod ||
786 node->op == op_Div ||
787 node->op == op_Mod ||
788 node->op == op_And ||
790 node->op == op_Eor ||
791 node->op == op_Shl ||
792 node->op == op_Shr ||
793 node->op == op_Shrs ||
794 node->op == op_Rot ||
795 node->op == op_Cmp );
797 switch (get_irn_opcode (node)) {
798 case iro_Add : set_Add_left(node, left); break;
799 case iro_Sub : set_Sub_left(node, left); break;
800 case iro_Mul : set_Mul_left(node, left); break;
801 case iro_Quot : set_Quot_left(node, left); break;
802 case iro_DivMod: set_DivMod_left(node, left); break;
803 case iro_Div : set_Div_left(node, left); break;
804 case iro_Mod : set_Mod_left(node, left); break;
805 case iro_And : set_And_left(node, left); break;
806 case iro_Or : set_Or_left(node, left); break;
807 case iro_Eor : set_Eor_left(node, left); break;
808 case iro_Shl : set_Shl_left(node, left); break;
809 case iro_Shr : set_Shr_left(node, left); break;
810 case iro_Shrs : set_Shrs_left(node, left); break;
811 case iro_Rot : set_Rot_left(node, left); break;
812 case iro_Cmp : set_Cmp_left(node, left); break;
818 get_binop_right (ir_node *node) {
819 assert (node->op == op_Add ||
820 node->op == op_Sub ||
821 node->op == op_Mul ||
822 node->op == op_Quot ||
823 node->op == op_DivMod ||
824 node->op == op_Div ||
825 node->op == op_Mod ||
826 node->op == op_And ||
828 node->op == op_Eor ||
829 node->op == op_Shl ||
830 node->op == op_Shr ||
831 node->op == op_Shrs ||
832 node->op == op_Rot ||
833 node->op == op_Cmp );
835 switch (get_irn_opcode (node)) {
836 case iro_Add : return get_Add_right(node); break;
837 case iro_Sub : return get_Sub_right(node); break;
838 case iro_Mul : return get_Mul_right(node); break;
839 case iro_Quot : return get_Quot_right(node); break;
840 case iro_DivMod: return get_DivMod_right(node); break;
841 case iro_Div : return get_Div_right(node); break;
842 case iro_Mod : return get_Mod_right(node); break;
843 case iro_And : return get_And_right(node); break;
844 case iro_Or : return get_Or_right(node); break;
845 case iro_Eor : return get_Eor_right(node); break;
846 case iro_Shl : return get_Shl_right(node); break;
847 case iro_Shr : return get_Shr_right(node); break;
848 case iro_Shrs : return get_Shrs_right(node); break;
849 case iro_Rot : return get_Rot_right(node); break;
850 case iro_Cmp : return get_Cmp_right(node); break;
851 default: return NULL;
856 set_binop_right (ir_node *node, ir_node *right) {
857 assert (node->op == op_Add ||
858 node->op == op_Sub ||
859 node->op == op_Mul ||
860 node->op == op_Quot ||
861 node->op == op_DivMod ||
862 node->op == op_Div ||
863 node->op == op_Mod ||
864 node->op == op_And ||
866 node->op == op_Eor ||
867 node->op == op_Shl ||
868 node->op == op_Shr ||
869 node->op == op_Shrs ||
870 node->op == op_Rot ||
871 node->op == op_Cmp );
873 switch (get_irn_opcode (node)) {
874 case iro_Add : set_Add_right(node, right); break;
875 case iro_Sub : set_Sub_right(node, right); break;
876 case iro_Mul : set_Mul_right(node, right); break;
877 case iro_Quot : set_Quot_right(node, right); break;
878 case iro_DivMod: set_DivMod_right(node, right); break;
879 case iro_Div : set_Div_right(node, right); break;
880 case iro_Mod : set_Mod_right(node, right); break;
881 case iro_And : set_And_right(node, right); break;
882 case iro_Or : set_Or_right(node, right); break;
883 case iro_Eor : set_Eor_right(node, right); break;
884 case iro_Shl : set_Shl_right(node, right); break;
885 case iro_Shr : set_Shr_right(node, right); break;
886 case iro_Shrs : set_Shrs_right(node, right); break;
887 case iro_Rot : set_Rot_right(node, right); break;
888 case iro_Cmp : set_Cmp_right(node, right); break;
894 get_Add_left (ir_node *node) {
895 assert (node->op == op_Add);
896 return get_irn_n(node, 0);
900 set_Add_left (ir_node *node, ir_node *left) {
901 assert (node->op == op_Add);
902 set_irn_n(node, 0, left);
906 get_Add_right (ir_node *node) {
907 assert (node->op == op_Add);
908 return get_irn_n(node, 1);
912 set_Add_right (ir_node *node, ir_node *right) {
913 assert (node->op == op_Add);
914 set_irn_n(node, 1, right);
918 get_Sub_left (ir_node *node) {
919 assert (node->op == op_Sub);
920 return get_irn_n(node, 0);
924 set_Sub_left (ir_node *node, ir_node *left) {
925 assert (node->op == op_Sub);
926 set_irn_n(node, 0, left);
930 get_Sub_right (ir_node *node) {
931 assert (node->op == op_Sub);
932 return get_irn_n(node, 1);
936 set_Sub_right (ir_node *node, ir_node *right) {
937 assert (node->op == op_Sub);
938 set_irn_n(node, 1, right);
943 get_Minus_op (ir_node *node) {
944 assert (node->op == op_Minus);
945 return get_irn_n(node, 0);
949 set_Minus_op (ir_node *node, ir_node *op) {
950 assert (node->op == op_Minus);
951 set_irn_n(node, 0, op);
956 get_Mul_left (ir_node *node) {
957 assert (node->op == op_Mul);
958 return get_irn_n(node, 0);
962 set_Mul_left (ir_node *node, ir_node *left) {
963 assert (node->op == op_Mul);
964 set_irn_n(node, 0, left);
968 get_Mul_right (ir_node *node) {
969 assert (node->op == op_Mul);
970 return get_irn_n(node, 1);
974 set_Mul_right (ir_node *node, ir_node *right) {
975 assert (node->op == op_Mul);
976 set_irn_n(node, 1, right);
980 get_Quot_left (ir_node *node) {
981 assert (node->op == op_Quot);
982 return get_irn_n(node, 1);
986 set_Quot_left (ir_node *node, ir_node *left) {
987 assert (node->op == op_Quot);
988 set_irn_n(node, 1, left);
992 get_Quot_right (ir_node *node) {
993 assert (node->op == op_Quot);
994 return get_irn_n(node, 2);
998 set_Quot_right (ir_node *node, ir_node *right) {
999 assert (node->op == op_Quot);
1000 set_irn_n(node, 2, right);
1004 get_Quot_mem (ir_node *node) {
1005 assert (node->op == op_Quot);
1006 return get_irn_n(node, 0);
1010 set_Quot_mem (ir_node *node, ir_node *mem) {
1011 assert (node->op == op_Quot);
1012 set_irn_n(node, 0, mem);
1016 get_DivMod_left (ir_node *node) {
1017 assert (node->op == op_DivMod);
1018 return get_irn_n(node, 1);
1022 set_DivMod_left (ir_node *node, ir_node *left) {
1023 assert (node->op == op_DivMod);
1024 set_irn_n(node, 1, left);
1028 get_DivMod_right (ir_node *node) {
1029 assert (node->op == op_DivMod);
1030 return get_irn_n(node, 2);
1034 set_DivMod_right (ir_node *node, ir_node *right) {
1035 assert (node->op == op_DivMod);
1036 set_irn_n(node, 2, right);
1040 get_DivMod_mem (ir_node *node) {
1041 assert (node->op == op_DivMod);
1042 return get_irn_n(node, 0);
1046 set_DivMod_mem (ir_node *node, ir_node *mem) {
1047 assert (node->op == op_DivMod);
1048 set_irn_n(node, 0, mem);
1052 get_Div_left (ir_node *node) {
1053 assert (node->op == op_Div);
1054 return get_irn_n(node, 1);
1058 set_Div_left (ir_node *node, ir_node *left) {
1059 assert (node->op == op_Div);
1060 set_irn_n(node, 1, left);
1064 get_Div_right (ir_node *node) {
1065 assert (node->op == op_Div);
1066 return get_irn_n(node, 2);
1070 set_Div_right (ir_node *node, ir_node *right) {
1071 assert (node->op == op_Div);
1072 set_irn_n(node, 2, right);
1076 get_Div_mem (ir_node *node) {
1077 assert (node->op == op_Div);
1078 return get_irn_n(node, 0);
1082 set_Div_mem (ir_node *node, ir_node *mem) {
1083 assert (node->op == op_Div);
1084 set_irn_n(node, 0, mem);
1088 get_Mod_left (ir_node *node) {
1089 assert (node->op == op_Mod);
1090 return get_irn_n(node, 1);
1094 set_Mod_left (ir_node *node, ir_node *left) {
1095 assert (node->op == op_Mod);
1096 set_irn_n(node, 1, left);
1100 get_Mod_right (ir_node *node) {
1101 assert (node->op == op_Mod);
1102 return get_irn_n(node, 2);
1106 set_Mod_right (ir_node *node, ir_node *right) {
1107 assert (node->op == op_Mod);
1108 set_irn_n(node, 2, right);
1112 get_Mod_mem (ir_node *node) {
1113 assert (node->op == op_Mod);
1114 return get_irn_n(node, 0);
1118 set_Mod_mem (ir_node *node, ir_node *mem) {
1119 assert (node->op == op_Mod);
1120 set_irn_n(node, 0, mem);
1124 get_Abs_op (ir_node *node) {
1125 assert (node->op == op_Abs);
1126 return get_irn_n(node, 0);
1130 set_Abs_op (ir_node *node, ir_node *op) {
1131 assert (node->op == op_Abs);
1132 set_irn_n(node, 0, op);
1136 get_And_left (ir_node *node) {
1137 assert (node->op == op_And);
1138 return get_irn_n(node, 0);
1142 set_And_left (ir_node *node, ir_node *left) {
1143 assert (node->op == op_And);
1144 set_irn_n(node, 0, left);
1148 get_And_right (ir_node *node) {
1149 assert (node->op == op_And);
1150 return get_irn_n(node, 1);
1154 set_And_right (ir_node *node, ir_node *right) {
1155 assert (node->op == op_And);
1156 set_irn_n(node, 1, right);
1160 get_Or_left (ir_node *node) {
1161 assert (node->op == op_Or);
1162 return get_irn_n(node, 0);
1166 set_Or_left (ir_node *node, ir_node *left) {
1167 assert (node->op == op_Or);
1168 set_irn_n(node, 0, left);
1172 get_Or_right (ir_node *node) {
1173 assert (node->op == op_Or);
1174 return get_irn_n(node, 1);
1178 set_Or_right (ir_node *node, ir_node *right) {
1179 assert (node->op == op_Or);
1180 set_irn_n(node, 1, right);
1184 get_Eor_left (ir_node *node) {
1185 assert (node->op == op_Eor);
1186 return get_irn_n(node, 0);
1190 set_Eor_left (ir_node *node, ir_node *left) {
1191 assert (node->op == op_Eor);
1192 set_irn_n(node, 0, left);
1196 get_Eor_right (ir_node *node) {
1197 assert (node->op == op_Eor);
1198 return get_irn_n(node, 1);
1202 set_Eor_right (ir_node *node, ir_node *right) {
1203 assert (node->op == op_Eor);
1204 set_irn_n(node, 1, right);
1209 get_Not_op (ir_node *node) {
1210 assert (node->op == op_Not);
1211 return get_irn_n(node, 0);
1215 set_Not_op (ir_node *node, ir_node *op) {
1216 assert (node->op == op_Not);
1217 set_irn_n(node, 0, op);
1222 get_Shl_left (ir_node *node) {
1223 assert (node->op == op_Shl);
1224 return get_irn_n(node, 0);
1228 set_Shl_left (ir_node *node, ir_node *left) {
1229 assert (node->op == op_Shl);
1230 set_irn_n(node, 0, left);
1234 get_Shl_right (ir_node *node) {
1235 assert (node->op == op_Shl);
1236 return get_irn_n(node, 1);
1240 set_Shl_right (ir_node *node, ir_node *right) {
1241 assert (node->op == op_Shl);
1242 set_irn_n(node, 1, right);
1246 get_Shr_left (ir_node *node) {
1247 assert (node->op == op_Shr);
1248 return get_irn_n(node, 0);
1252 set_Shr_left (ir_node *node, ir_node *left) {
1253 assert (node->op == op_Shr);
1254 set_irn_n(node, 0, left);
1258 get_Shr_right (ir_node *node) {
1259 assert (node->op == op_Shr);
1260 return get_irn_n(node, 1);
1264 set_Shr_right (ir_node *node, ir_node *right) {
1265 assert (node->op == op_Shr);
1266 set_irn_n(node, 1, right);
1270 get_Shrs_left (ir_node *node) {
1271 assert (node->op == op_Shrs);
1272 return get_irn_n(node, 0);
1276 set_Shrs_left (ir_node *node, ir_node *left) {
1277 assert (node->op == op_Shrs);
1278 set_irn_n(node, 0, left);
1282 get_Shrs_right (ir_node *node) {
1283 assert (node->op == op_Shrs);
1284 return get_irn_n(node, 1);
1288 set_Shrs_right (ir_node *node, ir_node *right) {
1289 assert (node->op == op_Shrs);
1290 set_irn_n(node, 1, right);
1294 get_Rot_left (ir_node *node) {
1295 assert (node->op == op_Rot);
1296 return get_irn_n(node, 0);
1300 set_Rot_left (ir_node *node, ir_node *left) {
1301 assert (node->op == op_Rot);
1302 set_irn_n(node, 0, left);
1306 get_Rot_right (ir_node *node) {
1307 assert (node->op == op_Rot);
1308 return get_irn_n(node, 1);
1312 set_Rot_right (ir_node *node, ir_node *right) {
1313 assert (node->op == op_Rot);
1314 set_irn_n(node, 1, right);
1318 get_Cmp_left (ir_node *node) {
1319 assert (node->op == op_Cmp);
1320 return get_irn_n(node, 0);
1324 set_Cmp_left (ir_node *node, ir_node *left) {
1325 assert (node->op == op_Cmp);
1326 set_irn_n(node, 0, left);
1330 get_Cmp_right (ir_node *node) {
1331 assert (node->op == op_Cmp);
1332 return get_irn_n(node, 1);
1336 set_Cmp_right (ir_node *node, ir_node *right) {
1337 assert (node->op == op_Cmp);
1338 set_irn_n(node, 1, right);
1342 get_Conv_op (ir_node *node) {
1343 assert (node->op == op_Conv);
1344 return get_irn_n(node, 0);
1348 set_Conv_op (ir_node *node, ir_node *op) {
1349 assert (node->op == op_Conv);
1350 set_irn_n(node, 0, op);
1354 get_Phi_preds_arr (ir_node *node) {
1355 assert (node->op == op_Phi);
1356 return ((ir_node **)get_Phi_pred(node, 0));
1360 get_Phi_n_preds (ir_node *node) {
1361 assert (node->op == op_Phi);
1362 return (get_irn_arity(node));
1366 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1367 assert (node->op == op_Phi);
1372 get_Phi_pred (ir_node *node, int pos) {
1373 assert (node->op == op_Phi);
1374 return get_irn_n(node, pos);
1378 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1379 assert (node->op == op_Phi);
1380 set_irn_n(node, pos, pred);
1384 get_Load_mem (ir_node *node) {
1385 assert (node->op == op_Load);
1386 return get_irn_n(node, 0);
1390 set_Load_mem (ir_node *node, ir_node *mem) {
1391 assert (node->op == op_Load);
1392 set_irn_n(node, 0, mem);
1396 get_Load_ptr (ir_node *node) {
1397 assert (node->op == op_Load);
1398 return get_irn_n(node, 1);
1402 set_Load_ptr (ir_node *node, ir_node *ptr) {
1403 assert (node->op == op_Load);
1404 set_irn_n(node, 1, ptr);
1409 get_Store_mem (ir_node *node) {
1410 assert (node->op == op_Store);
1411 return get_irn_n(node, 0);
1415 set_Store_mem (ir_node *node, ir_node *mem) {
1416 assert (node->op == op_Store);
1417 set_irn_n(node, 0, mem);
1421 get_Store_ptr (ir_node *node) {
1422 assert (node->op == op_Store);
1423 return get_irn_n(node, 1);
1427 set_Store_ptr (ir_node *node, ir_node *ptr) {
1428 assert (node->op == op_Store);
1429 set_irn_n(node, 1, ptr);
1433 get_Store_value (ir_node *node) {
1434 assert (node->op == op_Store);
1435 return get_irn_n(node, 2);
1439 set_Store_value (ir_node *node, ir_node *value) {
1440 assert (node->op == op_Store);
1441 set_irn_n(node, 2, value);
1445 get_Alloc_mem (ir_node *node) {
1446 assert (node->op == op_Alloc);
1447 return get_irn_n(node, 0);
1451 set_Alloc_mem (ir_node *node, ir_node *mem) {
1452 assert (node->op == op_Alloc);
1453 set_irn_n(node, 0, mem);
1457 get_Alloc_size (ir_node *node) {
1458 assert (node->op == op_Alloc);
1459 return get_irn_n(node, 1);
1463 set_Allco_size (ir_node *node, ir_node *size) {
1464 assert (node->op == op_Alloc);
1465 set_irn_n(node, 1, size);
1469 get_Alloc_type (ir_node *node) {
1470 assert (node->op == op_Alloc);
1471 return node->attr.a.type;
1475 set_Alloc_type (ir_node *node, type *type) {
1476 assert (node->op == op_Alloc);
1477 node->attr.a.type = type;
1481 get_Alloc_where (ir_node *node) {
1482 assert (node->op == op_Alloc);
1483 return node->attr.a.where;
1487 set_Alloc_where (ir_node *node, where_alloc where) {
1488 assert (node->op == op_Alloc);
1489 node->attr.a.where = where;
1494 get_Free_mem (ir_node *node) {
1495 assert (node->op == op_Free);
1496 return get_irn_n(node, 0);
1500 set_Free_mem (ir_node *node, ir_node *mem) {
1501 assert (node->op == op_Free);
1502 set_irn_n(node, 0, mem);
1506 get_Free_ptr (ir_node *node) {
1507 assert (node->op == op_Free);
1508 return get_irn_n(node, 1);
1512 set_Free_ptr (ir_node *node, ir_node *ptr) {
1513 assert (node->op == op_Free);
1514 set_irn_n(node, 1, ptr);
1518 get_Free_size (ir_node *node) {
1519 assert (node->op == op_Free);
1520 return get_irn_n(node, 2);
1524 set_Free_size (ir_node *node, ir_node *size) {
1525 assert (node->op == op_Free);
1526 set_irn_n(node, 2, size);
1530 get_Free_type (ir_node *node) {
1531 assert (node->op == op_Free);
1532 return node->attr.f;
1536 set_Free_type (ir_node *node, type *type) {
1537 assert (node->op == op_Free);
1538 node->attr.f = type;
1542 get_Sync_preds_arr (ir_node *node) {
1543 assert (node->op == op_Sync);
1544 return ((ir_node **)get_Sync_pred(node, 0));
1548 get_Sync_n_preds (ir_node *node) {
1549 assert (node->op == op_Sync);
1550 return (get_irn_arity(node));
1555 set_Sync_n_preds (ir_node *node, int n_preds) {
1556 assert (node->op == op_Sync);
1561 get_Sync_pred (ir_node *node, int pos) {
1562 assert (node->op == op_Sync);
1563 return get_irn_n(node, pos);
1567 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1568 assert (node->op == op_Sync);
1569 set_irn_n(node, pos, pred);
1573 get_Proj_pred (ir_node *node) {
1574 assert (node->op == op_Proj);
1575 return get_irn_n(node, 0);
1579 set_Proj_pred (ir_node *node, ir_node *pred) {
1580 assert (node->op == op_Proj);
1581 set_irn_n(node, 0, pred);
1585 get_Proj_proj (ir_node *node) {
1586 assert (node->op == op_Proj);
1587 return node->attr.proj;
1591 set_Proj_proj (ir_node *node, long proj) {
1592 assert (node->op == op_Proj);
1593 node->attr.proj = proj;
1597 get_Tuple_preds_arr (ir_node *node) {
1598 assert (node->op == op_Tuple);
1599 return ((ir_node **)get_Tuple_pred(node, 0));
1603 get_Tuple_n_preds (ir_node *node) {
1604 assert (node->op == op_Tuple);
1605 return (get_irn_arity(node));
1610 set_Tuple_n_preds (ir_node *node, int n_preds) {
1611 assert (node->op == op_Tuple);
1616 get_Tuple_pred (ir_node *node, int pos) {
1617 assert (node->op == op_Tuple);
1618 return get_irn_n(node, pos);
1622 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1623 assert (node->op == op_Tuple);
1624 set_irn_n(node, pos, pred);
1628 get_Id_pred (ir_node *node) {
1629 assert (node->op == op_Id);
1630 return get_irn_n(node, 0);
1634 set_Id_pred (ir_node *node, ir_node *pred) {
1635 assert (node->op == op_Id);
1636 set_irn_n(node, 0, pred);
1639 /******************************************************************/
1640 /* Auxiliary routines */
1641 /******************************************************************/
1644 skip_Proj (ir_node *node) {
1645 /* don't assert node !!! */
1646 if (node && (node->op == op_Proj)) {
1647 return get_Proj_pred(node);
1654 skip_nop (ir_node *node) {
1655 /* don't assert node !!! */
1656 if (node && (node->op == op_Id)) {
1657 return get_Id_pred(node);
1664 is_Bad (ir_node *node) {
1666 if ((node) && get_irn_opcode(node) == iro_Bad)
1672 is_no_Block (ir_node *node) {
1674 return (get_irn_opcode(node) != iro_Block);
1677 /* Returns true if the operation manipulates control flow. */
1679 is_cfop(ir_node *node) {
1680 return ( (get_irn_opcode(node) == iro_Start)
1681 || (get_irn_opcode(node) == iro_Jmp)
1682 || (get_irn_opcode(node) == iro_Cond)
1683 || (get_irn_opcode(node) == iro_Return)
1684 || (get_irn_opcode(node) == iro_Raise)
1685 || (get_irn_opcode(node) == iro_Bad));
1688 /* Returns true if the operation can change the control flow because
1691 is_fragile_op(ir_node *node) {
1692 return ( (get_irn_opcode(node) == iro_Call)
1693 || (get_irn_opcode(node) == iro_Quot)
1694 || (get_irn_opcode(node) == iro_DivMod)
1695 || (get_irn_opcode(node) == iro_Div)
1696 || (get_irn_opcode(node) == iro_Mod)
1697 || (get_irn_opcode(node) == iro_Load)
1698 || (get_irn_opcode(node) == iro_Store)
1699 || (get_irn_opcode(node) == iro_Alloc)
1700 || (get_irn_opcode(node) == iro_Bad));