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();
94 /* IR-Nodes with attributes */
96 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
99 ir_node *np = XP_GETARG (ir_node *, 0);
102 XPS ("<null ir_node>");
106 XPF1 ("%I", get_irn_opname(np));
108 switch (get_irn_opcode (np)) { /* node label */
110 XPF1 ("%I", get_irn_mode(np)->name);
112 XPF1 ("%v", get_irn_const_attr);
115 if (get_irn_modecode (np) == irm_b) {
117 XP (pnc_name_arr[get_irn_proj_attr(np)]);
118 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
120 XP (pns_name_arr[get_irn_proj_attr(np)]);
122 XPF1 ("%I", get_irn_mode(np)->name);
124 XPF1 ("%d", get_irn_proj_attr(np));
128 XPF1 ("%I", get_irn_mode(np)->name);
130 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
131 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
133 case iro_Start: /* don't dump mode of these */
142 XPF1 ("%I", get_irn_mode(np)->name);
149 /** getting some parameters from ir_nodes **/
151 /* returns the number of predecessors without the block predecessor. */
153 get_irn_arity (ir_node *node)
156 return (ARR_LEN((node)->in)-1);
159 /* Returns the array with ins. This array is shifted with respect to the
160 array accessed by get_irn_n: The block operand is at position 0 not -1.
161 (@@@ This should be changed.)
162 The order of the predecessors in this array is not guaranteed, except that
163 lists of operands as predecessors of Block or arguments of a Call are
166 get_irn_in (ir_node *node)
172 /* to iterate through the predecessors without touching the array */
173 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
174 to iterate includind the Block predecessor iterate from i = -1 to
176 If it is a block, the entry -1 is NULL. */
178 get_irn_n (ir_node *node, int n)
181 assert (get_irn_arity (node) > n);
182 return skip_nop(node->in[n+1]);
186 set_irn_n (ir_node *node, int n, ir_node *in)
189 assert (get_irn_arity (node) > n);
194 get_irn_mode (ir_node *node)
201 get_irn_modecode (ir_node *node)
204 return node->mode->code;
209 get_irn_modename (ir_node *node)
212 return node->mode->name;
216 get_irn_op (ir_node *node)
222 /* should be private to the library: */
224 set_irn_op (ir_node *node, ir_op *op)
231 get_irn_opcode (ir_node *node)
234 return node->op->code;
238 get_irn_opname (ir_node *node)
241 return node->op->name;
245 get_irn_visited (ir_node *node)
248 return node->visited;
252 set_irn_visited (ir_node *node, unsigned long visited)
255 node->visited = visited;
258 set_irn_link (ir_node *node, ir_node *link) {
264 get_irn_link (ir_node *node) {
270 /* Outputs a unique number for this node */
272 get_irn_node_nr(ir_node *node) {
274 return node->node_nr;
279 get_irn_const_attr (ir_node *node)
281 assert (node->op == op_Const);
282 return node->attr.con;
286 get_irn_proj_attr (ir_node *node)
288 assert (node->op == op_Proj);
289 return node->attr.proj;
293 get_irn_alloc_attr (ir_node *node)
295 assert (node->op == op_Alloc);
300 get_irn_free_attr (ir_node *node)
302 assert (node->op == op_Free);
307 get_irn_symconst_attr (ir_node *node)
309 assert (node->op == op_SymConst);
314 get_irn_call_attr (ir_node *node)
316 assert (node->op == op_Call);
317 return node->attr.call;
321 get_irn_sel_attr (ir_node *node)
323 assert (node->op == op_Sel);
328 get_irn_phi_attr (ir_node *node)
330 assert (node->op == op_Phi);
331 return node->attr.phi0_pos;
335 get_irn_block_attr (ir_node *node)
337 assert (node->op == op_Block);
338 return node->attr.block;
341 /** manipulate fields of individual nodes **/
343 /* this works for all except Block */
345 get_nodes_Block (ir_node *node) {
346 assert (!(node->op == op_Block));
347 return get_irn_n(node, -1);
351 set_nodes_Block (ir_node *node, ir_node *block) {
352 assert (!(node->op == op_Block));
353 set_irn_n(node, -1, block);
356 /* Returns an array with the predecessors of the Block. Depending on
357 the implementation of the graph datastructure this can be a copy of
358 the internal representation of predecessors as well as the internal
359 array itself. Therefore writing to this array might obstruct the ir. */
361 get_Block_cfgpred_arr (ir_node *node)
363 assert ((node->op == op_Block));
364 return (ir_node **)&(get_irn_in(node)[1]);
369 get_Block_n_cfgpreds (ir_node *node) {
370 assert ((node->op == op_Block));
371 return (get_irn_arity(node));
376 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
377 assert ((node->op == op_Block));
382 get_Block_cfgpred (ir_node *node, int pos) {
383 assert (node->op == op_Block);
384 return get_irn_n(node, pos);
388 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
389 assert (node->op == op_Block);
390 set_irn_n(node, pos, pred);
394 get_Block_matured (ir_node *node) {
395 assert (node->op == op_Block);
396 return node->attr.block.matured;
400 set_Block_matured (ir_node *node, bool matured) {
401 assert (node->op == op_Block);
402 node->attr.block.matured = matured;
405 get_Block_block_visited (ir_node *node) {
406 assert (node->op == op_Block);
407 return node->attr.block.block_visited;
411 set_Block_block_visited (ir_node *node, unsigned long visit) {
412 assert (node->op == op_Block);
413 node->attr.block.block_visited = visit;
417 get_Block_graph_arr (ir_node *node, int pos) {
418 assert (node->op == op_Block);
419 return node->attr.block.graph_arr[pos+1];
423 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
424 assert (node->op == op_Block);
425 node->attr.block.graph_arr[pos+1] = value;
429 get_Cond_selector (ir_node *node) {
430 assert (node->op == op_Cond);
431 return get_irn_n(node, 0);
435 set_Cond_selector (ir_node *node, ir_node *selector) {
436 assert (node->op == op_Cond);
437 set_irn_n(node, 0, selector);
441 get_Return_mem (ir_node *node) {
442 assert (node->op == op_Return);
443 return get_irn_n(node, 0);
447 set_Return_mem (ir_node *node, ir_node *mem) {
448 assert (node->op == op_Return);
449 set_irn_n(node, 0, mem);
453 get_Return_res_arr (ir_node *node)
455 assert ((node->op == op_Return));
456 if (get_Return_n_res(node) > 0)
457 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
463 get_Return_n_res (ir_node *node) {
464 assert (node->op == op_Return);
465 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
470 set_Return_n_res (ir_node *node, int results) {
471 assert (node->op == op_Return);
476 get_Return_res (ir_node *node, int pos) {
477 assert (node->op == op_Return);
478 assert (get_Return_n_res(node) > pos);
479 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
483 set_Return_res (ir_node *node, int pos, ir_node *res){
484 assert (node->op == op_Return);
485 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
489 get_Raise_mem (ir_node *node) {
490 assert (node->op == op_Return);
491 return get_irn_n(node, 0);
495 set_Raise_mem (ir_node *node, ir_node *mem) {
496 assert (node->op == op_Raise);
497 set_irn_n(node, 0, mem);
501 get_Raise_exo_ptr (ir_node *node) {
502 assert (node->op == op_Raise);
503 return get_irn_n(node, 1);
507 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
508 assert (node->op == op_Raise);
509 set_irn_n(node, 1, exo_ptr);
512 inline tarval *get_Const_tarval (ir_node *node) {
513 assert (node->op == op_Const);
514 return get_irn_const_attr(node);
518 set_Const_tarval (ir_node *node, tarval *con) {
519 assert (node->op == op_Const);
520 node->attr.con = con;
524 get_SymConst_kind (ir_node *node) {
525 assert (node->op == op_SymConst);
526 return node->attr.i.num;
530 set_SymConst_kind (ir_node *node, symconst_kind num) {
531 assert (node->op == op_SymConst);
532 node->attr.i.num = num;
536 get_SymConst_type (ir_node *node) {
537 assert ( (node->op == op_SymConst)
538 && ( get_SymConst_kind(node) == type_tag
539 || get_SymConst_kind(node) == size));
540 return node->attr.i.tori.typ;
544 set_SymConst_type (ir_node *node, type *type) {
545 assert ( (node->op == op_SymConst)
546 && ( get_SymConst_kind(node) == type_tag
547 || get_SymConst_kind(node) == size));
548 node->attr.i.tori.typ = type;
552 get_SymConst_ptrinfo (ir_node *node) {
553 assert ( (node->op == op_SymConst)
554 && (get_SymConst_kind(node) == linkage_ptr_info));
555 return node->attr.i.tori.ptrinfo;
561 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
562 assert ( (node->op == op_SymConst)
563 && (get_SymConst_kind(node) == linkage_ptr_info));
564 node->attr.i.tori.ptrinfo = ptrinfo;
568 get_Sel_mem (ir_node *node) {
569 assert (node->op == op_Sel);
570 return get_irn_n(node, 0);
574 set_Sel_mem (ir_node *node, ir_node *mem) {
575 assert (node->op == op_Sel);
576 set_irn_n(node, 0, mem);
580 get_Sel_ptr (ir_node *node) {
581 assert (node->op == op_Sel);
582 return get_irn_n(node, 1);
586 set_Sel_ptr (ir_node *node, ir_node *ptr) {
587 assert (node->op == op_Sel);
588 set_irn_n(node, 1, ptr);
592 get_Sel_index_arr (ir_node *node)
594 assert ((node->op == op_Sel));
595 if (get_Sel_n_index(node) > 0)
596 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
602 get_Sel_n_index (ir_node *node) {
603 assert (node->op == op_Sel);
604 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
609 set_Sel_n_index (ir_node *node, int n_index) {
610 assert (node->op == op_Sel);
615 get_Sel_index (ir_node *node, int pos) {
616 assert (node->op == op_Sel);
617 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
621 set_Sel_index (ir_node *node, int pos, ir_node *index) {
622 assert (node->op == op_Sel);
623 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
627 get_Sel_entity (ir_node *node) {
628 assert (node->op == op_Sel);
629 return node->attr.s.ent;
633 set_Sel_entity (ir_node *node, entity *ent) {
634 assert (node->op == op_Sel);
635 node->attr.s.ent = ent;
639 get_Sel_linkage_type (ir_node *node) {
640 assert (node->op == op_Sel);
641 return node->attr.s.ltyp;
645 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
646 assert (node->op == op_Sel);
647 node->attr.s.ltyp = lt;
651 get_Call_mem (ir_node *node) {
652 assert (node->op == op_Call);
653 return get_irn_n(node, 0);
657 set_Call_mem (ir_node *node, ir_node *mem) {
658 assert (node->op == op_Call);
659 set_irn_n(node, 0, mem);
663 get_Call_ptr (ir_node *node) {
664 assert (node->op == op_Call);
665 return get_irn_n(node, 1);
669 set_Call_ptr (ir_node *node, ir_node *ptr) {
670 assert (node->op == op_Call);
671 set_irn_n(node, 1, ptr);
675 get_Call_param_arr (ir_node *node) {
676 assert (node->op == op_Call);
677 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
681 get_Call_arity (ir_node *node) {
682 assert (node->op == op_Call);
683 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
687 set_Call_arity (ir_node *node, ir_node *arity) {
688 assert (node->op == op_Call);
693 get_Call_param (ir_node *node, int pos) {
694 assert (node->op == op_Call);
695 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
699 set_Call_param (ir_node *node, int pos, ir_node *param) {
700 assert (node->op == op_Call);
701 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
705 get_Call_type (ir_node *node) {
706 assert (node->op == op_Call);
707 return node->attr.call;
711 set_Call_type (ir_node *node, type_method *type) {
712 assert (node->op == op_Call);
713 node->attr.call = type;
716 /* For unary and binary arithmetic operations the access to the
717 operands can be factored out. Left is the first, right the
718 second arithmetic value as listed in tech report 0999-33.
719 unops are: Minus, Abs, Not, Conv
720 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
721 Shr, Shrs, Rotate, Cmp */
724 is_unop (ir_node *node) {
725 return ( node->op == op_Minus ||
726 node->op == op_Abs ||
727 node->op == op_Not ||
728 node->op == op_Conv );
732 get_unop_op (ir_node *node) {
733 assert ( node->op == op_Minus ||
734 node->op == op_Abs ||
735 node->op == op_Not ||
736 node->op == op_Conv );
737 switch (get_irn_opcode (node)) {
738 case iro_Minus: return get_Minus_op(node); break;
739 case iro_Abs: return get_Abs_op(node); break;
740 case iro_Not: return get_Not_op(node); break;
741 case iro_Conv: return get_Conv_op(node); break;
742 default: return NULL;
747 set_unop_op (ir_node *node, ir_node *op) {
748 assert (node->op == op_Minus ||
749 node->op == op_Abs ||
750 node->op == op_Not ||
751 node->op == op_Conv );
752 switch (get_irn_opcode (node)) {
753 case iro_Minus: set_Minus_op(node, op); break;
754 case iro_Abs: set_Abs_op(node, op); break;
755 case iro_Not: set_Not_op(node, op); break;
756 case iro_Conv: set_Conv_op(node, op); break;
763 is_binop (ir_node *node) {
764 return (node->op == op_Add ||
765 node->op == op_Sub ||
766 node->op == op_Mul ||
767 node->op == op_Quot ||
768 node->op == op_DivMod ||
769 node->op == op_Div ||
770 node->op == op_Mod ||
771 node->op == op_And ||
773 node->op == op_Eor ||
774 node->op == op_Shl ||
775 node->op == op_Shr ||
776 node->op == op_Shrs ||
777 node->op == op_Rot ||
778 node->op == op_Cmp );
782 get_binop_left (ir_node *node) {
783 assert (node->op == op_Add ||
784 node->op == op_Sub ||
785 node->op == op_Mul ||
786 node->op == op_Quot ||
787 node->op == op_DivMod ||
788 node->op == op_Div ||
789 node->op == op_Mod ||
790 node->op == op_And ||
792 node->op == op_Eor ||
793 node->op == op_Shl ||
794 node->op == op_Shr ||
795 node->op == op_Shrs ||
796 node->op == op_Rot ||
797 node->op == op_Cmp );
799 switch (get_irn_opcode (node)) {
800 case iro_Add : return get_Add_left(node); break;
801 case iro_Sub : return get_Sub_left(node); break;
802 case iro_Mul : return get_Mul_left(node); break;
803 case iro_Quot : return get_Quot_left(node); break;
804 case iro_DivMod: return get_DivMod_left(node); break;
805 case iro_Div : return get_Div_left(node); break;
806 case iro_Mod : return get_Mod_left(node); break;
807 case iro_And : return get_And_left(node); break;
808 case iro_Or : return get_Or_left(node); break;
809 case iro_Eor : return get_Eor_left(node); break;
810 case iro_Shl : return get_Shl_left(node); break;
811 case iro_Shr : return get_Shr_left(node); break;
812 case iro_Shrs : return get_Shrs_left(node); break;
813 case iro_Rot : return get_Rot_left(node); break;
814 case iro_Cmp : return get_Cmp_left(node); break;
815 default: return NULL;
820 set_binop_left (ir_node *node, ir_node *left) {
821 assert (node->op == op_Add ||
822 node->op == op_Sub ||
823 node->op == op_Mul ||
824 node->op == op_Quot ||
825 node->op == op_DivMod ||
826 node->op == op_Div ||
827 node->op == op_Mod ||
828 node->op == op_And ||
830 node->op == op_Eor ||
831 node->op == op_Shl ||
832 node->op == op_Shr ||
833 node->op == op_Shrs ||
834 node->op == op_Rot ||
835 node->op == op_Cmp );
837 switch (get_irn_opcode (node)) {
838 case iro_Add : set_Add_left(node, left); break;
839 case iro_Sub : set_Sub_left(node, left); break;
840 case iro_Mul : set_Mul_left(node, left); break;
841 case iro_Quot : set_Quot_left(node, left); break;
842 case iro_DivMod: set_DivMod_left(node, left); break;
843 case iro_Div : set_Div_left(node, left); break;
844 case iro_Mod : set_Mod_left(node, left); break;
845 case iro_And : set_And_left(node, left); break;
846 case iro_Or : set_Or_left(node, left); break;
847 case iro_Eor : set_Eor_left(node, left); break;
848 case iro_Shl : set_Shl_left(node, left); break;
849 case iro_Shr : set_Shr_left(node, left); break;
850 case iro_Shrs : set_Shrs_left(node, left); break;
851 case iro_Rot : set_Rot_left(node, left); break;
852 case iro_Cmp : set_Cmp_left(node, left); break;
858 get_binop_right (ir_node *node) {
859 assert (node->op == op_Add ||
860 node->op == op_Sub ||
861 node->op == op_Mul ||
862 node->op == op_Quot ||
863 node->op == op_DivMod ||
864 node->op == op_Div ||
865 node->op == op_Mod ||
866 node->op == op_And ||
868 node->op == op_Eor ||
869 node->op == op_Shl ||
870 node->op == op_Shr ||
871 node->op == op_Shrs ||
872 node->op == op_Rot ||
873 node->op == op_Cmp );
875 switch (get_irn_opcode (node)) {
876 case iro_Add : return get_Add_right(node); break;
877 case iro_Sub : return get_Sub_right(node); break;
878 case iro_Mul : return get_Mul_right(node); break;
879 case iro_Quot : return get_Quot_right(node); break;
880 case iro_DivMod: return get_DivMod_right(node); break;
881 case iro_Div : return get_Div_right(node); break;
882 case iro_Mod : return get_Mod_right(node); break;
883 case iro_And : return get_And_right(node); break;
884 case iro_Or : return get_Or_right(node); break;
885 case iro_Eor : return get_Eor_right(node); break;
886 case iro_Shl : return get_Shl_right(node); break;
887 case iro_Shr : return get_Shr_right(node); break;
888 case iro_Shrs : return get_Shrs_right(node); break;
889 case iro_Rot : return get_Rot_right(node); break;
890 case iro_Cmp : return get_Cmp_right(node); break;
891 default: return NULL;
896 set_binop_right (ir_node *node, ir_node *right) {
897 assert (node->op == op_Add ||
898 node->op == op_Sub ||
899 node->op == op_Mul ||
900 node->op == op_Quot ||
901 node->op == op_DivMod ||
902 node->op == op_Div ||
903 node->op == op_Mod ||
904 node->op == op_And ||
906 node->op == op_Eor ||
907 node->op == op_Shl ||
908 node->op == op_Shr ||
909 node->op == op_Shrs ||
910 node->op == op_Rot ||
911 node->op == op_Cmp );
913 switch (get_irn_opcode (node)) {
914 case iro_Add : set_Add_right(node, right); break;
915 case iro_Sub : set_Sub_right(node, right); break;
916 case iro_Mul : set_Mul_right(node, right); break;
917 case iro_Quot : set_Quot_right(node, right); break;
918 case iro_DivMod: set_DivMod_right(node, right); break;
919 case iro_Div : set_Div_right(node, right); break;
920 case iro_Mod : set_Mod_right(node, right); break;
921 case iro_And : set_And_right(node, right); break;
922 case iro_Or : set_Or_right(node, right); break;
923 case iro_Eor : set_Eor_right(node, right); break;
924 case iro_Shl : set_Shl_right(node, right); break;
925 case iro_Shr : set_Shr_right(node, right); break;
926 case iro_Shrs : set_Shrs_right(node, right); break;
927 case iro_Rot : set_Rot_right(node, right); break;
928 case iro_Cmp : set_Cmp_right(node, right); break;
934 get_Add_left (ir_node *node) {
935 assert (node->op == op_Add);
936 return get_irn_n(node, 0);
940 set_Add_left (ir_node *node, ir_node *left) {
941 assert (node->op == op_Add);
942 set_irn_n(node, 0, left);
946 get_Add_right (ir_node *node) {
947 assert (node->op == op_Add);
948 return get_irn_n(node, 1);
952 set_Add_right (ir_node *node, ir_node *right) {
953 assert (node->op == op_Add);
954 set_irn_n(node, 1, right);
958 get_Sub_left (ir_node *node) {
959 assert (node->op == op_Sub);
960 return get_irn_n(node, 0);
964 set_Sub_left (ir_node *node, ir_node *left) {
965 assert (node->op == op_Sub);
966 set_irn_n(node, 0, left);
970 get_Sub_right (ir_node *node) {
971 assert (node->op == op_Sub);
972 return get_irn_n(node, 1);
976 set_Sub_right (ir_node *node, ir_node *right) {
977 assert (node->op == op_Sub);
978 set_irn_n(node, 1, right);
983 get_Minus_op (ir_node *node) {
984 assert (node->op == op_Minus);
985 return get_irn_n(node, 0);
989 set_Minus_op (ir_node *node, ir_node *op) {
990 assert (node->op == op_Minus);
991 set_irn_n(node, 0, op);
996 get_Mul_left (ir_node *node) {
997 assert (node->op == op_Mul);
998 return get_irn_n(node, 0);
1002 set_Mul_left (ir_node *node, ir_node *left) {
1003 assert (node->op == op_Mul);
1004 set_irn_n(node, 0, left);
1008 get_Mul_right (ir_node *node) {
1009 assert (node->op == op_Mul);
1010 return get_irn_n(node, 1);
1014 set_Mul_right (ir_node *node, ir_node *right) {
1015 assert (node->op == op_Mul);
1016 set_irn_n(node, 1, right);
1020 get_Quot_left (ir_node *node) {
1021 assert (node->op == op_Quot);
1022 return get_irn_n(node, 1);
1026 set_Quot_left (ir_node *node, ir_node *left) {
1027 assert (node->op == op_Quot);
1028 set_irn_n(node, 1, left);
1032 get_Quot_right (ir_node *node) {
1033 assert (node->op == op_Quot);
1034 return get_irn_n(node, 2);
1038 set_Quot_right (ir_node *node, ir_node *right) {
1039 assert (node->op == op_Quot);
1040 set_irn_n(node, 2, right);
1044 get_Quot_mem (ir_node *node) {
1045 assert (node->op == op_Quot);
1046 return get_irn_n(node, 0);
1050 set_Quot_mem (ir_node *node, ir_node *mem) {
1051 assert (node->op == op_Quot);
1052 set_irn_n(node, 0, mem);
1056 get_DivMod_left (ir_node *node) {
1057 assert (node->op == op_DivMod);
1058 return get_irn_n(node, 1);
1062 set_DivMod_left (ir_node *node, ir_node *left) {
1063 assert (node->op == op_DivMod);
1064 set_irn_n(node, 1, left);
1068 get_DivMod_right (ir_node *node) {
1069 assert (node->op == op_DivMod);
1070 return get_irn_n(node, 2);
1074 set_DivMod_right (ir_node *node, ir_node *right) {
1075 assert (node->op == op_DivMod);
1076 set_irn_n(node, 2, right);
1080 get_DivMod_mem (ir_node *node) {
1081 assert (node->op == op_DivMod);
1082 return get_irn_n(node, 0);
1086 set_DivMod_mem (ir_node *node, ir_node *mem) {
1087 assert (node->op == op_DivMod);
1088 set_irn_n(node, 0, mem);
1092 get_Div_left (ir_node *node) {
1093 assert (node->op == op_Div);
1094 return get_irn_n(node, 1);
1098 set_Div_left (ir_node *node, ir_node *left) {
1099 assert (node->op == op_Div);
1100 set_irn_n(node, 1, left);
1104 get_Div_right (ir_node *node) {
1105 assert (node->op == op_Div);
1106 return get_irn_n(node, 2);
1110 set_Div_right (ir_node *node, ir_node *right) {
1111 assert (node->op == op_Div);
1112 set_irn_n(node, 2, right);
1116 get_Div_mem (ir_node *node) {
1117 assert (node->op == op_Div);
1118 return get_irn_n(node, 0);
1122 set_Div_mem (ir_node *node, ir_node *mem) {
1123 assert (node->op == op_Div);
1124 set_irn_n(node, 0, mem);
1128 get_Mod_left (ir_node *node) {
1129 assert (node->op == op_Mod);
1130 return get_irn_n(node, 1);
1134 set_Mod_left (ir_node *node, ir_node *left) {
1135 assert (node->op == op_Mod);
1136 set_irn_n(node, 1, left);
1140 get_Mod_right (ir_node *node) {
1141 assert (node->op == op_Mod);
1142 return get_irn_n(node, 2);
1146 set_Mod_right (ir_node *node, ir_node *right) {
1147 assert (node->op == op_Mod);
1148 set_irn_n(node, 2, right);
1152 get_Mod_mem (ir_node *node) {
1153 assert (node->op == op_Mod);
1154 return get_irn_n(node, 0);
1158 set_Mod_mem (ir_node *node, ir_node *mem) {
1159 assert (node->op == op_Mod);
1160 set_irn_n(node, 0, mem);
1164 get_Abs_op (ir_node *node) {
1165 assert (node->op == op_Abs);
1166 return get_irn_n(node, 0);
1170 set_Abs_op (ir_node *node, ir_node *op) {
1171 assert (node->op == op_Abs);
1172 set_irn_n(node, 0, op);
1176 get_And_left (ir_node *node) {
1177 assert (node->op == op_And);
1178 return get_irn_n(node, 0);
1182 set_And_left (ir_node *node, ir_node *left) {
1183 assert (node->op == op_And);
1184 set_irn_n(node, 0, left);
1188 get_And_right (ir_node *node) {
1189 assert (node->op == op_And);
1190 return get_irn_n(node, 1);
1194 set_And_right (ir_node *node, ir_node *right) {
1195 assert (node->op == op_And);
1196 set_irn_n(node, 1, right);
1200 get_Or_left (ir_node *node) {
1201 assert (node->op == op_Or);
1202 return get_irn_n(node, 0);
1206 set_Or_left (ir_node *node, ir_node *left) {
1207 assert (node->op == op_Or);
1208 set_irn_n(node, 0, left);
1212 get_Or_right (ir_node *node) {
1213 assert (node->op == op_Or);
1214 return get_irn_n(node, 1);
1218 set_Or_right (ir_node *node, ir_node *right) {
1219 assert (node->op == op_Or);
1220 set_irn_n(node, 1, right);
1224 get_Eor_left (ir_node *node) {
1225 assert (node->op == op_Eor);
1226 return get_irn_n(node, 0);
1230 set_Eor_left (ir_node *node, ir_node *left) {
1231 assert (node->op == op_Eor);
1232 set_irn_n(node, 0, left);
1236 get_Eor_right (ir_node *node) {
1237 assert (node->op == op_Eor);
1238 return get_irn_n(node, 1);
1242 set_Eor_right (ir_node *node, ir_node *right) {
1243 assert (node->op == op_Eor);
1244 set_irn_n(node, 1, right);
1249 get_Not_op (ir_node *node) {
1250 assert (node->op == op_Not);
1251 return get_irn_n(node, 0);
1255 set_Not_op (ir_node *node, ir_node *op) {
1256 assert (node->op == op_Not);
1257 set_irn_n(node, 0, op);
1262 get_Shl_left (ir_node *node) {
1263 assert (node->op == op_Shl);
1264 return get_irn_n(node, 0);
1268 set_Shl_left (ir_node *node, ir_node *left) {
1269 assert (node->op == op_Shl);
1270 set_irn_n(node, 0, left);
1274 get_Shl_right (ir_node *node) {
1275 assert (node->op == op_Shl);
1276 return get_irn_n(node, 1);
1280 set_Shl_right (ir_node *node, ir_node *right) {
1281 assert (node->op == op_Shl);
1282 set_irn_n(node, 1, right);
1286 get_Shr_left (ir_node *node) {
1287 assert (node->op == op_Shr);
1288 return get_irn_n(node, 0);
1292 set_Shr_left (ir_node *node, ir_node *left) {
1293 assert (node->op == op_Shr);
1294 set_irn_n(node, 0, left);
1298 get_Shr_right (ir_node *node) {
1299 assert (node->op == op_Shr);
1300 return get_irn_n(node, 1);
1304 set_Shr_right (ir_node *node, ir_node *right) {
1305 assert (node->op == op_Shr);
1306 set_irn_n(node, 1, right);
1310 get_Shrs_left (ir_node *node) {
1311 assert (node->op == op_Shrs);
1312 return get_irn_n(node, 0);
1316 set_Shrs_left (ir_node *node, ir_node *left) {
1317 assert (node->op == op_Shrs);
1318 set_irn_n(node, 0, left);
1322 get_Shrs_right (ir_node *node) {
1323 assert (node->op == op_Shrs);
1324 return get_irn_n(node, 1);
1328 set_Shrs_right (ir_node *node, ir_node *right) {
1329 assert (node->op == op_Shrs);
1330 set_irn_n(node, 1, right);
1334 get_Rot_left (ir_node *node) {
1335 assert (node->op == op_Rot);
1336 return get_irn_n(node, 0);
1340 set_Rot_left (ir_node *node, ir_node *left) {
1341 assert (node->op == op_Rot);
1342 set_irn_n(node, 0, left);
1346 get_Rot_right (ir_node *node) {
1347 assert (node->op == op_Rot);
1348 return get_irn_n(node, 1);
1352 set_Rot_right (ir_node *node, ir_node *right) {
1353 assert (node->op == op_Rot);
1354 set_irn_n(node, 1, right);
1358 get_Cmp_left (ir_node *node) {
1359 assert (node->op == op_Cmp);
1360 return get_irn_n(node, 0);
1364 set_Cmp_left (ir_node *node, ir_node *left) {
1365 assert (node->op == op_Cmp);
1366 set_irn_n(node, 0, left);
1370 get_Cmp_right (ir_node *node) {
1371 assert (node->op == op_Cmp);
1372 return get_irn_n(node, 1);
1376 set_Cmp_right (ir_node *node, ir_node *right) {
1377 assert (node->op == op_Cmp);
1378 set_irn_n(node, 1, right);
1382 get_Conv_op (ir_node *node) {
1383 assert (node->op == op_Conv);
1384 return get_irn_n(node, 0);
1388 set_Conv_op (ir_node *node, ir_node *op) {
1389 assert (node->op == op_Conv);
1390 set_irn_n(node, 0, op);
1394 get_Phi_preds_arr (ir_node *node) {
1395 assert (node->op == op_Phi);
1396 return (ir_node **)&(get_irn_in(node)[1]);
1400 get_Phi_n_preds (ir_node *node) {
1401 assert (node->op == op_Phi);
1402 return (get_irn_arity(node));
1406 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1407 assert (node->op == op_Phi);
1412 get_Phi_pred (ir_node *node, int pos) {
1413 assert (node->op == op_Phi);
1414 return get_irn_n(node, pos);
1418 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1419 assert (node->op == op_Phi);
1420 set_irn_n(node, pos, pred);
1424 get_Load_mem (ir_node *node) {
1425 assert (node->op == op_Load);
1426 return get_irn_n(node, 0);
1430 set_Load_mem (ir_node *node, ir_node *mem) {
1431 assert (node->op == op_Load);
1432 set_irn_n(node, 0, mem);
1436 get_Load_ptr (ir_node *node) {
1437 assert (node->op == op_Load);
1438 return get_irn_n(node, 1);
1442 set_Load_ptr (ir_node *node, ir_node *ptr) {
1443 assert (node->op == op_Load);
1444 set_irn_n(node, 1, ptr);
1449 get_Store_mem (ir_node *node) {
1450 assert (node->op == op_Store);
1451 return get_irn_n(node, 0);
1455 set_Store_mem (ir_node *node, ir_node *mem) {
1456 assert (node->op == op_Store);
1457 set_irn_n(node, 0, mem);
1461 get_Store_ptr (ir_node *node) {
1462 assert (node->op == op_Store);
1463 return get_irn_n(node, 1);
1467 set_Store_ptr (ir_node *node, ir_node *ptr) {
1468 assert (node->op == op_Store);
1469 set_irn_n(node, 1, ptr);
1473 get_Store_value (ir_node *node) {
1474 assert (node->op == op_Store);
1475 return get_irn_n(node, 2);
1479 set_Store_value (ir_node *node, ir_node *value) {
1480 assert (node->op == op_Store);
1481 set_irn_n(node, 2, value);
1485 get_Alloc_mem (ir_node *node) {
1486 assert (node->op == op_Alloc);
1487 return get_irn_n(node, 0);
1491 set_Alloc_mem (ir_node *node, ir_node *mem) {
1492 assert (node->op == op_Alloc);
1493 set_irn_n(node, 0, mem);
1497 get_Alloc_size (ir_node *node) {
1498 assert (node->op == op_Alloc);
1499 return get_irn_n(node, 1);
1503 set_Allco_size (ir_node *node, ir_node *size) {
1504 assert (node->op == op_Alloc);
1505 set_irn_n(node, 1, size);
1509 get_Alloc_type (ir_node *node) {
1510 assert (node->op == op_Alloc);
1511 return node->attr.a.type;
1515 set_Alloc_type (ir_node *node, type *type) {
1516 assert (node->op == op_Alloc);
1517 node->attr.a.type = type;
1521 get_Alloc_where (ir_node *node) {
1522 assert (node->op == op_Alloc);
1523 return node->attr.a.where;
1527 set_Alloc_where (ir_node *node, where_alloc where) {
1528 assert (node->op == op_Alloc);
1529 node->attr.a.where = where;
1534 get_Free_mem (ir_node *node) {
1535 assert (node->op == op_Free);
1536 return get_irn_n(node, 0);
1540 set_Free_mem (ir_node *node, ir_node *mem) {
1541 assert (node->op == op_Free);
1542 set_irn_n(node, 0, mem);
1546 get_Free_ptr (ir_node *node) {
1547 assert (node->op == op_Free);
1548 return get_irn_n(node, 1);
1552 set_Free_ptr (ir_node *node, ir_node *ptr) {
1553 assert (node->op == op_Free);
1554 set_irn_n(node, 1, ptr);
1558 get_Free_size (ir_node *node) {
1559 assert (node->op == op_Free);
1560 return get_irn_n(node, 2);
1564 set_Free_size (ir_node *node, ir_node *size) {
1565 assert (node->op == op_Free);
1566 set_irn_n(node, 2, size);
1570 get_Free_type (ir_node *node) {
1571 assert (node->op == op_Free);
1572 return node->attr.f;
1576 set_Free_type (ir_node *node, type *type) {
1577 assert (node->op == op_Free);
1578 node->attr.f = type;
1582 get_Sync_preds_arr (ir_node *node) {
1583 assert (node->op == op_Sync);
1584 return (ir_node **)&(get_irn_in(node)[1]);
1588 get_Sync_n_preds (ir_node *node) {
1589 assert (node->op == op_Sync);
1590 return (get_irn_arity(node));
1595 set_Sync_n_preds (ir_node *node, int n_preds) {
1596 assert (node->op == op_Sync);
1601 get_Sync_pred (ir_node *node, int pos) {
1602 assert (node->op == op_Sync);
1603 return get_irn_n(node, pos);
1607 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1608 assert (node->op == op_Sync);
1609 set_irn_n(node, pos, pred);
1613 get_Proj_pred (ir_node *node) {
1614 assert (node->op == op_Proj);
1615 return get_irn_n(node, 0);
1619 set_Proj_pred (ir_node *node, ir_node *pred) {
1620 assert (node->op == op_Proj);
1621 set_irn_n(node, 0, pred);
1625 get_Proj_proj (ir_node *node) {
1626 assert (node->op == op_Proj);
1627 return node->attr.proj;
1631 set_Proj_proj (ir_node *node, long proj) {
1632 assert (node->op == op_Proj);
1633 node->attr.proj = proj;
1637 get_Tuple_preds_arr (ir_node *node) {
1638 assert (node->op == op_Tuple);
1639 return (ir_node **)&(get_irn_in(node)[1]);
1643 get_Tuple_n_preds (ir_node *node) {
1644 assert (node->op == op_Tuple);
1645 return (get_irn_arity(node));
1650 set_Tuple_n_preds (ir_node *node, int n_preds) {
1651 assert (node->op == op_Tuple);
1656 get_Tuple_pred (ir_node *node, int pos) {
1657 assert (node->op == op_Tuple);
1658 return get_irn_n(node, pos);
1662 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1663 assert (node->op == op_Tuple);
1664 set_irn_n(node, pos, pred);
1668 get_Id_pred (ir_node *node) {
1669 assert (node->op == op_Id);
1670 return get_irn_n(node, 0);
1674 set_Id_pred (ir_node *node, ir_node *pred) {
1675 assert (node->op == op_Id);
1676 set_irn_n(node, 0, pred);
1679 /******************************************************************/
1680 /* Auxiliary routines */
1681 /******************************************************************/
1684 skip_Proj (ir_node *node) {
1685 /* don't assert node !!! */
1686 if (node && (node->op == op_Proj)) {
1687 return get_Proj_pred(node);
1694 skip_nop (ir_node *node) {
1695 /* don't assert node !!! */
1697 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1698 return get_Id_pred(node);
1705 is_Bad (ir_node *node) {
1707 if ((node) && get_irn_opcode(node) == iro_Bad)
1713 is_no_Block (ir_node *node) {
1715 return (get_irn_opcode(node) != iro_Block);
1718 /* Returns true if the operation manipulates control flow. */
1720 is_cfop(ir_node *node) {
1721 return ( (get_irn_opcode(node) == iro_Start)
1722 || (get_irn_opcode(node) == iro_Jmp)
1723 || (get_irn_opcode(node) == iro_Cond)
1724 || (get_irn_opcode(node) == iro_Return)
1725 || (get_irn_opcode(node) == iro_Raise)
1726 || (get_irn_opcode(node) == iro_Bad));
1729 /* Returns true if the operation can change the control flow because
1732 is_fragile_op(ir_node *node) {
1733 return ( (get_irn_opcode(node) == iro_Call)
1734 || (get_irn_opcode(node) == iro_Quot)
1735 || (get_irn_opcode(node) == iro_DivMod)
1736 || (get_irn_opcode(node) == iro_Div)
1737 || (get_irn_opcode(node) == iro_Mod)
1738 || (get_irn_opcode(node) == iro_Load)
1739 || (get_irn_opcode(node) == iro_Store)
1740 || (get_irn_opcode(node) == iro_Alloc)
1741 || (get_irn_opcode(node) == iro_Bad));