1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
11 /* some constants fixing the positions of nodes predecessors
13 #define CALL_PARAM_OFFSET 2
14 #define SEL_INDEX_OFFSET 2
15 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
17 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
18 "Gt", "Ge", "Lg", "Leg", "Uo",
19 "Ue", "Ul", "Ule", "Ug", "Uge",
22 inline char *get_pnc_string(int pnc) {
23 return pnc_name_arr[pnc];
28 get_negated_pnc(int pnc) {
30 case False: return True; break;
31 case Eq: return Ne; break;
32 case Lt: return Uge; break;
33 case Le: return Ug; break;
34 case Gt: return Ule; break;
35 case Ge: return Ul; break;
36 case Lg: return Ue; break;
37 case Leg: return Uo; break;
38 case Uo: return Leg; break;
39 case Ue: return Lg; break;
40 case Ul: return Ge; break;
41 case Ule: return Gt; break;
42 case Ug: return Le; break;
43 case Uge: return Lt; break;
44 case Ne: return Eq; break;
45 case True: return False; break;
47 return 99; /* to shut up gcc */
50 static char *pns_name_arr [] = {"initial_exec", "global_store",
51 "frame_base", "globals", "args"};
53 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
60 /* irnode constructor */
61 /* create a new irnode in irg, with an op, mode, arity and */
62 /* some incoming irnodes */
63 /* this constructor is used in every specified irnode constructor */
65 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
66 int arity, ir_node **in)
69 int node_size = offsetof (ir_node, attr) + op->attr_size;
71 res = (ir_node *) obstack_alloc (irg->obst, node_size);
73 res->kind = k_ir_node;
79 res->in = NEW_ARR_F (ir_node *, 1);
81 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
82 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
87 res->node_nr = get_irp_new_node_nr();
93 /* Copies all attributes stored in the old node to the new node.
94 Assumes both have the same opcode and sufficient size. */
96 copy_attrs (ir_node *old, ir_node *new) {
97 assert (get_irn_opcode(old) == get_irn_opcode(new));
98 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
101 /* IR-Nodes with attributes */
103 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
106 ir_node *np = XP_GETARG (ir_node *, 0);
109 XPS ("<null ir_node>");
113 XPF1 ("%I", get_irn_opname(np));
115 switch (get_irn_opcode (np)) { /* node label */
117 XPF1 ("%I", get_irn_mode(np)->name);
119 XPF1 ("%v", get_irn_const_attr);
122 if (get_irn_modecode (np) == irm_b) {
124 XP (pnc_name_arr[get_irn_proj_attr(np)]);
125 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
127 XP (pns_name_arr[get_irn_proj_attr(np)]);
129 XPF1 ("%I", get_irn_mode(np)->name);
131 XPF1 ("%d", get_irn_proj_attr(np));
135 XPF1 ("%I", get_irn_mode(np)->name);
137 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
138 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
140 case iro_Start: /* don't dump mode of these */
149 XPF1 ("%I", get_irn_mode(np)->name);
156 /** getting some parameters from ir_nodes **/
158 /* returns the number of predecessors without the block predecessor. */
160 get_irn_arity (ir_node *node)
163 return (ARR_LEN((node)->in)-1);
166 /* Returns the array with ins. This array is shifted with respect to the
167 array accessed by get_irn_n: The block operand is at position 0 not -1.
168 (@@@ This should be changed.)
169 The order of the predecessors in this array is not guaranteed, except that
170 lists of operands as predecessors of Block or arguments of a Call are
173 get_irn_in (ir_node *node)
179 /* to iterate through the predecessors without touching the array */
180 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
181 to iterate includind the Block predecessor iterate from i = -1 to
183 If it is a block, the entry -1 is NULL. */
185 get_irn_n (ir_node *node, int n)
188 assert (get_irn_arity (node) > n);
189 return skip_nop(node->in[n+1]);
193 set_irn_n (ir_node *node, int n, ir_node *in)
196 assert (get_irn_arity (node) > n);
201 get_irn_mode (ir_node *node)
208 get_irn_modecode (ir_node *node)
211 return node->mode->code;
216 get_irn_modename (ir_node *node)
219 return node->mode->name;
223 get_irn_op (ir_node *node)
229 /* should be private to the library: */
231 set_irn_op (ir_node *node, ir_op *op)
238 get_irn_opcode (ir_node *node)
241 return node->op->code;
245 get_irn_opname (ir_node *node)
248 return node->op->name;
252 get_irn_visited (ir_node *node)
255 return node->visited;
259 set_irn_visited (ir_node *node, unsigned long visited)
262 node->visited = visited;
265 set_irn_link (ir_node *node, ir_node *link) {
271 get_irn_link (ir_node *node) {
277 /* Outputs a unique number for this node */
279 get_irn_node_nr(ir_node *node) {
281 return node->node_nr;
286 get_irn_const_attr (ir_node *node)
288 assert (node->op == op_Const);
289 return node->attr.con;
293 get_irn_proj_attr (ir_node *node)
295 assert (node->op == op_Proj);
296 return node->attr.proj;
300 get_irn_alloc_attr (ir_node *node)
302 assert (node->op == op_Alloc);
307 get_irn_free_attr (ir_node *node)
309 assert (node->op == op_Free);
314 get_irn_symconst_attr (ir_node *node)
316 assert (node->op == op_SymConst);
321 get_irn_call_attr (ir_node *node)
323 assert (node->op == op_Call);
324 return node->attr.call;
328 get_irn_sel_attr (ir_node *node)
330 assert (node->op == op_Sel);
335 get_irn_phi_attr (ir_node *node)
337 assert (node->op == op_Phi);
338 return node->attr.phi0_pos;
342 get_irn_block_attr (ir_node *node)
344 assert (node->op == op_Block);
345 return node->attr.block;
348 /** manipulate fields of individual nodes **/
350 /* this works for all except Block */
352 get_nodes_Block (ir_node *node) {
353 assert (!(node->op == op_Block));
354 return get_irn_n(node, -1);
358 set_nodes_Block (ir_node *node, ir_node *block) {
359 assert (!(node->op == op_Block));
360 set_irn_n(node, -1, block);
363 /* Returns an array with the predecessors of the Block. Depending on
364 the implementation of the graph datastructure this can be a copy of
365 the internal representation of predecessors as well as the internal
366 array itself. Therefore writing to this array might obstruct the ir. */
368 get_Block_cfgpred_arr (ir_node *node)
370 assert ((node->op == op_Block));
371 return (ir_node **)&(get_irn_in(node)[1]);
376 get_Block_n_cfgpreds (ir_node *node) {
377 assert ((node->op == op_Block));
378 return (get_irn_arity(node));
383 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
384 assert ((node->op == op_Block));
389 get_Block_cfgpred (ir_node *node, int pos) {
390 assert (node->op == op_Block);
391 return get_irn_n(node, pos);
395 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
396 assert (node->op == op_Block);
397 set_irn_n(node, pos, pred);
401 get_Block_matured (ir_node *node) {
402 assert (node->op == op_Block);
403 return node->attr.block.matured;
407 set_Block_matured (ir_node *node, bool matured) {
408 assert (node->op == op_Block);
409 node->attr.block.matured = matured;
412 get_Block_block_visited (ir_node *node) {
413 assert (node->op == op_Block);
414 return node->attr.block.block_visited;
418 set_Block_block_visited (ir_node *node, unsigned long visit) {
419 assert (node->op == op_Block);
420 node->attr.block.block_visited = visit;
424 get_Block_graph_arr (ir_node *node, int pos) {
425 assert (node->op == op_Block);
426 return node->attr.block.graph_arr[pos+1];
430 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
431 assert (node->op == op_Block);
432 node->attr.block.graph_arr[pos+1] = value;
436 get_Cond_selector (ir_node *node) {
437 assert (node->op == op_Cond);
438 return get_irn_n(node, 0);
442 set_Cond_selector (ir_node *node, ir_node *selector) {
443 assert (node->op == op_Cond);
444 set_irn_n(node, 0, selector);
448 get_Return_mem (ir_node *node) {
449 assert (node->op == op_Return);
450 return get_irn_n(node, 0);
454 set_Return_mem (ir_node *node, ir_node *mem) {
455 assert (node->op == op_Return);
456 set_irn_n(node, 0, mem);
460 get_Return_res_arr (ir_node *node)
462 assert ((node->op == op_Return));
463 if (get_Return_n_res(node) > 0)
464 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
470 get_Return_n_res (ir_node *node) {
471 assert (node->op == op_Return);
472 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
477 set_Return_n_res (ir_node *node, int results) {
478 assert (node->op == op_Return);
483 get_Return_res (ir_node *node, int pos) {
484 assert (node->op == op_Return);
485 assert (get_Return_n_res(node) > pos);
486 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
490 set_Return_res (ir_node *node, int pos, ir_node *res){
491 assert (node->op == op_Return);
492 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
496 get_Raise_mem (ir_node *node) {
497 assert (node->op == op_Return);
498 return get_irn_n(node, 0);
502 set_Raise_mem (ir_node *node, ir_node *mem) {
503 assert (node->op == op_Raise);
504 set_irn_n(node, 0, mem);
508 get_Raise_exo_ptr (ir_node *node) {
509 assert (node->op == op_Raise);
510 return get_irn_n(node, 1);
514 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
515 assert (node->op == op_Raise);
516 set_irn_n(node, 1, exo_ptr);
519 inline tarval *get_Const_tarval (ir_node *node) {
520 assert (node->op == op_Const);
521 return get_irn_const_attr(node);
525 set_Const_tarval (ir_node *node, tarval *con) {
526 assert (node->op == op_Const);
527 node->attr.con = con;
531 get_SymConst_kind (ir_node *node) {
532 assert (node->op == op_SymConst);
533 return node->attr.i.num;
537 set_SymConst_kind (ir_node *node, symconst_kind num) {
538 assert (node->op == op_SymConst);
539 node->attr.i.num = num;
543 get_SymConst_type (ir_node *node) {
544 assert ( (node->op == op_SymConst)
545 && ( get_SymConst_kind(node) == type_tag
546 || get_SymConst_kind(node) == size));
547 return node->attr.i.tori.typ;
551 set_SymConst_type (ir_node *node, type *type) {
552 assert ( (node->op == op_SymConst)
553 && ( get_SymConst_kind(node) == type_tag
554 || get_SymConst_kind(node) == size));
555 node->attr.i.tori.typ = type;
559 get_SymConst_ptrinfo (ir_node *node) {
560 assert ( (node->op == op_SymConst)
561 && (get_SymConst_kind(node) == linkage_ptr_info));
562 return node->attr.i.tori.ptrinfo;
568 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
569 assert ( (node->op == op_SymConst)
570 && (get_SymConst_kind(node) == linkage_ptr_info));
571 node->attr.i.tori.ptrinfo = ptrinfo;
575 get_Sel_mem (ir_node *node) {
576 assert (node->op == op_Sel);
577 return get_irn_n(node, 0);
581 set_Sel_mem (ir_node *node, ir_node *mem) {
582 assert (node->op == op_Sel);
583 set_irn_n(node, 0, mem);
587 get_Sel_ptr (ir_node *node) {
588 assert (node->op == op_Sel);
589 return get_irn_n(node, 1);
593 set_Sel_ptr (ir_node *node, ir_node *ptr) {
594 assert (node->op == op_Sel);
595 set_irn_n(node, 1, ptr);
599 get_Sel_index_arr (ir_node *node)
601 assert ((node->op == op_Sel));
602 if (get_Sel_n_index(node) > 0)
603 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
609 get_Sel_n_index (ir_node *node) {
610 assert (node->op == op_Sel);
611 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
616 set_Sel_n_index (ir_node *node, int n_index) {
617 assert (node->op == op_Sel);
622 get_Sel_index (ir_node *node, int pos) {
623 assert (node->op == op_Sel);
624 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
628 set_Sel_index (ir_node *node, int pos, ir_node *index) {
629 assert (node->op == op_Sel);
630 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
634 get_Sel_entity (ir_node *node) {
635 assert (node->op == op_Sel);
636 return node->attr.s.ent;
640 set_Sel_entity (ir_node *node, entity *ent) {
641 assert (node->op == op_Sel);
642 node->attr.s.ent = ent;
646 get_Sel_linkage_type (ir_node *node) {
647 assert (node->op == op_Sel);
648 return node->attr.s.ltyp;
652 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
653 assert (node->op == op_Sel);
654 node->attr.s.ltyp = lt;
658 get_Call_mem (ir_node *node) {
659 assert (node->op == op_Call);
660 return get_irn_n(node, 0);
664 set_Call_mem (ir_node *node, ir_node *mem) {
665 assert (node->op == op_Call);
666 set_irn_n(node, 0, mem);
670 get_Call_ptr (ir_node *node) {
671 assert (node->op == op_Call);
672 return get_irn_n(node, 1);
676 set_Call_ptr (ir_node *node, ir_node *ptr) {
677 assert (node->op == op_Call);
678 set_irn_n(node, 1, ptr);
682 get_Call_param_arr (ir_node *node) {
683 assert (node->op == op_Call);
684 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
688 get_Call_arity (ir_node *node) {
689 assert (node->op == op_Call);
690 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
694 set_Call_arity (ir_node *node, ir_node *arity) {
695 assert (node->op == op_Call);
700 get_Call_param (ir_node *node, int pos) {
701 assert (node->op == op_Call);
702 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
706 set_Call_param (ir_node *node, int pos, ir_node *param) {
707 assert (node->op == op_Call);
708 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
712 get_Call_type (ir_node *node) {
713 assert (node->op == op_Call);
714 return node->attr.call;
718 set_Call_type (ir_node *node, type_method *type) {
719 assert (node->op == op_Call);
720 node->attr.call = type;
723 /* For unary and binary arithmetic operations the access to the
724 operands can be factored out. Left is the first, right the
725 second arithmetic value as listed in tech report 0999-33.
726 unops are: Minus, Abs, Not, Conv
727 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
728 Shr, Shrs, Rotate, Cmp */
731 is_unop (ir_node *node) {
732 return ( node->op == op_Minus ||
733 node->op == op_Abs ||
734 node->op == op_Not ||
735 node->op == op_Conv );
739 get_unop_op (ir_node *node) {
740 assert ( node->op == op_Minus ||
741 node->op == op_Abs ||
742 node->op == op_Not ||
743 node->op == op_Conv );
744 switch (get_irn_opcode (node)) {
745 case iro_Minus: return get_Minus_op(node); break;
746 case iro_Abs: return get_Abs_op(node); break;
747 case iro_Not: return get_Not_op(node); break;
748 case iro_Conv: return get_Conv_op(node); break;
749 default: return NULL;
754 set_unop_op (ir_node *node, ir_node *op) {
755 assert (node->op == op_Minus ||
756 node->op == op_Abs ||
757 node->op == op_Not ||
758 node->op == op_Conv );
759 switch (get_irn_opcode (node)) {
760 case iro_Minus: set_Minus_op(node, op); break;
761 case iro_Abs: set_Abs_op(node, op); break;
762 case iro_Not: set_Not_op(node, op); break;
763 case iro_Conv: set_Conv_op(node, op); break;
770 is_binop (ir_node *node) {
771 return (node->op == op_Add ||
772 node->op == op_Sub ||
773 node->op == op_Mul ||
774 node->op == op_Quot ||
775 node->op == op_DivMod ||
776 node->op == op_Div ||
777 node->op == op_Mod ||
778 node->op == op_And ||
780 node->op == op_Eor ||
781 node->op == op_Shl ||
782 node->op == op_Shr ||
783 node->op == op_Shrs ||
784 node->op == op_Rot ||
785 node->op == op_Cmp );
789 get_binop_left (ir_node *node) {
790 assert (node->op == op_Add ||
791 node->op == op_Sub ||
792 node->op == op_Mul ||
793 node->op == op_Quot ||
794 node->op == op_DivMod ||
795 node->op == op_Div ||
796 node->op == op_Mod ||
797 node->op == op_And ||
799 node->op == op_Eor ||
800 node->op == op_Shl ||
801 node->op == op_Shr ||
802 node->op == op_Shrs ||
803 node->op == op_Rot ||
804 node->op == op_Cmp );
806 switch (get_irn_opcode (node)) {
807 case iro_Add : return get_Add_left(node); break;
808 case iro_Sub : return get_Sub_left(node); break;
809 case iro_Mul : return get_Mul_left(node); break;
810 case iro_Quot : return get_Quot_left(node); break;
811 case iro_DivMod: return get_DivMod_left(node); break;
812 case iro_Div : return get_Div_left(node); break;
813 case iro_Mod : return get_Mod_left(node); break;
814 case iro_And : return get_And_left(node); break;
815 case iro_Or : return get_Or_left(node); break;
816 case iro_Eor : return get_Eor_left(node); break;
817 case iro_Shl : return get_Shl_left(node); break;
818 case iro_Shr : return get_Shr_left(node); break;
819 case iro_Shrs : return get_Shrs_left(node); break;
820 case iro_Rot : return get_Rot_left(node); break;
821 case iro_Cmp : return get_Cmp_left(node); break;
822 default: return NULL;
827 set_binop_left (ir_node *node, ir_node *left) {
828 assert (node->op == op_Add ||
829 node->op == op_Sub ||
830 node->op == op_Mul ||
831 node->op == op_Quot ||
832 node->op == op_DivMod ||
833 node->op == op_Div ||
834 node->op == op_Mod ||
835 node->op == op_And ||
837 node->op == op_Eor ||
838 node->op == op_Shl ||
839 node->op == op_Shr ||
840 node->op == op_Shrs ||
841 node->op == op_Rot ||
842 node->op == op_Cmp );
844 switch (get_irn_opcode (node)) {
845 case iro_Add : set_Add_left(node, left); break;
846 case iro_Sub : set_Sub_left(node, left); break;
847 case iro_Mul : set_Mul_left(node, left); break;
848 case iro_Quot : set_Quot_left(node, left); break;
849 case iro_DivMod: set_DivMod_left(node, left); break;
850 case iro_Div : set_Div_left(node, left); break;
851 case iro_Mod : set_Mod_left(node, left); break;
852 case iro_And : set_And_left(node, left); break;
853 case iro_Or : set_Or_left(node, left); break;
854 case iro_Eor : set_Eor_left(node, left); break;
855 case iro_Shl : set_Shl_left(node, left); break;
856 case iro_Shr : set_Shr_left(node, left); break;
857 case iro_Shrs : set_Shrs_left(node, left); break;
858 case iro_Rot : set_Rot_left(node, left); break;
859 case iro_Cmp : set_Cmp_left(node, left); break;
865 get_binop_right (ir_node *node) {
866 assert (node->op == op_Add ||
867 node->op == op_Sub ||
868 node->op == op_Mul ||
869 node->op == op_Quot ||
870 node->op == op_DivMod ||
871 node->op == op_Div ||
872 node->op == op_Mod ||
873 node->op == op_And ||
875 node->op == op_Eor ||
876 node->op == op_Shl ||
877 node->op == op_Shr ||
878 node->op == op_Shrs ||
879 node->op == op_Rot ||
880 node->op == op_Cmp );
882 switch (get_irn_opcode (node)) {
883 case iro_Add : return get_Add_right(node); break;
884 case iro_Sub : return get_Sub_right(node); break;
885 case iro_Mul : return get_Mul_right(node); break;
886 case iro_Quot : return get_Quot_right(node); break;
887 case iro_DivMod: return get_DivMod_right(node); break;
888 case iro_Div : return get_Div_right(node); break;
889 case iro_Mod : return get_Mod_right(node); break;
890 case iro_And : return get_And_right(node); break;
891 case iro_Or : return get_Or_right(node); break;
892 case iro_Eor : return get_Eor_right(node); break;
893 case iro_Shl : return get_Shl_right(node); break;
894 case iro_Shr : return get_Shr_right(node); break;
895 case iro_Shrs : return get_Shrs_right(node); break;
896 case iro_Rot : return get_Rot_right(node); break;
897 case iro_Cmp : return get_Cmp_right(node); break;
898 default: return NULL;
903 set_binop_right (ir_node *node, ir_node *right) {
904 assert (node->op == op_Add ||
905 node->op == op_Sub ||
906 node->op == op_Mul ||
907 node->op == op_Quot ||
908 node->op == op_DivMod ||
909 node->op == op_Div ||
910 node->op == op_Mod ||
911 node->op == op_And ||
913 node->op == op_Eor ||
914 node->op == op_Shl ||
915 node->op == op_Shr ||
916 node->op == op_Shrs ||
917 node->op == op_Rot ||
918 node->op == op_Cmp );
920 switch (get_irn_opcode (node)) {
921 case iro_Add : set_Add_right(node, right); break;
922 case iro_Sub : set_Sub_right(node, right); break;
923 case iro_Mul : set_Mul_right(node, right); break;
924 case iro_Quot : set_Quot_right(node, right); break;
925 case iro_DivMod: set_DivMod_right(node, right); break;
926 case iro_Div : set_Div_right(node, right); break;
927 case iro_Mod : set_Mod_right(node, right); break;
928 case iro_And : set_And_right(node, right); break;
929 case iro_Or : set_Or_right(node, right); break;
930 case iro_Eor : set_Eor_right(node, right); break;
931 case iro_Shl : set_Shl_right(node, right); break;
932 case iro_Shr : set_Shr_right(node, right); break;
933 case iro_Shrs : set_Shrs_right(node, right); break;
934 case iro_Rot : set_Rot_right(node, right); break;
935 case iro_Cmp : set_Cmp_right(node, right); break;
941 get_Add_left (ir_node *node) {
942 assert (node->op == op_Add);
943 return get_irn_n(node, 0);
947 set_Add_left (ir_node *node, ir_node *left) {
948 assert (node->op == op_Add);
949 set_irn_n(node, 0, left);
953 get_Add_right (ir_node *node) {
954 assert (node->op == op_Add);
955 return get_irn_n(node, 1);
959 set_Add_right (ir_node *node, ir_node *right) {
960 assert (node->op == op_Add);
961 set_irn_n(node, 1, right);
965 get_Sub_left (ir_node *node) {
966 assert (node->op == op_Sub);
967 return get_irn_n(node, 0);
971 set_Sub_left (ir_node *node, ir_node *left) {
972 assert (node->op == op_Sub);
973 set_irn_n(node, 0, left);
977 get_Sub_right (ir_node *node) {
978 assert (node->op == op_Sub);
979 return get_irn_n(node, 1);
983 set_Sub_right (ir_node *node, ir_node *right) {
984 assert (node->op == op_Sub);
985 set_irn_n(node, 1, right);
990 get_Minus_op (ir_node *node) {
991 assert (node->op == op_Minus);
992 return get_irn_n(node, 0);
996 set_Minus_op (ir_node *node, ir_node *op) {
997 assert (node->op == op_Minus);
998 set_irn_n(node, 0, op);
1003 get_Mul_left (ir_node *node) {
1004 assert (node->op == op_Mul);
1005 return get_irn_n(node, 0);
1009 set_Mul_left (ir_node *node, ir_node *left) {
1010 assert (node->op == op_Mul);
1011 set_irn_n(node, 0, left);
1015 get_Mul_right (ir_node *node) {
1016 assert (node->op == op_Mul);
1017 return get_irn_n(node, 1);
1021 set_Mul_right (ir_node *node, ir_node *right) {
1022 assert (node->op == op_Mul);
1023 set_irn_n(node, 1, right);
1027 get_Quot_left (ir_node *node) {
1028 assert (node->op == op_Quot);
1029 return get_irn_n(node, 1);
1033 set_Quot_left (ir_node *node, ir_node *left) {
1034 assert (node->op == op_Quot);
1035 set_irn_n(node, 1, left);
1039 get_Quot_right (ir_node *node) {
1040 assert (node->op == op_Quot);
1041 return get_irn_n(node, 2);
1045 set_Quot_right (ir_node *node, ir_node *right) {
1046 assert (node->op == op_Quot);
1047 set_irn_n(node, 2, right);
1051 get_Quot_mem (ir_node *node) {
1052 assert (node->op == op_Quot);
1053 return get_irn_n(node, 0);
1057 set_Quot_mem (ir_node *node, ir_node *mem) {
1058 assert (node->op == op_Quot);
1059 set_irn_n(node, 0, mem);
1063 get_DivMod_left (ir_node *node) {
1064 assert (node->op == op_DivMod);
1065 return get_irn_n(node, 1);
1069 set_DivMod_left (ir_node *node, ir_node *left) {
1070 assert (node->op == op_DivMod);
1071 set_irn_n(node, 1, left);
1075 get_DivMod_right (ir_node *node) {
1076 assert (node->op == op_DivMod);
1077 return get_irn_n(node, 2);
1081 set_DivMod_right (ir_node *node, ir_node *right) {
1082 assert (node->op == op_DivMod);
1083 set_irn_n(node, 2, right);
1087 get_DivMod_mem (ir_node *node) {
1088 assert (node->op == op_DivMod);
1089 return get_irn_n(node, 0);
1093 set_DivMod_mem (ir_node *node, ir_node *mem) {
1094 assert (node->op == op_DivMod);
1095 set_irn_n(node, 0, mem);
1099 get_Div_left (ir_node *node) {
1100 assert (node->op == op_Div);
1101 return get_irn_n(node, 1);
1105 set_Div_left (ir_node *node, ir_node *left) {
1106 assert (node->op == op_Div);
1107 set_irn_n(node, 1, left);
1111 get_Div_right (ir_node *node) {
1112 assert (node->op == op_Div);
1113 return get_irn_n(node, 2);
1117 set_Div_right (ir_node *node, ir_node *right) {
1118 assert (node->op == op_Div);
1119 set_irn_n(node, 2, right);
1123 get_Div_mem (ir_node *node) {
1124 assert (node->op == op_Div);
1125 return get_irn_n(node, 0);
1129 set_Div_mem (ir_node *node, ir_node *mem) {
1130 assert (node->op == op_Div);
1131 set_irn_n(node, 0, mem);
1135 get_Mod_left (ir_node *node) {
1136 assert (node->op == op_Mod);
1137 return get_irn_n(node, 1);
1141 set_Mod_left (ir_node *node, ir_node *left) {
1142 assert (node->op == op_Mod);
1143 set_irn_n(node, 1, left);
1147 get_Mod_right (ir_node *node) {
1148 assert (node->op == op_Mod);
1149 return get_irn_n(node, 2);
1153 set_Mod_right (ir_node *node, ir_node *right) {
1154 assert (node->op == op_Mod);
1155 set_irn_n(node, 2, right);
1159 get_Mod_mem (ir_node *node) {
1160 assert (node->op == op_Mod);
1161 return get_irn_n(node, 0);
1165 set_Mod_mem (ir_node *node, ir_node *mem) {
1166 assert (node->op == op_Mod);
1167 set_irn_n(node, 0, mem);
1171 get_Abs_op (ir_node *node) {
1172 assert (node->op == op_Abs);
1173 return get_irn_n(node, 0);
1177 set_Abs_op (ir_node *node, ir_node *op) {
1178 assert (node->op == op_Abs);
1179 set_irn_n(node, 0, op);
1183 get_And_left (ir_node *node) {
1184 assert (node->op == op_And);
1185 return get_irn_n(node, 0);
1189 set_And_left (ir_node *node, ir_node *left) {
1190 assert (node->op == op_And);
1191 set_irn_n(node, 0, left);
1195 get_And_right (ir_node *node) {
1196 assert (node->op == op_And);
1197 return get_irn_n(node, 1);
1201 set_And_right (ir_node *node, ir_node *right) {
1202 assert (node->op == op_And);
1203 set_irn_n(node, 1, right);
1207 get_Or_left (ir_node *node) {
1208 assert (node->op == op_Or);
1209 return get_irn_n(node, 0);
1213 set_Or_left (ir_node *node, ir_node *left) {
1214 assert (node->op == op_Or);
1215 set_irn_n(node, 0, left);
1219 get_Or_right (ir_node *node) {
1220 assert (node->op == op_Or);
1221 return get_irn_n(node, 1);
1225 set_Or_right (ir_node *node, ir_node *right) {
1226 assert (node->op == op_Or);
1227 set_irn_n(node, 1, right);
1231 get_Eor_left (ir_node *node) {
1232 assert (node->op == op_Eor);
1233 return get_irn_n(node, 0);
1237 set_Eor_left (ir_node *node, ir_node *left) {
1238 assert (node->op == op_Eor);
1239 set_irn_n(node, 0, left);
1243 get_Eor_right (ir_node *node) {
1244 assert (node->op == op_Eor);
1245 return get_irn_n(node, 1);
1249 set_Eor_right (ir_node *node, ir_node *right) {
1250 assert (node->op == op_Eor);
1251 set_irn_n(node, 1, right);
1256 get_Not_op (ir_node *node) {
1257 assert (node->op == op_Not);
1258 return get_irn_n(node, 0);
1262 set_Not_op (ir_node *node, ir_node *op) {
1263 assert (node->op == op_Not);
1264 set_irn_n(node, 0, op);
1269 get_Shl_left (ir_node *node) {
1270 assert (node->op == op_Shl);
1271 return get_irn_n(node, 0);
1275 set_Shl_left (ir_node *node, ir_node *left) {
1276 assert (node->op == op_Shl);
1277 set_irn_n(node, 0, left);
1281 get_Shl_right (ir_node *node) {
1282 assert (node->op == op_Shl);
1283 return get_irn_n(node, 1);
1287 set_Shl_right (ir_node *node, ir_node *right) {
1288 assert (node->op == op_Shl);
1289 set_irn_n(node, 1, right);
1293 get_Shr_left (ir_node *node) {
1294 assert (node->op == op_Shr);
1295 return get_irn_n(node, 0);
1299 set_Shr_left (ir_node *node, ir_node *left) {
1300 assert (node->op == op_Shr);
1301 set_irn_n(node, 0, left);
1305 get_Shr_right (ir_node *node) {
1306 assert (node->op == op_Shr);
1307 return get_irn_n(node, 1);
1311 set_Shr_right (ir_node *node, ir_node *right) {
1312 assert (node->op == op_Shr);
1313 set_irn_n(node, 1, right);
1317 get_Shrs_left (ir_node *node) {
1318 assert (node->op == op_Shrs);
1319 return get_irn_n(node, 0);
1323 set_Shrs_left (ir_node *node, ir_node *left) {
1324 assert (node->op == op_Shrs);
1325 set_irn_n(node, 0, left);
1329 get_Shrs_right (ir_node *node) {
1330 assert (node->op == op_Shrs);
1331 return get_irn_n(node, 1);
1335 set_Shrs_right (ir_node *node, ir_node *right) {
1336 assert (node->op == op_Shrs);
1337 set_irn_n(node, 1, right);
1341 get_Rot_left (ir_node *node) {
1342 assert (node->op == op_Rot);
1343 return get_irn_n(node, 0);
1347 set_Rot_left (ir_node *node, ir_node *left) {
1348 assert (node->op == op_Rot);
1349 set_irn_n(node, 0, left);
1353 get_Rot_right (ir_node *node) {
1354 assert (node->op == op_Rot);
1355 return get_irn_n(node, 1);
1359 set_Rot_right (ir_node *node, ir_node *right) {
1360 assert (node->op == op_Rot);
1361 set_irn_n(node, 1, right);
1365 get_Cmp_left (ir_node *node) {
1366 assert (node->op == op_Cmp);
1367 return get_irn_n(node, 0);
1371 set_Cmp_left (ir_node *node, ir_node *left) {
1372 assert (node->op == op_Cmp);
1373 set_irn_n(node, 0, left);
1377 get_Cmp_right (ir_node *node) {
1378 assert (node->op == op_Cmp);
1379 return get_irn_n(node, 1);
1383 set_Cmp_right (ir_node *node, ir_node *right) {
1384 assert (node->op == op_Cmp);
1385 set_irn_n(node, 1, right);
1389 get_Conv_op (ir_node *node) {
1390 assert (node->op == op_Conv);
1391 return get_irn_n(node, 0);
1395 set_Conv_op (ir_node *node, ir_node *op) {
1396 assert (node->op == op_Conv);
1397 set_irn_n(node, 0, op);
1401 get_Phi_preds_arr (ir_node *node) {
1402 assert (node->op == op_Phi);
1403 return (ir_node **)&(get_irn_in(node)[1]);
1407 get_Phi_n_preds (ir_node *node) {
1408 assert (node->op == op_Phi);
1409 return (get_irn_arity(node));
1413 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1414 assert (node->op == op_Phi);
1419 get_Phi_pred (ir_node *node, int pos) {
1420 assert (node->op == op_Phi);
1421 return get_irn_n(node, pos);
1425 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1426 assert (node->op == op_Phi);
1427 set_irn_n(node, pos, pred);
1431 get_Load_mem (ir_node *node) {
1432 assert (node->op == op_Load);
1433 return get_irn_n(node, 0);
1437 set_Load_mem (ir_node *node, ir_node *mem) {
1438 assert (node->op == op_Load);
1439 set_irn_n(node, 0, mem);
1443 get_Load_ptr (ir_node *node) {
1444 assert (node->op == op_Load);
1445 return get_irn_n(node, 1);
1449 set_Load_ptr (ir_node *node, ir_node *ptr) {
1450 assert (node->op == op_Load);
1451 set_irn_n(node, 1, ptr);
1456 get_Store_mem (ir_node *node) {
1457 assert (node->op == op_Store);
1458 return get_irn_n(node, 0);
1462 set_Store_mem (ir_node *node, ir_node *mem) {
1463 assert (node->op == op_Store);
1464 set_irn_n(node, 0, mem);
1468 get_Store_ptr (ir_node *node) {
1469 assert (node->op == op_Store);
1470 return get_irn_n(node, 1);
1474 set_Store_ptr (ir_node *node, ir_node *ptr) {
1475 assert (node->op == op_Store);
1476 set_irn_n(node, 1, ptr);
1480 get_Store_value (ir_node *node) {
1481 assert (node->op == op_Store);
1482 return get_irn_n(node, 2);
1486 set_Store_value (ir_node *node, ir_node *value) {
1487 assert (node->op == op_Store);
1488 set_irn_n(node, 2, value);
1492 get_Alloc_mem (ir_node *node) {
1493 assert (node->op == op_Alloc);
1494 return get_irn_n(node, 0);
1498 set_Alloc_mem (ir_node *node, ir_node *mem) {
1499 assert (node->op == op_Alloc);
1500 set_irn_n(node, 0, mem);
1504 get_Alloc_size (ir_node *node) {
1505 assert (node->op == op_Alloc);
1506 return get_irn_n(node, 1);
1510 set_Allco_size (ir_node *node, ir_node *size) {
1511 assert (node->op == op_Alloc);
1512 set_irn_n(node, 1, size);
1516 get_Alloc_type (ir_node *node) {
1517 assert (node->op == op_Alloc);
1518 return node->attr.a.type;
1522 set_Alloc_type (ir_node *node, type *type) {
1523 assert (node->op == op_Alloc);
1524 node->attr.a.type = type;
1528 get_Alloc_where (ir_node *node) {
1529 assert (node->op == op_Alloc);
1530 return node->attr.a.where;
1534 set_Alloc_where (ir_node *node, where_alloc where) {
1535 assert (node->op == op_Alloc);
1536 node->attr.a.where = where;
1541 get_Free_mem (ir_node *node) {
1542 assert (node->op == op_Free);
1543 return get_irn_n(node, 0);
1547 set_Free_mem (ir_node *node, ir_node *mem) {
1548 assert (node->op == op_Free);
1549 set_irn_n(node, 0, mem);
1553 get_Free_ptr (ir_node *node) {
1554 assert (node->op == op_Free);
1555 return get_irn_n(node, 1);
1559 set_Free_ptr (ir_node *node, ir_node *ptr) {
1560 assert (node->op == op_Free);
1561 set_irn_n(node, 1, ptr);
1565 get_Free_size (ir_node *node) {
1566 assert (node->op == op_Free);
1567 return get_irn_n(node, 2);
1571 set_Free_size (ir_node *node, ir_node *size) {
1572 assert (node->op == op_Free);
1573 set_irn_n(node, 2, size);
1577 get_Free_type (ir_node *node) {
1578 assert (node->op == op_Free);
1579 return node->attr.f;
1583 set_Free_type (ir_node *node, type *type) {
1584 assert (node->op == op_Free);
1585 node->attr.f = type;
1589 get_Sync_preds_arr (ir_node *node) {
1590 assert (node->op == op_Sync);
1591 return (ir_node **)&(get_irn_in(node)[1]);
1595 get_Sync_n_preds (ir_node *node) {
1596 assert (node->op == op_Sync);
1597 return (get_irn_arity(node));
1602 set_Sync_n_preds (ir_node *node, int n_preds) {
1603 assert (node->op == op_Sync);
1608 get_Sync_pred (ir_node *node, int pos) {
1609 assert (node->op == op_Sync);
1610 return get_irn_n(node, pos);
1614 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1615 assert (node->op == op_Sync);
1616 set_irn_n(node, pos, pred);
1620 get_Proj_pred (ir_node *node) {
1621 assert (node->op == op_Proj);
1622 return get_irn_n(node, 0);
1626 set_Proj_pred (ir_node *node, ir_node *pred) {
1627 assert (node->op == op_Proj);
1628 set_irn_n(node, 0, pred);
1632 get_Proj_proj (ir_node *node) {
1633 assert (node->op == op_Proj);
1634 return node->attr.proj;
1638 set_Proj_proj (ir_node *node, long proj) {
1639 assert (node->op == op_Proj);
1640 node->attr.proj = proj;
1644 get_Tuple_preds_arr (ir_node *node) {
1645 assert (node->op == op_Tuple);
1646 return (ir_node **)&(get_irn_in(node)[1]);
1650 get_Tuple_n_preds (ir_node *node) {
1651 assert (node->op == op_Tuple);
1652 return (get_irn_arity(node));
1657 set_Tuple_n_preds (ir_node *node, int n_preds) {
1658 assert (node->op == op_Tuple);
1663 get_Tuple_pred (ir_node *node, int pos) {
1664 assert (node->op == op_Tuple);
1665 return get_irn_n(node, pos);
1669 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1670 assert (node->op == op_Tuple);
1671 set_irn_n(node, pos, pred);
1675 get_Id_pred (ir_node *node) {
1676 assert (node->op == op_Id);
1677 return get_irn_n(node, 0);
1681 set_Id_pred (ir_node *node, ir_node *pred) {
1682 assert (node->op == op_Id);
1683 set_irn_n(node, 0, pred);
1686 /******************************************************************/
1687 /* Auxiliary routines */
1688 /******************************************************************/
1691 skip_Proj (ir_node *node) {
1692 /* don't assert node !!! */
1693 if (node && (node->op == op_Proj)) {
1694 return get_Proj_pred(node);
1701 skip_nop (ir_node *node) {
1702 /* don't assert node !!! */
1704 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1705 return get_Id_pred(node);
1712 is_Bad (ir_node *node) {
1714 if ((node) && get_irn_opcode(node) == iro_Bad)
1720 is_no_Block (ir_node *node) {
1722 return (get_irn_opcode(node) != iro_Block);
1725 /* Returns true if the operation manipulates control flow. */
1727 is_cfop(ir_node *node) {
1728 return ( (get_irn_opcode(node) == iro_Start)
1729 || (get_irn_opcode(node) == iro_Jmp)
1730 || (get_irn_opcode(node) == iro_Cond)
1731 || (get_irn_opcode(node) == iro_Return)
1732 || (get_irn_opcode(node) == iro_Raise)
1733 || (get_irn_opcode(node) == iro_Bad));
1736 /* Returns true if the operation can change the control flow because
1739 is_fragile_op(ir_node *node) {
1740 return ( (get_irn_opcode(node) == iro_Call)
1741 || (get_irn_opcode(node) == iro_Quot)
1742 || (get_irn_opcode(node) == iro_DivMod)
1743 || (get_irn_opcode(node) == iro_Div)
1744 || (get_irn_opcode(node) == iro_Mod)
1745 || (get_irn_opcode(node) == iro_Load)
1746 || (get_irn_opcode(node) == iro_Store)
1747 || (get_irn_opcode(node) == iro_Alloc)
1748 || (get_irn_opcode(node) == iro_Bad));