1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
15 /* some constants fixing the positions of nodes predecessors
17 #define CALL_PARAM_OFFSET 2
18 #define SEL_INDEX_OFFSET 2
19 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
21 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
22 "Gt", "Ge", "Lg", "Leg", "Uo",
23 "Ue", "Ul", "Ule", "Ug", "Uge",
26 inline char *get_pnc_string(int pnc) {
27 return pnc_name_arr[pnc];
32 get_negated_pnc(int pnc) {
34 case False: return True; break;
35 case Eq: return Ne; break;
36 case Lt: return Uge; break;
37 case Le: return Ug; break;
38 case Gt: return Ule; break;
39 case Ge: return Ul; break;
40 case Lg: return Ue; break;
41 case Leg: return Uo; break;
42 case Uo: return Leg; break;
43 case Ue: return Lg; break;
44 case Ul: return Ge; break;
45 case Ule: return Gt; break;
46 case Ug: return Le; break;
47 case Uge: return Lt; break;
48 case Ne: return Eq; break;
49 case True: return False; break;
51 return 99; /* to shut up gcc */
54 static char *pns_name_arr [] = {"initial_exec", "global_store",
55 "frame_base", "globals", "args"};
57 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
64 /* irnode constructor */
65 /* create a new irnode in irg, with an op, mode, arity and */
66 /* some incoming irnodes */
67 /* this constructor is used in every specified irnode constructor */
69 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
70 int arity, ir_node **in)
73 int node_size = offsetof (ir_node, attr) + op->attr_size;
75 res = (ir_node *) obstack_alloc (irg->obst, node_size);
77 res->kind = k_ir_node;
83 res->in = NEW_ARR_F (ir_node *, 1);
85 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
86 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
91 res->node_nr = get_irp_new_node_nr();
97 /* Copies all attributes stored in the old node to the new node.
98 Assumes both have the same opcode and sufficient size. */
100 copy_attrs (ir_node *old, ir_node *new) {
101 assert (get_irn_opcode(old) == get_irn_opcode(new));
102 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
105 /* IR-Nodes with attributes */
107 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
110 ir_node *np = XP_GETARG (ir_node *, 0);
113 XPS ("<null ir_node>");
117 XPF1 ("%I", get_irn_opname(np));
119 switch (get_irn_opcode (np)) { /* node label */
121 XPF1 ("%I", get_irn_mode(np)->name);
123 XPF1 ("%v", get_irn_const_attr);
126 if (get_irn_modecode (np) == irm_b) {
128 XP (pnc_name_arr[get_irn_proj_attr(np)]);
129 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
131 XP (pns_name_arr[get_irn_proj_attr(np)]);
133 XPF1 ("%I", get_irn_mode(np)->name);
135 XPF1 ("%d", get_irn_proj_attr(np));
139 XPF1 ("%I", get_irn_mode(np)->name);
141 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
142 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
144 case iro_Start: /* don't dump mode of these */
153 XPF1 ("%I", get_irn_mode(np)->name);
160 /** getting some parameters from ir_nodes **/
162 /* returns the number of predecessors without the block predecessor. */
164 get_irn_arity (ir_node *node)
167 return (ARR_LEN((node)->in)-1);
170 /* Returns the array with ins. This array is shifted with respect to the
171 array accessed by get_irn_n: The block operand is at position 0 not -1.
172 (@@@ This should be changed.)
173 The order of the predecessors in this array is not guaranteed, except that
174 lists of operands as predecessors of Block or arguments of a Call are
177 get_irn_in (ir_node *node)
183 /* to iterate through the predecessors without touching the array */
184 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
185 to iterate includind the Block predecessor iterate from i = -1 to
187 If it is a block, the entry -1 is NULL. */
189 get_irn_n (ir_node *node, int n)
192 assert (get_irn_arity (node) > n);
193 return skip_nop(node->in[n+1]);
197 set_irn_n (ir_node *node, int n, ir_node *in)
200 assert (get_irn_arity (node) > n);
205 get_irn_mode (ir_node *node)
212 get_irn_modecode (ir_node *node)
215 return node->mode->code;
220 get_irn_modename (ir_node *node)
223 return node->mode->name;
227 get_irn_op (ir_node *node)
233 /* should be private to the library: */
235 set_irn_op (ir_node *node, ir_op *op)
242 get_irn_opcode (ir_node *node)
245 return node->op->code;
249 get_irn_opname (ir_node *node)
252 return node->op->name;
256 get_irn_visited (ir_node *node)
259 return node->visited;
263 set_irn_visited (ir_node *node, unsigned long visited)
266 node->visited = visited;
269 set_irn_link (ir_node *node, ir_node *link) {
275 get_irn_link (ir_node *node) {
281 /* Outputs a unique number for this node */
283 get_irn_node_nr(ir_node *node) {
285 return node->node_nr;
290 get_irn_const_attr (ir_node *node)
292 assert (node->op == op_Const);
293 return node->attr.con;
297 get_irn_proj_attr (ir_node *node)
299 assert (node->op == op_Proj);
300 return node->attr.proj;
304 get_irn_alloc_attr (ir_node *node)
306 assert (node->op == op_Alloc);
311 get_irn_free_attr (ir_node *node)
313 assert (node->op == op_Free);
318 get_irn_symconst_attr (ir_node *node)
320 assert (node->op == op_SymConst);
325 get_irn_call_attr (ir_node *node)
327 assert (node->op == op_Call);
328 return node->attr.call;
332 get_irn_sel_attr (ir_node *node)
334 assert (node->op == op_Sel);
339 get_irn_phi_attr (ir_node *node)
341 assert (node->op == op_Phi);
342 return node->attr.phi0_pos;
346 get_irn_block_attr (ir_node *node)
348 assert (node->op == op_Block);
349 return node->attr.block;
352 /** manipulate fields of individual nodes **/
354 /* this works for all except Block */
356 get_nodes_Block (ir_node *node) {
357 assert (!(node->op == op_Block));
358 return get_irn_n(node, -1);
362 set_nodes_Block (ir_node *node, ir_node *block) {
363 assert (!(node->op == op_Block));
364 set_irn_n(node, -1, block);
367 /* Returns an array with the predecessors of the Block. Depending on
368 the implementation of the graph datastructure this can be a copy of
369 the internal representation of predecessors as well as the internal
370 array itself. Therefore writing to this array might obstruct the ir. */
372 get_Block_cfgpred_arr (ir_node *node)
374 assert ((node->op == op_Block));
375 return (ir_node **)&(get_irn_in(node)[1]);
380 get_Block_n_cfgpreds (ir_node *node) {
381 assert ((node->op == op_Block));
382 return (get_irn_arity(node));
387 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
388 assert ((node->op == op_Block));
393 get_Block_cfgpred (ir_node *node, int pos) {
394 assert (node->op == op_Block);
395 return get_irn_n(node, pos);
399 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
400 assert (node->op == op_Block);
401 set_irn_n(node, pos, pred);
405 get_Block_matured (ir_node *node) {
406 assert (node->op == op_Block);
407 return node->attr.block.matured;
411 set_Block_matured (ir_node *node, bool matured) {
412 assert (node->op == op_Block);
413 node->attr.block.matured = matured;
416 get_Block_block_visited (ir_node *node) {
417 assert (node->op == op_Block);
418 return node->attr.block.block_visited;
422 set_Block_block_visited (ir_node *node, unsigned long visit) {
423 assert (node->op == op_Block);
424 node->attr.block.block_visited = visit;
428 get_Block_graph_arr (ir_node *node, int pos) {
429 assert (node->op == op_Block);
430 return node->attr.block.graph_arr[pos+1];
434 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
435 assert (node->op == op_Block);
436 node->attr.block.graph_arr[pos+1] = value;
440 get_Cond_selector (ir_node *node) {
441 assert (node->op == op_Cond);
442 return get_irn_n(node, 0);
446 set_Cond_selector (ir_node *node, ir_node *selector) {
447 assert (node->op == op_Cond);
448 set_irn_n(node, 0, selector);
452 get_Return_mem (ir_node *node) {
453 assert (node->op == op_Return);
454 return get_irn_n(node, 0);
458 set_Return_mem (ir_node *node, ir_node *mem) {
459 assert (node->op == op_Return);
460 set_irn_n(node, 0, mem);
464 get_Return_res_arr (ir_node *node)
466 assert ((node->op == op_Return));
467 if (get_Return_n_res(node) > 0)
468 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
474 get_Return_n_res (ir_node *node) {
475 assert (node->op == op_Return);
476 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
481 set_Return_n_res (ir_node *node, int results) {
482 assert (node->op == op_Return);
487 get_Return_res (ir_node *node, int pos) {
488 assert (node->op == op_Return);
489 assert (get_Return_n_res(node) > pos);
490 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
494 set_Return_res (ir_node *node, int pos, ir_node *res){
495 assert (node->op == op_Return);
496 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
500 get_Raise_mem (ir_node *node) {
501 assert (node->op == op_Return);
502 return get_irn_n(node, 0);
506 set_Raise_mem (ir_node *node, ir_node *mem) {
507 assert (node->op == op_Raise);
508 set_irn_n(node, 0, mem);
512 get_Raise_exo_ptr (ir_node *node) {
513 assert (node->op == op_Raise);
514 return get_irn_n(node, 1);
518 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
519 assert (node->op == op_Raise);
520 set_irn_n(node, 1, exo_ptr);
523 inline tarval *get_Const_tarval (ir_node *node) {
524 assert (node->op == op_Const);
525 return get_irn_const_attr(node);
529 set_Const_tarval (ir_node *node, tarval *con) {
530 assert (node->op == op_Const);
531 node->attr.con = con;
535 get_SymConst_kind (ir_node *node) {
536 assert (node->op == op_SymConst);
537 return node->attr.i.num;
541 set_SymConst_kind (ir_node *node, symconst_kind num) {
542 assert (node->op == op_SymConst);
543 node->attr.i.num = num;
547 get_SymConst_type (ir_node *node) {
548 assert ( (node->op == op_SymConst)
549 && ( get_SymConst_kind(node) == type_tag
550 || get_SymConst_kind(node) == size));
551 return node->attr.i.tori.typ;
555 set_SymConst_type (ir_node *node, type *type) {
556 assert ( (node->op == op_SymConst)
557 && ( get_SymConst_kind(node) == type_tag
558 || get_SymConst_kind(node) == size));
559 node->attr.i.tori.typ = type;
563 get_SymConst_ptrinfo (ir_node *node) {
564 assert ( (node->op == op_SymConst)
565 && (get_SymConst_kind(node) == linkage_ptr_info));
566 return node->attr.i.tori.ptrinfo;
572 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
573 assert ( (node->op == op_SymConst)
574 && (get_SymConst_kind(node) == linkage_ptr_info));
575 node->attr.i.tori.ptrinfo = ptrinfo;
579 get_Sel_mem (ir_node *node) {
580 assert (node->op == op_Sel);
581 return get_irn_n(node, 0);
585 set_Sel_mem (ir_node *node, ir_node *mem) {
586 assert (node->op == op_Sel);
587 set_irn_n(node, 0, mem);
591 get_Sel_ptr (ir_node *node) {
592 assert (node->op == op_Sel);
593 return get_irn_n(node, 1);
597 set_Sel_ptr (ir_node *node, ir_node *ptr) {
598 assert (node->op == op_Sel);
599 set_irn_n(node, 1, ptr);
603 get_Sel_index_arr (ir_node *node)
605 assert ((node->op == op_Sel));
606 if (get_Sel_n_index(node) > 0)
607 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
613 get_Sel_n_index (ir_node *node) {
614 assert (node->op == op_Sel);
615 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
620 set_Sel_n_index (ir_node *node, int n_index) {
621 assert (node->op == op_Sel);
626 get_Sel_index (ir_node *node, int pos) {
627 assert (node->op == op_Sel);
628 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
632 set_Sel_index (ir_node *node, int pos, ir_node *index) {
633 assert (node->op == op_Sel);
634 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
638 get_Sel_entity (ir_node *node) {
639 assert (node->op == op_Sel);
640 return node->attr.s.ent;
644 set_Sel_entity (ir_node *node, entity *ent) {
645 assert (node->op == op_Sel);
646 node->attr.s.ent = ent;
650 get_Sel_linkage_type (ir_node *node) {
651 assert (node->op == op_Sel);
652 return node->attr.s.ltyp;
656 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
657 assert (node->op == op_Sel);
658 node->attr.s.ltyp = lt;
662 get_Call_mem (ir_node *node) {
663 assert (node->op == op_Call);
664 return get_irn_n(node, 0);
668 set_Call_mem (ir_node *node, ir_node *mem) {
669 assert (node->op == op_Call);
670 set_irn_n(node, 0, mem);
674 get_Call_ptr (ir_node *node) {
675 assert (node->op == op_Call);
676 return get_irn_n(node, 1);
680 set_Call_ptr (ir_node *node, ir_node *ptr) {
681 assert (node->op == op_Call);
682 set_irn_n(node, 1, ptr);
686 get_Call_param_arr (ir_node *node) {
687 assert (node->op == op_Call);
688 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
692 get_Call_arity (ir_node *node) {
693 assert (node->op == op_Call);
694 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
698 set_Call_arity (ir_node *node, ir_node *arity) {
699 assert (node->op == op_Call);
704 get_Call_param (ir_node *node, int pos) {
705 assert (node->op == op_Call);
706 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
710 set_Call_param (ir_node *node, int pos, ir_node *param) {
711 assert (node->op == op_Call);
712 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
716 get_Call_type (ir_node *node) {
717 assert (node->op == op_Call);
718 return node->attr.call;
722 set_Call_type (ir_node *node, type_method *type) {
723 assert (node->op == op_Call);
724 node->attr.call = type;
727 /* For unary and binary arithmetic operations the access to the
728 operands can be factored out. Left is the first, right the
729 second arithmetic value as listed in tech report 0999-33.
730 unops are: Minus, Abs, Not, Conv
731 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
732 Shr, Shrs, Rotate, Cmp */
735 is_unop (ir_node *node) {
736 return ( node->op == op_Minus ||
737 node->op == op_Abs ||
738 node->op == op_Not ||
739 node->op == op_Conv );
743 get_unop_op (ir_node *node) {
744 assert ( node->op == op_Minus ||
745 node->op == op_Abs ||
746 node->op == op_Not ||
747 node->op == op_Conv );
748 switch (get_irn_opcode (node)) {
749 case iro_Minus: return get_Minus_op(node); break;
750 case iro_Abs: return get_Abs_op(node); break;
751 case iro_Not: return get_Not_op(node); break;
752 case iro_Conv: return get_Conv_op(node); break;
753 default: return NULL;
758 set_unop_op (ir_node *node, ir_node *op) {
759 assert (node->op == op_Minus ||
760 node->op == op_Abs ||
761 node->op == op_Not ||
762 node->op == op_Conv );
763 switch (get_irn_opcode (node)) {
764 case iro_Minus: set_Minus_op(node, op); break;
765 case iro_Abs: set_Abs_op(node, op); break;
766 case iro_Not: set_Not_op(node, op); break;
767 case iro_Conv: set_Conv_op(node, op); break;
774 is_binop (ir_node *node) {
775 return (node->op == op_Add ||
776 node->op == op_Sub ||
777 node->op == op_Mul ||
778 node->op == op_Quot ||
779 node->op == op_DivMod ||
780 node->op == op_Div ||
781 node->op == op_Mod ||
782 node->op == op_And ||
784 node->op == op_Eor ||
785 node->op == op_Shl ||
786 node->op == op_Shr ||
787 node->op == op_Shrs ||
788 node->op == op_Rot ||
789 node->op == op_Cmp );
793 get_binop_left (ir_node *node) {
794 assert (node->op == op_Add ||
795 node->op == op_Sub ||
796 node->op == op_Mul ||
797 node->op == op_Quot ||
798 node->op == op_DivMod ||
799 node->op == op_Div ||
800 node->op == op_Mod ||
801 node->op == op_And ||
803 node->op == op_Eor ||
804 node->op == op_Shl ||
805 node->op == op_Shr ||
806 node->op == op_Shrs ||
807 node->op == op_Rot ||
808 node->op == op_Cmp );
810 switch (get_irn_opcode (node)) {
811 case iro_Add : return get_Add_left(node); break;
812 case iro_Sub : return get_Sub_left(node); break;
813 case iro_Mul : return get_Mul_left(node); break;
814 case iro_Quot : return get_Quot_left(node); break;
815 case iro_DivMod: return get_DivMod_left(node); break;
816 case iro_Div : return get_Div_left(node); break;
817 case iro_Mod : return get_Mod_left(node); break;
818 case iro_And : return get_And_left(node); break;
819 case iro_Or : return get_Or_left(node); break;
820 case iro_Eor : return get_Eor_left(node); break;
821 case iro_Shl : return get_Shl_left(node); break;
822 case iro_Shr : return get_Shr_left(node); break;
823 case iro_Shrs : return get_Shrs_left(node); break;
824 case iro_Rot : return get_Rot_left(node); break;
825 case iro_Cmp : return get_Cmp_left(node); break;
826 default: return NULL;
831 set_binop_left (ir_node *node, ir_node *left) {
832 assert (node->op == op_Add ||
833 node->op == op_Sub ||
834 node->op == op_Mul ||
835 node->op == op_Quot ||
836 node->op == op_DivMod ||
837 node->op == op_Div ||
838 node->op == op_Mod ||
839 node->op == op_And ||
841 node->op == op_Eor ||
842 node->op == op_Shl ||
843 node->op == op_Shr ||
844 node->op == op_Shrs ||
845 node->op == op_Rot ||
846 node->op == op_Cmp );
848 switch (get_irn_opcode (node)) {
849 case iro_Add : set_Add_left(node, left); break;
850 case iro_Sub : set_Sub_left(node, left); break;
851 case iro_Mul : set_Mul_left(node, left); break;
852 case iro_Quot : set_Quot_left(node, left); break;
853 case iro_DivMod: set_DivMod_left(node, left); break;
854 case iro_Div : set_Div_left(node, left); break;
855 case iro_Mod : set_Mod_left(node, left); break;
856 case iro_And : set_And_left(node, left); break;
857 case iro_Or : set_Or_left(node, left); break;
858 case iro_Eor : set_Eor_left(node, left); break;
859 case iro_Shl : set_Shl_left(node, left); break;
860 case iro_Shr : set_Shr_left(node, left); break;
861 case iro_Shrs : set_Shrs_left(node, left); break;
862 case iro_Rot : set_Rot_left(node, left); break;
863 case iro_Cmp : set_Cmp_left(node, left); break;
869 get_binop_right (ir_node *node) {
870 assert (node->op == op_Add ||
871 node->op == op_Sub ||
872 node->op == op_Mul ||
873 node->op == op_Quot ||
874 node->op == op_DivMod ||
875 node->op == op_Div ||
876 node->op == op_Mod ||
877 node->op == op_And ||
879 node->op == op_Eor ||
880 node->op == op_Shl ||
881 node->op == op_Shr ||
882 node->op == op_Shrs ||
883 node->op == op_Rot ||
884 node->op == op_Cmp );
886 switch (get_irn_opcode (node)) {
887 case iro_Add : return get_Add_right(node); break;
888 case iro_Sub : return get_Sub_right(node); break;
889 case iro_Mul : return get_Mul_right(node); break;
890 case iro_Quot : return get_Quot_right(node); break;
891 case iro_DivMod: return get_DivMod_right(node); break;
892 case iro_Div : return get_Div_right(node); break;
893 case iro_Mod : return get_Mod_right(node); break;
894 case iro_And : return get_And_right(node); break;
895 case iro_Or : return get_Or_right(node); break;
896 case iro_Eor : return get_Eor_right(node); break;
897 case iro_Shl : return get_Shl_right(node); break;
898 case iro_Shr : return get_Shr_right(node); break;
899 case iro_Shrs : return get_Shrs_right(node); break;
900 case iro_Rot : return get_Rot_right(node); break;
901 case iro_Cmp : return get_Cmp_right(node); break;
902 default: return NULL;
907 set_binop_right (ir_node *node, ir_node *right) {
908 assert (node->op == op_Add ||
909 node->op == op_Sub ||
910 node->op == op_Mul ||
911 node->op == op_Quot ||
912 node->op == op_DivMod ||
913 node->op == op_Div ||
914 node->op == op_Mod ||
915 node->op == op_And ||
917 node->op == op_Eor ||
918 node->op == op_Shl ||
919 node->op == op_Shr ||
920 node->op == op_Shrs ||
921 node->op == op_Rot ||
922 node->op == op_Cmp );
924 switch (get_irn_opcode (node)) {
925 case iro_Add : set_Add_right(node, right); break;
926 case iro_Sub : set_Sub_right(node, right); break;
927 case iro_Mul : set_Mul_right(node, right); break;
928 case iro_Quot : set_Quot_right(node, right); break;
929 case iro_DivMod: set_DivMod_right(node, right); break;
930 case iro_Div : set_Div_right(node, right); break;
931 case iro_Mod : set_Mod_right(node, right); break;
932 case iro_And : set_And_right(node, right); break;
933 case iro_Or : set_Or_right(node, right); break;
934 case iro_Eor : set_Eor_right(node, right); break;
935 case iro_Shl : set_Shl_right(node, right); break;
936 case iro_Shr : set_Shr_right(node, right); break;
937 case iro_Shrs : set_Shrs_right(node, right); break;
938 case iro_Rot : set_Rot_right(node, right); break;
939 case iro_Cmp : set_Cmp_right(node, right); break;
945 get_Add_left (ir_node *node) {
946 assert (node->op == op_Add);
947 return get_irn_n(node, 0);
951 set_Add_left (ir_node *node, ir_node *left) {
952 assert (node->op == op_Add);
953 set_irn_n(node, 0, left);
957 get_Add_right (ir_node *node) {
958 assert (node->op == op_Add);
959 return get_irn_n(node, 1);
963 set_Add_right (ir_node *node, ir_node *right) {
964 assert (node->op == op_Add);
965 set_irn_n(node, 1, right);
969 get_Sub_left (ir_node *node) {
970 assert (node->op == op_Sub);
971 return get_irn_n(node, 0);
975 set_Sub_left (ir_node *node, ir_node *left) {
976 assert (node->op == op_Sub);
977 set_irn_n(node, 0, left);
981 get_Sub_right (ir_node *node) {
982 assert (node->op == op_Sub);
983 return get_irn_n(node, 1);
987 set_Sub_right (ir_node *node, ir_node *right) {
988 assert (node->op == op_Sub);
989 set_irn_n(node, 1, right);
994 get_Minus_op (ir_node *node) {
995 assert (node->op == op_Minus);
996 return get_irn_n(node, 0);
1000 set_Minus_op (ir_node *node, ir_node *op) {
1001 assert (node->op == op_Minus);
1002 set_irn_n(node, 0, op);
1007 get_Mul_left (ir_node *node) {
1008 assert (node->op == op_Mul);
1009 return get_irn_n(node, 0);
1013 set_Mul_left (ir_node *node, ir_node *left) {
1014 assert (node->op == op_Mul);
1015 set_irn_n(node, 0, left);
1019 get_Mul_right (ir_node *node) {
1020 assert (node->op == op_Mul);
1021 return get_irn_n(node, 1);
1025 set_Mul_right (ir_node *node, ir_node *right) {
1026 assert (node->op == op_Mul);
1027 set_irn_n(node, 1, right);
1031 get_Quot_left (ir_node *node) {
1032 assert (node->op == op_Quot);
1033 return get_irn_n(node, 1);
1037 set_Quot_left (ir_node *node, ir_node *left) {
1038 assert (node->op == op_Quot);
1039 set_irn_n(node, 1, left);
1043 get_Quot_right (ir_node *node) {
1044 assert (node->op == op_Quot);
1045 return get_irn_n(node, 2);
1049 set_Quot_right (ir_node *node, ir_node *right) {
1050 assert (node->op == op_Quot);
1051 set_irn_n(node, 2, right);
1055 get_Quot_mem (ir_node *node) {
1056 assert (node->op == op_Quot);
1057 return get_irn_n(node, 0);
1061 set_Quot_mem (ir_node *node, ir_node *mem) {
1062 assert (node->op == op_Quot);
1063 set_irn_n(node, 0, mem);
1067 get_DivMod_left (ir_node *node) {
1068 assert (node->op == op_DivMod);
1069 return get_irn_n(node, 1);
1073 set_DivMod_left (ir_node *node, ir_node *left) {
1074 assert (node->op == op_DivMod);
1075 set_irn_n(node, 1, left);
1079 get_DivMod_right (ir_node *node) {
1080 assert (node->op == op_DivMod);
1081 return get_irn_n(node, 2);
1085 set_DivMod_right (ir_node *node, ir_node *right) {
1086 assert (node->op == op_DivMod);
1087 set_irn_n(node, 2, right);
1091 get_DivMod_mem (ir_node *node) {
1092 assert (node->op == op_DivMod);
1093 return get_irn_n(node, 0);
1097 set_DivMod_mem (ir_node *node, ir_node *mem) {
1098 assert (node->op == op_DivMod);
1099 set_irn_n(node, 0, mem);
1103 get_Div_left (ir_node *node) {
1104 assert (node->op == op_Div);
1105 return get_irn_n(node, 1);
1109 set_Div_left (ir_node *node, ir_node *left) {
1110 assert (node->op == op_Div);
1111 set_irn_n(node, 1, left);
1115 get_Div_right (ir_node *node) {
1116 assert (node->op == op_Div);
1117 return get_irn_n(node, 2);
1121 set_Div_right (ir_node *node, ir_node *right) {
1122 assert (node->op == op_Div);
1123 set_irn_n(node, 2, right);
1127 get_Div_mem (ir_node *node) {
1128 assert (node->op == op_Div);
1129 return get_irn_n(node, 0);
1133 set_Div_mem (ir_node *node, ir_node *mem) {
1134 assert (node->op == op_Div);
1135 set_irn_n(node, 0, mem);
1139 get_Mod_left (ir_node *node) {
1140 assert (node->op == op_Mod);
1141 return get_irn_n(node, 1);
1145 set_Mod_left (ir_node *node, ir_node *left) {
1146 assert (node->op == op_Mod);
1147 set_irn_n(node, 1, left);
1151 get_Mod_right (ir_node *node) {
1152 assert (node->op == op_Mod);
1153 return get_irn_n(node, 2);
1157 set_Mod_right (ir_node *node, ir_node *right) {
1158 assert (node->op == op_Mod);
1159 set_irn_n(node, 2, right);
1163 get_Mod_mem (ir_node *node) {
1164 assert (node->op == op_Mod);
1165 return get_irn_n(node, 0);
1169 set_Mod_mem (ir_node *node, ir_node *mem) {
1170 assert (node->op == op_Mod);
1171 set_irn_n(node, 0, mem);
1175 get_Abs_op (ir_node *node) {
1176 assert (node->op == op_Abs);
1177 return get_irn_n(node, 0);
1181 set_Abs_op (ir_node *node, ir_node *op) {
1182 assert (node->op == op_Abs);
1183 set_irn_n(node, 0, op);
1187 get_And_left (ir_node *node) {
1188 assert (node->op == op_And);
1189 return get_irn_n(node, 0);
1193 set_And_left (ir_node *node, ir_node *left) {
1194 assert (node->op == op_And);
1195 set_irn_n(node, 0, left);
1199 get_And_right (ir_node *node) {
1200 assert (node->op == op_And);
1201 return get_irn_n(node, 1);
1205 set_And_right (ir_node *node, ir_node *right) {
1206 assert (node->op == op_And);
1207 set_irn_n(node, 1, right);
1211 get_Or_left (ir_node *node) {
1212 assert (node->op == op_Or);
1213 return get_irn_n(node, 0);
1217 set_Or_left (ir_node *node, ir_node *left) {
1218 assert (node->op == op_Or);
1219 set_irn_n(node, 0, left);
1223 get_Or_right (ir_node *node) {
1224 assert (node->op == op_Or);
1225 return get_irn_n(node, 1);
1229 set_Or_right (ir_node *node, ir_node *right) {
1230 assert (node->op == op_Or);
1231 set_irn_n(node, 1, right);
1235 get_Eor_left (ir_node *node) {
1236 assert (node->op == op_Eor);
1237 return get_irn_n(node, 0);
1241 set_Eor_left (ir_node *node, ir_node *left) {
1242 assert (node->op == op_Eor);
1243 set_irn_n(node, 0, left);
1247 get_Eor_right (ir_node *node) {
1248 assert (node->op == op_Eor);
1249 return get_irn_n(node, 1);
1253 set_Eor_right (ir_node *node, ir_node *right) {
1254 assert (node->op == op_Eor);
1255 set_irn_n(node, 1, right);
1260 get_Not_op (ir_node *node) {
1261 assert (node->op == op_Not);
1262 return get_irn_n(node, 0);
1266 set_Not_op (ir_node *node, ir_node *op) {
1267 assert (node->op == op_Not);
1268 set_irn_n(node, 0, op);
1273 get_Shl_left (ir_node *node) {
1274 assert (node->op == op_Shl);
1275 return get_irn_n(node, 0);
1279 set_Shl_left (ir_node *node, ir_node *left) {
1280 assert (node->op == op_Shl);
1281 set_irn_n(node, 0, left);
1285 get_Shl_right (ir_node *node) {
1286 assert (node->op == op_Shl);
1287 return get_irn_n(node, 1);
1291 set_Shl_right (ir_node *node, ir_node *right) {
1292 assert (node->op == op_Shl);
1293 set_irn_n(node, 1, right);
1297 get_Shr_left (ir_node *node) {
1298 assert (node->op == op_Shr);
1299 return get_irn_n(node, 0);
1303 set_Shr_left (ir_node *node, ir_node *left) {
1304 assert (node->op == op_Shr);
1305 set_irn_n(node, 0, left);
1309 get_Shr_right (ir_node *node) {
1310 assert (node->op == op_Shr);
1311 return get_irn_n(node, 1);
1315 set_Shr_right (ir_node *node, ir_node *right) {
1316 assert (node->op == op_Shr);
1317 set_irn_n(node, 1, right);
1321 get_Shrs_left (ir_node *node) {
1322 assert (node->op == op_Shrs);
1323 return get_irn_n(node, 0);
1327 set_Shrs_left (ir_node *node, ir_node *left) {
1328 assert (node->op == op_Shrs);
1329 set_irn_n(node, 0, left);
1333 get_Shrs_right (ir_node *node) {
1334 assert (node->op == op_Shrs);
1335 return get_irn_n(node, 1);
1339 set_Shrs_right (ir_node *node, ir_node *right) {
1340 assert (node->op == op_Shrs);
1341 set_irn_n(node, 1, right);
1345 get_Rot_left (ir_node *node) {
1346 assert (node->op == op_Rot);
1347 return get_irn_n(node, 0);
1351 set_Rot_left (ir_node *node, ir_node *left) {
1352 assert (node->op == op_Rot);
1353 set_irn_n(node, 0, left);
1357 get_Rot_right (ir_node *node) {
1358 assert (node->op == op_Rot);
1359 return get_irn_n(node, 1);
1363 set_Rot_right (ir_node *node, ir_node *right) {
1364 assert (node->op == op_Rot);
1365 set_irn_n(node, 1, right);
1369 get_Cmp_left (ir_node *node) {
1370 assert (node->op == op_Cmp);
1371 return get_irn_n(node, 0);
1375 set_Cmp_left (ir_node *node, ir_node *left) {
1376 assert (node->op == op_Cmp);
1377 set_irn_n(node, 0, left);
1381 get_Cmp_right (ir_node *node) {
1382 assert (node->op == op_Cmp);
1383 return get_irn_n(node, 1);
1387 set_Cmp_right (ir_node *node, ir_node *right) {
1388 assert (node->op == op_Cmp);
1389 set_irn_n(node, 1, right);
1393 get_Conv_op (ir_node *node) {
1394 assert (node->op == op_Conv);
1395 return get_irn_n(node, 0);
1399 set_Conv_op (ir_node *node, ir_node *op) {
1400 assert (node->op == op_Conv);
1401 set_irn_n(node, 0, op);
1405 get_Phi_preds_arr (ir_node *node) {
1406 assert (node->op == op_Phi);
1407 return (ir_node **)&(get_irn_in(node)[1]);
1411 get_Phi_n_preds (ir_node *node) {
1412 assert (node->op == op_Phi);
1413 return (get_irn_arity(node));
1417 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1418 assert (node->op == op_Phi);
1423 get_Phi_pred (ir_node *node, int pos) {
1424 assert (node->op == op_Phi);
1425 return get_irn_n(node, pos);
1429 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1430 assert (node->op == op_Phi);
1431 set_irn_n(node, pos, pred);
1435 get_Load_mem (ir_node *node) {
1436 assert (node->op == op_Load);
1437 return get_irn_n(node, 0);
1441 set_Load_mem (ir_node *node, ir_node *mem) {
1442 assert (node->op == op_Load);
1443 set_irn_n(node, 0, mem);
1447 get_Load_ptr (ir_node *node) {
1448 assert (node->op == op_Load);
1449 return get_irn_n(node, 1);
1453 set_Load_ptr (ir_node *node, ir_node *ptr) {
1454 assert (node->op == op_Load);
1455 set_irn_n(node, 1, ptr);
1460 get_Store_mem (ir_node *node) {
1461 assert (node->op == op_Store);
1462 return get_irn_n(node, 0);
1466 set_Store_mem (ir_node *node, ir_node *mem) {
1467 assert (node->op == op_Store);
1468 set_irn_n(node, 0, mem);
1472 get_Store_ptr (ir_node *node) {
1473 assert (node->op == op_Store);
1474 return get_irn_n(node, 1);
1478 set_Store_ptr (ir_node *node, ir_node *ptr) {
1479 assert (node->op == op_Store);
1480 set_irn_n(node, 1, ptr);
1484 get_Store_value (ir_node *node) {
1485 assert (node->op == op_Store);
1486 return get_irn_n(node, 2);
1490 set_Store_value (ir_node *node, ir_node *value) {
1491 assert (node->op == op_Store);
1492 set_irn_n(node, 2, value);
1496 get_Alloc_mem (ir_node *node) {
1497 assert (node->op == op_Alloc);
1498 return get_irn_n(node, 0);
1502 set_Alloc_mem (ir_node *node, ir_node *mem) {
1503 assert (node->op == op_Alloc);
1504 set_irn_n(node, 0, mem);
1508 get_Alloc_size (ir_node *node) {
1509 assert (node->op == op_Alloc);
1510 return get_irn_n(node, 1);
1514 set_Allco_size (ir_node *node, ir_node *size) {
1515 assert (node->op == op_Alloc);
1516 set_irn_n(node, 1, size);
1520 get_Alloc_type (ir_node *node) {
1521 assert (node->op == op_Alloc);
1522 return node->attr.a.type;
1526 set_Alloc_type (ir_node *node, type *type) {
1527 assert (node->op == op_Alloc);
1528 node->attr.a.type = type;
1532 get_Alloc_where (ir_node *node) {
1533 assert (node->op == op_Alloc);
1534 return node->attr.a.where;
1538 set_Alloc_where (ir_node *node, where_alloc where) {
1539 assert (node->op == op_Alloc);
1540 node->attr.a.where = where;
1545 get_Free_mem (ir_node *node) {
1546 assert (node->op == op_Free);
1547 return get_irn_n(node, 0);
1551 set_Free_mem (ir_node *node, ir_node *mem) {
1552 assert (node->op == op_Free);
1553 set_irn_n(node, 0, mem);
1557 get_Free_ptr (ir_node *node) {
1558 assert (node->op == op_Free);
1559 return get_irn_n(node, 1);
1563 set_Free_ptr (ir_node *node, ir_node *ptr) {
1564 assert (node->op == op_Free);
1565 set_irn_n(node, 1, ptr);
1569 get_Free_size (ir_node *node) {
1570 assert (node->op == op_Free);
1571 return get_irn_n(node, 2);
1575 set_Free_size (ir_node *node, ir_node *size) {
1576 assert (node->op == op_Free);
1577 set_irn_n(node, 2, size);
1581 get_Free_type (ir_node *node) {
1582 assert (node->op == op_Free);
1583 return node->attr.f;
1587 set_Free_type (ir_node *node, type *type) {
1588 assert (node->op == op_Free);
1589 node->attr.f = type;
1593 get_Sync_preds_arr (ir_node *node) {
1594 assert (node->op == op_Sync);
1595 return (ir_node **)&(get_irn_in(node)[1]);
1599 get_Sync_n_preds (ir_node *node) {
1600 assert (node->op == op_Sync);
1601 return (get_irn_arity(node));
1606 set_Sync_n_preds (ir_node *node, int n_preds) {
1607 assert (node->op == op_Sync);
1612 get_Sync_pred (ir_node *node, int pos) {
1613 assert (node->op == op_Sync);
1614 return get_irn_n(node, pos);
1618 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1619 assert (node->op == op_Sync);
1620 set_irn_n(node, pos, pred);
1624 get_Proj_pred (ir_node *node) {
1625 assert (node->op == op_Proj);
1626 return get_irn_n(node, 0);
1630 set_Proj_pred (ir_node *node, ir_node *pred) {
1631 assert (node->op == op_Proj);
1632 set_irn_n(node, 0, pred);
1636 get_Proj_proj (ir_node *node) {
1637 assert (node->op == op_Proj);
1638 return node->attr.proj;
1642 set_Proj_proj (ir_node *node, long proj) {
1643 assert (node->op == op_Proj);
1644 node->attr.proj = proj;
1648 get_Tuple_preds_arr (ir_node *node) {
1649 assert (node->op == op_Tuple);
1650 return (ir_node **)&(get_irn_in(node)[1]);
1654 get_Tuple_n_preds (ir_node *node) {
1655 assert (node->op == op_Tuple);
1656 return (get_irn_arity(node));
1661 set_Tuple_n_preds (ir_node *node, int n_preds) {
1662 assert (node->op == op_Tuple);
1667 get_Tuple_pred (ir_node *node, int pos) {
1668 assert (node->op == op_Tuple);
1669 return get_irn_n(node, pos);
1673 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1674 assert (node->op == op_Tuple);
1675 set_irn_n(node, pos, pred);
1679 get_Id_pred (ir_node *node) {
1680 assert (node->op == op_Id);
1681 return get_irn_n(node, 0);
1685 set_Id_pred (ir_node *node, ir_node *pred) {
1686 assert (node->op == op_Id);
1687 set_irn_n(node, 0, pred);
1690 /******************************************************************/
1691 /* Auxiliary routines */
1692 /******************************************************************/
1695 skip_Proj (ir_node *node) {
1696 /* don't assert node !!! */
1697 if (node && (node->op == op_Proj)) {
1698 return get_Proj_pred(node);
1705 skip_nop (ir_node *node) {
1706 /* don't assert node !!! */
1708 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1709 return get_Id_pred(node);
1716 is_Bad (ir_node *node) {
1718 if ((node) && get_irn_opcode(node) == iro_Bad)
1724 is_no_Block (ir_node *node) {
1726 return (get_irn_opcode(node) != iro_Block);
1729 /* Returns true if the operation manipulates control flow. */
1731 is_cfop(ir_node *node) {
1732 return ( (get_irn_opcode(node) == iro_Start)
1733 || (get_irn_opcode(node) == iro_Jmp)
1734 || (get_irn_opcode(node) == iro_Cond)
1735 || (get_irn_opcode(node) == iro_Return)
1736 || (get_irn_opcode(node) == iro_Raise)
1737 || (get_irn_opcode(node) == iro_Bad));
1740 /* Returns true if the operation can change the control flow because
1743 is_fragile_op(ir_node *node) {
1744 return ( (get_irn_opcode(node) == iro_Call)
1745 || (get_irn_opcode(node) == iro_Quot)
1746 || (get_irn_opcode(node) == iro_DivMod)
1747 || (get_irn_opcode(node) == iro_Div)
1748 || (get_irn_opcode(node) == iro_Mod)
1749 || (get_irn_opcode(node) == iro_Load)
1750 || (get_irn_opcode(node) == iro_Store)
1751 || (get_irn_opcode(node) == iro_Alloc)
1752 || (get_irn_opcode(node) == iro_Bad));