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"};
54 /* irnode constructor */
55 /* create a new irnode in irg, with an op, mode, arity and */
56 /* some incoming irnodes */
57 /* this constructor is used in every specified irnode constructor */
59 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
60 int arity, ir_node **in)
63 int node_size = offsetof (ir_node, attr) + op->attr_size;
65 res = (ir_node *) obstack_alloc (irg->obst, node_size);
67 res->kind = k_ir_node;
73 res->in = NEW_ARR_F (ir_node *, 1);
75 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
76 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
81 res->node_nr = get_irp_new_node_nr();
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_opname(np));
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)
150 return (ARR_LEN((node)->in)-1);
153 /* Returns the array with ins. This array is shifted with respect to the
154 array accessed by get_irn_n: The block operand is at position 0 not -1.
155 (@@@ This should be changed.)
156 The order of the predecessors in this array is not guaranteed, except that
157 lists of operands as predecessors of Block or arguments of a Call are
160 get_irn_in (ir_node *node)
166 /* to iterate through the predecessors without touching the array */
167 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
168 to iterate includind the Block predecessor iterate from i = -1 to
170 If it is a block, the entry -1 is NULL. */
173 get_irn_n (ir_node *node, int n)
176 // assert (get_irn_arity (node) > n);
177 return skip_nop(node->in[n+1]);
181 set_irn_n (ir_node *node, int n, ir_node *in)
184 assert (get_irn_arity (node) > n);
189 get_irn_mode (ir_node *node)
196 get_irn_modecode (ir_node *node)
199 return node->mode->code;
204 get_irn_modename (ir_node *node)
207 return node->mode->name;
211 get_irn_op (ir_node *node)
217 /* should be private to the library: */
219 set_irn_op (ir_node *node, ir_op *op)
226 get_irn_opcode (ir_node *node)
229 return node->op->code;
233 get_irn_opname (ir_node *node)
236 return node->op->name;
240 get_irn_visited (ir_node *node)
243 return node->visited;
247 set_irn_visited (ir_node *node, unsigned long visited)
250 node->visited = visited;
253 set_irn_link (ir_node *node, ir_node *link) {
259 get_irn_link (ir_node *node) {
265 /* Outputs a unique number for this node */
267 get_irn_node_nr(ir_node *node) {
269 return node->node_nr;
274 get_irn_const_attr (ir_node *node)
276 assert (node->op == op_Const);
277 return node->attr.con;
281 get_irn_proj_attr (ir_node *node)
283 assert (node->op == op_Proj);
284 return node->attr.proj;
288 get_irn_alloc_attr (ir_node *node)
290 assert (node->op == op_Alloc);
295 get_irn_free_attr (ir_node *node)
297 assert (node->op == op_Free);
302 get_irn_symconst_attr (ir_node *node)
304 assert (node->op == op_SymConst);
309 get_irn_call_attr (ir_node *node)
311 assert (node->op == op_Call);
312 return node->attr.call;
316 get_irn_sel_attr (ir_node *node)
318 assert (node->op == op_Sel);
323 get_irn_phi_attr (ir_node *node)
325 assert (node->op == op_Phi);
326 return node->attr.phi0_pos;
330 get_irn_block_attr (ir_node *node)
332 assert (node->op == op_Block);
333 return node->attr.block;
336 /** manipulate fields of individual nodes **/
338 /* this works for all except Block */
340 get_nodes_Block (ir_node *node) {
341 assert (!(node->op == op_Block));
342 return get_irn_n(node, -1);
346 set_nodes_Block (ir_node *node, ir_node *block) {
347 assert (!(node->op == op_Block));
348 set_irn_n(node, -1, block);
351 /* Returns an array with the predecessors of the Block. Depending on
352 the implementation of the graph datastructure this can be a copy of
353 the internal representation of predecessors as well as the internal
354 array itself. Therefore writing to this array might obstruct the ir. */
356 get_Block_cfgpred_arr (ir_node *node)
358 assert ((node->op == op_Block));
359 return (ir_node **)get_Block_cfgpred(node, 0);
364 get_Block_n_cfgpreds (ir_node *node) {
365 assert ((node->op == op_Block));
366 return (get_irn_arity(node));
371 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
372 assert ((node->op == op_Block));
377 get_Block_cfgpred (ir_node *node, int pos) {
378 assert (node->op == op_Block);
379 return get_irn_n(node, pos);
383 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
384 assert (node->op == op_Block);
385 set_irn_n(node, pos, pred);
389 get_Block_matured (ir_node *node) {
390 assert (node->op == op_Block);
391 return node->attr.block.matured;
395 set_Block_matured (ir_node *node, bool matured) {
396 assert (node->op == op_Block);
397 node->attr.block.matured = matured;
400 get_Block_block_visited (ir_node *node) {
401 assert (node->op == op_Block);
402 return node->attr.block.block_visited;
406 set_Block_block_visited (ir_node *node, unsigned long visit) {
407 assert (node->op == op_Block);
408 node->attr.block.block_visited = visit;
412 get_Block_graph_arr (ir_node *node, int pos) {
413 assert (node->op == op_Block);
414 return node->attr.block.graph_arr[pos+1];
418 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
419 assert (node->op == op_Block);
420 node->attr.block.graph_arr[pos+1] = value;
424 get_Cond_selector (ir_node *node) {
425 assert (node->op == op_Cond);
426 return get_irn_n(node, 0);
430 set_Cond_selector (ir_node *node, ir_node *selector) {
431 assert (node->op == op_Cond);
432 set_irn_n(node, 0, selector);
436 get_Return_mem (ir_node *node) {
437 assert (node->op == op_Return);
438 return get_irn_n(node, 0);
442 set_Return_mem (ir_node *node, ir_node *mem) {
443 assert (node->op == op_Return);
444 set_irn_n(node, 0, mem);
448 get_Return_res_arr (ir_node *node)
450 assert ((node->op == op_Return));
451 if (get_Return_n_res(node) > 0)
452 return ((ir_node **)get_Return_res(node, 0));
458 get_Return_n_res (ir_node *node) {
459 assert (node->op == op_Return);
460 return (get_irn_arity(node) - 1);
465 set_Return_n_res (ir_node *node, int results) {
466 assert (node->op == op_Return);
471 get_Return_res (ir_node *node, int pos) {
472 assert (node->op == op_Return);
473 assert (get_Return_n_res(node) > pos);
474 return get_irn_n(node, pos+1);
478 set_Return_res (ir_node *node, int pos, ir_node *res){
479 assert (node->op == op_Return);
480 set_irn_n(node, pos+1, res);
484 get_Raise_mem (ir_node *node) {
485 assert (node->op == op_Return);
486 return get_irn_n(node, 0);
490 set_Raise_mem (ir_node *node, ir_node *mem) {
491 assert (node->op == op_Raise);
492 set_irn_n(node, 0, mem);
496 get_Raise_exo_ptr (ir_node *node) {
497 assert (node->op == op_Raise);
498 return get_irn_n(node, 1);
502 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
503 assert (node->op == op_Raise);
504 set_irn_n(node, 1, exo_ptr);
507 inline tarval *get_Const_tarval (ir_node *node) {
508 assert (node->op == op_Const);
509 return get_irn_const_attr(node);
513 set_Const_tarval (ir_node *node, tarval *con) {
514 assert (node->op == op_Const);
515 node->attr.con = con;
519 get_SymConst_kind (ir_node *node) {
520 assert (node->op == op_SymConst);
521 return node->attr.i.num;
525 set_SymConst_kind (ir_node *node, symconst_kind num) {
526 assert (node->op == op_SymConst);
527 node->attr.i.num = num;
531 get_SymConst_type (ir_node *node) {
532 assert ( (node->op == op_SymConst)
533 && ( get_SymConst_kind(node) == type_tag
534 || get_SymConst_kind(node) == size));
535 return node->attr.i.tori.typ;
539 set_SymConst_type (ir_node *node, type *type) {
540 assert ( (node->op == op_SymConst)
541 && ( get_SymConst_kind(node) == type_tag
542 || get_SymConst_kind(node) == size));
543 node->attr.i.tori.typ = type;
547 get_SymConst_ptrinfo (ir_node *node) {
548 assert ( (node->op == op_SymConst)
549 && (get_SymConst_kind(node) == linkage_ptr_info));
550 return node->attr.i.tori.ptrinfo;
556 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
557 assert ( (node->op == op_SymConst)
558 && (get_SymConst_kind(node) == linkage_ptr_info));
559 node->attr.i.tori.ptrinfo = ptrinfo;
563 get_Sel_mem (ir_node *node) {
564 assert (node->op == op_Sel);
565 return get_irn_n(node, 0);
569 set_Sel_mem (ir_node *node, ir_node *mem) {
570 assert (node->op == op_Sel);
571 set_irn_n(node, 0, mem);
575 get_Sel_ptr (ir_node *node) {
576 assert (node->op == op_Sel);
577 return get_irn_n(node, 1);
581 set_Sel_ptr (ir_node *node, ir_node *ptr) {
582 assert (node->op == op_Sel);
583 set_irn_n(node, 1, ptr);
587 get_Sel_index_arr (ir_node *node)
589 assert ((node->op == op_Sel));
590 if (get_Sel_n_index(node) > 0)
591 return (ir_node **)get_Sel_index(node, 0);
597 get_Sel_n_index (ir_node *node) {
598 assert (node->op == op_Sel);
599 return (get_irn_arity(node) - 2);
604 set_Sel_n_index (ir_node *node, int n_index) {
605 assert (node->op == op_Sel);
610 get_Sel_index (ir_node *node, int pos) {
611 assert (node->op == op_Sel);
612 return get_irn_n(node, pos+2);
616 set_Sel_index (ir_node *node, int pos, ir_node *index) {
617 assert (node->op == op_Sel);
618 set_irn_n(node, pos+2, index);
622 get_Sel_entity (ir_node *node) {
623 assert (node->op == op_Sel);
624 return node->attr.s.ent;
628 set_Sel_entity (ir_node *node, entity *ent) {
629 assert (node->op == op_Sel);
630 node->attr.s.ent = ent;
634 get_Sel_linkage_type (ir_node *node) {
635 assert (node->op == op_Sel);
636 return node->attr.s.ltyp;
640 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
641 assert (node->op == op_Sel);
642 node->attr.s.ltyp = lt;
646 get_Call_mem (ir_node *node) {
647 assert (node->op == op_Call);
648 return get_irn_n(node, 0);
652 set_Call_mem (ir_node *node, ir_node *mem) {
653 assert (node->op == op_Call);
654 set_irn_n(node, 0, mem);
658 get_Call_ptr (ir_node *node) {
659 assert (node->op == op_Call);
660 return get_irn_n(node, 1);
664 set_Call_ptr (ir_node *node, ir_node *ptr) {
665 assert (node->op == op_Call);
666 set_irn_n(node, 1, ptr);
670 get_Call_param_arr (ir_node *node) {
671 assert (node->op == op_Call);
672 if (get_Call_arity(node) > 0)
673 return ((ir_node **)get_Call_param (node, 0));
679 get_Call_arity (ir_node *node) {
680 assert (node->op == op_Call);
681 return (get_irn_arity(node) - 2);
685 set_Call_arity (ir_node *node, ir_node *arity) {
686 assert (node->op == op_Call);
691 get_Call_param (ir_node *node, int pos) {
692 assert (node->op == op_Call);
693 return get_irn_n(node, pos+1);
697 set_Call_param (ir_node *node, int pos, ir_node *param) {
698 assert (node->op == op_Call);
699 set_irn_n(node, pos+1, param);
703 get_Call_type (ir_node *node) {
704 assert (node->op == op_Call);
705 return node->attr.call;
709 set_Call_type (ir_node *node, type_method *type) {
710 assert (node->op == op_Call);
711 node->attr.call = type;
714 /* For unary and binary arithmetic operations the access to the
715 operands can be factored out. Left is the first, right the
716 second arithmetic value as listed in tech report 0999-33.
717 unops are: Minus, Abs, Not, Conv
718 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
719 Shr, Shrs, Rotate, Cmp */
722 is_unop (ir_node *node) {
723 return ( node->op == op_Minus ||
724 node->op == op_Abs ||
725 node->op == op_Not ||
726 node->op == op_Conv );
730 get_unop_op (ir_node *node) {
731 assert ( node->op == op_Minus ||
732 node->op == op_Abs ||
733 node->op == op_Not ||
734 node->op == op_Conv );
735 switch (get_irn_opcode (node)) {
736 case iro_Minus: return get_Minus_op(node); break;
737 case iro_Abs: return get_Abs_op(node); break;
738 case iro_Not: return get_Not_op(node); break;
739 case iro_Conv: return get_Conv_op(node); break;
740 default: return NULL;
745 set_unop_op (ir_node *node, ir_node *op) {
746 assert (node->op == op_Minus ||
747 node->op == op_Abs ||
748 node->op == op_Not ||
749 node->op == op_Conv );
750 switch (get_irn_opcode (node)) {
751 case iro_Minus: set_Minus_op(node, op); break;
752 case iro_Abs: set_Abs_op(node, op); break;
753 case iro_Not: set_Not_op(node, op); break;
754 case iro_Conv: set_Conv_op(node, op); break;
761 is_binop (ir_node *node) {
762 return (node->op == op_Add ||
763 node->op == op_Sub ||
764 node->op == op_Mul ||
765 node->op == op_Quot ||
766 node->op == op_DivMod ||
767 node->op == op_Div ||
768 node->op == op_Mod ||
769 node->op == op_And ||
771 node->op == op_Eor ||
772 node->op == op_Shl ||
773 node->op == op_Shr ||
774 node->op == op_Shrs ||
775 node->op == op_Rot ||
776 node->op == op_Cmp );
780 get_binop_left (ir_node *node) {
781 assert (node->op == op_Add ||
782 node->op == op_Sub ||
783 node->op == op_Mul ||
784 node->op == op_Quot ||
785 node->op == op_DivMod ||
786 node->op == op_Div ||
787 node->op == op_Mod ||
788 node->op == op_And ||
790 node->op == op_Eor ||
791 node->op == op_Shl ||
792 node->op == op_Shr ||
793 node->op == op_Shrs ||
794 node->op == op_Rot ||
795 node->op == op_Cmp );
797 switch (get_irn_opcode (node)) {
798 case iro_Add : return get_Add_left(node); break;
799 case iro_Sub : return get_Sub_left(node); break;
800 case iro_Mul : return get_Mul_left(node); break;
801 case iro_Quot : return get_Quot_left(node); break;
802 case iro_DivMod: return get_DivMod_left(node); break;
803 case iro_Div : return get_Div_left(node); break;
804 case iro_Mod : return get_Mod_left(node); break;
805 case iro_And : return get_And_left(node); break;
806 case iro_Or : return get_Or_left(node); break;
807 case iro_Eor : return get_Eor_left(node); break;
808 case iro_Shl : return get_Shl_left(node); break;
809 case iro_Shr : return get_Shr_left(node); break;
810 case iro_Shrs : return get_Shrs_left(node); break;
811 case iro_Rot : return get_Rot_left(node); break;
812 case iro_Cmp : return get_Cmp_left(node); break;
813 default: return NULL;
818 set_binop_left (ir_node *node, ir_node *left) {
819 assert (node->op == op_Add ||
820 node->op == op_Sub ||
821 node->op == op_Mul ||
822 node->op == op_Quot ||
823 node->op == op_DivMod ||
824 node->op == op_Div ||
825 node->op == op_Mod ||
826 node->op == op_And ||
828 node->op == op_Eor ||
829 node->op == op_Shl ||
830 node->op == op_Shr ||
831 node->op == op_Shrs ||
832 node->op == op_Rot ||
833 node->op == op_Cmp );
835 switch (get_irn_opcode (node)) {
836 case iro_Add : set_Add_left(node, left); break;
837 case iro_Sub : set_Sub_left(node, left); break;
838 case iro_Mul : set_Mul_left(node, left); break;
839 case iro_Quot : set_Quot_left(node, left); break;
840 case iro_DivMod: set_DivMod_left(node, left); break;
841 case iro_Div : set_Div_left(node, left); break;
842 case iro_Mod : set_Mod_left(node, left); break;
843 case iro_And : set_And_left(node, left); break;
844 case iro_Or : set_Or_left(node, left); break;
845 case iro_Eor : set_Eor_left(node, left); break;
846 case iro_Shl : set_Shl_left(node, left); break;
847 case iro_Shr : set_Shr_left(node, left); break;
848 case iro_Shrs : set_Shrs_left(node, left); break;
849 case iro_Rot : set_Rot_left(node, left); break;
850 case iro_Cmp : set_Cmp_left(node, left); break;
856 get_binop_right (ir_node *node) {
857 assert (node->op == op_Add ||
858 node->op == op_Sub ||
859 node->op == op_Mul ||
860 node->op == op_Quot ||
861 node->op == op_DivMod ||
862 node->op == op_Div ||
863 node->op == op_Mod ||
864 node->op == op_And ||
866 node->op == op_Eor ||
867 node->op == op_Shl ||
868 node->op == op_Shr ||
869 node->op == op_Shrs ||
870 node->op == op_Rot ||
871 node->op == op_Cmp );
873 switch (get_irn_opcode (node)) {
874 case iro_Add : return get_Add_right(node); break;
875 case iro_Sub : return get_Sub_right(node); break;
876 case iro_Mul : return get_Mul_right(node); break;
877 case iro_Quot : return get_Quot_right(node); break;
878 case iro_DivMod: return get_DivMod_right(node); break;
879 case iro_Div : return get_Div_right(node); break;
880 case iro_Mod : return get_Mod_right(node); break;
881 case iro_And : return get_And_right(node); break;
882 case iro_Or : return get_Or_right(node); break;
883 case iro_Eor : return get_Eor_right(node); break;
884 case iro_Shl : return get_Shl_right(node); break;
885 case iro_Shr : return get_Shr_right(node); break;
886 case iro_Shrs : return get_Shrs_right(node); break;
887 case iro_Rot : return get_Rot_right(node); break;
888 case iro_Cmp : return get_Cmp_right(node); break;
889 default: return NULL;
894 set_binop_right (ir_node *node, ir_node *right) {
895 assert (node->op == op_Add ||
896 node->op == op_Sub ||
897 node->op == op_Mul ||
898 node->op == op_Quot ||
899 node->op == op_DivMod ||
900 node->op == op_Div ||
901 node->op == op_Mod ||
902 node->op == op_And ||
904 node->op == op_Eor ||
905 node->op == op_Shl ||
906 node->op == op_Shr ||
907 node->op == op_Shrs ||
908 node->op == op_Rot ||
909 node->op == op_Cmp );
911 switch (get_irn_opcode (node)) {
912 case iro_Add : set_Add_right(node, right); break;
913 case iro_Sub : set_Sub_right(node, right); break;
914 case iro_Mul : set_Mul_right(node, right); break;
915 case iro_Quot : set_Quot_right(node, right); break;
916 case iro_DivMod: set_DivMod_right(node, right); break;
917 case iro_Div : set_Div_right(node, right); break;
918 case iro_Mod : set_Mod_right(node, right); break;
919 case iro_And : set_And_right(node, right); break;
920 case iro_Or : set_Or_right(node, right); break;
921 case iro_Eor : set_Eor_right(node, right); break;
922 case iro_Shl : set_Shl_right(node, right); break;
923 case iro_Shr : set_Shr_right(node, right); break;
924 case iro_Shrs : set_Shrs_right(node, right); break;
925 case iro_Rot : set_Rot_right(node, right); break;
926 case iro_Cmp : set_Cmp_right(node, right); break;
932 get_Add_left (ir_node *node) {
933 assert (node->op == op_Add);
934 return get_irn_n(node, 0);
938 set_Add_left (ir_node *node, ir_node *left) {
939 assert (node->op == op_Add);
940 set_irn_n(node, 0, left);
944 get_Add_right (ir_node *node) {
945 assert (node->op == op_Add);
946 return get_irn_n(node, 1);
950 set_Add_right (ir_node *node, ir_node *right) {
951 assert (node->op == op_Add);
952 set_irn_n(node, 1, right);
956 get_Sub_left (ir_node *node) {
957 assert (node->op == op_Sub);
958 return get_irn_n(node, 0);
962 set_Sub_left (ir_node *node, ir_node *left) {
963 assert (node->op == op_Sub);
964 set_irn_n(node, 0, left);
968 get_Sub_right (ir_node *node) {
969 assert (node->op == op_Sub);
970 return get_irn_n(node, 1);
974 set_Sub_right (ir_node *node, ir_node *right) {
975 assert (node->op == op_Sub);
976 set_irn_n(node, 1, right);
981 get_Minus_op (ir_node *node) {
982 assert (node->op == op_Minus);
983 return get_irn_n(node, 0);
987 set_Minus_op (ir_node *node, ir_node *op) {
988 assert (node->op == op_Minus);
989 set_irn_n(node, 0, op);
994 get_Mul_left (ir_node *node) {
995 assert (node->op == op_Mul);
996 return get_irn_n(node, 0);
1000 set_Mul_left (ir_node *node, ir_node *left) {
1001 assert (node->op == op_Mul);
1002 set_irn_n(node, 0, left);
1006 get_Mul_right (ir_node *node) {
1007 assert (node->op == op_Mul);
1008 return get_irn_n(node, 1);
1012 set_Mul_right (ir_node *node, ir_node *right) {
1013 assert (node->op == op_Mul);
1014 set_irn_n(node, 1, right);
1018 get_Quot_left (ir_node *node) {
1019 assert (node->op == op_Quot);
1020 return get_irn_n(node, 1);
1024 set_Quot_left (ir_node *node, ir_node *left) {
1025 assert (node->op == op_Quot);
1026 set_irn_n(node, 1, left);
1030 get_Quot_right (ir_node *node) {
1031 assert (node->op == op_Quot);
1032 return get_irn_n(node, 2);
1036 set_Quot_right (ir_node *node, ir_node *right) {
1037 assert (node->op == op_Quot);
1038 set_irn_n(node, 2, right);
1042 get_Quot_mem (ir_node *node) {
1043 assert (node->op == op_Quot);
1044 return get_irn_n(node, 0);
1048 set_Quot_mem (ir_node *node, ir_node *mem) {
1049 assert (node->op == op_Quot);
1050 set_irn_n(node, 0, mem);
1054 get_DivMod_left (ir_node *node) {
1055 assert (node->op == op_DivMod);
1056 return get_irn_n(node, 1);
1060 set_DivMod_left (ir_node *node, ir_node *left) {
1061 assert (node->op == op_DivMod);
1062 set_irn_n(node, 1, left);
1066 get_DivMod_right (ir_node *node) {
1067 assert (node->op == op_DivMod);
1068 return get_irn_n(node, 2);
1072 set_DivMod_right (ir_node *node, ir_node *right) {
1073 assert (node->op == op_DivMod);
1074 set_irn_n(node, 2, right);
1078 get_DivMod_mem (ir_node *node) {
1079 assert (node->op == op_DivMod);
1080 return get_irn_n(node, 0);
1084 set_DivMod_mem (ir_node *node, ir_node *mem) {
1085 assert (node->op == op_DivMod);
1086 set_irn_n(node, 0, mem);
1090 get_Div_left (ir_node *node) {
1091 assert (node->op == op_Div);
1092 return get_irn_n(node, 1);
1096 set_Div_left (ir_node *node, ir_node *left) {
1097 assert (node->op == op_Div);
1098 set_irn_n(node, 1, left);
1102 get_Div_right (ir_node *node) {
1103 assert (node->op == op_Div);
1104 return get_irn_n(node, 2);
1108 set_Div_right (ir_node *node, ir_node *right) {
1109 assert (node->op == op_Div);
1110 set_irn_n(node, 2, right);
1114 get_Div_mem (ir_node *node) {
1115 assert (node->op == op_Div);
1116 return get_irn_n(node, 0);
1120 set_Div_mem (ir_node *node, ir_node *mem) {
1121 assert (node->op == op_Div);
1122 set_irn_n(node, 0, mem);
1126 get_Mod_left (ir_node *node) {
1127 assert (node->op == op_Mod);
1128 return get_irn_n(node, 1);
1132 set_Mod_left (ir_node *node, ir_node *left) {
1133 assert (node->op == op_Mod);
1134 set_irn_n(node, 1, left);
1138 get_Mod_right (ir_node *node) {
1139 assert (node->op == op_Mod);
1140 return get_irn_n(node, 2);
1144 set_Mod_right (ir_node *node, ir_node *right) {
1145 assert (node->op == op_Mod);
1146 set_irn_n(node, 2, right);
1150 get_Mod_mem (ir_node *node) {
1151 assert (node->op == op_Mod);
1152 return get_irn_n(node, 0);
1156 set_Mod_mem (ir_node *node, ir_node *mem) {
1157 assert (node->op == op_Mod);
1158 set_irn_n(node, 0, mem);
1162 get_Abs_op (ir_node *node) {
1163 assert (node->op == op_Abs);
1164 return get_irn_n(node, 0);
1168 set_Abs_op (ir_node *node, ir_node *op) {
1169 assert (node->op == op_Abs);
1170 set_irn_n(node, 0, op);
1174 get_And_left (ir_node *node) {
1175 assert (node->op == op_And);
1176 return get_irn_n(node, 0);
1180 set_And_left (ir_node *node, ir_node *left) {
1181 assert (node->op == op_And);
1182 set_irn_n(node, 0, left);
1186 get_And_right (ir_node *node) {
1187 assert (node->op == op_And);
1188 return get_irn_n(node, 1);
1192 set_And_right (ir_node *node, ir_node *right) {
1193 assert (node->op == op_And);
1194 set_irn_n(node, 1, right);
1198 get_Or_left (ir_node *node) {
1199 assert (node->op == op_Or);
1200 return get_irn_n(node, 0);
1204 set_Or_left (ir_node *node, ir_node *left) {
1205 assert (node->op == op_Or);
1206 set_irn_n(node, 0, left);
1210 get_Or_right (ir_node *node) {
1211 assert (node->op == op_Or);
1212 return get_irn_n(node, 1);
1216 set_Or_right (ir_node *node, ir_node *right) {
1217 assert (node->op == op_Or);
1218 set_irn_n(node, 1, right);
1222 get_Eor_left (ir_node *node) {
1223 assert (node->op == op_Eor);
1224 return get_irn_n(node, 0);
1228 set_Eor_left (ir_node *node, ir_node *left) {
1229 assert (node->op == op_Eor);
1230 set_irn_n(node, 0, left);
1234 get_Eor_right (ir_node *node) {
1235 assert (node->op == op_Eor);
1236 return get_irn_n(node, 1);
1240 set_Eor_right (ir_node *node, ir_node *right) {
1241 assert (node->op == op_Eor);
1242 set_irn_n(node, 1, right);
1247 get_Not_op (ir_node *node) {
1248 assert (node->op == op_Not);
1249 return get_irn_n(node, 0);
1253 set_Not_op (ir_node *node, ir_node *op) {
1254 assert (node->op == op_Not);
1255 set_irn_n(node, 0, op);
1260 get_Shl_left (ir_node *node) {
1261 assert (node->op == op_Shl);
1262 return get_irn_n(node, 0);
1266 set_Shl_left (ir_node *node, ir_node *left) {
1267 assert (node->op == op_Shl);
1268 set_irn_n(node, 0, left);
1272 get_Shl_right (ir_node *node) {
1273 assert (node->op == op_Shl);
1274 return get_irn_n(node, 1);
1278 set_Shl_right (ir_node *node, ir_node *right) {
1279 assert (node->op == op_Shl);
1280 set_irn_n(node, 1, right);
1284 get_Shr_left (ir_node *node) {
1285 assert (node->op == op_Shr);
1286 return get_irn_n(node, 0);
1290 set_Shr_left (ir_node *node, ir_node *left) {
1291 assert (node->op == op_Shr);
1292 set_irn_n(node, 0, left);
1296 get_Shr_right (ir_node *node) {
1297 assert (node->op == op_Shr);
1298 return get_irn_n(node, 1);
1302 set_Shr_right (ir_node *node, ir_node *right) {
1303 assert (node->op == op_Shr);
1304 set_irn_n(node, 1, right);
1308 get_Shrs_left (ir_node *node) {
1309 assert (node->op == op_Shrs);
1310 return get_irn_n(node, 0);
1314 set_Shrs_left (ir_node *node, ir_node *left) {
1315 assert (node->op == op_Shrs);
1316 set_irn_n(node, 0, left);
1320 get_Shrs_right (ir_node *node) {
1321 assert (node->op == op_Shrs);
1322 return get_irn_n(node, 1);
1326 set_Shrs_right (ir_node *node, ir_node *right) {
1327 assert (node->op == op_Shrs);
1328 set_irn_n(node, 1, right);
1332 get_Rot_left (ir_node *node) {
1333 assert (node->op == op_Rot);
1334 return get_irn_n(node, 0);
1338 set_Rot_left (ir_node *node, ir_node *left) {
1339 assert (node->op == op_Rot);
1340 set_irn_n(node, 0, left);
1344 get_Rot_right (ir_node *node) {
1345 assert (node->op == op_Rot);
1346 return get_irn_n(node, 1);
1350 set_Rot_right (ir_node *node, ir_node *right) {
1351 assert (node->op == op_Rot);
1352 set_irn_n(node, 1, right);
1356 get_Cmp_left (ir_node *node) {
1357 assert (node->op == op_Cmp);
1358 return get_irn_n(node, 0);
1362 set_Cmp_left (ir_node *node, ir_node *left) {
1363 assert (node->op == op_Cmp);
1364 set_irn_n(node, 0, left);
1368 get_Cmp_right (ir_node *node) {
1369 assert (node->op == op_Cmp);
1370 return get_irn_n(node, 1);
1374 set_Cmp_right (ir_node *node, ir_node *right) {
1375 assert (node->op == op_Cmp);
1376 set_irn_n(node, 1, right);
1380 get_Conv_op (ir_node *node) {
1381 assert (node->op == op_Conv);
1382 return get_irn_n(node, 0);
1386 set_Conv_op (ir_node *node, ir_node *op) {
1387 assert (node->op == op_Conv);
1388 set_irn_n(node, 0, op);
1392 get_Phi_preds_arr (ir_node *node) {
1393 assert (node->op == op_Phi);
1394 return ((ir_node **)get_Phi_pred(node, 0));
1398 get_Phi_n_preds (ir_node *node) {
1399 assert (node->op == op_Phi);
1400 return (get_irn_arity(node));
1404 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1405 assert (node->op == op_Phi);
1410 get_Phi_pred (ir_node *node, int pos) {
1411 assert (node->op == op_Phi);
1412 return get_irn_n(node, pos);
1416 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1417 assert (node->op == op_Phi);
1418 set_irn_n(node, pos, pred);
1422 get_Load_mem (ir_node *node) {
1423 assert (node->op == op_Load);
1424 return get_irn_n(node, 0);
1428 set_Load_mem (ir_node *node, ir_node *mem) {
1429 assert (node->op == op_Load);
1430 set_irn_n(node, 0, mem);
1434 get_Load_ptr (ir_node *node) {
1435 assert (node->op == op_Load);
1436 return get_irn_n(node, 1);
1440 set_Load_ptr (ir_node *node, ir_node *ptr) {
1441 assert (node->op == op_Load);
1442 set_irn_n(node, 1, ptr);
1447 get_Store_mem (ir_node *node) {
1448 assert (node->op == op_Store);
1449 return get_irn_n(node, 0);
1453 set_Store_mem (ir_node *node, ir_node *mem) {
1454 assert (node->op == op_Store);
1455 set_irn_n(node, 0, mem);
1459 get_Store_ptr (ir_node *node) {
1460 assert (node->op == op_Store);
1461 return get_irn_n(node, 1);
1465 set_Store_ptr (ir_node *node, ir_node *ptr) {
1466 assert (node->op == op_Store);
1467 set_irn_n(node, 1, ptr);
1471 get_Store_value (ir_node *node) {
1472 assert (node->op == op_Store);
1473 return get_irn_n(node, 2);
1477 set_Store_value (ir_node *node, ir_node *value) {
1478 assert (node->op == op_Store);
1479 set_irn_n(node, 2, value);
1483 get_Alloc_mem (ir_node *node) {
1484 assert (node->op == op_Alloc);
1485 return get_irn_n(node, 0);
1489 set_Alloc_mem (ir_node *node, ir_node *mem) {
1490 assert (node->op == op_Alloc);
1491 set_irn_n(node, 0, mem);
1495 get_Alloc_size (ir_node *node) {
1496 assert (node->op == op_Alloc);
1497 return get_irn_n(node, 1);
1501 set_Allco_size (ir_node *node, ir_node *size) {
1502 assert (node->op == op_Alloc);
1503 set_irn_n(node, 1, size);
1507 get_Alloc_type (ir_node *node) {
1508 assert (node->op == op_Alloc);
1509 return node->attr.a.type;
1513 set_Alloc_type (ir_node *node, type *type) {
1514 assert (node->op == op_Alloc);
1515 node->attr.a.type = type;
1519 get_Alloc_where (ir_node *node) {
1520 assert (node->op == op_Alloc);
1521 return node->attr.a.where;
1525 set_Alloc_where (ir_node *node, where_alloc where) {
1526 assert (node->op == op_Alloc);
1527 node->attr.a.where = where;
1532 get_Free_mem (ir_node *node) {
1533 assert (node->op == op_Free);
1534 return get_irn_n(node, 0);
1538 set_Free_mem (ir_node *node, ir_node *mem) {
1539 assert (node->op == op_Free);
1540 set_irn_n(node, 0, mem);
1544 get_Free_ptr (ir_node *node) {
1545 assert (node->op == op_Free);
1546 return get_irn_n(node, 1);
1550 set_Free_ptr (ir_node *node, ir_node *ptr) {
1551 assert (node->op == op_Free);
1552 set_irn_n(node, 1, ptr);
1556 get_Free_size (ir_node *node) {
1557 assert (node->op == op_Free);
1558 return get_irn_n(node, 2);
1562 set_Free_size (ir_node *node, ir_node *size) {
1563 assert (node->op == op_Free);
1564 set_irn_n(node, 2, size);
1568 get_Free_type (ir_node *node) {
1569 assert (node->op == op_Free);
1570 return node->attr.f;
1574 set_Free_type (ir_node *node, type *type) {
1575 assert (node->op == op_Free);
1576 node->attr.f = type;
1580 get_Sync_preds_arr (ir_node *node) {
1581 assert (node->op == op_Sync);
1582 return ((ir_node **)get_Sync_pred(node, 0));
1586 get_Sync_n_preds (ir_node *node) {
1587 assert (node->op == op_Sync);
1588 return (get_irn_arity(node));
1593 set_Sync_n_preds (ir_node *node, int n_preds) {
1594 assert (node->op == op_Sync);
1599 get_Sync_pred (ir_node *node, int pos) {
1600 assert (node->op == op_Sync);
1601 return get_irn_n(node, pos);
1605 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1606 assert (node->op == op_Sync);
1607 set_irn_n(node, pos, pred);
1611 get_Proj_pred (ir_node *node) {
1612 assert (node->op == op_Proj);
1613 return get_irn_n(node, 0);
1617 set_Proj_pred (ir_node *node, ir_node *pred) {
1618 assert (node->op == op_Proj);
1619 set_irn_n(node, 0, pred);
1623 get_Proj_proj (ir_node *node) {
1624 assert (node->op == op_Proj);
1625 return node->attr.proj;
1629 set_Proj_proj (ir_node *node, long proj) {
1630 assert (node->op == op_Proj);
1631 node->attr.proj = proj;
1635 get_Tuple_preds_arr (ir_node *node) {
1636 assert (node->op == op_Tuple);
1637 return ((ir_node **)get_Tuple_pred(node, 0));
1641 get_Tuple_n_preds (ir_node *node) {
1642 assert (node->op == op_Tuple);
1643 return (get_irn_arity(node));
1648 set_Tuple_n_preds (ir_node *node, int n_preds) {
1649 assert (node->op == op_Tuple);
1654 get_Tuple_pred (ir_node *node, int pos) {
1655 assert (node->op == op_Tuple);
1656 return get_irn_n(node, pos);
1660 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1661 assert (node->op == op_Tuple);
1662 set_irn_n(node, pos, pred);
1666 get_Id_pred (ir_node *node) {
1667 assert (node->op == op_Id);
1668 return get_irn_n(node, 0);
1672 set_Id_pred (ir_node *node, ir_node *pred) {
1673 assert (node->op == op_Id);
1674 set_irn_n(node, 0, pred);
1677 /******************************************************************/
1678 /* Auxiliary routines */
1679 /******************************************************************/
1682 skip_Proj (ir_node *node) {
1683 /* don't assert node !!! */
1684 if (node && (node->op == op_Proj)) {
1685 return get_Proj_pred(node);
1692 skip_nop (ir_node *node) {
1693 /* don't assert node !!! */
1694 if (node && (node->op == op_Id)) {
1695 return get_Id_pred(node);
1702 is_Bad (ir_node *node) {
1704 if ((node) && get_irn_opcode(node) == iro_Bad)
1710 is_no_Block (ir_node *node) {
1712 return (get_irn_opcode(node) != iro_Block);
1715 /* Returns true if the operation manipulates control flow. */
1717 is_cfop(ir_node *node) {
1718 return ( (get_irn_opcode(node) == iro_Start)
1719 || (get_irn_opcode(node) == iro_Jmp)
1720 || (get_irn_opcode(node) == iro_Cond)
1721 || (get_irn_opcode(node) == iro_Return)
1722 || (get_irn_opcode(node) == iro_Raise)
1723 || (get_irn_opcode(node) == iro_Bad));
1726 /* Returns true if the operation can change the control flow because
1729 is_fragile_op(ir_node *node) {
1730 return ( (get_irn_opcode(node) == iro_Call)
1731 || (get_irn_opcode(node) == iro_Quot)
1732 || (get_irn_opcode(node) == iro_DivMod)
1733 || (get_irn_opcode(node) == iro_Div)
1734 || (get_irn_opcode(node) == iro_Mod)
1735 || (get_irn_opcode(node) == iro_Load)
1736 || (get_irn_opcode(node) == iro_Store)
1737 || (get_irn_opcode(node) == iro_Alloc)
1738 || (get_irn_opcode(node) == iro_Bad));