1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
17 /* some constants fixing the positions of nodes predecessors
19 #define CALL_PARAM_OFFSET 2
20 #define SEL_INDEX_OFFSET 2
21 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
23 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
24 "Gt", "Ge", "Lg", "Leg", "Uo",
25 "Ue", "Ul", "Ule", "Ug", "Uge",
28 inline char *get_pnc_string(int pnc) {
29 return pnc_name_arr[pnc];
34 get_negated_pnc(int pnc) {
36 case False: return True; break;
37 case Eq: return Ne; break;
38 case Lt: return Uge; break;
39 case Le: return Ug; break;
40 case Gt: return Ule; break;
41 case Ge: return Ul; break;
42 case Lg: return Ue; break;
43 case Leg: return Uo; break;
44 case Uo: return Leg; break;
45 case Ue: return Lg; break;
46 case Ul: return Ge; break;
47 case Ule: return Gt; break;
48 case Ug: return Le; break;
49 case Uge: return Lt; break;
50 case Ne: return Eq; break;
51 case True: return False; break;
53 return 99; /* to shut up gcc */
56 static char *pns_name_arr [] = {"initial_exec", "global_store",
57 "frame_base", "globals", "args"};
59 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
66 /* irnode constructor */
67 /* create a new irnode in irg, with an op, mode, arity and */
68 /* some incoming irnodes */
69 /* this constructor is used in every specified irnode constructor */
71 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
72 int arity, ir_node **in)
75 int node_size = offsetof (ir_node, attr) + op->attr_size;
77 res = (ir_node *) obstack_alloc (irg->obst, node_size);
79 res->kind = k_ir_node;
85 res->in = NEW_ARR_F (ir_node *, 1);
87 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
88 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
93 res->node_nr = get_irp_new_node_nr();
99 /* Copies all attributes stored in the old node to the new node.
100 Assumes both have the same opcode and sufficient size. */
102 copy_attrs (ir_node *old, ir_node *new) {
103 assert (get_irn_opcode(old) == get_irn_opcode(new));
104 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
107 /* IR-Nodes with attributes */
109 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
112 ir_node *np = XP_GETARG (ir_node *, 0);
115 XPS ("<null ir_node>");
119 XPF1 ("%I", get_irn_opname(np));
121 switch (get_irn_opcode (np)) { /* node label */
123 XPF1 ("%I", get_irn_mode(np)->name);
125 XPF1 ("%v", get_irn_const_attr);
128 if (get_irn_modecode (np) == irm_b) {
130 XP (pnc_name_arr[get_irn_proj_attr(np)]);
131 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
133 XP (pns_name_arr[get_irn_proj_attr(np)]);
135 XPF1 ("%I", get_irn_mode(np)->name);
137 XPF1 ("%d", get_irn_proj_attr(np));
141 XPF1 ("%I", get_irn_mode(np)->name);
143 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
144 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
146 case iro_Start: /* don't dump mode of these */
155 XPF1 ("%I", get_irn_mode(np)->name);
162 /** getting some parameters from ir_nodes **/
164 /* returns the number of predecessors without the block predecessor. */
166 get_irn_arity (ir_node *node)
169 return (ARR_LEN((node)->in)-1);
172 /* Returns the array with ins. This array is shifted with respect to the
173 array accessed by get_irn_n: The block operand is at position 0 not -1.
174 (@@@ This should be changed.)
175 The order of the predecessors in this array is not guaranteed, except that
176 lists of operands as predecessors of Block or arguments of a Call are
179 get_irn_in (ir_node *node)
185 /* to iterate through the predecessors without touching the array */
186 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
187 to iterate includind the Block predecessor iterate from i = -1 to
189 If it is a block, the entry -1 is NULL. */
191 get_irn_n (ir_node *node, int n)
194 assert (get_irn_arity (node) > n);
195 return skip_nop(node->in[n+1]);
199 set_irn_n (ir_node *node, int n, ir_node *in)
202 assert (get_irn_arity (node) > n);
207 get_irn_mode (ir_node *node)
214 get_irn_modecode (ir_node *node)
217 return node->mode->code;
222 get_irn_modename (ir_node *node)
225 return node->mode->name;
229 get_irn_op (ir_node *node)
235 /* should be private to the library: */
237 set_irn_op (ir_node *node, ir_op *op)
244 get_irn_opcode (ir_node *node)
247 return node->op->code;
251 get_irn_opname (ir_node *node)
254 return node->op->name;
258 get_irn_visited (ir_node *node)
261 return node->visited;
265 set_irn_visited (ir_node *node, unsigned long visited)
268 node->visited = visited;
271 set_irn_link (ir_node *node, ir_node *link) {
277 get_irn_link (ir_node *node) {
283 /* Outputs a unique number for this node */
285 get_irn_node_nr(ir_node *node) {
287 return node->node_nr;
292 get_irn_const_attr (ir_node *node)
294 assert (node->op == op_Const);
295 return node->attr.con;
299 get_irn_proj_attr (ir_node *node)
301 assert (node->op == op_Proj);
302 return node->attr.proj;
306 get_irn_alloc_attr (ir_node *node)
308 assert (node->op == op_Alloc);
313 get_irn_free_attr (ir_node *node)
315 assert (node->op == op_Free);
320 get_irn_symconst_attr (ir_node *node)
322 assert (node->op == op_SymConst);
327 get_irn_call_attr (ir_node *node)
329 assert (node->op == op_Call);
330 return node->attr.call;
334 get_irn_sel_attr (ir_node *node)
336 assert (node->op == op_Sel);
341 get_irn_phi_attr (ir_node *node)
343 assert (node->op == op_Phi);
344 return node->attr.phi0_pos;
348 get_irn_block_attr (ir_node *node)
350 assert (node->op == op_Block);
351 return node->attr.block;
354 /** manipulate fields of individual nodes **/
356 /* this works for all except Block */
358 get_nodes_Block (ir_node *node) {
359 assert (!(node->op == op_Block));
360 return get_irn_n(node, -1);
364 set_nodes_Block (ir_node *node, ir_node *block) {
365 assert (!(node->op == op_Block));
366 set_irn_n(node, -1, block);
369 /* Returns an array with the predecessors of the Block. Depending on
370 the implementation of the graph datastructure this can be a copy of
371 the internal representation of predecessors as well as the internal
372 array itself. Therefore writing to this array might obstruct the ir. */
374 get_Block_cfgpred_arr (ir_node *node)
376 assert ((node->op == op_Block));
377 return (ir_node **)&(get_irn_in(node)[1]);
382 get_Block_n_cfgpreds (ir_node *node) {
383 assert ((node->op == op_Block));
384 return (get_irn_arity(node));
389 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
390 assert ((node->op == op_Block));
395 get_Block_cfgpred (ir_node *node, int pos) {
396 assert (node->op == op_Block);
397 return get_irn_n(node, pos);
401 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
402 assert (node->op == op_Block);
403 set_irn_n(node, pos, pred);
407 get_Block_matured (ir_node *node) {
408 assert (node->op == op_Block);
409 return node->attr.block.matured;
413 set_Block_matured (ir_node *node, bool matured) {
414 assert (node->op == op_Block);
415 node->attr.block.matured = matured;
418 get_Block_block_visited (ir_node *node) {
419 assert (node->op == op_Block);
420 return node->attr.block.block_visited;
424 set_Block_block_visited (ir_node *node, unsigned long visit) {
425 assert (node->op == op_Block);
426 node->attr.block.block_visited = visit;
430 get_Block_graph_arr (ir_node *node, int pos) {
431 assert (node->op == op_Block);
432 return node->attr.block.graph_arr[pos+1];
436 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
437 assert (node->op == op_Block);
438 node->attr.block.graph_arr[pos+1] = value;
442 get_Cond_selector (ir_node *node) {
443 assert (node->op == op_Cond);
444 return get_irn_n(node, 0);
448 set_Cond_selector (ir_node *node, ir_node *selector) {
449 assert (node->op == op_Cond);
450 set_irn_n(node, 0, selector);
454 get_Return_mem (ir_node *node) {
455 assert (node->op == op_Return);
456 return get_irn_n(node, 0);
460 set_Return_mem (ir_node *node, ir_node *mem) {
461 assert (node->op == op_Return);
462 set_irn_n(node, 0, mem);
466 get_Return_res_arr (ir_node *node)
468 assert ((node->op == op_Return));
469 if (get_Return_n_res(node) > 0)
470 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
476 get_Return_n_res (ir_node *node) {
477 assert (node->op == op_Return);
478 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
483 set_Return_n_res (ir_node *node, int results) {
484 assert (node->op == op_Return);
489 get_Return_res (ir_node *node, int pos) {
490 assert (node->op == op_Return);
491 assert (get_Return_n_res(node) > pos);
492 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
496 set_Return_res (ir_node *node, int pos, ir_node *res){
497 assert (node->op == op_Return);
498 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
502 get_Raise_mem (ir_node *node) {
503 assert (node->op == op_Return);
504 return get_irn_n(node, 0);
508 set_Raise_mem (ir_node *node, ir_node *mem) {
509 assert (node->op == op_Raise);
510 set_irn_n(node, 0, mem);
514 get_Raise_exo_ptr (ir_node *node) {
515 assert (node->op == op_Raise);
516 return get_irn_n(node, 1);
520 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
521 assert (node->op == op_Raise);
522 set_irn_n(node, 1, exo_ptr);
525 inline tarval *get_Const_tarval (ir_node *node) {
526 assert (node->op == op_Const);
527 return get_irn_const_attr(node);
531 set_Const_tarval (ir_node *node, tarval *con) {
532 assert (node->op == op_Const);
533 node->attr.con = con;
537 get_SymConst_kind (ir_node *node) {
538 assert (node->op == op_SymConst);
539 return node->attr.i.num;
543 set_SymConst_kind (ir_node *node, symconst_kind num) {
544 assert (node->op == op_SymConst);
545 node->attr.i.num = num;
549 get_SymConst_type (ir_node *node) {
550 assert ( (node->op == op_SymConst)
551 && ( get_SymConst_kind(node) == type_tag
552 || get_SymConst_kind(node) == size));
553 return node->attr.i.tori.typ;
557 set_SymConst_type (ir_node *node, type *type) {
558 assert ( (node->op == op_SymConst)
559 && ( get_SymConst_kind(node) == type_tag
560 || get_SymConst_kind(node) == size));
561 node->attr.i.tori.typ = type;
565 get_SymConst_ptrinfo (ir_node *node) {
566 assert ( (node->op == op_SymConst)
567 && (get_SymConst_kind(node) == linkage_ptr_info));
568 return node->attr.i.tori.ptrinfo;
574 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
575 assert ( (node->op == op_SymConst)
576 && (get_SymConst_kind(node) == linkage_ptr_info));
577 node->attr.i.tori.ptrinfo = ptrinfo;
581 get_Sel_mem (ir_node *node) {
582 assert (node->op == op_Sel);
583 return get_irn_n(node, 0);
587 set_Sel_mem (ir_node *node, ir_node *mem) {
588 assert (node->op == op_Sel);
589 set_irn_n(node, 0, mem);
593 get_Sel_ptr (ir_node *node) {
594 assert (node->op == op_Sel);
595 return get_irn_n(node, 1);
599 set_Sel_ptr (ir_node *node, ir_node *ptr) {
600 assert (node->op == op_Sel);
601 set_irn_n(node, 1, ptr);
605 get_Sel_index_arr (ir_node *node)
607 assert ((node->op == op_Sel));
608 if (get_Sel_n_index(node) > 0)
609 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
615 get_Sel_n_index (ir_node *node) {
616 assert (node->op == op_Sel);
617 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
622 set_Sel_n_index (ir_node *node, int n_index) {
623 assert (node->op == op_Sel);
628 get_Sel_index (ir_node *node, int pos) {
629 assert (node->op == op_Sel);
630 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
634 set_Sel_index (ir_node *node, int pos, ir_node *index) {
635 assert (node->op == op_Sel);
636 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
640 get_Sel_entity (ir_node *node) {
641 assert (node->op == op_Sel);
642 return node->attr.s.ent;
646 set_Sel_entity (ir_node *node, entity *ent) {
647 assert (node->op == op_Sel);
648 node->attr.s.ent = ent;
652 get_Sel_linkage_type (ir_node *node) {
653 assert (node->op == op_Sel);
654 return node->attr.s.ltyp;
658 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
659 assert (node->op == op_Sel);
660 node->attr.s.ltyp = lt;
664 get_Call_mem (ir_node *node) {
665 assert (node->op == op_Call);
666 return get_irn_n(node, 0);
670 set_Call_mem (ir_node *node, ir_node *mem) {
671 assert (node->op == op_Call);
672 set_irn_n(node, 0, mem);
676 get_Call_ptr (ir_node *node) {
677 assert (node->op == op_Call);
678 return get_irn_n(node, 1);
682 set_Call_ptr (ir_node *node, ir_node *ptr) {
683 assert (node->op == op_Call);
684 set_irn_n(node, 1, ptr);
688 get_Call_param_arr (ir_node *node) {
689 assert (node->op == op_Call);
690 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
694 get_Call_arity (ir_node *node) {
695 assert (node->op == op_Call);
696 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
700 set_Call_arity (ir_node *node, ir_node *arity) {
701 assert (node->op == op_Call);
706 get_Call_param (ir_node *node, int pos) {
707 assert (node->op == op_Call);
708 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
712 set_Call_param (ir_node *node, int pos, ir_node *param) {
713 assert (node->op == op_Call);
714 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
718 get_Call_type (ir_node *node) {
719 assert (node->op == op_Call);
720 return node->attr.call;
724 set_Call_type (ir_node *node, type_method *type) {
725 assert (node->op == op_Call);
726 node->attr.call = type;
729 /* For unary and binary arithmetic operations the access to the
730 operands can be factored out. Left is the first, right the
731 second arithmetic value as listed in tech report 0999-33.
732 unops are: Minus, Abs, Not, Conv
733 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
734 Shr, Shrs, Rotate, Cmp */
737 is_unop (ir_node *node) {
738 return ( node->op == op_Minus ||
739 node->op == op_Abs ||
740 node->op == op_Not ||
741 node->op == op_Conv );
745 get_unop_op (ir_node *node) {
746 assert ( node->op == op_Minus ||
747 node->op == op_Abs ||
748 node->op == op_Not ||
749 node->op == op_Conv );
750 switch (get_irn_opcode (node)) {
751 case iro_Minus: return get_Minus_op(node); break;
752 case iro_Abs: return get_Abs_op(node); break;
753 case iro_Not: return get_Not_op(node); break;
754 case iro_Conv: return get_Conv_op(node); break;
755 default: return NULL;
760 set_unop_op (ir_node *node, ir_node *op) {
761 assert (node->op == op_Minus ||
762 node->op == op_Abs ||
763 node->op == op_Not ||
764 node->op == op_Conv );
765 switch (get_irn_opcode (node)) {
766 case iro_Minus: set_Minus_op(node, op); break;
767 case iro_Abs: set_Abs_op(node, op); break;
768 case iro_Not: set_Not_op(node, op); break;
769 case iro_Conv: set_Conv_op(node, op); break;
776 is_binop (ir_node *node) {
777 return (node->op == op_Add ||
778 node->op == op_Sub ||
779 node->op == op_Mul ||
780 node->op == op_Quot ||
781 node->op == op_DivMod ||
782 node->op == op_Div ||
783 node->op == op_Mod ||
784 node->op == op_And ||
786 node->op == op_Eor ||
787 node->op == op_Shl ||
788 node->op == op_Shr ||
789 node->op == op_Shrs ||
790 node->op == op_Rot ||
791 node->op == op_Cmp );
795 get_binop_left (ir_node *node) {
796 assert (node->op == op_Add ||
797 node->op == op_Sub ||
798 node->op == op_Mul ||
799 node->op == op_Quot ||
800 node->op == op_DivMod ||
801 node->op == op_Div ||
802 node->op == op_Mod ||
803 node->op == op_And ||
805 node->op == op_Eor ||
806 node->op == op_Shl ||
807 node->op == op_Shr ||
808 node->op == op_Shrs ||
809 node->op == op_Rot ||
810 node->op == op_Cmp );
812 switch (get_irn_opcode (node)) {
813 case iro_Add : return get_Add_left(node); break;
814 case iro_Sub : return get_Sub_left(node); break;
815 case iro_Mul : return get_Mul_left(node); break;
816 case iro_Quot : return get_Quot_left(node); break;
817 case iro_DivMod: return get_DivMod_left(node); break;
818 case iro_Div : return get_Div_left(node); break;
819 case iro_Mod : return get_Mod_left(node); break;
820 case iro_And : return get_And_left(node); break;
821 case iro_Or : return get_Or_left(node); break;
822 case iro_Eor : return get_Eor_left(node); break;
823 case iro_Shl : return get_Shl_left(node); break;
824 case iro_Shr : return get_Shr_left(node); break;
825 case iro_Shrs : return get_Shrs_left(node); break;
826 case iro_Rot : return get_Rot_left(node); break;
827 case iro_Cmp : return get_Cmp_left(node); break;
828 default: return NULL;
833 set_binop_left (ir_node *node, ir_node *left) {
834 assert (node->op == op_Add ||
835 node->op == op_Sub ||
836 node->op == op_Mul ||
837 node->op == op_Quot ||
838 node->op == op_DivMod ||
839 node->op == op_Div ||
840 node->op == op_Mod ||
841 node->op == op_And ||
843 node->op == op_Eor ||
844 node->op == op_Shl ||
845 node->op == op_Shr ||
846 node->op == op_Shrs ||
847 node->op == op_Rot ||
848 node->op == op_Cmp );
850 switch (get_irn_opcode (node)) {
851 case iro_Add : set_Add_left(node, left); break;
852 case iro_Sub : set_Sub_left(node, left); break;
853 case iro_Mul : set_Mul_left(node, left); break;
854 case iro_Quot : set_Quot_left(node, left); break;
855 case iro_DivMod: set_DivMod_left(node, left); break;
856 case iro_Div : set_Div_left(node, left); break;
857 case iro_Mod : set_Mod_left(node, left); break;
858 case iro_And : set_And_left(node, left); break;
859 case iro_Or : set_Or_left(node, left); break;
860 case iro_Eor : set_Eor_left(node, left); break;
861 case iro_Shl : set_Shl_left(node, left); break;
862 case iro_Shr : set_Shr_left(node, left); break;
863 case iro_Shrs : set_Shrs_left(node, left); break;
864 case iro_Rot : set_Rot_left(node, left); break;
865 case iro_Cmp : set_Cmp_left(node, left); break;
871 get_binop_right (ir_node *node) {
872 assert (node->op == op_Add ||
873 node->op == op_Sub ||
874 node->op == op_Mul ||
875 node->op == op_Quot ||
876 node->op == op_DivMod ||
877 node->op == op_Div ||
878 node->op == op_Mod ||
879 node->op == op_And ||
881 node->op == op_Eor ||
882 node->op == op_Shl ||
883 node->op == op_Shr ||
884 node->op == op_Shrs ||
885 node->op == op_Rot ||
886 node->op == op_Cmp );
888 switch (get_irn_opcode (node)) {
889 case iro_Add : return get_Add_right(node); break;
890 case iro_Sub : return get_Sub_right(node); break;
891 case iro_Mul : return get_Mul_right(node); break;
892 case iro_Quot : return get_Quot_right(node); break;
893 case iro_DivMod: return get_DivMod_right(node); break;
894 case iro_Div : return get_Div_right(node); break;
895 case iro_Mod : return get_Mod_right(node); break;
896 case iro_And : return get_And_right(node); break;
897 case iro_Or : return get_Or_right(node); break;
898 case iro_Eor : return get_Eor_right(node); break;
899 case iro_Shl : return get_Shl_right(node); break;
900 case iro_Shr : return get_Shr_right(node); break;
901 case iro_Shrs : return get_Shrs_right(node); break;
902 case iro_Rot : return get_Rot_right(node); break;
903 case iro_Cmp : return get_Cmp_right(node); break;
904 default: return NULL;
909 set_binop_right (ir_node *node, ir_node *right) {
910 assert (node->op == op_Add ||
911 node->op == op_Sub ||
912 node->op == op_Mul ||
913 node->op == op_Quot ||
914 node->op == op_DivMod ||
915 node->op == op_Div ||
916 node->op == op_Mod ||
917 node->op == op_And ||
919 node->op == op_Eor ||
920 node->op == op_Shl ||
921 node->op == op_Shr ||
922 node->op == op_Shrs ||
923 node->op == op_Rot ||
924 node->op == op_Cmp );
926 switch (get_irn_opcode (node)) {
927 case iro_Add : set_Add_right(node, right); break;
928 case iro_Sub : set_Sub_right(node, right); break;
929 case iro_Mul : set_Mul_right(node, right); break;
930 case iro_Quot : set_Quot_right(node, right); break;
931 case iro_DivMod: set_DivMod_right(node, right); break;
932 case iro_Div : set_Div_right(node, right); break;
933 case iro_Mod : set_Mod_right(node, right); break;
934 case iro_And : set_And_right(node, right); break;
935 case iro_Or : set_Or_right(node, right); break;
936 case iro_Eor : set_Eor_right(node, right); break;
937 case iro_Shl : set_Shl_right(node, right); break;
938 case iro_Shr : set_Shr_right(node, right); break;
939 case iro_Shrs : set_Shrs_right(node, right); break;
940 case iro_Rot : set_Rot_right(node, right); break;
941 case iro_Cmp : set_Cmp_right(node, right); break;
947 get_Add_left (ir_node *node) {
948 assert (node->op == op_Add);
949 return get_irn_n(node, 0);
953 set_Add_left (ir_node *node, ir_node *left) {
954 assert (node->op == op_Add);
955 set_irn_n(node, 0, left);
959 get_Add_right (ir_node *node) {
960 assert (node->op == op_Add);
961 return get_irn_n(node, 1);
965 set_Add_right (ir_node *node, ir_node *right) {
966 assert (node->op == op_Add);
967 set_irn_n(node, 1, right);
971 get_Sub_left (ir_node *node) {
972 assert (node->op == op_Sub);
973 return get_irn_n(node, 0);
977 set_Sub_left (ir_node *node, ir_node *left) {
978 assert (node->op == op_Sub);
979 set_irn_n(node, 0, left);
983 get_Sub_right (ir_node *node) {
984 assert (node->op == op_Sub);
985 return get_irn_n(node, 1);
989 set_Sub_right (ir_node *node, ir_node *right) {
990 assert (node->op == op_Sub);
991 set_irn_n(node, 1, right);
996 get_Minus_op (ir_node *node) {
997 assert (node->op == op_Minus);
998 return get_irn_n(node, 0);
1002 set_Minus_op (ir_node *node, ir_node *op) {
1003 assert (node->op == op_Minus);
1004 set_irn_n(node, 0, op);
1009 get_Mul_left (ir_node *node) {
1010 assert (node->op == op_Mul);
1011 return get_irn_n(node, 0);
1015 set_Mul_left (ir_node *node, ir_node *left) {
1016 assert (node->op == op_Mul);
1017 set_irn_n(node, 0, left);
1021 get_Mul_right (ir_node *node) {
1022 assert (node->op == op_Mul);
1023 return get_irn_n(node, 1);
1027 set_Mul_right (ir_node *node, ir_node *right) {
1028 assert (node->op == op_Mul);
1029 set_irn_n(node, 1, right);
1033 get_Quot_left (ir_node *node) {
1034 assert (node->op == op_Quot);
1035 return get_irn_n(node, 1);
1039 set_Quot_left (ir_node *node, ir_node *left) {
1040 assert (node->op == op_Quot);
1041 set_irn_n(node, 1, left);
1045 get_Quot_right (ir_node *node) {
1046 assert (node->op == op_Quot);
1047 return get_irn_n(node, 2);
1051 set_Quot_right (ir_node *node, ir_node *right) {
1052 assert (node->op == op_Quot);
1053 set_irn_n(node, 2, right);
1057 get_Quot_mem (ir_node *node) {
1058 assert (node->op == op_Quot);
1059 return get_irn_n(node, 0);
1063 set_Quot_mem (ir_node *node, ir_node *mem) {
1064 assert (node->op == op_Quot);
1065 set_irn_n(node, 0, mem);
1069 get_DivMod_left (ir_node *node) {
1070 assert (node->op == op_DivMod);
1071 return get_irn_n(node, 1);
1075 set_DivMod_left (ir_node *node, ir_node *left) {
1076 assert (node->op == op_DivMod);
1077 set_irn_n(node, 1, left);
1081 get_DivMod_right (ir_node *node) {
1082 assert (node->op == op_DivMod);
1083 return get_irn_n(node, 2);
1087 set_DivMod_right (ir_node *node, ir_node *right) {
1088 assert (node->op == op_DivMod);
1089 set_irn_n(node, 2, right);
1093 get_DivMod_mem (ir_node *node) {
1094 assert (node->op == op_DivMod);
1095 return get_irn_n(node, 0);
1099 set_DivMod_mem (ir_node *node, ir_node *mem) {
1100 assert (node->op == op_DivMod);
1101 set_irn_n(node, 0, mem);
1105 get_Div_left (ir_node *node) {
1106 assert (node->op == op_Div);
1107 return get_irn_n(node, 1);
1111 set_Div_left (ir_node *node, ir_node *left) {
1112 assert (node->op == op_Div);
1113 set_irn_n(node, 1, left);
1117 get_Div_right (ir_node *node) {
1118 assert (node->op == op_Div);
1119 return get_irn_n(node, 2);
1123 set_Div_right (ir_node *node, ir_node *right) {
1124 assert (node->op == op_Div);
1125 set_irn_n(node, 2, right);
1129 get_Div_mem (ir_node *node) {
1130 assert (node->op == op_Div);
1131 return get_irn_n(node, 0);
1135 set_Div_mem (ir_node *node, ir_node *mem) {
1136 assert (node->op == op_Div);
1137 set_irn_n(node, 0, mem);
1141 get_Mod_left (ir_node *node) {
1142 assert (node->op == op_Mod);
1143 return get_irn_n(node, 1);
1147 set_Mod_left (ir_node *node, ir_node *left) {
1148 assert (node->op == op_Mod);
1149 set_irn_n(node, 1, left);
1153 get_Mod_right (ir_node *node) {
1154 assert (node->op == op_Mod);
1155 return get_irn_n(node, 2);
1159 set_Mod_right (ir_node *node, ir_node *right) {
1160 assert (node->op == op_Mod);
1161 set_irn_n(node, 2, right);
1165 get_Mod_mem (ir_node *node) {
1166 assert (node->op == op_Mod);
1167 return get_irn_n(node, 0);
1171 set_Mod_mem (ir_node *node, ir_node *mem) {
1172 assert (node->op == op_Mod);
1173 set_irn_n(node, 0, mem);
1177 get_Abs_op (ir_node *node) {
1178 assert (node->op == op_Abs);
1179 return get_irn_n(node, 0);
1183 set_Abs_op (ir_node *node, ir_node *op) {
1184 assert (node->op == op_Abs);
1185 set_irn_n(node, 0, op);
1189 get_And_left (ir_node *node) {
1190 assert (node->op == op_And);
1191 return get_irn_n(node, 0);
1195 set_And_left (ir_node *node, ir_node *left) {
1196 assert (node->op == op_And);
1197 set_irn_n(node, 0, left);
1201 get_And_right (ir_node *node) {
1202 assert (node->op == op_And);
1203 return get_irn_n(node, 1);
1207 set_And_right (ir_node *node, ir_node *right) {
1208 assert (node->op == op_And);
1209 set_irn_n(node, 1, right);
1213 get_Or_left (ir_node *node) {
1214 assert (node->op == op_Or);
1215 return get_irn_n(node, 0);
1219 set_Or_left (ir_node *node, ir_node *left) {
1220 assert (node->op == op_Or);
1221 set_irn_n(node, 0, left);
1225 get_Or_right (ir_node *node) {
1226 assert (node->op == op_Or);
1227 return get_irn_n(node, 1);
1231 set_Or_right (ir_node *node, ir_node *right) {
1232 assert (node->op == op_Or);
1233 set_irn_n(node, 1, right);
1237 get_Eor_left (ir_node *node) {
1238 assert (node->op == op_Eor);
1239 return get_irn_n(node, 0);
1243 set_Eor_left (ir_node *node, ir_node *left) {
1244 assert (node->op == op_Eor);
1245 set_irn_n(node, 0, left);
1249 get_Eor_right (ir_node *node) {
1250 assert (node->op == op_Eor);
1251 return get_irn_n(node, 1);
1255 set_Eor_right (ir_node *node, ir_node *right) {
1256 assert (node->op == op_Eor);
1257 set_irn_n(node, 1, right);
1262 get_Not_op (ir_node *node) {
1263 assert (node->op == op_Not);
1264 return get_irn_n(node, 0);
1268 set_Not_op (ir_node *node, ir_node *op) {
1269 assert (node->op == op_Not);
1270 set_irn_n(node, 0, op);
1275 get_Shl_left (ir_node *node) {
1276 assert (node->op == op_Shl);
1277 return get_irn_n(node, 0);
1281 set_Shl_left (ir_node *node, ir_node *left) {
1282 assert (node->op == op_Shl);
1283 set_irn_n(node, 0, left);
1287 get_Shl_right (ir_node *node) {
1288 assert (node->op == op_Shl);
1289 return get_irn_n(node, 1);
1293 set_Shl_right (ir_node *node, ir_node *right) {
1294 assert (node->op == op_Shl);
1295 set_irn_n(node, 1, right);
1299 get_Shr_left (ir_node *node) {
1300 assert (node->op == op_Shr);
1301 return get_irn_n(node, 0);
1305 set_Shr_left (ir_node *node, ir_node *left) {
1306 assert (node->op == op_Shr);
1307 set_irn_n(node, 0, left);
1311 get_Shr_right (ir_node *node) {
1312 assert (node->op == op_Shr);
1313 return get_irn_n(node, 1);
1317 set_Shr_right (ir_node *node, ir_node *right) {
1318 assert (node->op == op_Shr);
1319 set_irn_n(node, 1, right);
1323 get_Shrs_left (ir_node *node) {
1324 assert (node->op == op_Shrs);
1325 return get_irn_n(node, 0);
1329 set_Shrs_left (ir_node *node, ir_node *left) {
1330 assert (node->op == op_Shrs);
1331 set_irn_n(node, 0, left);
1335 get_Shrs_right (ir_node *node) {
1336 assert (node->op == op_Shrs);
1337 return get_irn_n(node, 1);
1341 set_Shrs_right (ir_node *node, ir_node *right) {
1342 assert (node->op == op_Shrs);
1343 set_irn_n(node, 1, right);
1347 get_Rot_left (ir_node *node) {
1348 assert (node->op == op_Rot);
1349 return get_irn_n(node, 0);
1353 set_Rot_left (ir_node *node, ir_node *left) {
1354 assert (node->op == op_Rot);
1355 set_irn_n(node, 0, left);
1359 get_Rot_right (ir_node *node) {
1360 assert (node->op == op_Rot);
1361 return get_irn_n(node, 1);
1365 set_Rot_right (ir_node *node, ir_node *right) {
1366 assert (node->op == op_Rot);
1367 set_irn_n(node, 1, right);
1371 get_Cmp_left (ir_node *node) {
1372 assert (node->op == op_Cmp);
1373 return get_irn_n(node, 0);
1377 set_Cmp_left (ir_node *node, ir_node *left) {
1378 assert (node->op == op_Cmp);
1379 set_irn_n(node, 0, left);
1383 get_Cmp_right (ir_node *node) {
1384 assert (node->op == op_Cmp);
1385 return get_irn_n(node, 1);
1389 set_Cmp_right (ir_node *node, ir_node *right) {
1390 assert (node->op == op_Cmp);
1391 set_irn_n(node, 1, right);
1395 get_Conv_op (ir_node *node) {
1396 assert (node->op == op_Conv);
1397 return get_irn_n(node, 0);
1401 set_Conv_op (ir_node *node, ir_node *op) {
1402 assert (node->op == op_Conv);
1403 set_irn_n(node, 0, op);
1407 get_Phi_preds_arr (ir_node *node) {
1408 assert (node->op == op_Phi);
1409 return (ir_node **)&(get_irn_in(node)[1]);
1413 get_Phi_n_preds (ir_node *node) {
1414 assert (node->op == op_Phi);
1415 return (get_irn_arity(node));
1419 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1420 assert (node->op == op_Phi);
1425 get_Phi_pred (ir_node *node, int pos) {
1426 assert (node->op == op_Phi);
1427 return get_irn_n(node, pos);
1431 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1432 assert (node->op == op_Phi);
1433 set_irn_n(node, pos, pred);
1437 get_Load_mem (ir_node *node) {
1438 assert (node->op == op_Load);
1439 return get_irn_n(node, 0);
1443 set_Load_mem (ir_node *node, ir_node *mem) {
1444 assert (node->op == op_Load);
1445 set_irn_n(node, 0, mem);
1449 get_Load_ptr (ir_node *node) {
1450 assert (node->op == op_Load);
1451 return get_irn_n(node, 1);
1455 set_Load_ptr (ir_node *node, ir_node *ptr) {
1456 assert (node->op == op_Load);
1457 set_irn_n(node, 1, ptr);
1462 get_Store_mem (ir_node *node) {
1463 assert (node->op == op_Store);
1464 return get_irn_n(node, 0);
1468 set_Store_mem (ir_node *node, ir_node *mem) {
1469 assert (node->op == op_Store);
1470 set_irn_n(node, 0, mem);
1474 get_Store_ptr (ir_node *node) {
1475 assert (node->op == op_Store);
1476 return get_irn_n(node, 1);
1480 set_Store_ptr (ir_node *node, ir_node *ptr) {
1481 assert (node->op == op_Store);
1482 set_irn_n(node, 1, ptr);
1486 get_Store_value (ir_node *node) {
1487 assert (node->op == op_Store);
1488 return get_irn_n(node, 2);
1492 set_Store_value (ir_node *node, ir_node *value) {
1493 assert (node->op == op_Store);
1494 set_irn_n(node, 2, value);
1498 get_Alloc_mem (ir_node *node) {
1499 assert (node->op == op_Alloc);
1500 return get_irn_n(node, 0);
1504 set_Alloc_mem (ir_node *node, ir_node *mem) {
1505 assert (node->op == op_Alloc);
1506 set_irn_n(node, 0, mem);
1510 get_Alloc_size (ir_node *node) {
1511 assert (node->op == op_Alloc);
1512 return get_irn_n(node, 1);
1516 set_Allco_size (ir_node *node, ir_node *size) {
1517 assert (node->op == op_Alloc);
1518 set_irn_n(node, 1, size);
1522 get_Alloc_type (ir_node *node) {
1523 assert (node->op == op_Alloc);
1524 return node->attr.a.type;
1528 set_Alloc_type (ir_node *node, type *type) {
1529 assert (node->op == op_Alloc);
1530 node->attr.a.type = type;
1534 get_Alloc_where (ir_node *node) {
1535 assert (node->op == op_Alloc);
1536 return node->attr.a.where;
1540 set_Alloc_where (ir_node *node, where_alloc where) {
1541 assert (node->op == op_Alloc);
1542 node->attr.a.where = where;
1547 get_Free_mem (ir_node *node) {
1548 assert (node->op == op_Free);
1549 return get_irn_n(node, 0);
1553 set_Free_mem (ir_node *node, ir_node *mem) {
1554 assert (node->op == op_Free);
1555 set_irn_n(node, 0, mem);
1559 get_Free_ptr (ir_node *node) {
1560 assert (node->op == op_Free);
1561 return get_irn_n(node, 1);
1565 set_Free_ptr (ir_node *node, ir_node *ptr) {
1566 assert (node->op == op_Free);
1567 set_irn_n(node, 1, ptr);
1571 get_Free_size (ir_node *node) {
1572 assert (node->op == op_Free);
1573 return get_irn_n(node, 2);
1577 set_Free_size (ir_node *node, ir_node *size) {
1578 assert (node->op == op_Free);
1579 set_irn_n(node, 2, size);
1583 get_Free_type (ir_node *node) {
1584 assert (node->op == op_Free);
1585 return node->attr.f;
1589 set_Free_type (ir_node *node, type *type) {
1590 assert (node->op == op_Free);
1591 node->attr.f = type;
1595 get_Sync_preds_arr (ir_node *node) {
1596 assert (node->op == op_Sync);
1597 return (ir_node **)&(get_irn_in(node)[1]);
1601 get_Sync_n_preds (ir_node *node) {
1602 assert (node->op == op_Sync);
1603 return (get_irn_arity(node));
1608 set_Sync_n_preds (ir_node *node, int n_preds) {
1609 assert (node->op == op_Sync);
1614 get_Sync_pred (ir_node *node, int pos) {
1615 assert (node->op == op_Sync);
1616 return get_irn_n(node, pos);
1620 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1621 assert (node->op == op_Sync);
1622 set_irn_n(node, pos, pred);
1626 get_Proj_pred (ir_node *node) {
1627 assert (node->op == op_Proj);
1628 return get_irn_n(node, 0);
1632 set_Proj_pred (ir_node *node, ir_node *pred) {
1633 assert (node->op == op_Proj);
1634 set_irn_n(node, 0, pred);
1638 get_Proj_proj (ir_node *node) {
1639 assert (node->op == op_Proj);
1640 return node->attr.proj;
1644 set_Proj_proj (ir_node *node, long proj) {
1645 assert (node->op == op_Proj);
1646 node->attr.proj = proj;
1650 get_Tuple_preds_arr (ir_node *node) {
1651 assert (node->op == op_Tuple);
1652 return (ir_node **)&(get_irn_in(node)[1]);
1656 get_Tuple_n_preds (ir_node *node) {
1657 assert (node->op == op_Tuple);
1658 return (get_irn_arity(node));
1663 set_Tuple_n_preds (ir_node *node, int n_preds) {
1664 assert (node->op == op_Tuple);
1669 get_Tuple_pred (ir_node *node, int pos) {
1670 assert (node->op == op_Tuple);
1671 return get_irn_n(node, pos);
1675 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1676 assert (node->op == op_Tuple);
1677 set_irn_n(node, pos, pred);
1681 get_Id_pred (ir_node *node) {
1682 assert (node->op == op_Id);
1683 return get_irn_n(node, 0);
1687 set_Id_pred (ir_node *node, ir_node *pred) {
1688 assert (node->op == op_Id);
1689 set_irn_n(node, 0, pred);
1692 /******************************************************************/
1693 /* Auxiliary routines */
1694 /******************************************************************/
1697 skip_Proj (ir_node *node) {
1698 /* don't assert node !!! */
1699 if (node && (node->op == op_Proj)) {
1700 return get_Proj_pred(node);
1707 skip_nop (ir_node *node) {
1708 /* don't assert node !!! */
1710 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1711 return get_Id_pred(node);
1718 is_Bad (ir_node *node) {
1720 if ((node) && get_irn_opcode(node) == iro_Bad)
1726 is_no_Block (ir_node *node) {
1728 return (get_irn_opcode(node) != iro_Block);
1731 /* Returns true if the operation manipulates control flow. */
1733 is_cfop(ir_node *node) {
1734 return ( (get_irn_opcode(node) == iro_Start)
1735 || (get_irn_opcode(node) == iro_Jmp)
1736 || (get_irn_opcode(node) == iro_Cond)
1737 || (get_irn_opcode(node) == iro_Return)
1738 || (get_irn_opcode(node) == iro_Raise)
1739 || (get_irn_opcode(node) == iro_Bad));
1742 /* Returns true if the operation can change the control flow because
1745 is_fragile_op(ir_node *node) {
1746 return ( (get_irn_opcode(node) == iro_Call)
1747 || (get_irn_opcode(node) == iro_Quot)
1748 || (get_irn_opcode(node) == iro_DivMod)
1749 || (get_irn_opcode(node) == iro_Div)
1750 || (get_irn_opcode(node) == iro_Mod)
1751 || (get_irn_opcode(node) == iro_Load)
1752 || (get_irn_opcode(node) == iro_Store)
1753 || (get_irn_opcode(node) == iro_Alloc)
1754 || (get_irn_opcode(node) == iro_Bad));