1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
12 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
13 "Gt", "Ge", "Lg", "Leg", "Uo",
14 "Ue", "Ul", "Ule", "Ug", "Uge",
17 inline char *get_pnc_string(int pnc) {
18 return pnc_name_arr[pnc];
23 get_negated_pnc(int pnc) {
25 case False: return True; break;
26 case Eq: return Ne; break;
27 case Lt: return Uge; break;
28 case Le: return Ug; break;
29 case Gt: return Ule; break;
30 case Ge: return Ul; break;
31 case Lg: return Ue; break;
32 case Leg: return Uo; break;
33 case Uo: return Leg; break;
34 case Ue: return Lg; break;
35 case Ul: return Ge; break;
36 case Ule: return Gt; break;
37 case Ug: return Le; break;
38 case Uge: return Lt; break;
39 case Ne: return Eq; break;
40 case True: return False; break;
42 return 99; /* to shut up gcc */
45 static char *pns_name_arr [] = {"initial_exec", "global_store",
46 "frame_base", "globals", "args"};
48 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
57 /* irnode constructor */
58 /* create a new irnode in irg, with an op, mode, arity and */
59 /* some incoming irnodes */
60 /* this constructor is used in every specified irnode constructor */
62 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
63 int arity, ir_node **in)
66 int node_size = offsetof (ir_node, attr) + op->attr_size;
68 res = (ir_node *) obstack_alloc (irg->obst, node_size);
70 res->kind = k_ir_node;
76 res->in = NEW_ARR_F (ir_node *, 1);
78 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
79 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
86 /* IR-Nodes with attributes */
88 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
91 ir_node *np = XP_GETARG (ir_node *, 0);
94 XPS ("<null ir_node>");
98 XPF1 ("%I", get_irn_op(np)->name);
100 switch (get_irn_opcode (np)) { /* node label */
102 XPF1 ("%I", get_irn_mode(np)->name);
104 XPF1 ("%v", get_irn_const_attr);
107 if (get_irn_modecode (np) == irm_b) {
109 XP (pnc_name_arr[get_irn_proj_attr(np)]);
110 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
112 XP (pns_name_arr[get_irn_proj_attr(np)]);
114 XPF1 ("%I", get_irn_mode(np)->name);
116 XPF1 ("%d", get_irn_proj_attr(np));
120 XPF1 ("%I", get_irn_mode(np)->name);
122 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
123 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
125 case iro_Start: /* don't dump mode of these */
134 XPF1 ("%I", get_irn_mode(np)->name);
141 /** getting some parameters from ir_nodes **/
143 /* returns the number of predecessors without the block predecessor. */
145 get_irn_arity (ir_node *node)
147 // printf("called for node %s\n", ID_TO_STR(node->op->name));
148 // if (get_irn_opcode(node) == iro_Block) return (ARR_LEN((node)->in));
149 return (ARR_LEN((node)->in)-1);
152 /* returns the array with ins */
154 get_irn_in (ir_node *node)
160 /* to iterate through the predecessors without touching the array */
161 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
162 to iterate includind the Block predecessor iterate from i = -1 to
164 Don't know how to iterate if it is a block ?? */
166 get_irn_n (ir_node *node, int n)
169 // assert (get_irn_arity (node) > n);
170 return skip_nop(node->in[n+1]);
174 set_irn_n (ir_node *node, int n, ir_node *in)
177 assert (get_irn_arity (node) > n);
182 get_irn_mode (ir_node *node)
189 get_irn_modecode (ir_node *node)
192 return node->mode->code;
196 get_irn_op (ir_node *node)
202 /* should be private to the library: */
204 set_irn_op (ir_node *node, ir_op *op)
211 get_irn_opcode (ir_node *node)
214 return node->op->code;
218 set_irn_link (ir_node *node, ir_node *link) {
224 get_irn_link (ir_node *node) {
230 get_irn_const_attr (ir_node *node)
232 assert (node->op == op_Const);
233 return node->attr.con;
237 get_irn_proj_attr (ir_node *node)
239 assert (node->op == op_Proj);
240 return node->attr.proj;
244 get_irn_alloc_attr (ir_node *node)
246 assert (node->op == op_Alloc);
251 get_irn_free_attr (ir_node *node)
253 assert (node->op == op_Free);
258 get_irn_symconst_attr (ir_node *node)
260 assert (node->op == op_SymConst);
265 get_irn_call_attr (ir_node *node)
267 assert (node->op == op_Call);
268 return node->attr.call;
272 get_irn_sel_attr (ir_node *node)
274 assert (node->op == op_Sel);
279 get_irn_phi_attr (ir_node *node)
281 assert (node->op == op_Phi);
282 return node->attr.phi0_pos;
286 get_irn_block_attr (ir_node *node)
288 assert (node->op == op_Block);
289 return node->attr.block;
292 /** manipulate fields of individual nodes **/
294 /* this works for all except Block */
296 get_nodes_Block (ir_node *node) {
297 assert (!(node->op == op_Block));
298 return get_irn_n(node, -1);
302 set_nodes_Block (ir_node *node, ir_node *block) {
303 assert (!(node->op == op_Block));
304 set_irn_n(node, -1, block);
308 get_Block_n_cfgpreds (ir_node *node) {
309 assert ((node->op == op_Block));
310 return (get_irn_arity(node));
315 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
316 assert ((node->op == op_Block));
321 get_Block_cfgpred (ir_node *node, int pos) {
322 assert (node->op == op_Block);
323 return get_irn_n(node, pos);
327 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
328 assert (node->op == op_Block);
329 set_irn_n(node, pos, pred);
333 get_Block_matured (ir_node *node) {
334 assert (node->op == op_Block);
335 return node->attr.block.matured;
339 set_Block_matured (ir_node *node, bool matured) {
340 assert (node->op == op_Block);
341 node->attr.block.matured = matured;
344 get_Block_block_visit (ir_node *node) {
345 assert (node->op == op_Block);
346 return node->attr.block.block_visit;
350 set_Block_block_visit (ir_node *node, unsigned long visit) {
351 assert (node->op == op_Block);
352 node->attr.block.block_visit = visit;
356 get_Block_graph_arr (ir_node *node, int pos) {
357 assert (node->op == op_Block);
358 return node->attr.block.graph_arr[pos+1];
362 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
363 assert (node->op == op_Block);
364 node->attr.block.graph_arr[pos+1] = value;
368 get_Cond_selector (ir_node *node) {
369 assert (node->op == op_Cond);
370 return get_irn_n(node, 0);
374 set_Cond_selector (ir_node *node, ir_node *selector) {
375 assert (node->op == op_Cond);
376 set_irn_n(node, 0, selector);
380 get_Return_mem (ir_node *node) {
381 assert (node->op == op_Cond);
382 return get_irn_n(node, 0);
386 set_Return_mem (ir_node *node, ir_node *mem) {
387 assert (node->op == op_Return);
388 set_irn_n(node, 0, mem);
392 get_Return_n_res (ir_node *node) {
393 assert (node->op == op_Return);
394 return (get_irn_arity(node) - 1);
399 set_Return_n_res (ir_node *node, int results) {
400 assert (node->op == op_Return);
405 get_Return_res (ir_node *node, int pos) {
406 assert (node->op == op_Return);
407 return get_irn_n(node, pos+1);
411 set_Return_res (ir_node *node, int pos, ir_node *res){
412 assert (node->op == op_Raise);
413 set_irn_n(node, pos+1, res);
417 get_Raise_mem (ir_node *node) {
418 assert (node->op == op_Return);
419 return get_irn_n(node, 0);
423 set_Raise_mem (ir_node *node, ir_node *mem) {
424 assert (node->op == op_Raise);
425 set_irn_n(node, 0, mem);
429 get_Raise_exo_ptr (ir_node *node) {
430 assert (node->op == op_Raise);
431 return get_irn_n(node, 1);
435 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
436 assert (node->op == op_Raise);
437 set_irn_n(node, 1, exo_ptr);
440 inline tarval *get_Const_tarval (ir_node *node) {
441 assert (node->op == op_Const);
442 return get_irn_const_attr(node);
446 set_Const_tarval (ir_node *node, tarval *con) {
447 assert (node->op == op_Const);
448 node->attr.con = con;
452 get_SymConst_kind (ir_node *node) {
453 assert (node->op == op_SymConst);
454 return node->attr.i.num;
458 set_SymConst_kind (ir_node *node, symconst_kind num) {
459 assert (node->op == op_SymConst);
460 node->attr.i.num = num;
464 get_SymConst_type (ir_node *node) {
465 assert ( (node->op == op_SymConst)
466 && ( get_SymConst_kind(node) == type_tag
467 || get_SymConst_kind(node) == size));
468 return node->attr.i.tori.typ;
472 set_SymConst_type (ir_node *node, type *type) {
473 assert ( (node->op == op_SymConst)
474 && ( get_SymConst_kind(node) == type_tag
475 || get_SymConst_kind(node) == size));
476 node->attr.i.tori.typ = type;
480 get_SymConst_ptrinfo (ir_node *node) {
481 assert ( (node->op == op_SymConst)
482 && (get_SymConst_kind(node) == linkage_ptr_info));
483 return node->attr.i.tori.ptrinfo;
489 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
490 assert ( (node->op == op_SymConst)
491 && (get_SymConst_kind(node) == linkage_ptr_info));
492 node->attr.i.tori.ptrinfo = ptrinfo;
496 get_Sel_mem (ir_node *node) {
497 assert (node->op == op_Sel);
498 return get_irn_n(node, 0);
502 set_Sel_mem (ir_node *node, ir_node *mem) {
503 assert (node->op == op_Sel);
504 set_irn_n(node, 0, mem);
508 get_Sel_ptr (ir_node *node) {
509 assert (node->op == op_Sel);
510 return get_irn_n(node, 1);
514 set_Sel_ptr (ir_node *node, ir_node *ptr) {
515 assert (node->op == op_Sel);
516 set_irn_n(node, 1, ptr);
520 get_Sel_n_index (ir_node *node) {
521 assert (node->op == op_Sel);
522 return (get_irn_arity(node) - 2);
527 set_Sel_n_index (ir_node *node, int n_index) {
528 assert (node->op == op_Sel);
533 get_Sel_index (ir_node *node, int pos) {
534 assert (node->op == op_Sel);
535 return get_irn_n(node, pos+2);
539 set_Sel_index (ir_node *node, int pos, ir_node *index) {
540 assert (node->op == op_Sel);
541 set_irn_n(node, pos+2, index);
545 get_Sel_entity (ir_node *node) {
546 assert (node->op == op_Sel);
547 return node->attr.s.ent;
551 set_Sel_entity (ir_node *node, entity *ent) {
552 assert (node->op == op_Sel);
553 node->attr.s.ent = ent;
556 inline linkage_type *
557 get_Sel_linkage_type (ir_node *node) {
558 assert (node->op == op_Sel);
559 return node->attr.s.ltyp;
563 set_Sel_linkage_type (ir_node *node, linkage_type *lt) {
564 assert (node->op == op_Sel);
565 node->attr.s.ltyp = lt;
569 get_Call_mem (ir_node *node) {
570 assert (node->op == op_Call);
571 return get_irn_n(node, 0);
575 set_Call_mem (ir_node *node, ir_node *mem) {
576 assert (node->op == op_Call);
577 set_irn_n(node, 0, mem);
581 get_Call_ptr (ir_node *node) {
582 assert (node->op == op_Call);
583 return get_irn_n(node, 1);
587 set_Call_ptr (ir_node *node, ir_node *ptr) {
588 assert (node->op == op_Call);
589 set_irn_n(node, 1, ptr);
593 get_Call_arity (ir_node *node) {
594 assert (node->op == op_Call);
595 return (get_irn_arity(node) - 2);
599 set_Call_arity (ir_node *node, ir_node *arity) {
600 assert (node->op == op_Call);
605 get_Call_param (ir_node *node, int pos) {
606 assert (node->op == op_Call);
607 return get_irn_n(node, pos+1);
611 set_Call_param (ir_node *node, int pos, ir_node *param) {
612 assert (node->op == op_Call);
613 set_irn_n(node, pos+1, param);
617 get_Call_type (ir_node *node) {
618 assert (node->op == op_Call);
619 return node->attr.call;
623 set_Call_type (ir_node *node, type_method *type) {
624 assert (node->op == op_Call);
625 node->attr.call = type;
628 /* For unary and binary arithmetic operations the access to the
629 operands can be factored out. Left is the first, right the
630 second arithmetic value as listed in tech report 0999-33.
631 unops are: Minus, Abs, Not, Conv
632 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
633 Shr, Shrs, Rotate, Cmp */
636 is_unop (ir_node *node) {
637 return ( node->op == op_Minus ||
638 node->op == op_Abs ||
639 node->op == op_Not ||
640 node->op == op_Conv );
644 get_unop_op (ir_node *node) {
645 assert ( node->op == op_Minus ||
646 node->op == op_Abs ||
647 node->op == op_Not ||
648 node->op == op_Conv );
649 switch (get_irn_opcode (node)) {
650 case iro_Minus: return get_Minus_op(node); break;
651 case iro_Abs: return get_Abs_op(node); break;
652 case iro_Not: return get_Not_op(node); break;
653 case iro_Conv: return get_Conv_op(node); break;
654 default: return NULL;
659 set_unop_op (ir_node *node, ir_node *op) {
660 assert (node->op == op_Minus ||
661 node->op == op_Abs ||
662 node->op == op_Not ||
663 node->op == op_Conv );
664 switch (get_irn_opcode (node)) {
665 case iro_Minus: set_Minus_op(node, op); break;
666 case iro_Abs: set_Abs_op(node, op); break;
667 case iro_Not: set_Not_op(node, op); break;
668 case iro_Conv: set_Conv_op(node, op); break;
675 is_binop (ir_node *node) {
676 return (node->op == op_Add ||
677 node->op == op_Sub ||
678 node->op == op_Mul ||
679 node->op == op_Quot ||
680 node->op == op_DivMod ||
681 node->op == op_Div ||
682 node->op == op_Mod ||
683 node->op == op_And ||
685 node->op == op_Eor ||
686 node->op == op_Shl ||
687 node->op == op_Shr ||
688 node->op == op_Shrs ||
689 node->op == op_Rot ||
690 node->op == op_Cmp );
694 get_binop_left (ir_node *node) {
695 assert (node->op == op_Add ||
696 node->op == op_Sub ||
697 node->op == op_Mul ||
698 node->op == op_Quot ||
699 node->op == op_DivMod ||
700 node->op == op_Div ||
701 node->op == op_Mod ||
702 node->op == op_And ||
704 node->op == op_Eor ||
705 node->op == op_Shl ||
706 node->op == op_Shr ||
707 node->op == op_Shrs ||
708 node->op == op_Rot ||
709 node->op == op_Cmp );
711 switch (get_irn_opcode (node)) {
712 case iro_Add : return get_Add_left(node); break;
713 case iro_Sub : return get_Sub_left(node); break;
714 case iro_Mul : return get_Mul_left(node); break;
715 case iro_Quot : return get_Quot_left(node); break;
716 case iro_DivMod: return get_DivMod_left(node); break;
717 case iro_Div : return get_Div_left(node); break;
718 case iro_Mod : return get_Mod_left(node); break;
719 case iro_And : return get_And_left(node); break;
720 case iro_Or : return get_Or_left(node); break;
721 case iro_Eor : return get_Eor_left(node); break;
722 case iro_Shl : return get_Shl_left(node); break;
723 case iro_Shr : return get_Shr_left(node); break;
724 case iro_Shrs : return get_Shrs_left(node); break;
725 case iro_Rot : return get_Rot_left(node); break;
726 case iro_Cmp : return get_Cmp_left(node); break;
727 default: return NULL;
732 set_binop_left (ir_node *node, ir_node *left) {
733 assert (node->op == op_Add ||
734 node->op == op_Sub ||
735 node->op == op_Mul ||
736 node->op == op_Quot ||
737 node->op == op_DivMod ||
738 node->op == op_Div ||
739 node->op == op_Mod ||
740 node->op == op_And ||
742 node->op == op_Eor ||
743 node->op == op_Shl ||
744 node->op == op_Shr ||
745 node->op == op_Shrs ||
746 node->op == op_Rot ||
747 node->op == op_Cmp );
749 switch (get_irn_opcode (node)) {
750 case iro_Add : set_Add_left(node, left); break;
751 case iro_Sub : set_Sub_left(node, left); break;
752 case iro_Mul : set_Mul_left(node, left); break;
753 case iro_Quot : set_Quot_left(node, left); break;
754 case iro_DivMod: set_DivMod_left(node, left); break;
755 case iro_Div : set_Div_left(node, left); break;
756 case iro_Mod : set_Mod_left(node, left); break;
757 case iro_And : set_And_left(node, left); break;
758 case iro_Or : set_Or_left(node, left); break;
759 case iro_Eor : set_Eor_left(node, left); break;
760 case iro_Shl : set_Shl_left(node, left); break;
761 case iro_Shr : set_Shr_left(node, left); break;
762 case iro_Shrs : set_Shrs_left(node, left); break;
763 case iro_Rot : set_Rot_left(node, left); break;
764 case iro_Cmp : set_Cmp_left(node, left); break;
770 get_binop_right (ir_node *node) {
771 assert (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 );
787 switch (get_irn_opcode (node)) {
788 case iro_Add : return get_Add_right(node); break;
789 case iro_Sub : return get_Sub_right(node); break;
790 case iro_Mul : return get_Mul_right(node); break;
791 case iro_Quot : return get_Quot_right(node); break;
792 case iro_DivMod: return get_DivMod_right(node); break;
793 case iro_Div : return get_Div_right(node); break;
794 case iro_Mod : return get_Mod_right(node); break;
795 case iro_And : return get_And_right(node); break;
796 case iro_Or : return get_Or_right(node); break;
797 case iro_Eor : return get_Eor_right(node); break;
798 case iro_Shl : return get_Shl_right(node); break;
799 case iro_Shr : return get_Shr_right(node); break;
800 case iro_Shrs : return get_Shrs_right(node); break;
801 case iro_Rot : return get_Rot_right(node); break;
802 case iro_Cmp : return get_Cmp_right(node); break;
803 default: return NULL;
808 set_binop_right (ir_node *node, ir_node *right) {
809 assert (node->op == op_Add ||
810 node->op == op_Sub ||
811 node->op == op_Mul ||
812 node->op == op_Quot ||
813 node->op == op_DivMod ||
814 node->op == op_Div ||
815 node->op == op_Mod ||
816 node->op == op_And ||
818 node->op == op_Eor ||
819 node->op == op_Shl ||
820 node->op == op_Shr ||
821 node->op == op_Shrs ||
822 node->op == op_Rot ||
823 node->op == op_Cmp );
825 switch (get_irn_opcode (node)) {
826 case iro_Add : set_Add_right(node, right); break;
827 case iro_Sub : set_Sub_right(node, right); break;
828 case iro_Mul : set_Mul_right(node, right); break;
829 case iro_Quot : set_Quot_right(node, right); break;
830 case iro_DivMod: set_DivMod_right(node, right); break;
831 case iro_Div : set_Div_right(node, right); break;
832 case iro_Mod : set_Mod_right(node, right); break;
833 case iro_And : set_And_right(node, right); break;
834 case iro_Or : set_Or_right(node, right); break;
835 case iro_Eor : set_Eor_right(node, right); break;
836 case iro_Shl : set_Shl_right(node, right); break;
837 case iro_Shr : set_Shr_right(node, right); break;
838 case iro_Shrs : set_Shrs_right(node, right); break;
839 case iro_Rot : set_Rot_right(node, right); break;
840 case iro_Cmp : set_Cmp_right(node, right); break;
846 get_Add_left (ir_node *node) {
847 assert (node->op == op_Add);
848 return get_irn_n(node, 0);
852 set_Add_left (ir_node *node, ir_node *left) {
853 assert (node->op == op_Add);
854 set_irn_n(node, 0, left);
858 get_Add_right (ir_node *node) {
859 assert (node->op == op_Add);
860 return get_irn_n(node, 1);
864 set_Add_right (ir_node *node, ir_node *right) {
865 assert (node->op == op_Add);
866 set_irn_n(node, 1, right);
870 get_Sub_left (ir_node *node) {
871 assert (node->op == op_Sub);
872 return get_irn_n(node, 0);
876 set_Sub_left (ir_node *node, ir_node *left) {
877 assert (node->op == op_Sub);
878 set_irn_n(node, 0, left);
882 get_Sub_right (ir_node *node) {
883 assert (node->op == op_Sub);
884 return get_irn_n(node, 1);
888 set_Sub_right (ir_node *node, ir_node *right) {
889 assert (node->op == op_Sub);
890 set_irn_n(node, 1, right);
895 get_Minus_op (ir_node *node) {
896 assert (node->op == op_Minus);
897 return get_irn_n(node, 0);
901 set_Minus_op (ir_node *node, ir_node *op) {
902 assert (node->op == op_Minus);
903 set_irn_n(node, 0, op);
908 get_Mul_left (ir_node *node) {
909 assert (node->op == op_Mul);
910 return get_irn_n(node, 0);
914 set_Mul_left (ir_node *node, ir_node *left) {
915 assert (node->op == op_Mul);
916 set_irn_n(node, 0, left);
920 get_Mul_right (ir_node *node) {
921 assert (node->op == op_Mul);
922 return get_irn_n(node, 1);
926 set_Mul_right (ir_node *node, ir_node *right) {
927 assert (node->op == op_Mul);
928 set_irn_n(node, 1, right);
932 get_Quot_left (ir_node *node) {
933 assert (node->op == op_Quot);
934 return get_irn_n(node, 1);
938 set_Quot_left (ir_node *node, ir_node *left) {
939 assert (node->op == op_Quot);
940 set_irn_n(node, 1, left);
944 get_Quot_right (ir_node *node) {
945 assert (node->op == op_Quot);
946 return get_irn_n(node, 2);
950 set_Quot_right (ir_node *node, ir_node *right) {
951 assert (node->op == op_Quot);
952 set_irn_n(node, 2, right);
956 get_Quot_mem (ir_node *node) {
957 assert (node->op == op_Quot);
958 return get_irn_n(node, 0);
962 set_Quot_mem (ir_node *node, ir_node *mem) {
963 assert (node->op == op_Quot);
964 set_irn_n(node, 0, mem);
968 get_DivMod_left (ir_node *node) {
969 assert (node->op == op_DivMod);
970 return get_irn_n(node, 1);
974 set_DivMod_left (ir_node *node, ir_node *left) {
975 assert (node->op == op_DivMod);
976 set_irn_n(node, 1, left);
980 get_DivMod_right (ir_node *node) {
981 assert (node->op == op_DivMod);
982 return get_irn_n(node, 2);
986 set_DivMod_right (ir_node *node, ir_node *right) {
987 assert (node->op == op_DivMod);
988 set_irn_n(node, 2, right);
992 get_DivMod_mem (ir_node *node) {
993 assert (node->op == op_DivMod);
994 return get_irn_n(node, 0);
998 set_DivMod_mem (ir_node *node, ir_node *mem) {
999 assert (node->op == op_DivMod);
1000 set_irn_n(node, 0, mem);
1004 get_Div_left (ir_node *node) {
1005 assert (node->op == op_Div);
1006 return get_irn_n(node, 1);
1010 set_Div_left (ir_node *node, ir_node *left) {
1011 assert (node->op == op_Div);
1012 set_irn_n(node, 1, left);
1016 get_Div_right (ir_node *node) {
1017 assert (node->op == op_Div);
1018 return get_irn_n(node, 2);
1022 set_Div_right (ir_node *node, ir_node *right) {
1023 assert (node->op == op_Div);
1024 set_irn_n(node, 2, right);
1028 get_Div_mem (ir_node *node) {
1029 assert (node->op == op_Div);
1030 return get_irn_n(node, 0);
1034 set_Div_mem (ir_node *node, ir_node *mem) {
1035 assert (node->op == op_Div);
1036 set_irn_n(node, 0, mem);
1040 get_Mod_left (ir_node *node) {
1041 assert (node->op == op_Mod);
1042 return get_irn_n(node, 1);
1046 set_Mod_left (ir_node *node, ir_node *left) {
1047 assert (node->op == op_Mod);
1048 set_irn_n(node, 1, left);
1052 get_Mod_right (ir_node *node) {
1053 assert (node->op == op_Mod);
1054 return get_irn_n(node, 2);
1058 set_Mod_right (ir_node *node, ir_node *right) {
1059 assert (node->op == op_Mod);
1060 set_irn_n(node, 2, right);
1064 get_Mod_mem (ir_node *node) {
1065 assert (node->op == op_Mod);
1066 return get_irn_n(node, 0);
1070 set_Mod_mem (ir_node *node, ir_node *mem) {
1071 assert (node->op == op_Mod);
1072 set_irn_n(node, 0, mem);
1076 get_Abs_op (ir_node *node) {
1077 assert (node->op == op_Abs);
1078 return get_irn_n(node, 0);
1082 set_Abs_op (ir_node *node, ir_node *op) {
1083 assert (node->op == op_Abs);
1084 set_irn_n(node, 0, op);
1088 get_And_left (ir_node *node) {
1089 assert (node->op == op_And);
1090 return get_irn_n(node, 0);
1094 set_And_left (ir_node *node, ir_node *left) {
1095 assert (node->op == op_And);
1096 set_irn_n(node, 0, left);
1100 get_And_right (ir_node *node) {
1101 assert (node->op == op_And);
1102 return get_irn_n(node, 1);
1106 set_And_right (ir_node *node, ir_node *right) {
1107 assert (node->op == op_And);
1108 set_irn_n(node, 1, right);
1112 get_Or_left (ir_node *node) {
1113 assert (node->op == op_Or);
1114 return get_irn_n(node, 0);
1118 set_Or_left (ir_node *node, ir_node *left) {
1119 assert (node->op == op_Or);
1120 set_irn_n(node, 0, left);
1124 get_Or_right (ir_node *node) {
1125 assert (node->op == op_Or);
1126 return get_irn_n(node, 1);
1130 set_Or_right (ir_node *node, ir_node *right) {
1131 assert (node->op == op_Or);
1132 set_irn_n(node, 1, right);
1136 get_Eor_left (ir_node *node) {
1137 assert (node->op == op_Eor);
1138 return get_irn_n(node, 0);
1142 set_Eor_left (ir_node *node, ir_node *left) {
1143 assert (node->op == op_Eor);
1144 set_irn_n(node, 0, left);
1148 get_Eor_right (ir_node *node) {
1149 assert (node->op == op_Eor);
1150 return get_irn_n(node, 1);
1154 set_Eor_right (ir_node *node, ir_node *right) {
1155 assert (node->op == op_Eor);
1156 set_irn_n(node, 1, right);
1161 get_Not_op (ir_node *node) {
1162 assert (node->op == op_Not);
1163 return get_irn_n(node, 0);
1167 set_Not_op (ir_node *node, ir_node *op) {
1168 assert (node->op == op_Not);
1169 set_irn_n(node, 0, op);
1174 get_Shl_left (ir_node *node) {
1175 assert (node->op == op_Shl);
1176 return get_irn_n(node, 0);
1180 set_Shl_left (ir_node *node, ir_node *left) {
1181 assert (node->op == op_Shl);
1182 set_irn_n(node, 0, left);
1186 get_Shl_right (ir_node *node) {
1187 assert (node->op == op_Shl);
1188 return get_irn_n(node, 1);
1192 set_Shl_right (ir_node *node, ir_node *right) {
1193 assert (node->op == op_Shl);
1194 set_irn_n(node, 1, right);
1198 get_Shr_left (ir_node *node) {
1199 assert (node->op == op_Shr);
1200 return get_irn_n(node, 0);
1204 set_Shr_left (ir_node *node, ir_node *left) {
1205 assert (node->op == op_Shr);
1206 set_irn_n(node, 0, left);
1210 get_Shr_right (ir_node *node) {
1211 assert (node->op == op_Shr);
1212 return get_irn_n(node, 1);
1216 set_Shr_right (ir_node *node, ir_node *right) {
1217 assert (node->op == op_Shr);
1218 set_irn_n(node, 1, right);
1222 get_Shrs_left (ir_node *node) {
1223 assert (node->op == op_Shrs);
1224 return get_irn_n(node, 0);
1228 set_Shrs_left (ir_node *node, ir_node *left) {
1229 assert (node->op == op_Shrs);
1230 set_irn_n(node, 0, left);
1234 get_Shrs_right (ir_node *node) {
1235 assert (node->op == op_Shrs);
1236 return get_irn_n(node, 1);
1240 set_Shrs_right (ir_node *node, ir_node *right) {
1241 assert (node->op == op_Shrs);
1242 set_irn_n(node, 1, right);
1246 get_Rot_left (ir_node *node) {
1247 assert (node->op == op_Rot);
1248 return get_irn_n(node, 0);
1252 set_Rot_left (ir_node *node, ir_node *left) {
1253 assert (node->op == op_Rot);
1254 set_irn_n(node, 0, left);
1258 get_Rot_right (ir_node *node) {
1259 assert (node->op == op_Rot);
1260 return get_irn_n(node, 1);
1264 set_Rot_right (ir_node *node, ir_node *right) {
1265 assert (node->op == op_Rot);
1266 set_irn_n(node, 1, right);
1270 get_Cmp_left (ir_node *node) {
1271 assert (node->op == op_Cmp);
1272 return get_irn_n(node, 0);
1276 set_Cmp_left (ir_node *node, ir_node *left) {
1277 assert (node->op == op_Cmp);
1278 set_irn_n(node, 0, left);
1282 get_Cmp_right (ir_node *node) {
1283 assert (node->op == op_Cmp);
1284 return get_irn_n(node, 1);
1288 set_Cmp_right (ir_node *node, ir_node *right) {
1289 assert (node->op == op_Cmp);
1290 set_irn_n(node, 1, right);
1294 get_Conv_op (ir_node *node) {
1295 assert (node->op == op_Conv);
1296 return get_irn_n(node, 0);
1300 set_Conv_op (ir_node *node, ir_node *op) {
1301 assert (node->op == op_Conv);
1302 set_irn_n(node, 0, op);
1306 get_Phi_n_preds (ir_node *node) {
1307 assert (node->op == op_Phi);
1308 return (get_irn_arity(node));
1312 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1313 assert (node->op == op_Phi);
1318 get_Phi_pred (ir_node *node, int pos) {
1319 assert (node->op == op_Phi);
1320 return get_irn_n(node, pos);
1324 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1325 assert (node->op == op_Phi);
1326 set_irn_n(node, pos, pred);
1330 get_Load_mem (ir_node *node) {
1331 assert (node->op == op_Load);
1332 return get_irn_n(node, 0);
1336 set_Load_mem (ir_node *node, ir_node *mem) {
1337 assert (node->op == op_Load);
1338 set_irn_n(node, 0, mem);
1342 get_Load_ptr (ir_node *node) {
1343 assert (node->op == op_Load);
1344 return get_irn_n(node, 1);
1348 set_Load_ptr (ir_node *node, ir_node *ptr) {
1349 assert (node->op == op_Load);
1350 set_irn_n(node, 1, ptr);
1355 get_Store_mem (ir_node *node) {
1356 assert (node->op == op_Store);
1357 return get_irn_n(node, 0);
1361 set_Store_mem (ir_node *node, ir_node *mem) {
1362 assert (node->op == op_Store);
1363 set_irn_n(node, 0, mem);
1367 get_Store_ptr (ir_node *node) {
1368 assert (node->op == op_Store);
1369 return get_irn_n(node, 1);
1373 set_Store_ptr (ir_node *node, ir_node *ptr) {
1374 assert (node->op == op_Store);
1375 set_irn_n(node, 1, ptr);
1379 get_Store_value (ir_node *node) {
1380 assert (node->op == op_Store);
1381 return get_irn_n(node, 2);
1385 set_Store_value (ir_node *node, ir_node *value) {
1386 assert (node->op == op_Store);
1387 set_irn_n(node, 2, value);
1391 get_Alloc_mem (ir_node *node) {
1392 assert (node->op == op_Alloc);
1393 return get_irn_n(node, 0);
1397 set_Alloc_mem (ir_node *node, ir_node *mem) {
1398 assert (node->op == op_Alloc);
1399 set_irn_n(node, 0, mem);
1403 get_Alloc_size (ir_node *node) {
1404 assert (node->op == op_Alloc);
1405 return get_irn_n(node, 1);
1409 set_Allco_size (ir_node *node, ir_node *size) {
1410 assert (node->op == op_Alloc);
1411 set_irn_n(node, 1, size);
1415 get_Alloc_type (ir_node *node) {
1416 assert (node->op == op_Alloc);
1417 return node->attr.a.type;
1421 set_Alloc_type (ir_node *node, type *type) {
1422 assert (node->op == op_Alloc);
1423 node->attr.a.type = type;
1427 get_Alloc_where (ir_node *node) {
1428 assert (node->op == op_Alloc);
1429 return node->attr.a.where;
1433 set_Alloc_where (ir_node *node, where_alloc where) {
1434 assert (node->op == op_Alloc);
1435 node->attr.a.where = where;
1440 get_Free_mem (ir_node *node) {
1441 assert (node->op == op_Free);
1442 return get_irn_n(node, 0);
1446 set_Free_mem (ir_node *node, ir_node *mem) {
1447 assert (node->op == op_Free);
1448 set_irn_n(node, 0, mem);
1452 get_Free_ptr (ir_node *node) {
1453 assert (node->op == op_Free);
1454 return get_irn_n(node, 1);
1458 set_Free_ptr (ir_node *node, ir_node *ptr) {
1459 assert (node->op == op_Free);
1460 set_irn_n(node, 1, ptr);
1464 get_Free_size (ir_node *node) {
1465 assert (node->op == op_Free);
1466 return get_irn_n(node, 2);
1470 set_Free_size (ir_node *node, ir_node *size) {
1471 assert (node->op == op_Free);
1472 set_irn_n(node, 2, size);
1476 get_Free_type (ir_node *node) {
1477 assert (node->op == op_Free);
1478 return node->attr.f;
1482 set_Free_type (ir_node *node, type *type) {
1483 assert (node->op == op_Free);
1484 node->attr.f = type;
1488 get_Sync_n_preds (ir_node *node) {
1489 assert (node->op == op_Sync);
1490 return (get_irn_arity(node));
1495 set_Sync_n_preds (ir_node *node, int n_preds) {
1496 assert (node->op == op_Sync);
1501 get_Sync_pred (ir_node *node, int pos) {
1502 assert (node->op == op_Sync);
1503 return get_irn_n(node, pos);
1507 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1508 assert (node->op == op_Sync);
1509 set_irn_n(node, pos, pred);
1513 get_Proj_pred (ir_node *node) {
1514 assert (node->op == op_Proj);
1515 return get_irn_n(node, 0);
1519 set_Proj_pred (ir_node *node, ir_node *pred) {
1520 assert (node->op == op_Proj);
1521 set_irn_n(node, 0, pred);
1525 get_Proj_proj (ir_node *node) {
1526 assert (node->op == op_Proj);
1527 return node->attr.proj;
1531 set_Proj_proj (ir_node *node, long proj) {
1532 assert (node->op == op_Proj);
1533 node->attr.proj = proj;
1537 get_Tuple_n_preds (ir_node *node) {
1538 assert (node->op == op_Tuple);
1539 return (get_irn_arity(node));
1544 set_Tuple_n_preds (ir_node *node, int n_preds) {
1545 assert (node->op == op_Tuple);
1550 get_Tuple_pred (ir_node *node, int pos) {
1551 assert (node->op == op_Tuple);
1552 return get_irn_n(node, pos);
1556 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1557 assert (node->op == op_Tuple);
1558 set_irn_n(node, pos, pred);
1562 get_Id_pred (ir_node *node) {
1563 assert (node->op == op_Id);
1564 return get_irn_n(node, 0);
1568 set_Id_pred (ir_node *node, ir_node *pred) {
1569 assert (node->op == op_Id);
1570 set_irn_n(node, 0, pred);
1573 /******************************************************************/
1574 /* Auxiliary routines */
1575 /******************************************************************/
1578 skip_Proj (ir_node *node) {
1579 /* don't assert node !!! */
1580 if (node && (node->op == op_Proj)) {
1581 return get_Proj_pred(node);
1588 skip_nop (ir_node *node) {
1589 /* don't assert node !!! */
1590 if (node && (node->op == op_Id)) {
1591 return get_Id_pred(node);
1598 is_Bad (ir_node *node) {
1600 if ((node) && get_irn_opcode(node) == iro_Bad)
1606 is_no_Block (ir_node *node) {
1608 return (get_irn_opcode(node) != iro_Block);
1611 /* Returns true if the operation manipulates control flow. */
1613 is_cfop(ir_node *node) {
1614 return ( (get_irn_opcode(node) == iro_Start)
1615 || (get_irn_opcode(node) == iro_Jmp)
1616 || (get_irn_opcode(node) == iro_Cond)
1617 || (get_irn_opcode(node) == iro_Return)
1618 || (get_irn_opcode(node) == iro_Raise)
1619 || (get_irn_opcode(node) == iro_Bad));
1622 /* Returns true if the operation can change the control flow because
1625 is_fragile_op(ir_node *node) {
1626 return ( (get_irn_opcode(node) == iro_Call)
1627 || (get_irn_opcode(node) == iro_Quot)
1628 || (get_irn_opcode(node) == iro_DivMod)
1629 || (get_irn_opcode(node) == iro_Div)
1630 || (get_irn_opcode(node) == iro_Mod)
1631 || (get_irn_opcode(node) == iro_Load)
1632 || (get_irn_opcode(node) == iro_Store)
1633 || (get_irn_opcode(node) == iro_Alloc)
1634 || (get_irn_opcode(node) == iro_Bad));