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 return ((ir_node **)get_Return_res(node, 0));
455 get_Return_n_res (ir_node *node) {
456 assert (node->op == op_Return);
457 return (get_irn_arity(node) - 1);
462 set_Return_n_res (ir_node *node, int results) {
463 assert (node->op == op_Return);
468 get_Return_res (ir_node *node, int pos) {
469 assert (node->op == op_Return);
470 return get_irn_n(node, pos+1);
474 set_Return_res (ir_node *node, int pos, ir_node *res){
475 assert (node->op == op_Return);
476 set_irn_n(node, pos+1, res);
480 get_Raise_mem (ir_node *node) {
481 assert (node->op == op_Return);
482 return get_irn_n(node, 0);
486 set_Raise_mem (ir_node *node, ir_node *mem) {
487 assert (node->op == op_Raise);
488 set_irn_n(node, 0, mem);
492 get_Raise_exo_ptr (ir_node *node) {
493 assert (node->op == op_Raise);
494 return get_irn_n(node, 1);
498 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
499 assert (node->op == op_Raise);
500 set_irn_n(node, 1, exo_ptr);
503 inline tarval *get_Const_tarval (ir_node *node) {
504 assert (node->op == op_Const);
505 return get_irn_const_attr(node);
509 set_Const_tarval (ir_node *node, tarval *con) {
510 assert (node->op == op_Const);
511 node->attr.con = con;
515 get_SymConst_kind (ir_node *node) {
516 assert (node->op == op_SymConst);
517 return node->attr.i.num;
521 set_SymConst_kind (ir_node *node, symconst_kind num) {
522 assert (node->op == op_SymConst);
523 node->attr.i.num = num;
527 get_SymConst_type (ir_node *node) {
528 assert ( (node->op == op_SymConst)
529 && ( get_SymConst_kind(node) == type_tag
530 || get_SymConst_kind(node) == size));
531 return node->attr.i.tori.typ;
535 set_SymConst_type (ir_node *node, type *type) {
536 assert ( (node->op == op_SymConst)
537 && ( get_SymConst_kind(node) == type_tag
538 || get_SymConst_kind(node) == size));
539 node->attr.i.tori.typ = type;
543 get_SymConst_ptrinfo (ir_node *node) {
544 assert ( (node->op == op_SymConst)
545 && (get_SymConst_kind(node) == linkage_ptr_info));
546 return node->attr.i.tori.ptrinfo;
552 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
553 assert ( (node->op == op_SymConst)
554 && (get_SymConst_kind(node) == linkage_ptr_info));
555 node->attr.i.tori.ptrinfo = ptrinfo;
559 get_Sel_mem (ir_node *node) {
560 assert (node->op == op_Sel);
561 return get_irn_n(node, 0);
565 set_Sel_mem (ir_node *node, ir_node *mem) {
566 assert (node->op == op_Sel);
567 set_irn_n(node, 0, mem);
571 get_Sel_ptr (ir_node *node) {
572 assert (node->op == op_Sel);
573 return get_irn_n(node, 1);
577 set_Sel_ptr (ir_node *node, ir_node *ptr) {
578 assert (node->op == op_Sel);
579 set_irn_n(node, 1, ptr);
583 get_Sel_index_arr (ir_node *node)
585 assert ((node->op == op_Sel));
586 return (ir_node **)get_Sel_index(node, 0);
590 get_Sel_n_index (ir_node *node) {
591 assert (node->op == op_Sel);
592 return (get_irn_arity(node) - 2);
597 set_Sel_n_index (ir_node *node, int n_index) {
598 assert (node->op == op_Sel);
603 get_Sel_index (ir_node *node, int pos) {
604 assert (node->op == op_Sel);
605 return get_irn_n(node, pos+2);
609 set_Sel_index (ir_node *node, int pos, ir_node *index) {
610 assert (node->op == op_Sel);
611 set_irn_n(node, pos+2, index);
615 get_Sel_entity (ir_node *node) {
616 assert (node->op == op_Sel);
617 return node->attr.s.ent;
621 set_Sel_entity (ir_node *node, entity *ent) {
622 assert (node->op == op_Sel);
623 node->attr.s.ent = ent;
627 get_Sel_linkage_type (ir_node *node) {
628 assert (node->op == op_Sel);
629 return node->attr.s.ltyp;
633 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
634 assert (node->op == op_Sel);
635 node->attr.s.ltyp = lt;
639 get_Call_mem (ir_node *node) {
640 assert (node->op == op_Call);
641 return get_irn_n(node, 0);
645 set_Call_mem (ir_node *node, ir_node *mem) {
646 assert (node->op == op_Call);
647 set_irn_n(node, 0, mem);
651 get_Call_ptr (ir_node *node) {
652 assert (node->op == op_Call);
653 return get_irn_n(node, 1);
657 set_Call_ptr (ir_node *node, ir_node *ptr) {
658 assert (node->op == op_Call);
659 set_irn_n(node, 1, ptr);
663 get_Call_param_arr (ir_node *node) {
664 assert (node->op == op_Call);
665 return ((ir_node **)get_Call_param (node, 0));
669 get_Call_arity (ir_node *node) {
670 assert (node->op == op_Call);
671 return (get_irn_arity(node) - 2);
675 set_Call_arity (ir_node *node, ir_node *arity) {
676 assert (node->op == op_Call);
681 get_Call_param (ir_node *node, int pos) {
682 assert (node->op == op_Call);
683 return get_irn_n(node, pos+1);
687 set_Call_param (ir_node *node, int pos, ir_node *param) {
688 assert (node->op == op_Call);
689 set_irn_n(node, pos+1, param);
693 get_Call_type (ir_node *node) {
694 assert (node->op == op_Call);
695 return node->attr.call;
699 set_Call_type (ir_node *node, type_method *type) {
700 assert (node->op == op_Call);
701 node->attr.call = type;
704 /* For unary and binary arithmetic operations the access to the
705 operands can be factored out. Left is the first, right the
706 second arithmetic value as listed in tech report 0999-33.
707 unops are: Minus, Abs, Not, Conv
708 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
709 Shr, Shrs, Rotate, Cmp */
712 is_unop (ir_node *node) {
713 return ( node->op == op_Minus ||
714 node->op == op_Abs ||
715 node->op == op_Not ||
716 node->op == op_Conv );
720 get_unop_op (ir_node *node) {
721 assert ( node->op == op_Minus ||
722 node->op == op_Abs ||
723 node->op == op_Not ||
724 node->op == op_Conv );
725 switch (get_irn_opcode (node)) {
726 case iro_Minus: return get_Minus_op(node); break;
727 case iro_Abs: return get_Abs_op(node); break;
728 case iro_Not: return get_Not_op(node); break;
729 case iro_Conv: return get_Conv_op(node); break;
730 default: return NULL;
735 set_unop_op (ir_node *node, ir_node *op) {
736 assert (node->op == op_Minus ||
737 node->op == op_Abs ||
738 node->op == op_Not ||
739 node->op == op_Conv );
740 switch (get_irn_opcode (node)) {
741 case iro_Minus: set_Minus_op(node, op); break;
742 case iro_Abs: set_Abs_op(node, op); break;
743 case iro_Not: set_Not_op(node, op); break;
744 case iro_Conv: set_Conv_op(node, op); break;
751 is_binop (ir_node *node) {
752 return (node->op == op_Add ||
753 node->op == op_Sub ||
754 node->op == op_Mul ||
755 node->op == op_Quot ||
756 node->op == op_DivMod ||
757 node->op == op_Div ||
758 node->op == op_Mod ||
759 node->op == op_And ||
761 node->op == op_Eor ||
762 node->op == op_Shl ||
763 node->op == op_Shr ||
764 node->op == op_Shrs ||
765 node->op == op_Rot ||
766 node->op == op_Cmp );
770 get_binop_left (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_left(node); break;
789 case iro_Sub : return get_Sub_left(node); break;
790 case iro_Mul : return get_Mul_left(node); break;
791 case iro_Quot : return get_Quot_left(node); break;
792 case iro_DivMod: return get_DivMod_left(node); break;
793 case iro_Div : return get_Div_left(node); break;
794 case iro_Mod : return get_Mod_left(node); break;
795 case iro_And : return get_And_left(node); break;
796 case iro_Or : return get_Or_left(node); break;
797 case iro_Eor : return get_Eor_left(node); break;
798 case iro_Shl : return get_Shl_left(node); break;
799 case iro_Shr : return get_Shr_left(node); break;
800 case iro_Shrs : return get_Shrs_left(node); break;
801 case iro_Rot : return get_Rot_left(node); break;
802 case iro_Cmp : return get_Cmp_left(node); break;
803 default: return NULL;
808 set_binop_left (ir_node *node, ir_node *left) {
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_left(node, left); break;
827 case iro_Sub : set_Sub_left(node, left); break;
828 case iro_Mul : set_Mul_left(node, left); break;
829 case iro_Quot : set_Quot_left(node, left); break;
830 case iro_DivMod: set_DivMod_left(node, left); break;
831 case iro_Div : set_Div_left(node, left); break;
832 case iro_Mod : set_Mod_left(node, left); break;
833 case iro_And : set_And_left(node, left); break;
834 case iro_Or : set_Or_left(node, left); break;
835 case iro_Eor : set_Eor_left(node, left); break;
836 case iro_Shl : set_Shl_left(node, left); break;
837 case iro_Shr : set_Shr_left(node, left); break;
838 case iro_Shrs : set_Shrs_left(node, left); break;
839 case iro_Rot : set_Rot_left(node, left); break;
840 case iro_Cmp : set_Cmp_left(node, left); break;
846 get_binop_right (ir_node *node) {
847 assert (node->op == op_Add ||
848 node->op == op_Sub ||
849 node->op == op_Mul ||
850 node->op == op_Quot ||
851 node->op == op_DivMod ||
852 node->op == op_Div ||
853 node->op == op_Mod ||
854 node->op == op_And ||
856 node->op == op_Eor ||
857 node->op == op_Shl ||
858 node->op == op_Shr ||
859 node->op == op_Shrs ||
860 node->op == op_Rot ||
861 node->op == op_Cmp );
863 switch (get_irn_opcode (node)) {
864 case iro_Add : return get_Add_right(node); break;
865 case iro_Sub : return get_Sub_right(node); break;
866 case iro_Mul : return get_Mul_right(node); break;
867 case iro_Quot : return get_Quot_right(node); break;
868 case iro_DivMod: return get_DivMod_right(node); break;
869 case iro_Div : return get_Div_right(node); break;
870 case iro_Mod : return get_Mod_right(node); break;
871 case iro_And : return get_And_right(node); break;
872 case iro_Or : return get_Or_right(node); break;
873 case iro_Eor : return get_Eor_right(node); break;
874 case iro_Shl : return get_Shl_right(node); break;
875 case iro_Shr : return get_Shr_right(node); break;
876 case iro_Shrs : return get_Shrs_right(node); break;
877 case iro_Rot : return get_Rot_right(node); break;
878 case iro_Cmp : return get_Cmp_right(node); break;
879 default: return NULL;
884 set_binop_right (ir_node *node, ir_node *right) {
885 assert (node->op == op_Add ||
886 node->op == op_Sub ||
887 node->op == op_Mul ||
888 node->op == op_Quot ||
889 node->op == op_DivMod ||
890 node->op == op_Div ||
891 node->op == op_Mod ||
892 node->op == op_And ||
894 node->op == op_Eor ||
895 node->op == op_Shl ||
896 node->op == op_Shr ||
897 node->op == op_Shrs ||
898 node->op == op_Rot ||
899 node->op == op_Cmp );
901 switch (get_irn_opcode (node)) {
902 case iro_Add : set_Add_right(node, right); break;
903 case iro_Sub : set_Sub_right(node, right); break;
904 case iro_Mul : set_Mul_right(node, right); break;
905 case iro_Quot : set_Quot_right(node, right); break;
906 case iro_DivMod: set_DivMod_right(node, right); break;
907 case iro_Div : set_Div_right(node, right); break;
908 case iro_Mod : set_Mod_right(node, right); break;
909 case iro_And : set_And_right(node, right); break;
910 case iro_Or : set_Or_right(node, right); break;
911 case iro_Eor : set_Eor_right(node, right); break;
912 case iro_Shl : set_Shl_right(node, right); break;
913 case iro_Shr : set_Shr_right(node, right); break;
914 case iro_Shrs : set_Shrs_right(node, right); break;
915 case iro_Rot : set_Rot_right(node, right); break;
916 case iro_Cmp : set_Cmp_right(node, right); break;
922 get_Add_left (ir_node *node) {
923 assert (node->op == op_Add);
924 return get_irn_n(node, 0);
928 set_Add_left (ir_node *node, ir_node *left) {
929 assert (node->op == op_Add);
930 set_irn_n(node, 0, left);
934 get_Add_right (ir_node *node) {
935 assert (node->op == op_Add);
936 return get_irn_n(node, 1);
940 set_Add_right (ir_node *node, ir_node *right) {
941 assert (node->op == op_Add);
942 set_irn_n(node, 1, right);
946 get_Sub_left (ir_node *node) {
947 assert (node->op == op_Sub);
948 return get_irn_n(node, 0);
952 set_Sub_left (ir_node *node, ir_node *left) {
953 assert (node->op == op_Sub);
954 set_irn_n(node, 0, left);
958 get_Sub_right (ir_node *node) {
959 assert (node->op == op_Sub);
960 return get_irn_n(node, 1);
964 set_Sub_right (ir_node *node, ir_node *right) {
965 assert (node->op == op_Sub);
966 set_irn_n(node, 1, right);
971 get_Minus_op (ir_node *node) {
972 assert (node->op == op_Minus);
973 return get_irn_n(node, 0);
977 set_Minus_op (ir_node *node, ir_node *op) {
978 assert (node->op == op_Minus);
979 set_irn_n(node, 0, op);
984 get_Mul_left (ir_node *node) {
985 assert (node->op == op_Mul);
986 return get_irn_n(node, 0);
990 set_Mul_left (ir_node *node, ir_node *left) {
991 assert (node->op == op_Mul);
992 set_irn_n(node, 0, left);
996 get_Mul_right (ir_node *node) {
997 assert (node->op == op_Mul);
998 return get_irn_n(node, 1);
1002 set_Mul_right (ir_node *node, ir_node *right) {
1003 assert (node->op == op_Mul);
1004 set_irn_n(node, 1, right);
1008 get_Quot_left (ir_node *node) {
1009 assert (node->op == op_Quot);
1010 return get_irn_n(node, 1);
1014 set_Quot_left (ir_node *node, ir_node *left) {
1015 assert (node->op == op_Quot);
1016 set_irn_n(node, 1, left);
1020 get_Quot_right (ir_node *node) {
1021 assert (node->op == op_Quot);
1022 return get_irn_n(node, 2);
1026 set_Quot_right (ir_node *node, ir_node *right) {
1027 assert (node->op == op_Quot);
1028 set_irn_n(node, 2, right);
1032 get_Quot_mem (ir_node *node) {
1033 assert (node->op == op_Quot);
1034 return get_irn_n(node, 0);
1038 set_Quot_mem (ir_node *node, ir_node *mem) {
1039 assert (node->op == op_Quot);
1040 set_irn_n(node, 0, mem);
1044 get_DivMod_left (ir_node *node) {
1045 assert (node->op == op_DivMod);
1046 return get_irn_n(node, 1);
1050 set_DivMod_left (ir_node *node, ir_node *left) {
1051 assert (node->op == op_DivMod);
1052 set_irn_n(node, 1, left);
1056 get_DivMod_right (ir_node *node) {
1057 assert (node->op == op_DivMod);
1058 return get_irn_n(node, 2);
1062 set_DivMod_right (ir_node *node, ir_node *right) {
1063 assert (node->op == op_DivMod);
1064 set_irn_n(node, 2, right);
1068 get_DivMod_mem (ir_node *node) {
1069 assert (node->op == op_DivMod);
1070 return get_irn_n(node, 0);
1074 set_DivMod_mem (ir_node *node, ir_node *mem) {
1075 assert (node->op == op_DivMod);
1076 set_irn_n(node, 0, mem);
1080 get_Div_left (ir_node *node) {
1081 assert (node->op == op_Div);
1082 return get_irn_n(node, 1);
1086 set_Div_left (ir_node *node, ir_node *left) {
1087 assert (node->op == op_Div);
1088 set_irn_n(node, 1, left);
1092 get_Div_right (ir_node *node) {
1093 assert (node->op == op_Div);
1094 return get_irn_n(node, 2);
1098 set_Div_right (ir_node *node, ir_node *right) {
1099 assert (node->op == op_Div);
1100 set_irn_n(node, 2, right);
1104 get_Div_mem (ir_node *node) {
1105 assert (node->op == op_Div);
1106 return get_irn_n(node, 0);
1110 set_Div_mem (ir_node *node, ir_node *mem) {
1111 assert (node->op == op_Div);
1112 set_irn_n(node, 0, mem);
1116 get_Mod_left (ir_node *node) {
1117 assert (node->op == op_Mod);
1118 return get_irn_n(node, 1);
1122 set_Mod_left (ir_node *node, ir_node *left) {
1123 assert (node->op == op_Mod);
1124 set_irn_n(node, 1, left);
1128 get_Mod_right (ir_node *node) {
1129 assert (node->op == op_Mod);
1130 return get_irn_n(node, 2);
1134 set_Mod_right (ir_node *node, ir_node *right) {
1135 assert (node->op == op_Mod);
1136 set_irn_n(node, 2, right);
1140 get_Mod_mem (ir_node *node) {
1141 assert (node->op == op_Mod);
1142 return get_irn_n(node, 0);
1146 set_Mod_mem (ir_node *node, ir_node *mem) {
1147 assert (node->op == op_Mod);
1148 set_irn_n(node, 0, mem);
1152 get_Abs_op (ir_node *node) {
1153 assert (node->op == op_Abs);
1154 return get_irn_n(node, 0);
1158 set_Abs_op (ir_node *node, ir_node *op) {
1159 assert (node->op == op_Abs);
1160 set_irn_n(node, 0, op);
1164 get_And_left (ir_node *node) {
1165 assert (node->op == op_And);
1166 return get_irn_n(node, 0);
1170 set_And_left (ir_node *node, ir_node *left) {
1171 assert (node->op == op_And);
1172 set_irn_n(node, 0, left);
1176 get_And_right (ir_node *node) {
1177 assert (node->op == op_And);
1178 return get_irn_n(node, 1);
1182 set_And_right (ir_node *node, ir_node *right) {
1183 assert (node->op == op_And);
1184 set_irn_n(node, 1, right);
1188 get_Or_left (ir_node *node) {
1189 assert (node->op == op_Or);
1190 return get_irn_n(node, 0);
1194 set_Or_left (ir_node *node, ir_node *left) {
1195 assert (node->op == op_Or);
1196 set_irn_n(node, 0, left);
1200 get_Or_right (ir_node *node) {
1201 assert (node->op == op_Or);
1202 return get_irn_n(node, 1);
1206 set_Or_right (ir_node *node, ir_node *right) {
1207 assert (node->op == op_Or);
1208 set_irn_n(node, 1, right);
1212 get_Eor_left (ir_node *node) {
1213 assert (node->op == op_Eor);
1214 return get_irn_n(node, 0);
1218 set_Eor_left (ir_node *node, ir_node *left) {
1219 assert (node->op == op_Eor);
1220 set_irn_n(node, 0, left);
1224 get_Eor_right (ir_node *node) {
1225 assert (node->op == op_Eor);
1226 return get_irn_n(node, 1);
1230 set_Eor_right (ir_node *node, ir_node *right) {
1231 assert (node->op == op_Eor);
1232 set_irn_n(node, 1, right);
1237 get_Not_op (ir_node *node) {
1238 assert (node->op == op_Not);
1239 return get_irn_n(node, 0);
1243 set_Not_op (ir_node *node, ir_node *op) {
1244 assert (node->op == op_Not);
1245 set_irn_n(node, 0, op);
1250 get_Shl_left (ir_node *node) {
1251 assert (node->op == op_Shl);
1252 return get_irn_n(node, 0);
1256 set_Shl_left (ir_node *node, ir_node *left) {
1257 assert (node->op == op_Shl);
1258 set_irn_n(node, 0, left);
1262 get_Shl_right (ir_node *node) {
1263 assert (node->op == op_Shl);
1264 return get_irn_n(node, 1);
1268 set_Shl_right (ir_node *node, ir_node *right) {
1269 assert (node->op == op_Shl);
1270 set_irn_n(node, 1, right);
1274 get_Shr_left (ir_node *node) {
1275 assert (node->op == op_Shr);
1276 return get_irn_n(node, 0);
1280 set_Shr_left (ir_node *node, ir_node *left) {
1281 assert (node->op == op_Shr);
1282 set_irn_n(node, 0, left);
1286 get_Shr_right (ir_node *node) {
1287 assert (node->op == op_Shr);
1288 return get_irn_n(node, 1);
1292 set_Shr_right (ir_node *node, ir_node *right) {
1293 assert (node->op == op_Shr);
1294 set_irn_n(node, 1, right);
1298 get_Shrs_left (ir_node *node) {
1299 assert (node->op == op_Shrs);
1300 return get_irn_n(node, 0);
1304 set_Shrs_left (ir_node *node, ir_node *left) {
1305 assert (node->op == op_Shrs);
1306 set_irn_n(node, 0, left);
1310 get_Shrs_right (ir_node *node) {
1311 assert (node->op == op_Shrs);
1312 return get_irn_n(node, 1);
1316 set_Shrs_right (ir_node *node, ir_node *right) {
1317 assert (node->op == op_Shrs);
1318 set_irn_n(node, 1, right);
1322 get_Rot_left (ir_node *node) {
1323 assert (node->op == op_Rot);
1324 return get_irn_n(node, 0);
1328 set_Rot_left (ir_node *node, ir_node *left) {
1329 assert (node->op == op_Rot);
1330 set_irn_n(node, 0, left);
1334 get_Rot_right (ir_node *node) {
1335 assert (node->op == op_Rot);
1336 return get_irn_n(node, 1);
1340 set_Rot_right (ir_node *node, ir_node *right) {
1341 assert (node->op == op_Rot);
1342 set_irn_n(node, 1, right);
1346 get_Cmp_left (ir_node *node) {
1347 assert (node->op == op_Cmp);
1348 return get_irn_n(node, 0);
1352 set_Cmp_left (ir_node *node, ir_node *left) {
1353 assert (node->op == op_Cmp);
1354 set_irn_n(node, 0, left);
1358 get_Cmp_right (ir_node *node) {
1359 assert (node->op == op_Cmp);
1360 return get_irn_n(node, 1);
1364 set_Cmp_right (ir_node *node, ir_node *right) {
1365 assert (node->op == op_Cmp);
1366 set_irn_n(node, 1, right);
1370 get_Conv_op (ir_node *node) {
1371 assert (node->op == op_Conv);
1372 return get_irn_n(node, 0);
1376 set_Conv_op (ir_node *node, ir_node *op) {
1377 assert (node->op == op_Conv);
1378 set_irn_n(node, 0, op);
1382 get_Phi_preds_arr (ir_node *node) {
1383 assert (node->op == op_Phi);
1384 return ((ir_node **)get_Phi_pred(node, 0));
1388 get_Phi_n_preds (ir_node *node) {
1389 assert (node->op == op_Phi);
1390 return (get_irn_arity(node));
1394 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1395 assert (node->op == op_Phi);
1400 get_Phi_pred (ir_node *node, int pos) {
1401 assert (node->op == op_Phi);
1402 return get_irn_n(node, pos);
1406 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1407 assert (node->op == op_Phi);
1408 set_irn_n(node, pos, pred);
1412 get_Load_mem (ir_node *node) {
1413 assert (node->op == op_Load);
1414 return get_irn_n(node, 0);
1418 set_Load_mem (ir_node *node, ir_node *mem) {
1419 assert (node->op == op_Load);
1420 set_irn_n(node, 0, mem);
1424 get_Load_ptr (ir_node *node) {
1425 assert (node->op == op_Load);
1426 return get_irn_n(node, 1);
1430 set_Load_ptr (ir_node *node, ir_node *ptr) {
1431 assert (node->op == op_Load);
1432 set_irn_n(node, 1, ptr);
1437 get_Store_mem (ir_node *node) {
1438 assert (node->op == op_Store);
1439 return get_irn_n(node, 0);
1443 set_Store_mem (ir_node *node, ir_node *mem) {
1444 assert (node->op == op_Store);
1445 set_irn_n(node, 0, mem);
1449 get_Store_ptr (ir_node *node) {
1450 assert (node->op == op_Store);
1451 return get_irn_n(node, 1);
1455 set_Store_ptr (ir_node *node, ir_node *ptr) {
1456 assert (node->op == op_Store);
1457 set_irn_n(node, 1, ptr);
1461 get_Store_value (ir_node *node) {
1462 assert (node->op == op_Store);
1463 return get_irn_n(node, 2);
1467 set_Store_value (ir_node *node, ir_node *value) {
1468 assert (node->op == op_Store);
1469 set_irn_n(node, 2, value);
1473 get_Alloc_mem (ir_node *node) {
1474 assert (node->op == op_Alloc);
1475 return get_irn_n(node, 0);
1479 set_Alloc_mem (ir_node *node, ir_node *mem) {
1480 assert (node->op == op_Alloc);
1481 set_irn_n(node, 0, mem);
1485 get_Alloc_size (ir_node *node) {
1486 assert (node->op == op_Alloc);
1487 return get_irn_n(node, 1);
1491 set_Allco_size (ir_node *node, ir_node *size) {
1492 assert (node->op == op_Alloc);
1493 set_irn_n(node, 1, size);
1497 get_Alloc_type (ir_node *node) {
1498 assert (node->op == op_Alloc);
1499 return node->attr.a.type;
1503 set_Alloc_type (ir_node *node, type *type) {
1504 assert (node->op == op_Alloc);
1505 node->attr.a.type = type;
1509 get_Alloc_where (ir_node *node) {
1510 assert (node->op == op_Alloc);
1511 return node->attr.a.where;
1515 set_Alloc_where (ir_node *node, where_alloc where) {
1516 assert (node->op == op_Alloc);
1517 node->attr.a.where = where;
1522 get_Free_mem (ir_node *node) {
1523 assert (node->op == op_Free);
1524 return get_irn_n(node, 0);
1528 set_Free_mem (ir_node *node, ir_node *mem) {
1529 assert (node->op == op_Free);
1530 set_irn_n(node, 0, mem);
1534 get_Free_ptr (ir_node *node) {
1535 assert (node->op == op_Free);
1536 return get_irn_n(node, 1);
1540 set_Free_ptr (ir_node *node, ir_node *ptr) {
1541 assert (node->op == op_Free);
1542 set_irn_n(node, 1, ptr);
1546 get_Free_size (ir_node *node) {
1547 assert (node->op == op_Free);
1548 return get_irn_n(node, 2);
1552 set_Free_size (ir_node *node, ir_node *size) {
1553 assert (node->op == op_Free);
1554 set_irn_n(node, 2, size);
1558 get_Free_type (ir_node *node) {
1559 assert (node->op == op_Free);
1560 return node->attr.f;
1564 set_Free_type (ir_node *node, type *type) {
1565 assert (node->op == op_Free);
1566 node->attr.f = type;
1570 get_Sync_preds_arr (ir_node *node) {
1571 assert (node->op == op_Sync);
1572 return ((ir_node **)get_Sync_pred(node, 0));
1576 get_Sync_n_preds (ir_node *node) {
1577 assert (node->op == op_Sync);
1578 return (get_irn_arity(node));
1583 set_Sync_n_preds (ir_node *node, int n_preds) {
1584 assert (node->op == op_Sync);
1589 get_Sync_pred (ir_node *node, int pos) {
1590 assert (node->op == op_Sync);
1591 return get_irn_n(node, pos);
1595 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1596 assert (node->op == op_Sync);
1597 set_irn_n(node, pos, pred);
1601 get_Proj_pred (ir_node *node) {
1602 assert (node->op == op_Proj);
1603 return get_irn_n(node, 0);
1607 set_Proj_pred (ir_node *node, ir_node *pred) {
1608 assert (node->op == op_Proj);
1609 set_irn_n(node, 0, pred);
1613 get_Proj_proj (ir_node *node) {
1614 assert (node->op == op_Proj);
1615 return node->attr.proj;
1619 set_Proj_proj (ir_node *node, long proj) {
1620 assert (node->op == op_Proj);
1621 node->attr.proj = proj;
1625 get_Tuple_preds_arr (ir_node *node) {
1626 assert (node->op == op_Tuple);
1627 return ((ir_node **)get_Tuple_pred(node, 0));
1631 get_Tuple_n_preds (ir_node *node) {
1632 assert (node->op == op_Tuple);
1633 return (get_irn_arity(node));
1638 set_Tuple_n_preds (ir_node *node, int n_preds) {
1639 assert (node->op == op_Tuple);
1644 get_Tuple_pred (ir_node *node, int pos) {
1645 assert (node->op == op_Tuple);
1646 return get_irn_n(node, pos);
1650 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1651 assert (node->op == op_Tuple);
1652 set_irn_n(node, pos, pred);
1656 get_Id_pred (ir_node *node) {
1657 assert (node->op == op_Id);
1658 return get_irn_n(node, 0);
1662 set_Id_pred (ir_node *node, ir_node *pred) {
1663 assert (node->op == op_Id);
1664 set_irn_n(node, 0, pred);
1667 /******************************************************************/
1668 /* Auxiliary routines */
1669 /******************************************************************/
1672 skip_Proj (ir_node *node) {
1673 /* don't assert node !!! */
1674 if (node && (node->op == op_Proj)) {
1675 return get_Proj_pred(node);
1682 skip_nop (ir_node *node) {
1683 /* don't assert node !!! */
1684 if (node && (node->op == op_Id)) {
1685 return get_Id_pred(node);
1692 is_Bad (ir_node *node) {
1694 if ((node) && get_irn_opcode(node) == iro_Bad)
1700 is_no_Block (ir_node *node) {
1702 return (get_irn_opcode(node) != iro_Block);
1705 /* Returns true if the operation manipulates control flow. */
1707 is_cfop(ir_node *node) {
1708 return ( (get_irn_opcode(node) == iro_Start)
1709 || (get_irn_opcode(node) == iro_Jmp)
1710 || (get_irn_opcode(node) == iro_Cond)
1711 || (get_irn_opcode(node) == iro_Return)
1712 || (get_irn_opcode(node) == iro_Raise)
1713 || (get_irn_opcode(node) == iro_Bad));
1716 /* Returns true if the operation can change the control flow because
1719 is_fragile_op(ir_node *node) {
1720 return ( (get_irn_opcode(node) == iro_Call)
1721 || (get_irn_opcode(node) == iro_Quot)
1722 || (get_irn_opcode(node) == iro_DivMod)
1723 || (get_irn_opcode(node) == iro_Div)
1724 || (get_irn_opcode(node) == iro_Mod)
1725 || (get_irn_opcode(node) == iro_Load)
1726 || (get_irn_opcode(node) == iro_Store)
1727 || (get_irn_opcode(node) == iro_Alloc)
1728 || (get_irn_opcode(node) == iro_Bad));