1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
13 #include "irgraph_t.h"
22 /* some constants fixing the positions of nodes predecessors
24 #define CALL_PARAM_OFFSET 2
25 #define SEL_INDEX_OFFSET 2
26 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
28 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
29 "Gt", "Ge", "Lg", "Leg", "Uo",
30 "Ue", "Ul", "Ule", "Ug", "Uge",
33 inline char *get_pnc_string(int pnc) {
34 return pnc_name_arr[pnc];
39 get_negated_pnc(int pnc) {
41 case False: return True; break;
42 case Eq: return Ne; break;
43 case Lt: return Uge; break;
44 case Le: return Ug; break;
45 case Gt: return Ule; break;
46 case Ge: return Ul; break;
47 case Lg: return Ue; break;
48 case Leg: return Uo; break;
49 case Uo: return Leg; break;
50 case Ue: return Lg; break;
51 case Ul: return Ge; break;
52 case Ule: return Gt; break;
53 case Ug: return Le; break;
54 case Uge: return Lt; break;
55 case Ne: return Eq; break;
56 case True: return False; break;
58 return 99; /* to shut up gcc */
61 static char *pns_name_arr [] = {"initial_exec", "global_store",
62 "frame_base", "globals", "args"};
64 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
71 /* irnode constructor */
72 /* create a new irnode in irg, with an op, mode, arity and */
73 /* some incoming irnodes */
74 /* this constructor is used in every specified irnode constructor */
76 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
77 int arity, ir_node **in)
80 int node_size = offsetof (ir_node, attr) + op->attr_size;
82 res = (ir_node *) obstack_alloc (irg->obst, node_size);
84 res->kind = k_ir_node;
90 res->in = NEW_ARR_F (ir_node *, 1);
92 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
93 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
98 res->node_nr = get_irp_new_node_nr();
104 /* Copies all attributes stored in the old node to the new node.
105 Assumes both have the same opcode and sufficient size. */
107 copy_attrs (ir_node *old, ir_node *new) {
108 assert (get_irn_opcode(old) == get_irn_opcode(new));
109 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
112 /* IR-Nodes with attributes */
114 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
117 ir_node *np = XP_GETARG (ir_node *, 0);
120 XPS ("<null ir_node>");
124 XPF1 ("%I", get_irn_opident(np));
126 switch (get_irn_opcode (np)) { /* node label */
128 XPF1 ("%I", get_irn_mode(np)->name);
130 XPF1 ("%v", get_irn_const_attr);
133 if (get_irn_modecode (np) == irm_b) {
135 XP (pnc_name_arr[get_irn_proj_attr(np)]);
136 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
138 XP (pns_name_arr[get_irn_proj_attr(np)]);
140 XPF1 ("%I", get_irn_mode(np)->name);
142 XPF1 ("%d", get_irn_proj_attr(np));
146 XPF1 ("%I", get_irn_mode(np)->name);
148 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
149 XPF1 (" %#N", get_type_nameid(get_SymConst_type(np)));
151 case iro_Start: /* don't dump mode of these */
160 XPF1 ("%I", get_irn_mode(np)->name);
167 /** getting some parameters from ir_nodes **/
169 /* returns the number of predecessors without the block predecessor. */
171 get_irn_arity (ir_node *node)
174 return (ARR_LEN((node)->in)-1);
177 /* Returns the array with ins. This array is shifted with respect to the
178 array accessed by get_irn_n: The block operand is at position 0 not -1.
179 (@@@ This should be changed.)
180 The order of the predecessors in this array is not guaranteed, except that
181 lists of operands as predecessors of Block or arguments of a Call are
184 get_irn_in (ir_node *node)
190 /* to iterate through the predecessors without touching the array */
191 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
192 to iterate includind the Block predecessor iterate from i = -1 to
194 If it is a block, the entry -1 is NULL. */
196 get_irn_n (ir_node *node, int n)
199 assert (get_irn_arity (node) > n);
200 return skip_nop(node->in[n+1]);
204 set_irn_n (ir_node *node, int n, ir_node *in)
207 assert (get_irn_arity (node) > n);
212 get_irn_mode (ir_node *node)
219 get_irn_modecode (ir_node *node)
222 return node->mode->code;
227 get_irn_modeident (ir_node *node)
230 return node->mode->name;
234 get_irn_op (ir_node *node)
240 /* should be private to the library: */
242 set_irn_op (ir_node *node, ir_op *op)
249 get_irn_opcode (ir_node *node)
252 return node->op->code;
256 get_irn_opname (ir_node *node)
259 return id_to_str(node->op->name);
263 get_irn_opident (ir_node *node)
266 return node->op->name;
270 get_irn_visited (ir_node *node)
273 return node->visited;
277 set_irn_visited (ir_node *node, unsigned long visited)
280 node->visited = visited;
283 set_irn_link (ir_node *node, ir_node *link) {
289 get_irn_link (ir_node *node) {
295 /* Outputs a unique number for this node */
297 get_irn_node_nr(ir_node *node) {
299 return node->node_nr;
304 get_irn_const_attr (ir_node *node)
306 assert (node->op == op_Const);
307 return node->attr.con;
311 get_irn_proj_attr (ir_node *node)
313 assert (node->op == op_Proj);
314 return node->attr.proj;
318 get_irn_alloc_attr (ir_node *node)
320 assert (node->op == op_Alloc);
325 get_irn_free_attr (ir_node *node)
327 assert (node->op == op_Free);
332 get_irn_symconst_attr (ir_node *node)
334 assert (node->op == op_SymConst);
339 get_irn_call_attr (ir_node *node)
341 assert (node->op == op_Call);
342 return node->attr.call;
346 get_irn_sel_attr (ir_node *node)
348 assert (node->op == op_Sel);
353 get_irn_phi_attr (ir_node *node)
355 assert (node->op == op_Phi);
356 return node->attr.phi0_pos;
360 get_irn_block_attr (ir_node *node)
362 assert (node->op == op_Block);
363 return node->attr.block;
366 /** manipulate fields of individual nodes **/
368 /* this works for all except Block */
370 get_nodes_Block (ir_node *node) {
371 assert (!(node->op == op_Block));
372 return get_irn_n(node, -1);
376 set_nodes_Block (ir_node *node, ir_node *block) {
377 assert (!(node->op == op_Block));
378 set_irn_n(node, -1, block);
381 /* Returns an array with the predecessors of the Block. Depending on
382 the implementation of the graph datastructure this can be a copy of
383 the internal representation of predecessors as well as the internal
384 array itself. Therefore writing to this array might obstruct the ir. */
386 get_Block_cfgpred_arr (ir_node *node)
388 assert ((node->op == op_Block));
389 return (ir_node **)&(get_irn_in(node)[1]);
394 get_Block_n_cfgpreds (ir_node *node) {
395 assert ((node->op == op_Block));
396 return (get_irn_arity(node));
401 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
402 assert ((node->op == op_Block));
407 get_Block_cfgpred (ir_node *node, int pos) {
408 assert (node->op == op_Block);
409 return get_irn_n(node, pos);
413 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
414 assert (node->op == op_Block);
415 set_irn_n(node, pos, pred);
419 get_Block_matured (ir_node *node) {
420 assert (node->op == op_Block);
421 return node->attr.block.matured;
425 set_Block_matured (ir_node *node, bool matured) {
426 assert (node->op == op_Block);
427 node->attr.block.matured = matured;
430 get_Block_block_visited (ir_node *node) {
431 assert (node->op == op_Block);
432 return node->attr.block.block_visited;
436 set_Block_block_visited (ir_node *node, unsigned long visit) {
437 assert (node->op == op_Block);
438 node->attr.block.block_visited = visit;
442 get_Block_graph_arr (ir_node *node, int pos) {
443 assert (node->op == op_Block);
444 return node->attr.block.graph_arr[pos+1];
448 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
449 assert (node->op == op_Block);
450 node->attr.block.graph_arr[pos+1] = value;
454 get_Cond_selector (ir_node *node) {
455 assert (node->op == op_Cond);
456 return get_irn_n(node, 0);
460 set_Cond_selector (ir_node *node, ir_node *selector) {
461 assert (node->op == op_Cond);
462 set_irn_n(node, 0, selector);
466 get_Return_mem (ir_node *node) {
467 assert (node->op == op_Return);
468 return get_irn_n(node, 0);
472 set_Return_mem (ir_node *node, ir_node *mem) {
473 assert (node->op == op_Return);
474 set_irn_n(node, 0, mem);
478 get_Return_res_arr (ir_node *node)
480 assert ((node->op == op_Return));
481 if (get_Return_n_res(node) > 0)
482 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
488 get_Return_n_res (ir_node *node) {
489 assert (node->op == op_Return);
490 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
495 set_Return_n_res (ir_node *node, int results) {
496 assert (node->op == op_Return);
501 get_Return_res (ir_node *node, int pos) {
502 assert (node->op == op_Return);
503 assert (get_Return_n_res(node) > pos);
504 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
508 set_Return_res (ir_node *node, int pos, ir_node *res){
509 assert (node->op == op_Return);
510 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
514 get_Raise_mem (ir_node *node) {
515 assert (node->op == op_Return);
516 return get_irn_n(node, 0);
520 set_Raise_mem (ir_node *node, ir_node *mem) {
521 assert (node->op == op_Raise);
522 set_irn_n(node, 0, mem);
526 get_Raise_exo_ptr (ir_node *node) {
527 assert (node->op == op_Raise);
528 return get_irn_n(node, 1);
532 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
533 assert (node->op == op_Raise);
534 set_irn_n(node, 1, exo_ptr);
537 inline tarval *get_Const_tarval (ir_node *node) {
538 assert (node->op == op_Const);
539 return get_irn_const_attr(node);
543 set_Const_tarval (ir_node *node, tarval *con) {
544 assert (node->op == op_Const);
545 node->attr.con = con;
549 get_SymConst_kind (ir_node *node) {
550 assert (node->op == op_SymConst);
551 return node->attr.i.num;
555 set_SymConst_kind (ir_node *node, symconst_kind num) {
556 assert (node->op == op_SymConst);
557 node->attr.i.num = num;
561 get_SymConst_type (ir_node *node) {
562 assert ( (node->op == op_SymConst)
563 && ( get_SymConst_kind(node) == type_tag
564 || get_SymConst_kind(node) == size));
565 return node->attr.i.tori.typ;
569 set_SymConst_type (ir_node *node, type *type) {
570 assert ( (node->op == op_SymConst)
571 && ( get_SymConst_kind(node) == type_tag
572 || get_SymConst_kind(node) == size));
573 node->attr.i.tori.typ = type;
577 get_SymConst_ptrinfo (ir_node *node) {
578 assert ( (node->op == op_SymConst)
579 && (get_SymConst_kind(node) == linkage_ptr_info));
580 return node->attr.i.tori.ptrinfo;
584 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
585 assert ( (node->op == op_SymConst)
586 && (get_SymConst_kind(node) == linkage_ptr_info));
587 node->attr.i.tori.ptrinfo = ptrinfo;
591 get_SymConst_type_or_id (ir_node *node) {
592 assert (node->op == op_SymConst);
593 return &(node->attr.i.tori);
597 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
598 assert (node->op == op_SymConst);
599 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
603 get_Sel_mem (ir_node *node) {
604 assert (node->op == op_Sel);
605 return get_irn_n(node, 0);
609 set_Sel_mem (ir_node *node, ir_node *mem) {
610 assert (node->op == op_Sel);
611 set_irn_n(node, 0, mem);
615 get_Sel_ptr (ir_node *node) {
616 assert (node->op == op_Sel);
617 return get_irn_n(node, 1);
621 set_Sel_ptr (ir_node *node, ir_node *ptr) {
622 assert (node->op == op_Sel);
623 set_irn_n(node, 1, ptr);
627 get_Sel_index_arr (ir_node *node)
629 assert ((node->op == op_Sel));
630 if (get_Sel_n_index(node) > 0)
631 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
637 get_Sel_n_index (ir_node *node) {
638 assert (node->op == op_Sel);
639 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
644 set_Sel_n_index (ir_node *node, int n_index) {
645 assert (node->op == op_Sel);
650 get_Sel_index (ir_node *node, int pos) {
651 assert (node->op == op_Sel);
652 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
656 set_Sel_index (ir_node *node, int pos, ir_node *index) {
657 assert (node->op == op_Sel);
658 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
662 get_Sel_entity (ir_node *node) {
663 assert (node->op == op_Sel);
664 return node->attr.s.ent;
668 set_Sel_entity (ir_node *node, entity *ent) {
669 assert (node->op == op_Sel);
670 node->attr.s.ent = ent;
674 get_Sel_linkage_type (ir_node *node) {
675 assert (node->op == op_Sel);
676 return node->attr.s.ltyp;
680 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
681 assert (node->op == op_Sel);
682 node->attr.s.ltyp = lt;
686 get_Call_mem (ir_node *node) {
687 assert (node->op == op_Call);
688 return get_irn_n(node, 0);
692 set_Call_mem (ir_node *node, ir_node *mem) {
693 assert (node->op == op_Call);
694 set_irn_n(node, 0, mem);
698 get_Call_ptr (ir_node *node) {
699 assert (node->op == op_Call);
700 return get_irn_n(node, 1);
704 set_Call_ptr (ir_node *node, ir_node *ptr) {
705 assert (node->op == op_Call);
706 set_irn_n(node, 1, ptr);
710 get_Call_param_arr (ir_node *node) {
711 assert (node->op == op_Call);
712 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
716 get_Call_n_params (ir_node *node) {
717 assert (node->op == op_Call);
718 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
722 get_Call_arity (ir_node *node) {
723 return get_Call_n_params(node);
727 set_Call_arity (ir_node *node, ir_node *arity) {
728 assert (node->op == op_Call);
733 get_Call_param (ir_node *node, int pos) {
734 assert (node->op == op_Call);
735 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
739 set_Call_param (ir_node *node, int pos, ir_node *param) {
740 assert (node->op == op_Call);
741 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
745 get_Call_type (ir_node *node) {
746 assert (node->op == op_Call);
747 return node->attr.call;
751 set_Call_type (ir_node *node, type *type) {
752 assert (node->op == op_Call);
753 assert (is_method_type(type));
754 node->attr.call = type;
757 /* For unary and binary arithmetic operations the access to the
758 operands can be factored out. Left is the first, right the
759 second arithmetic value as listed in tech report 0999-33.
760 unops are: Minus, Abs, Not, Conv
761 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
762 Shr, Shrs, Rotate, Cmp */
765 is_unop (ir_node *node) {
766 return ( node->op == op_Minus ||
767 node->op == op_Abs ||
768 node->op == op_Not ||
769 node->op == op_Conv );
773 get_unop_op (ir_node *node) {
774 assert ( node->op == op_Minus ||
775 node->op == op_Abs ||
776 node->op == op_Not ||
777 node->op == op_Conv );
778 switch (get_irn_opcode (node)) {
779 case iro_Minus: return get_Minus_op(node); break;
780 case iro_Abs: return get_Abs_op(node); break;
781 case iro_Not: return get_Not_op(node); break;
782 case iro_Conv: return get_Conv_op(node); break;
783 default: return NULL;
788 set_unop_op (ir_node *node, ir_node *op) {
789 assert (node->op == op_Minus ||
790 node->op == op_Abs ||
791 node->op == op_Not ||
792 node->op == op_Conv );
793 switch (get_irn_opcode (node)) {
794 case iro_Minus: set_Minus_op(node, op); break;
795 case iro_Abs: set_Abs_op(node, op); break;
796 case iro_Not: set_Not_op(node, op); break;
797 case iro_Conv: set_Conv_op(node, op); break;
804 is_binop (ir_node *node) {
805 return (node->op == op_Add ||
806 node->op == op_Sub ||
807 node->op == op_Mul ||
808 node->op == op_Quot ||
809 node->op == op_DivMod ||
810 node->op == op_Div ||
811 node->op == op_Mod ||
812 node->op == op_And ||
814 node->op == op_Eor ||
815 node->op == op_Shl ||
816 node->op == op_Shr ||
817 node->op == op_Shrs ||
818 node->op == op_Rot ||
819 node->op == op_Cmp );
823 get_binop_left (ir_node *node) {
824 assert (node->op == op_Add ||
825 node->op == op_Sub ||
826 node->op == op_Mul ||
827 node->op == op_Quot ||
828 node->op == op_DivMod ||
829 node->op == op_Div ||
830 node->op == op_Mod ||
831 node->op == op_And ||
833 node->op == op_Eor ||
834 node->op == op_Shl ||
835 node->op == op_Shr ||
836 node->op == op_Shrs ||
837 node->op == op_Rot ||
838 node->op == op_Cmp );
840 switch (get_irn_opcode (node)) {
841 case iro_Add : return get_Add_left(node); break;
842 case iro_Sub : return get_Sub_left(node); break;
843 case iro_Mul : return get_Mul_left(node); break;
844 case iro_Quot : return get_Quot_left(node); break;
845 case iro_DivMod: return get_DivMod_left(node); break;
846 case iro_Div : return get_Div_left(node); break;
847 case iro_Mod : return get_Mod_left(node); break;
848 case iro_And : return get_And_left(node); break;
849 case iro_Or : return get_Or_left(node); break;
850 case iro_Eor : return get_Eor_left(node); break;
851 case iro_Shl : return get_Shl_left(node); break;
852 case iro_Shr : return get_Shr_left(node); break;
853 case iro_Shrs : return get_Shrs_left(node); break;
854 case iro_Rot : return get_Rot_left(node); break;
855 case iro_Cmp : return get_Cmp_left(node); break;
856 default: return NULL;
861 set_binop_left (ir_node *node, ir_node *left) {
862 assert (node->op == op_Add ||
863 node->op == op_Sub ||
864 node->op == op_Mul ||
865 node->op == op_Quot ||
866 node->op == op_DivMod ||
867 node->op == op_Div ||
868 node->op == op_Mod ||
869 node->op == op_And ||
871 node->op == op_Eor ||
872 node->op == op_Shl ||
873 node->op == op_Shr ||
874 node->op == op_Shrs ||
875 node->op == op_Rot ||
876 node->op == op_Cmp );
878 switch (get_irn_opcode (node)) {
879 case iro_Add : set_Add_left(node, left); break;
880 case iro_Sub : set_Sub_left(node, left); break;
881 case iro_Mul : set_Mul_left(node, left); break;
882 case iro_Quot : set_Quot_left(node, left); break;
883 case iro_DivMod: set_DivMod_left(node, left); break;
884 case iro_Div : set_Div_left(node, left); break;
885 case iro_Mod : set_Mod_left(node, left); break;
886 case iro_And : set_And_left(node, left); break;
887 case iro_Or : set_Or_left(node, left); break;
888 case iro_Eor : set_Eor_left(node, left); break;
889 case iro_Shl : set_Shl_left(node, left); break;
890 case iro_Shr : set_Shr_left(node, left); break;
891 case iro_Shrs : set_Shrs_left(node, left); break;
892 case iro_Rot : set_Rot_left(node, left); break;
893 case iro_Cmp : set_Cmp_left(node, left); break;
899 get_binop_right (ir_node *node) {
900 assert (node->op == op_Add ||
901 node->op == op_Sub ||
902 node->op == op_Mul ||
903 node->op == op_Quot ||
904 node->op == op_DivMod ||
905 node->op == op_Div ||
906 node->op == op_Mod ||
907 node->op == op_And ||
909 node->op == op_Eor ||
910 node->op == op_Shl ||
911 node->op == op_Shr ||
912 node->op == op_Shrs ||
913 node->op == op_Rot ||
914 node->op == op_Cmp );
916 switch (get_irn_opcode (node)) {
917 case iro_Add : return get_Add_right(node); break;
918 case iro_Sub : return get_Sub_right(node); break;
919 case iro_Mul : return get_Mul_right(node); break;
920 case iro_Quot : return get_Quot_right(node); break;
921 case iro_DivMod: return get_DivMod_right(node); break;
922 case iro_Div : return get_Div_right(node); break;
923 case iro_Mod : return get_Mod_right(node); break;
924 case iro_And : return get_And_right(node); break;
925 case iro_Or : return get_Or_right(node); break;
926 case iro_Eor : return get_Eor_right(node); break;
927 case iro_Shl : return get_Shl_right(node); break;
928 case iro_Shr : return get_Shr_right(node); break;
929 case iro_Shrs : return get_Shrs_right(node); break;
930 case iro_Rot : return get_Rot_right(node); break;
931 case iro_Cmp : return get_Cmp_right(node); break;
932 default: return NULL;
937 set_binop_right (ir_node *node, ir_node *right) {
938 assert (node->op == op_Add ||
939 node->op == op_Sub ||
940 node->op == op_Mul ||
941 node->op == op_Quot ||
942 node->op == op_DivMod ||
943 node->op == op_Div ||
944 node->op == op_Mod ||
945 node->op == op_And ||
947 node->op == op_Eor ||
948 node->op == op_Shl ||
949 node->op == op_Shr ||
950 node->op == op_Shrs ||
951 node->op == op_Rot ||
952 node->op == op_Cmp );
954 switch (get_irn_opcode (node)) {
955 case iro_Add : set_Add_right(node, right); break;
956 case iro_Sub : set_Sub_right(node, right); break;
957 case iro_Mul : set_Mul_right(node, right); break;
958 case iro_Quot : set_Quot_right(node, right); break;
959 case iro_DivMod: set_DivMod_right(node, right); break;
960 case iro_Div : set_Div_right(node, right); break;
961 case iro_Mod : set_Mod_right(node, right); break;
962 case iro_And : set_And_right(node, right); break;
963 case iro_Or : set_Or_right(node, right); break;
964 case iro_Eor : set_Eor_right(node, right); break;
965 case iro_Shl : set_Shl_right(node, right); break;
966 case iro_Shr : set_Shr_right(node, right); break;
967 case iro_Shrs : set_Shrs_right(node, right); break;
968 case iro_Rot : set_Rot_right(node, right); break;
969 case iro_Cmp : set_Cmp_right(node, right); break;
975 get_Add_left (ir_node *node) {
976 assert (node->op == op_Add);
977 return get_irn_n(node, 0);
981 set_Add_left (ir_node *node, ir_node *left) {
982 assert (node->op == op_Add);
983 set_irn_n(node, 0, left);
987 get_Add_right (ir_node *node) {
988 assert (node->op == op_Add);
989 return get_irn_n(node, 1);
993 set_Add_right (ir_node *node, ir_node *right) {
994 assert (node->op == op_Add);
995 set_irn_n(node, 1, right);
999 get_Sub_left (ir_node *node) {
1000 assert (node->op == op_Sub);
1001 return get_irn_n(node, 0);
1005 set_Sub_left (ir_node *node, ir_node *left) {
1006 assert (node->op == op_Sub);
1007 set_irn_n(node, 0, left);
1011 get_Sub_right (ir_node *node) {
1012 assert (node->op == op_Sub);
1013 return get_irn_n(node, 1);
1017 set_Sub_right (ir_node *node, ir_node *right) {
1018 assert (node->op == op_Sub);
1019 set_irn_n(node, 1, right);
1024 get_Minus_op (ir_node *node) {
1025 assert (node->op == op_Minus);
1026 return get_irn_n(node, 0);
1030 set_Minus_op (ir_node *node, ir_node *op) {
1031 assert (node->op == op_Minus);
1032 set_irn_n(node, 0, op);
1037 get_Mul_left (ir_node *node) {
1038 assert (node->op == op_Mul);
1039 return get_irn_n(node, 0);
1043 set_Mul_left (ir_node *node, ir_node *left) {
1044 assert (node->op == op_Mul);
1045 set_irn_n(node, 0, left);
1049 get_Mul_right (ir_node *node) {
1050 assert (node->op == op_Mul);
1051 return get_irn_n(node, 1);
1055 set_Mul_right (ir_node *node, ir_node *right) {
1056 assert (node->op == op_Mul);
1057 set_irn_n(node, 1, right);
1061 get_Quot_left (ir_node *node) {
1062 assert (node->op == op_Quot);
1063 return get_irn_n(node, 1);
1067 set_Quot_left (ir_node *node, ir_node *left) {
1068 assert (node->op == op_Quot);
1069 set_irn_n(node, 1, left);
1073 get_Quot_right (ir_node *node) {
1074 assert (node->op == op_Quot);
1075 return get_irn_n(node, 2);
1079 set_Quot_right (ir_node *node, ir_node *right) {
1080 assert (node->op == op_Quot);
1081 set_irn_n(node, 2, right);
1085 get_Quot_mem (ir_node *node) {
1086 assert (node->op == op_Quot);
1087 return get_irn_n(node, 0);
1091 set_Quot_mem (ir_node *node, ir_node *mem) {
1092 assert (node->op == op_Quot);
1093 set_irn_n(node, 0, mem);
1097 get_DivMod_left (ir_node *node) {
1098 assert (node->op == op_DivMod);
1099 return get_irn_n(node, 1);
1103 set_DivMod_left (ir_node *node, ir_node *left) {
1104 assert (node->op == op_DivMod);
1105 set_irn_n(node, 1, left);
1109 get_DivMod_right (ir_node *node) {
1110 assert (node->op == op_DivMod);
1111 return get_irn_n(node, 2);
1115 set_DivMod_right (ir_node *node, ir_node *right) {
1116 assert (node->op == op_DivMod);
1117 set_irn_n(node, 2, right);
1121 get_DivMod_mem (ir_node *node) {
1122 assert (node->op == op_DivMod);
1123 return get_irn_n(node, 0);
1127 set_DivMod_mem (ir_node *node, ir_node *mem) {
1128 assert (node->op == op_DivMod);
1129 set_irn_n(node, 0, mem);
1133 get_Div_left (ir_node *node) {
1134 assert (node->op == op_Div);
1135 return get_irn_n(node, 1);
1139 set_Div_left (ir_node *node, ir_node *left) {
1140 assert (node->op == op_Div);
1141 set_irn_n(node, 1, left);
1145 get_Div_right (ir_node *node) {
1146 assert (node->op == op_Div);
1147 return get_irn_n(node, 2);
1151 set_Div_right (ir_node *node, ir_node *right) {
1152 assert (node->op == op_Div);
1153 set_irn_n(node, 2, right);
1157 get_Div_mem (ir_node *node) {
1158 assert (node->op == op_Div);
1159 return get_irn_n(node, 0);
1163 set_Div_mem (ir_node *node, ir_node *mem) {
1164 assert (node->op == op_Div);
1165 set_irn_n(node, 0, mem);
1169 get_Mod_left (ir_node *node) {
1170 assert (node->op == op_Mod);
1171 return get_irn_n(node, 1);
1175 set_Mod_left (ir_node *node, ir_node *left) {
1176 assert (node->op == op_Mod);
1177 set_irn_n(node, 1, left);
1181 get_Mod_right (ir_node *node) {
1182 assert (node->op == op_Mod);
1183 return get_irn_n(node, 2);
1187 set_Mod_right (ir_node *node, ir_node *right) {
1188 assert (node->op == op_Mod);
1189 set_irn_n(node, 2, right);
1193 get_Mod_mem (ir_node *node) {
1194 assert (node->op == op_Mod);
1195 return get_irn_n(node, 0);
1199 set_Mod_mem (ir_node *node, ir_node *mem) {
1200 assert (node->op == op_Mod);
1201 set_irn_n(node, 0, mem);
1205 get_Abs_op (ir_node *node) {
1206 assert (node->op == op_Abs);
1207 return get_irn_n(node, 0);
1211 set_Abs_op (ir_node *node, ir_node *op) {
1212 assert (node->op == op_Abs);
1213 set_irn_n(node, 0, op);
1217 get_And_left (ir_node *node) {
1218 assert (node->op == op_And);
1219 return get_irn_n(node, 0);
1223 set_And_left (ir_node *node, ir_node *left) {
1224 assert (node->op == op_And);
1225 set_irn_n(node, 0, left);
1229 get_And_right (ir_node *node) {
1230 assert (node->op == op_And);
1231 return get_irn_n(node, 1);
1235 set_And_right (ir_node *node, ir_node *right) {
1236 assert (node->op == op_And);
1237 set_irn_n(node, 1, right);
1241 get_Or_left (ir_node *node) {
1242 assert (node->op == op_Or);
1243 return get_irn_n(node, 0);
1247 set_Or_left (ir_node *node, ir_node *left) {
1248 assert (node->op == op_Or);
1249 set_irn_n(node, 0, left);
1253 get_Or_right (ir_node *node) {
1254 assert (node->op == op_Or);
1255 return get_irn_n(node, 1);
1259 set_Or_right (ir_node *node, ir_node *right) {
1260 assert (node->op == op_Or);
1261 set_irn_n(node, 1, right);
1265 get_Eor_left (ir_node *node) {
1266 assert (node->op == op_Eor);
1267 return get_irn_n(node, 0);
1271 set_Eor_left (ir_node *node, ir_node *left) {
1272 assert (node->op == op_Eor);
1273 set_irn_n(node, 0, left);
1277 get_Eor_right (ir_node *node) {
1278 assert (node->op == op_Eor);
1279 return get_irn_n(node, 1);
1283 set_Eor_right (ir_node *node, ir_node *right) {
1284 assert (node->op == op_Eor);
1285 set_irn_n(node, 1, right);
1290 get_Not_op (ir_node *node) {
1291 assert (node->op == op_Not);
1292 return get_irn_n(node, 0);
1296 set_Not_op (ir_node *node, ir_node *op) {
1297 assert (node->op == op_Not);
1298 set_irn_n(node, 0, op);
1303 get_Shl_left (ir_node *node) {
1304 assert (node->op == op_Shl);
1305 return get_irn_n(node, 0);
1309 set_Shl_left (ir_node *node, ir_node *left) {
1310 assert (node->op == op_Shl);
1311 set_irn_n(node, 0, left);
1315 get_Shl_right (ir_node *node) {
1316 assert (node->op == op_Shl);
1317 return get_irn_n(node, 1);
1321 set_Shl_right (ir_node *node, ir_node *right) {
1322 assert (node->op == op_Shl);
1323 set_irn_n(node, 1, right);
1327 get_Shr_left (ir_node *node) {
1328 assert (node->op == op_Shr);
1329 return get_irn_n(node, 0);
1333 set_Shr_left (ir_node *node, ir_node *left) {
1334 assert (node->op == op_Shr);
1335 set_irn_n(node, 0, left);
1339 get_Shr_right (ir_node *node) {
1340 assert (node->op == op_Shr);
1341 return get_irn_n(node, 1);
1345 set_Shr_right (ir_node *node, ir_node *right) {
1346 assert (node->op == op_Shr);
1347 set_irn_n(node, 1, right);
1351 get_Shrs_left (ir_node *node) {
1352 assert (node->op == op_Shrs);
1353 return get_irn_n(node, 0);
1357 set_Shrs_left (ir_node *node, ir_node *left) {
1358 assert (node->op == op_Shrs);
1359 set_irn_n(node, 0, left);
1363 get_Shrs_right (ir_node *node) {
1364 assert (node->op == op_Shrs);
1365 return get_irn_n(node, 1);
1369 set_Shrs_right (ir_node *node, ir_node *right) {
1370 assert (node->op == op_Shrs);
1371 set_irn_n(node, 1, right);
1375 get_Rot_left (ir_node *node) {
1376 assert (node->op == op_Rot);
1377 return get_irn_n(node, 0);
1381 set_Rot_left (ir_node *node, ir_node *left) {
1382 assert (node->op == op_Rot);
1383 set_irn_n(node, 0, left);
1387 get_Rot_right (ir_node *node) {
1388 assert (node->op == op_Rot);
1389 return get_irn_n(node, 1);
1393 set_Rot_right (ir_node *node, ir_node *right) {
1394 assert (node->op == op_Rot);
1395 set_irn_n(node, 1, right);
1399 get_Cmp_left (ir_node *node) {
1400 assert (node->op == op_Cmp);
1401 return get_irn_n(node, 0);
1405 set_Cmp_left (ir_node *node, ir_node *left) {
1406 assert (node->op == op_Cmp);
1407 set_irn_n(node, 0, left);
1411 get_Cmp_right (ir_node *node) {
1412 assert (node->op == op_Cmp);
1413 return get_irn_n(node, 1);
1417 set_Cmp_right (ir_node *node, ir_node *right) {
1418 assert (node->op == op_Cmp);
1419 set_irn_n(node, 1, right);
1423 get_Conv_op (ir_node *node) {
1424 assert (node->op == op_Conv);
1425 return get_irn_n(node, 0);
1429 set_Conv_op (ir_node *node, ir_node *op) {
1430 assert (node->op == op_Conv);
1431 set_irn_n(node, 0, op);
1435 get_Phi_preds_arr (ir_node *node) {
1436 assert (node->op == op_Phi);
1437 return (ir_node **)&(get_irn_in(node)[1]);
1441 get_Phi_n_preds (ir_node *node) {
1442 assert (node->op == op_Phi);
1443 return (get_irn_arity(node));
1447 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1448 assert (node->op == op_Phi);
1453 get_Phi_pred (ir_node *node, int pos) {
1454 assert (node->op == op_Phi);
1455 return get_irn_n(node, pos);
1459 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1460 assert (node->op == op_Phi);
1461 set_irn_n(node, pos, pred);
1465 get_Load_mem (ir_node *node) {
1466 assert (node->op == op_Load);
1467 return get_irn_n(node, 0);
1471 set_Load_mem (ir_node *node, ir_node *mem) {
1472 assert (node->op == op_Load);
1473 set_irn_n(node, 0, mem);
1477 get_Load_ptr (ir_node *node) {
1478 assert (node->op == op_Load);
1479 return get_irn_n(node, 1);
1483 set_Load_ptr (ir_node *node, ir_node *ptr) {
1484 assert (node->op == op_Load);
1485 set_irn_n(node, 1, ptr);
1490 get_Store_mem (ir_node *node) {
1491 assert (node->op == op_Store);
1492 return get_irn_n(node, 0);
1496 set_Store_mem (ir_node *node, ir_node *mem) {
1497 assert (node->op == op_Store);
1498 set_irn_n(node, 0, mem);
1502 get_Store_ptr (ir_node *node) {
1503 assert (node->op == op_Store);
1504 return get_irn_n(node, 1);
1508 set_Store_ptr (ir_node *node, ir_node *ptr) {
1509 assert (node->op == op_Store);
1510 set_irn_n(node, 1, ptr);
1514 get_Store_value (ir_node *node) {
1515 assert (node->op == op_Store);
1516 return get_irn_n(node, 2);
1520 set_Store_value (ir_node *node, ir_node *value) {
1521 assert (node->op == op_Store);
1522 set_irn_n(node, 2, value);
1526 get_Alloc_mem (ir_node *node) {
1527 assert (node->op == op_Alloc);
1528 return get_irn_n(node, 0);
1532 set_Alloc_mem (ir_node *node, ir_node *mem) {
1533 assert (node->op == op_Alloc);
1534 set_irn_n(node, 0, mem);
1538 get_Alloc_size (ir_node *node) {
1539 assert (node->op == op_Alloc);
1540 return get_irn_n(node, 1);
1544 set_Alloc_size (ir_node *node, ir_node *size) {
1545 assert (node->op == op_Alloc);
1546 set_irn_n(node, 1, size);
1550 get_Alloc_type (ir_node *node) {
1551 assert (node->op == op_Alloc);
1552 return node->attr.a.type;
1556 set_Alloc_type (ir_node *node, type *type) {
1557 assert (node->op == op_Alloc);
1558 node->attr.a.type = type;
1562 get_Alloc_where (ir_node *node) {
1563 assert (node->op == op_Alloc);
1564 return node->attr.a.where;
1568 set_Alloc_where (ir_node *node, where_alloc where) {
1569 assert (node->op == op_Alloc);
1570 node->attr.a.where = where;
1575 get_Free_mem (ir_node *node) {
1576 assert (node->op == op_Free);
1577 return get_irn_n(node, 0);
1581 set_Free_mem (ir_node *node, ir_node *mem) {
1582 assert (node->op == op_Free);
1583 set_irn_n(node, 0, mem);
1587 get_Free_ptr (ir_node *node) {
1588 assert (node->op == op_Free);
1589 return get_irn_n(node, 1);
1593 set_Free_ptr (ir_node *node, ir_node *ptr) {
1594 assert (node->op == op_Free);
1595 set_irn_n(node, 1, ptr);
1599 get_Free_size (ir_node *node) {
1600 assert (node->op == op_Free);
1601 return get_irn_n(node, 2);
1605 set_Free_size (ir_node *node, ir_node *size) {
1606 assert (node->op == op_Free);
1607 set_irn_n(node, 2, size);
1611 get_Free_type (ir_node *node) {
1612 assert (node->op == op_Free);
1613 return node->attr.f;
1617 set_Free_type (ir_node *node, type *type) {
1618 assert (node->op == op_Free);
1619 node->attr.f = type;
1623 get_Sync_preds_arr (ir_node *node) {
1624 assert (node->op == op_Sync);
1625 return (ir_node **)&(get_irn_in(node)[1]);
1629 get_Sync_n_preds (ir_node *node) {
1630 assert (node->op == op_Sync);
1631 return (get_irn_arity(node));
1636 set_Sync_n_preds (ir_node *node, int n_preds) {
1637 assert (node->op == op_Sync);
1642 get_Sync_pred (ir_node *node, int pos) {
1643 assert (node->op == op_Sync);
1644 return get_irn_n(node, pos);
1648 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1649 assert (node->op == op_Sync);
1650 set_irn_n(node, pos, pred);
1654 get_Proj_pred (ir_node *node) {
1655 assert (node->op == op_Proj);
1656 return get_irn_n(node, 0);
1660 set_Proj_pred (ir_node *node, ir_node *pred) {
1661 assert (node->op == op_Proj);
1662 set_irn_n(node, 0, pred);
1666 get_Proj_proj (ir_node *node) {
1667 assert (node->op == op_Proj);
1668 return node->attr.proj;
1672 set_Proj_proj (ir_node *node, long proj) {
1673 assert (node->op == op_Proj);
1674 node->attr.proj = proj;
1678 get_Tuple_preds_arr (ir_node *node) {
1679 assert (node->op == op_Tuple);
1680 return (ir_node **)&(get_irn_in(node)[1]);
1684 get_Tuple_n_preds (ir_node *node) {
1685 assert (node->op == op_Tuple);
1686 return (get_irn_arity(node));
1691 set_Tuple_n_preds (ir_node *node, int n_preds) {
1692 assert (node->op == op_Tuple);
1697 get_Tuple_pred (ir_node *node, int pos) {
1698 assert (node->op == op_Tuple);
1699 return get_irn_n(node, pos);
1703 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1704 assert (node->op == op_Tuple);
1705 set_irn_n(node, pos, pred);
1709 get_Id_pred (ir_node *node) {
1710 assert (node->op == op_Id);
1711 return get_irn_n(node, 0);
1715 set_Id_pred (ir_node *node, ir_node *pred) {
1716 assert (node->op == op_Id);
1717 set_irn_n(node, 0, pred);
1720 /******************************************************************/
1721 /* Auxiliary routines */
1722 /******************************************************************/
1725 skip_Proj (ir_node *node) {
1726 /* don't assert node !!! */
1727 if (node && (node->op == op_Proj)) {
1728 return get_Proj_pred(node);
1735 skip_nop (ir_node *node) {
1736 /* don't assert node !!! */
1738 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1739 /* Don't use get_Id_pred: We get into an endless loop for
1740 self-referencing Ids. */
1741 assert (get_irn_arity (node) > 0);
1742 return node->in[0+1];
1749 is_Bad (ir_node *node) {
1751 if ((node) && get_irn_opcode(node) == iro_Bad)
1757 is_no_Block (ir_node *node) {
1759 return (get_irn_opcode(node) != iro_Block);
1762 /* Returns true if the operation manipulates control flow. */
1764 is_cfop(ir_node *node) {
1765 return ( (get_irn_opcode(node) == iro_Start)
1766 || (get_irn_opcode(node) == iro_Jmp)
1767 || (get_irn_opcode(node) == iro_Cond)
1768 || (get_irn_opcode(node) == iro_Return)
1769 || (get_irn_opcode(node) == iro_Raise)
1770 || (get_irn_opcode(node) == iro_Bad));
1773 /* Returns true if the operation can change the control flow because
1776 is_fragile_op(ir_node *node) {
1777 return ( (get_irn_opcode(node) == iro_Call)
1778 || (get_irn_opcode(node) == iro_Quot)
1779 || (get_irn_opcode(node) == iro_DivMod)
1780 || (get_irn_opcode(node) == iro_Div)
1781 || (get_irn_opcode(node) == iro_Mod)
1782 || (get_irn_opcode(node) == iro_Load)
1783 || (get_irn_opcode(node) == iro_Store)
1784 || (get_irn_opcode(node) == iro_Alloc)
1785 || (get_irn_opcode(node) == iro_Bad));