1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
11 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
12 "Gt", "Ge", "Lg", "Leg", "Uo",
13 "Ue", "Ul", "Ule", "Ug", "Uge",
16 inline char *get_pnc_string(int pnc) {
17 return pnc_name_arr[pnc];
22 get_negated_pnc(int pnc) {
24 case False: return True; break;
25 case Eq: return Ne; break;
26 case Lt: return Uge; break;
27 case Le: return Ug; break;
28 case Gt: return Ule; break;
29 case Ge: return Ul; break;
30 case Lg: return Ue; break;
31 case Leg: return Uo; break;
32 case Uo: return Leg; break;
33 case Ue: return Lg; break;
34 case Ul: return Ge; break;
35 case Ule: return Gt; break;
36 case Ug: return Le; break;
37 case Uge: return Lt; break;
38 case Ne: return Eq; break;
39 case True: return False; break;
41 return 99; /* to shut up gcc */
44 static char *pns_name_arr [] = {"initial_exec", "global_store",
45 "frame_base", "globals", "args"};
47 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
56 #if 0 /* I didn't manage to place this here as it causes cyclic inclusion
57 of header files/a cyclic dependency between ir_graph and ir_node. */
58 /* irnode constructor */
59 /* create a new irnode in irg, with an op, mode, arity and */
60 /* some incoming irnodes */
61 /* this constructor is used in every specified irnode constructor */
63 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
64 int arity, ir_node **in)
67 int node_size = offsetof (ir_node, attr) + op->attr_size;
69 res = (ir_node *) obstack_alloc (irg->obst, node_size);
71 res->kind = k_ir_node;
77 res->in = NEW_ARR_F (ir_node *, 1);
79 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
80 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
88 /* IR-Nodes with attributes */
90 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
93 ir_node *np = XP_GETARG (ir_node *, 0);
96 XPS ("<null ir_node>");
100 XPF1 ("%I", get_irn_op(np)->name);
102 switch (get_irn_opcode (np)) { /* node label */
104 XPF1 ("%I", get_irn_mode(np)->name);
106 XPF1 ("%v", get_irn_const_attr);
109 if (get_irn_modecode (np) == irm_b) {
111 XP (pnc_name_arr[get_irn_proj_attr(np)]);
112 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
114 XP (pns_name_arr[get_irn_proj_attr(np)]);
116 XPF1 ("%I", get_irn_mode(np)->name);
118 XPF1 ("%d", get_irn_proj_attr(np));
122 XPF1 ("%I", get_irn_mode(np)->name);
124 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
125 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
127 case iro_Start: /* don't dump mode of these */
136 XPF1 ("%I", get_irn_mode(np)->name);
143 /** getting some parameters from ir_nodes **/
145 /* returns the number of predecessors without the block predecessor. */
147 get_irn_arity (ir_node *node)
149 // printf("called for node %s\n", ID_TO_STR(node->op->name));
150 // if (get_irn_opcode(node) == iro_Block) return (ARR_LEN((node)->in));
151 return (ARR_LEN((node)->in)-1);
154 /* returns the array with ins */
156 get_irn_in (ir_node *node)
162 /* to iterate through the predecessors without touching the array */
163 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
164 to iterate includind the Block predecessor iterate from i = -1 to
166 Don't know how to iterate if it is a block ?? */
168 get_irn_n (ir_node *node, int n)
171 // assert (get_irn_arity (node) > n);
172 return skip_nop(node->in[n+1]);
176 set_irn_n (ir_node *node, int n, ir_node *in)
179 assert (get_irn_arity (node) > n);
184 get_irn_mode (ir_node *node)
191 get_irn_modecode (ir_node *node)
194 return node->mode->code;
198 get_irn_op (ir_node *node)
204 /* should be private to the library: */
206 set_irn_op (ir_node *node, ir_op *op)
213 get_irn_opcode (ir_node *node)
216 return node->op->code;
220 set_irn_link (ir_node *node, ir_node *link) {
226 get_irn_link (ir_node *node) {
232 get_irn_const_attr (ir_node *node)
234 assert (node->op == op_Const);
235 return node->attr.con;
239 get_irn_proj_attr (ir_node *node)
241 assert (node->op == op_Proj);
242 return node->attr.proj;
246 get_irn_alloc_attr (ir_node *node)
248 assert (node->op == op_Alloc);
253 get_irn_free_attr (ir_node *node)
255 assert (node->op == op_Free);
260 get_irn_symconst_attr (ir_node *node)
262 assert (node->op == op_SymConst);
267 get_irn_call_attr (ir_node *node)
269 assert (node->op == op_Call);
270 return node->attr.call;
274 get_irn_sel_attr (ir_node *node)
276 assert (node->op == op_Sel);
281 get_irn_phi_attr (ir_node *node)
283 assert (node->op == op_Phi);
284 return node->attr.phi0_pos;
288 get_irn_block_attr (ir_node *node)
290 assert (node->op == op_Block);
291 return node->attr.block;
294 /** manipulate fields of individual nodes **/
296 /* this works for all except Block */
298 get_nodes_Block (ir_node *node) {
299 assert (!(node->op == op_Block));
300 return get_irn_n(node, -1);
304 set_nodes_Block (ir_node *node, ir_node *block) {
305 assert (!(node->op == op_Block));
306 set_irn_n(node, -1, block);
310 get_Block_n_cfgpreds (ir_node *node) {
311 assert ((node->op == op_Block));
312 return (get_irn_arity(node));
317 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
318 assert ((node->op == op_Block));
323 get_Block_cfgpred (ir_node *node, int pos) {
324 assert (node->op == op_Block);
325 return get_irn_n(node, pos);
329 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
330 assert (node->op == op_Block);
331 set_irn_n(node, pos, pred);
335 get_Block_matured (ir_node *node) {
336 assert (node->op == op_Block);
337 return node->attr.block.matured;
341 set_Block_matured (ir_node *node, bool matured) {
342 assert (node->op == op_Block);
343 node->attr.block.matured = matured;
346 get_Block_block_visit (ir_node *node) {
347 assert (node->op == op_Block);
348 return node->attr.block.block_visit;
352 set_Block_block_visit (ir_node *node, unsigned long visit) {
353 assert (node->op == op_Block);
354 node->attr.block.block_visit = visit;
358 get_Block_graph_arr (ir_node *node, int pos) {
359 assert (node->op == op_Block);
360 return node->attr.block.graph_arr[pos+1];
364 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
365 assert (node->op == op_Block);
366 node->attr.block.graph_arr[pos+1] = value;
370 get_Cond_selector (ir_node *node) {
371 assert (node->op == op_Cond);
372 return get_irn_n(node, 0);
376 set_Cond_selector (ir_node *node, ir_node *selector) {
377 assert (node->op == op_Cond);
378 set_irn_n(node, 0, selector);
382 get_Return_mem (ir_node *node) {
383 assert (node->op == op_Cond);
384 return get_irn_n(node, 0);
388 set_Return_mem (ir_node *node, ir_node *mem) {
389 assert (node->op == op_Return);
390 set_irn_n(node, 0, mem);
394 get_Return_n_res (ir_node *node) {
395 assert (node->op == op_Return);
396 return (get_irn_arity(node) - 1);
401 set_Return_n_res (ir_node *node, int results) {
402 assert (node->op == op_Return);
407 get_Return_res (ir_node *node, int pos) {
408 assert (node->op == op_Return);
409 return get_irn_n(node, pos+1);
413 set_Return_res (ir_node *node, int pos, ir_node *res){
414 assert (node->op == op_Raise);
415 set_irn_n(node, pos+1, res);
419 get_Raise_mem (ir_node *node) {
420 assert (node->op == op_Return);
421 return get_irn_n(node, 0);
425 set_Raise_mem (ir_node *node, ir_node *mem) {
426 assert (node->op == op_Raise);
427 set_irn_n(node, 0, mem);
431 get_Raise_exo_ptr (ir_node *node) {
432 assert (node->op == op_Raise);
433 return get_irn_n(node, 1);
437 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
438 assert (node->op == op_Raise);
439 set_irn_n(node, 1, exo_ptr);
442 inline tarval *get_Const_tarval (ir_node *node) {
443 assert (node->op == op_Const);
444 return get_irn_const_attr(node);
448 set_Const_tarval (ir_node *node, tarval *con) {
449 assert (node->op == op_Const);
450 node->attr.con = con;
454 get_SymConst_kind (ir_node *node) {
455 assert (node->op == op_SymConst);
456 return node->attr.i.num;
460 set_SymConst_kind (ir_node *node, symconst_kind num) {
461 assert (node->op == op_SymConst);
462 node->attr.i.num = num;
466 get_SymConst_type (ir_node *node) {
467 assert ( (node->op == op_SymConst)
468 && ( get_SymConst_kind(node) == type_tag
469 || get_SymConst_kind(node) == size));
470 return node->attr.i.tori.typ;
474 set_SymConst_type (ir_node *node, type *type) {
475 assert ( (node->op == op_SymConst)
476 && ( get_SymConst_kind(node) == type_tag
477 || get_SymConst_kind(node) == size));
478 node->attr.i.tori.typ = type;
482 get_SymConst_ptrinfo (ir_node *node) {
483 assert ( (node->op == op_SymConst)
484 && (get_SymConst_kind(node) == linkage_ptr_info));
485 return node->attr.i.tori.ptrinfo;
491 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
492 assert ( (node->op == op_SymConst)
493 && (get_SymConst_kind(node) == linkage_ptr_info));
494 node->attr.i.tori.ptrinfo = ptrinfo;
498 get_Sel_mem (ir_node *node) {
499 assert (node->op == op_Sel);
500 return get_irn_n(node, 0);
504 set_Sel_mem (ir_node *node, ir_node *mem) {
505 assert (node->op == op_Sel);
506 set_irn_n(node, 0, mem);
510 get_Sel_ptr (ir_node *node) {
511 assert (node->op == op_Sel);
512 return get_irn_n(node, 1);
516 set_Sel_ptr (ir_node *node, ir_node *ptr) {
517 assert (node->op == op_Sel);
518 set_irn_n(node, 1, ptr);
522 get_Sel_n_index (ir_node *node) {
523 assert (node->op == op_Sel);
524 return (get_irn_arity(node) - 2);
529 set_Sel_n_index (ir_node *node, int n_index) {
530 assert (node->op == op_Sel);
535 get_Sel_index (ir_node *node, int pos) {
536 assert (node->op == op_Sel);
537 return get_irn_n(node, pos+2);
541 set_Sel_index (ir_node *node, int pos, ir_node *index) {
542 assert (node->op == op_Sel);
543 set_irn_n(node, pos+2, index);
547 get_Sel_entity (ir_node *node) {
548 assert (node->op == op_Sel);
549 return node->attr.s.ent;
553 set_Sel_entity (ir_node *node, entity *ent) {
554 assert (node->op == op_Sel);
555 node->attr.s.ent = ent;
558 inline linkage_type *
559 get_Sel_linkage_type (ir_node *node) {
560 assert (node->op == op_Sel);
561 return node->attr.s.ltyp;
565 set_Sel_linkage_type (ir_node *node, linkage_type *lt) {
566 assert (node->op == op_Sel);
567 node->attr.s.ltyp = lt;
571 get_Call_mem (ir_node *node) {
572 assert (node->op == op_Call);
573 return get_irn_n(node, 0);
577 set_Call_mem (ir_node *node, ir_node *mem) {
578 assert (node->op == op_Call);
579 set_irn_n(node, 0, mem);
583 get_Call_ptr (ir_node *node) {
584 assert (node->op == op_Call);
585 return get_irn_n(node, 1);
589 set_Call_ptr (ir_node *node, ir_node *ptr) {
590 assert (node->op == op_Call);
591 set_irn_n(node, 1, ptr);
595 get_Call_arity (ir_node *node) {
596 assert (node->op == op_Call);
597 return (get_irn_arity(node) - 2);
601 set_Call_arity (ir_node *node, ir_node *arity) {
602 assert (node->op == op_Call);
607 get_Call_param (ir_node *node, int pos) {
608 assert (node->op == op_Call);
609 return get_irn_n(node, pos+1);
613 set_Call_param (ir_node *node, int pos, ir_node *param) {
614 assert (node->op == op_Call);
615 set_irn_n(node, pos+1, param);
619 get_Call_type (ir_node *node) {
620 assert (node->op == op_Call);
621 return node->attr.call;
625 set_Call_type (ir_node *node, type_method *type) {
626 assert (node->op == op_Call);
627 node->attr.call = type;
630 /* For unary and binary arithmetic operations the access to the
631 operands can be factored out. Left is the first, right the
632 second arithmetic value as listed in tech report 0999-33.
633 unops are: Minus, Abs, Not, Conv
634 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
635 Shr, Shrs, Rotate, Cmp */
638 is_unop (ir_node *node) {
639 return ( node->op == op_Minus ||
640 node->op == op_Abs ||
641 node->op == op_Not ||
642 node->op == op_Conv );
646 get_unop_op (ir_node *node) {
647 assert ( node->op == op_Minus ||
648 node->op == op_Abs ||
649 node->op == op_Not ||
650 node->op == op_Conv );
651 switch (get_irn_opcode (node)) {
652 case iro_Minus: return get_Minus_op(node); break;
653 case iro_Abs: return get_Abs_op(node); break;
654 case iro_Not: return get_Not_op(node); break;
655 case iro_Conv: return get_Conv_op(node); break;
656 default: return NULL;
661 set_unop_op (ir_node *node, ir_node *op) {
662 assert (node->op == op_Minus ||
663 node->op == op_Abs ||
664 node->op == op_Not ||
665 node->op == op_Conv );
666 switch (get_irn_opcode (node)) {
667 case iro_Minus: set_Minus_op(node, op); break;
668 case iro_Abs: set_Abs_op(node, op); break;
669 case iro_Not: set_Not_op(node, op); break;
670 case iro_Conv: set_Conv_op(node, op); break;
677 is_binop (ir_node *node) {
678 return (node->op == op_Add ||
679 node->op == op_Sub ||
680 node->op == op_Mul ||
681 node->op == op_Quot ||
682 node->op == op_DivMod ||
683 node->op == op_Div ||
684 node->op == op_Mod ||
685 node->op == op_And ||
687 node->op == op_Eor ||
688 node->op == op_Shl ||
689 node->op == op_Shr ||
690 node->op == op_Shrs ||
691 node->op == op_Rot ||
692 node->op == op_Cmp );
696 get_binop_left (ir_node *node) {
697 assert (node->op == op_Add ||
698 node->op == op_Sub ||
699 node->op == op_Mul ||
700 node->op == op_Quot ||
701 node->op == op_DivMod ||
702 node->op == op_Div ||
703 node->op == op_Mod ||
704 node->op == op_And ||
706 node->op == op_Eor ||
707 node->op == op_Shl ||
708 node->op == op_Shr ||
709 node->op == op_Shrs ||
710 node->op == op_Rot ||
711 node->op == op_Cmp );
713 switch (get_irn_opcode (node)) {
714 case iro_Add : return get_Add_left(node); break;
715 case iro_Sub : return get_Sub_left(node); break;
716 case iro_Mul : return get_Mul_left(node); break;
717 case iro_Quot : return get_Quot_left(node); break;
718 case iro_DivMod: return get_DivMod_left(node); break;
719 case iro_Div : return get_Div_left(node); break;
720 case iro_Mod : return get_Mod_left(node); break;
721 case iro_And : return get_And_left(node); break;
722 case iro_Or : return get_Or_left(node); break;
723 case iro_Eor : return get_Eor_left(node); break;
724 case iro_Shl : return get_Shl_left(node); break;
725 case iro_Shr : return get_Shr_left(node); break;
726 case iro_Shrs : return get_Shrs_left(node); break;
727 case iro_Rot : return get_Rot_left(node); break;
728 case iro_Cmp : return get_Cmp_left(node); break;
729 default: return NULL;
734 set_binop_left (ir_node *node, ir_node *left) {
735 assert (node->op == op_Add ||
736 node->op == op_Sub ||
737 node->op == op_Mul ||
738 node->op == op_Quot ||
739 node->op == op_DivMod ||
740 node->op == op_Div ||
741 node->op == op_Mod ||
742 node->op == op_And ||
744 node->op == op_Eor ||
745 node->op == op_Shl ||
746 node->op == op_Shr ||
747 node->op == op_Shrs ||
748 node->op == op_Rot ||
749 node->op == op_Cmp );
751 switch (get_irn_opcode (node)) {
752 case iro_Add : set_Add_left(node, left); break;
753 case iro_Sub : set_Sub_left(node, left); break;
754 case iro_Mul : set_Mul_left(node, left); break;
755 case iro_Quot : set_Quot_left(node, left); break;
756 case iro_DivMod: set_DivMod_left(node, left); break;
757 case iro_Div : set_Div_left(node, left); break;
758 case iro_Mod : set_Mod_left(node, left); break;
759 case iro_And : set_And_left(node, left); break;
760 case iro_Or : set_Or_left(node, left); break;
761 case iro_Eor : set_Eor_left(node, left); break;
762 case iro_Shl : set_Shl_left(node, left); break;
763 case iro_Shr : set_Shr_left(node, left); break;
764 case iro_Shrs : set_Shrs_left(node, left); break;
765 case iro_Rot : set_Rot_left(node, left); break;
766 case iro_Cmp : set_Cmp_left(node, left); break;
772 get_binop_right (ir_node *node) {
773 assert (node->op == op_Add ||
774 node->op == op_Sub ||
775 node->op == op_Mul ||
776 node->op == op_Quot ||
777 node->op == op_DivMod ||
778 node->op == op_Div ||
779 node->op == op_Mod ||
780 node->op == op_And ||
782 node->op == op_Eor ||
783 node->op == op_Shl ||
784 node->op == op_Shr ||
785 node->op == op_Shrs ||
786 node->op == op_Rot ||
787 node->op == op_Cmp );
789 switch (get_irn_opcode (node)) {
790 case iro_Add : return get_Add_right(node); break;
791 case iro_Sub : return get_Sub_right(node); break;
792 case iro_Mul : return get_Mul_right(node); break;
793 case iro_Quot : return get_Quot_right(node); break;
794 case iro_DivMod: return get_DivMod_right(node); break;
795 case iro_Div : return get_Div_right(node); break;
796 case iro_Mod : return get_Mod_right(node); break;
797 case iro_And : return get_And_right(node); break;
798 case iro_Or : return get_Or_right(node); break;
799 case iro_Eor : return get_Eor_right(node); break;
800 case iro_Shl : return get_Shl_right(node); break;
801 case iro_Shr : return get_Shr_right(node); break;
802 case iro_Shrs : return get_Shrs_right(node); break;
803 case iro_Rot : return get_Rot_right(node); break;
804 case iro_Cmp : return get_Cmp_right(node); break;
805 default: return NULL;
810 set_binop_right (ir_node *node, ir_node *right) {
811 assert (node->op == op_Add ||
812 node->op == op_Sub ||
813 node->op == op_Mul ||
814 node->op == op_Quot ||
815 node->op == op_DivMod ||
816 node->op == op_Div ||
817 node->op == op_Mod ||
818 node->op == op_And ||
820 node->op == op_Eor ||
821 node->op == op_Shl ||
822 node->op == op_Shr ||
823 node->op == op_Shrs ||
824 node->op == op_Rot ||
825 node->op == op_Cmp );
827 switch (get_irn_opcode (node)) {
828 case iro_Add : set_Add_right(node, right); break;
829 case iro_Sub : set_Sub_right(node, right); break;
830 case iro_Mul : set_Mul_right(node, right); break;
831 case iro_Quot : set_Quot_right(node, right); break;
832 case iro_DivMod: set_DivMod_right(node, right); break;
833 case iro_Div : set_Div_right(node, right); break;
834 case iro_Mod : set_Mod_right(node, right); break;
835 case iro_And : set_And_right(node, right); break;
836 case iro_Or : set_Or_right(node, right); break;
837 case iro_Eor : set_Eor_right(node, right); break;
838 case iro_Shl : set_Shl_right(node, right); break;
839 case iro_Shr : set_Shr_right(node, right); break;
840 case iro_Shrs : set_Shrs_right(node, right); break;
841 case iro_Rot : set_Rot_right(node, right); break;
842 case iro_Cmp : set_Cmp_right(node, right); break;
848 get_Add_left (ir_node *node) {
849 assert (node->op == op_Add);
850 return get_irn_n(node, 0);
854 set_Add_left (ir_node *node, ir_node *left) {
855 assert (node->op == op_Add);
856 set_irn_n(node, 0, left);
860 get_Add_right (ir_node *node) {
861 assert (node->op == op_Add);
862 return get_irn_n(node, 1);
866 set_Add_right (ir_node *node, ir_node *right) {
867 assert (node->op == op_Add);
868 set_irn_n(node, 1, right);
872 get_Sub_left (ir_node *node) {
873 assert (node->op == op_Sub);
874 return get_irn_n(node, 0);
878 set_Sub_left (ir_node *node, ir_node *left) {
879 assert (node->op == op_Sub);
880 set_irn_n(node, 0, left);
884 get_Sub_right (ir_node *node) {
885 assert (node->op == op_Sub);
886 return get_irn_n(node, 1);
890 set_Sub_right (ir_node *node, ir_node *right) {
891 assert (node->op == op_Sub);
892 set_irn_n(node, 1, right);
897 get_Minus_op (ir_node *node) {
898 assert (node->op == op_Minus);
899 return get_irn_n(node, 0);
903 set_Minus_op (ir_node *node, ir_node *op) {
904 assert (node->op == op_Minus);
905 set_irn_n(node, 0, op);
910 get_Mul_left (ir_node *node) {
911 assert (node->op == op_Mul);
912 return get_irn_n(node, 0);
916 set_Mul_left (ir_node *node, ir_node *left) {
917 assert (node->op == op_Mul);
918 set_irn_n(node, 0, left);
922 get_Mul_right (ir_node *node) {
923 assert (node->op == op_Mul);
924 return get_irn_n(node, 1);
928 set_Mul_right (ir_node *node, ir_node *right) {
929 assert (node->op == op_Mul);
930 set_irn_n(node, 1, right);
934 get_Quot_left (ir_node *node) {
935 assert (node->op == op_Quot);
936 return get_irn_n(node, 1);
940 set_Quot_left (ir_node *node, ir_node *left) {
941 assert (node->op == op_Quot);
942 set_irn_n(node, 1, left);
946 get_Quot_right (ir_node *node) {
947 assert (node->op == op_Quot);
948 return get_irn_n(node, 2);
952 set_Quot_right (ir_node *node, ir_node *right) {
953 assert (node->op == op_Quot);
954 set_irn_n(node, 2, right);
958 get_Quot_mem (ir_node *node) {
959 assert (node->op == op_Quot);
960 return get_irn_n(node, 0);
964 set_Quot_mem (ir_node *node, ir_node *mem) {
965 assert (node->op == op_Quot);
966 set_irn_n(node, 0, mem);
970 get_DivMod_left (ir_node *node) {
971 assert (node->op == op_DivMod);
972 return get_irn_n(node, 1);
976 set_DivMod_left (ir_node *node, ir_node *left) {
977 assert (node->op == op_DivMod);
978 set_irn_n(node, 1, left);
982 get_DivMod_right (ir_node *node) {
983 assert (node->op == op_DivMod);
984 return get_irn_n(node, 2);
988 set_DivMod_right (ir_node *node, ir_node *right) {
989 assert (node->op == op_DivMod);
990 set_irn_n(node, 2, right);
994 get_DivMod_mem (ir_node *node) {
995 assert (node->op == op_DivMod);
996 return get_irn_n(node, 0);
1000 set_DivMod_mem (ir_node *node, ir_node *mem) {
1001 assert (node->op == op_DivMod);
1002 set_irn_n(node, 0, mem);
1006 get_Div_left (ir_node *node) {
1007 assert (node->op == op_Div);
1008 return get_irn_n(node, 1);
1012 set_Div_left (ir_node *node, ir_node *left) {
1013 assert (node->op == op_Div);
1014 set_irn_n(node, 1, left);
1018 get_Div_right (ir_node *node) {
1019 assert (node->op == op_Div);
1020 return get_irn_n(node, 2);
1024 set_Div_right (ir_node *node, ir_node *right) {
1025 assert (node->op == op_Div);
1026 set_irn_n(node, 2, right);
1030 get_Div_mem (ir_node *node) {
1031 assert (node->op == op_Div);
1032 return get_irn_n(node, 0);
1036 set_Div_mem (ir_node *node, ir_node *mem) {
1037 assert (node->op == op_Div);
1038 set_irn_n(node, 0, mem);
1042 get_Mod_left (ir_node *node) {
1043 assert (node->op == op_Mod);
1044 return get_irn_n(node, 1);
1048 set_Mod_left (ir_node *node, ir_node *left) {
1049 assert (node->op == op_Mod);
1050 set_irn_n(node, 1, left);
1054 get_Mod_right (ir_node *node) {
1055 assert (node->op == op_Mod);
1056 return get_irn_n(node, 2);
1060 set_Mod_right (ir_node *node, ir_node *right) {
1061 assert (node->op == op_Mod);
1062 set_irn_n(node, 2, right);
1066 get_Mod_mem (ir_node *node) {
1067 assert (node->op == op_Mod);
1068 return get_irn_n(node, 0);
1072 set_Mod_mem (ir_node *node, ir_node *mem) {
1073 assert (node->op == op_Mod);
1074 set_irn_n(node, 0, mem);
1078 get_Abs_op (ir_node *node) {
1079 assert (node->op == op_Abs);
1080 return get_irn_n(node, 0);
1084 set_Abs_op (ir_node *node, ir_node *op) {
1085 assert (node->op == op_Abs);
1086 set_irn_n(node, 0, op);
1090 get_And_left (ir_node *node) {
1091 assert (node->op == op_And);
1092 return get_irn_n(node, 0);
1096 set_And_left (ir_node *node, ir_node *left) {
1097 assert (node->op == op_And);
1098 set_irn_n(node, 0, left);
1102 get_And_right (ir_node *node) {
1103 assert (node->op == op_And);
1104 return get_irn_n(node, 1);
1108 set_And_right (ir_node *node, ir_node *right) {
1109 assert (node->op == op_And);
1110 set_irn_n(node, 1, right);
1114 get_Or_left (ir_node *node) {
1115 assert (node->op == op_Or);
1116 return get_irn_n(node, 0);
1120 set_Or_left (ir_node *node, ir_node *left) {
1121 assert (node->op == op_Or);
1122 set_irn_n(node, 0, left);
1126 get_Or_right (ir_node *node) {
1127 assert (node->op == op_Or);
1128 return get_irn_n(node, 1);
1132 set_Or_right (ir_node *node, ir_node *right) {
1133 assert (node->op == op_Or);
1134 set_irn_n(node, 1, right);
1138 get_Eor_left (ir_node *node) {
1139 assert (node->op == op_Eor);
1140 return get_irn_n(node, 0);
1144 set_Eor_left (ir_node *node, ir_node *left) {
1145 assert (node->op == op_Eor);
1146 set_irn_n(node, 0, left);
1150 get_Eor_right (ir_node *node) {
1151 assert (node->op == op_Eor);
1152 return get_irn_n(node, 1);
1156 set_Eor_right (ir_node *node, ir_node *right) {
1157 assert (node->op == op_Eor);
1158 set_irn_n(node, 1, right);
1163 get_Not_op (ir_node *node) {
1164 assert (node->op == op_Not);
1165 return get_irn_n(node, 0);
1169 set_Not_op (ir_node *node, ir_node *op) {
1170 assert (node->op == op_Not);
1171 set_irn_n(node, 0, op);
1176 get_Shl_left (ir_node *node) {
1177 assert (node->op == op_Shl);
1178 return get_irn_n(node, 0);
1182 set_Shl_left (ir_node *node, ir_node *left) {
1183 assert (node->op == op_Shl);
1184 set_irn_n(node, 0, left);
1188 get_Shl_right (ir_node *node) {
1189 assert (node->op == op_Shl);
1190 return get_irn_n(node, 1);
1194 set_Shl_right (ir_node *node, ir_node *right) {
1195 assert (node->op == op_Shl);
1196 set_irn_n(node, 1, right);
1200 get_Shr_left (ir_node *node) {
1201 assert (node->op == op_Shr);
1202 return get_irn_n(node, 0);
1206 set_Shr_left (ir_node *node, ir_node *left) {
1207 assert (node->op == op_Shr);
1208 set_irn_n(node, 0, left);
1212 get_Shr_right (ir_node *node) {
1213 assert (node->op == op_Shr);
1214 return get_irn_n(node, 1);
1218 set_Shr_right (ir_node *node, ir_node *right) {
1219 assert (node->op == op_Shr);
1220 set_irn_n(node, 1, right);
1224 get_Shrs_left (ir_node *node) {
1225 assert (node->op == op_Shrs);
1226 return get_irn_n(node, 0);
1230 set_Shrs_left (ir_node *node, ir_node *left) {
1231 assert (node->op == op_Shrs);
1232 set_irn_n(node, 0, left);
1236 get_Shrs_right (ir_node *node) {
1237 assert (node->op == op_Shrs);
1238 return get_irn_n(node, 1);
1242 set_Shrs_right (ir_node *node, ir_node *right) {
1243 assert (node->op == op_Shrs);
1244 set_irn_n(node, 1, right);
1248 get_Rot_left (ir_node *node) {
1249 assert (node->op == op_Rot);
1250 return get_irn_n(node, 0);
1254 set_Rot_left (ir_node *node, ir_node *left) {
1255 assert (node->op == op_Rot);
1256 set_irn_n(node, 0, left);
1260 get_Rot_right (ir_node *node) {
1261 assert (node->op == op_Rot);
1262 return get_irn_n(node, 1);
1266 set_Rot_right (ir_node *node, ir_node *right) {
1267 assert (node->op == op_Rot);
1268 set_irn_n(node, 1, right);
1272 get_Cmp_left (ir_node *node) {
1273 assert (node->op == op_Cmp);
1274 return get_irn_n(node, 0);
1278 set_Cmp_left (ir_node *node, ir_node *left) {
1279 assert (node->op == op_Cmp);
1280 set_irn_n(node, 0, left);
1284 get_Cmp_right (ir_node *node) {
1285 assert (node->op == op_Cmp);
1286 return get_irn_n(node, 1);
1290 set_Cmp_right (ir_node *node, ir_node *right) {
1291 assert (node->op == op_Cmp);
1292 set_irn_n(node, 1, right);
1296 get_Conv_op (ir_node *node) {
1297 assert (node->op == op_Conv);
1298 return get_irn_n(node, 0);
1302 set_Conv_op (ir_node *node, ir_node *op) {
1303 assert (node->op == op_Conv);
1304 set_irn_n(node, 0, op);
1308 get_Phi_n_preds (ir_node *node) {
1309 assert (node->op == op_Phi);
1310 return (get_irn_arity(node));
1314 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1315 assert (node->op == op_Phi);
1320 get_Phi_pred (ir_node *node, int pos) {
1321 assert (node->op == op_Phi);
1322 return get_irn_n(node, pos);
1326 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1327 assert (node->op == op_Phi);
1328 set_irn_n(node, pos, pred);
1332 get_Load_mem (ir_node *node) {
1333 assert (node->op == op_Load);
1334 return get_irn_n(node, 0);
1338 set_Load_mem (ir_node *node, ir_node *mem) {
1339 assert (node->op == op_Load);
1340 set_irn_n(node, 0, mem);
1344 get_Load_ptr (ir_node *node) {
1345 assert (node->op == op_Load);
1346 return get_irn_n(node, 1);
1350 set_Load_ptr (ir_node *node, ir_node *ptr) {
1351 assert (node->op == op_Load);
1352 set_irn_n(node, 1, ptr);
1357 get_Store_mem (ir_node *node) {
1358 assert (node->op == op_Store);
1359 return get_irn_n(node, 0);
1363 set_Store_mem (ir_node *node, ir_node *mem) {
1364 assert (node->op == op_Store);
1365 set_irn_n(node, 0, mem);
1369 get_Store_ptr (ir_node *node) {
1370 assert (node->op == op_Store);
1371 return get_irn_n(node, 1);
1375 set_Store_ptr (ir_node *node, ir_node *ptr) {
1376 assert (node->op == op_Store);
1377 set_irn_n(node, 1, ptr);
1381 get_Store_value (ir_node *node) {
1382 assert (node->op == op_Store);
1383 return get_irn_n(node, 2);
1387 set_Store_value (ir_node *node, ir_node *value) {
1388 assert (node->op == op_Store);
1389 set_irn_n(node, 2, value);
1393 get_Alloc_mem (ir_node *node) {
1394 assert (node->op == op_Alloc);
1395 return get_irn_n(node, 0);
1399 set_Alloc_mem (ir_node *node, ir_node *mem) {
1400 assert (node->op == op_Alloc);
1401 set_irn_n(node, 0, mem);
1405 get_Alloc_size (ir_node *node) {
1406 assert (node->op == op_Alloc);
1407 return get_irn_n(node, 1);
1411 set_Allco_size (ir_node *node, ir_node *size) {
1412 assert (node->op == op_Alloc);
1413 set_irn_n(node, 1, size);
1417 get_Alloc_type (ir_node *node) {
1418 assert (node->op == op_Alloc);
1419 return node->attr.a.type;
1423 set_Alloc_type (ir_node *node, type *type) {
1424 assert (node->op == op_Alloc);
1425 node->attr.a.type = type;
1429 get_Alloc_where (ir_node *node) {
1430 assert (node->op == op_Alloc);
1431 return node->attr.a.where;
1435 set_Alloc_where (ir_node *node, where_alloc where) {
1436 assert (node->op == op_Alloc);
1437 node->attr.a.where = where;
1442 get_Free_mem (ir_node *node) {
1443 assert (node->op == op_Free);
1444 return get_irn_n(node, 0);
1448 set_Free_mem (ir_node *node, ir_node *mem) {
1449 assert (node->op == op_Free);
1450 set_irn_n(node, 0, mem);
1454 get_Free_ptr (ir_node *node) {
1455 assert (node->op == op_Free);
1456 return get_irn_n(node, 1);
1460 set_Free_ptr (ir_node *node, ir_node *ptr) {
1461 assert (node->op == op_Free);
1462 set_irn_n(node, 1, ptr);
1466 get_Free_size (ir_node *node) {
1467 assert (node->op == op_Free);
1468 return get_irn_n(node, 2);
1472 set_Free_size (ir_node *node, ir_node *size) {
1473 assert (node->op == op_Free);
1474 set_irn_n(node, 2, size);
1478 get_Free_type (ir_node *node) {
1479 assert (node->op == op_Free);
1480 return node->attr.f;
1484 set_Free_type (ir_node *node, type *type) {
1485 assert (node->op == op_Free);
1486 node->attr.f = type;
1490 get_Sync_n_preds (ir_node *node) {
1491 assert (node->op == op_Sync);
1492 return (get_irn_arity(node));
1497 set_Sync_n_preds (ir_node *node, int n_preds) {
1498 assert (node->op == op_Sync);
1503 get_Sync_pred (ir_node *node, int pos) {
1504 assert (node->op == op_Sync);
1505 return get_irn_n(node, pos);
1509 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1510 assert (node->op == op_Sync);
1511 set_irn_n(node, pos, pred);
1515 get_Proj_pred (ir_node *node) {
1516 assert (node->op == op_Proj);
1517 return get_irn_n(node, 0);
1521 set_Proj_pred (ir_node *node, ir_node *pred) {
1522 assert (node->op == op_Proj);
1523 set_irn_n(node, 0, pred);
1527 get_Proj_proj (ir_node *node) {
1528 assert (node->op == op_Proj);
1529 return node->attr.proj;
1533 set_Proj_proj (ir_node *node, long proj) {
1534 assert (node->op == op_Proj);
1535 node->attr.proj = proj;
1539 get_Tuple_n_preds (ir_node *node) {
1540 assert (node->op == op_Tuple);
1541 return (get_irn_arity(node));
1546 set_Tuple_n_preds (ir_node *node, int n_preds) {
1547 assert (node->op == op_Tuple);
1552 get_Tuple_pred (ir_node *node, int pos) {
1553 assert (node->op == op_Tuple);
1554 return get_irn_n(node, pos);
1558 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1559 assert (node->op == op_Tuple);
1560 set_irn_n(node, pos, pred);
1564 get_Id_pred (ir_node *node) {
1565 assert (node->op == op_Id);
1566 return get_irn_n(node, 0);
1570 set_Id_pred (ir_node *node, ir_node *pred) {
1571 assert (node->op == op_Id);
1572 set_irn_n(node, 0, pred);
1575 /******************************************************************/
1576 /* Auxiliary routines */
1577 /******************************************************************/
1580 skip_Proj (ir_node *node) {
1581 /* don't assert node !!! */
1582 if (node && (node->op == op_Proj)) {
1583 return get_Proj_pred(node);
1590 skip_nop (ir_node *node) {
1591 /* don't assert node !!! */
1592 if (node && (node->op == op_Id)) {
1593 return get_Id_pred(node);
1600 is_Bad (ir_node *node) {
1602 if ((node) && get_irn_opcode(node) == iro_Bad)
1608 is_no_Block (ir_node *node) {
1610 return (get_irn_opcode(node) != iro_Block);
1613 /* Returns true if the operation manipulates control flow. */
1615 is_cfop(ir_node *node) {
1616 return ( (get_irn_opcode(node) == iro_Start)
1617 || (get_irn_opcode(node) == iro_Jmp)
1618 || (get_irn_opcode(node) == iro_Cond)
1619 || (get_irn_opcode(node) == iro_Return)
1620 || (get_irn_opcode(node) == iro_Raise)
1621 || (get_irn_opcode(node) == iro_Bad));
1624 /* Returns true if the operation can change the control flow because
1627 is_fragile_op(ir_node *node) {
1628 return ( (get_irn_opcode(node) == iro_Call)
1629 || (get_irn_opcode(node) == iro_Quot)
1630 || (get_irn_opcode(node) == iro_DivMod)
1631 || (get_irn_opcode(node) == iro_Div)
1632 || (get_irn_opcode(node) == iro_Mod)
1633 || (get_irn_opcode(node) == iro_Load)
1634 || (get_irn_opcode(node) == iro_Store)
1635 || (get_irn_opcode(node) == iro_Alloc)
1636 || (get_irn_opcode(node) == iro_Bad));