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_class_ident((type_class *)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_method *type) {
752 assert (node->op == op_Call);
753 node->attr.call = type;
756 /* For unary and binary arithmetic operations the access to the
757 operands can be factored out. Left is the first, right the
758 second arithmetic value as listed in tech report 0999-33.
759 unops are: Minus, Abs, Not, Conv
760 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
761 Shr, Shrs, Rotate, Cmp */
764 is_unop (ir_node *node) {
765 return ( node->op == op_Minus ||
766 node->op == op_Abs ||
767 node->op == op_Not ||
768 node->op == op_Conv );
772 get_unop_op (ir_node *node) {
773 assert ( node->op == op_Minus ||
774 node->op == op_Abs ||
775 node->op == op_Not ||
776 node->op == op_Conv );
777 switch (get_irn_opcode (node)) {
778 case iro_Minus: return get_Minus_op(node); break;
779 case iro_Abs: return get_Abs_op(node); break;
780 case iro_Not: return get_Not_op(node); break;
781 case iro_Conv: return get_Conv_op(node); break;
782 default: return NULL;
787 set_unop_op (ir_node *node, ir_node *op) {
788 assert (node->op == op_Minus ||
789 node->op == op_Abs ||
790 node->op == op_Not ||
791 node->op == op_Conv );
792 switch (get_irn_opcode (node)) {
793 case iro_Minus: set_Minus_op(node, op); break;
794 case iro_Abs: set_Abs_op(node, op); break;
795 case iro_Not: set_Not_op(node, op); break;
796 case iro_Conv: set_Conv_op(node, op); break;
803 is_binop (ir_node *node) {
804 return (node->op == op_Add ||
805 node->op == op_Sub ||
806 node->op == op_Mul ||
807 node->op == op_Quot ||
808 node->op == op_DivMod ||
809 node->op == op_Div ||
810 node->op == op_Mod ||
811 node->op == op_And ||
813 node->op == op_Eor ||
814 node->op == op_Shl ||
815 node->op == op_Shr ||
816 node->op == op_Shrs ||
817 node->op == op_Rot ||
818 node->op == op_Cmp );
822 get_binop_left (ir_node *node) {
823 assert (node->op == op_Add ||
824 node->op == op_Sub ||
825 node->op == op_Mul ||
826 node->op == op_Quot ||
827 node->op == op_DivMod ||
828 node->op == op_Div ||
829 node->op == op_Mod ||
830 node->op == op_And ||
832 node->op == op_Eor ||
833 node->op == op_Shl ||
834 node->op == op_Shr ||
835 node->op == op_Shrs ||
836 node->op == op_Rot ||
837 node->op == op_Cmp );
839 switch (get_irn_opcode (node)) {
840 case iro_Add : return get_Add_left(node); break;
841 case iro_Sub : return get_Sub_left(node); break;
842 case iro_Mul : return get_Mul_left(node); break;
843 case iro_Quot : return get_Quot_left(node); break;
844 case iro_DivMod: return get_DivMod_left(node); break;
845 case iro_Div : return get_Div_left(node); break;
846 case iro_Mod : return get_Mod_left(node); break;
847 case iro_And : return get_And_left(node); break;
848 case iro_Or : return get_Or_left(node); break;
849 case iro_Eor : return get_Eor_left(node); break;
850 case iro_Shl : return get_Shl_left(node); break;
851 case iro_Shr : return get_Shr_left(node); break;
852 case iro_Shrs : return get_Shrs_left(node); break;
853 case iro_Rot : return get_Rot_left(node); break;
854 case iro_Cmp : return get_Cmp_left(node); break;
855 default: return NULL;
860 set_binop_left (ir_node *node, ir_node *left) {
861 assert (node->op == op_Add ||
862 node->op == op_Sub ||
863 node->op == op_Mul ||
864 node->op == op_Quot ||
865 node->op == op_DivMod ||
866 node->op == op_Div ||
867 node->op == op_Mod ||
868 node->op == op_And ||
870 node->op == op_Eor ||
871 node->op == op_Shl ||
872 node->op == op_Shr ||
873 node->op == op_Shrs ||
874 node->op == op_Rot ||
875 node->op == op_Cmp );
877 switch (get_irn_opcode (node)) {
878 case iro_Add : set_Add_left(node, left); break;
879 case iro_Sub : set_Sub_left(node, left); break;
880 case iro_Mul : set_Mul_left(node, left); break;
881 case iro_Quot : set_Quot_left(node, left); break;
882 case iro_DivMod: set_DivMod_left(node, left); break;
883 case iro_Div : set_Div_left(node, left); break;
884 case iro_Mod : set_Mod_left(node, left); break;
885 case iro_And : set_And_left(node, left); break;
886 case iro_Or : set_Or_left(node, left); break;
887 case iro_Eor : set_Eor_left(node, left); break;
888 case iro_Shl : set_Shl_left(node, left); break;
889 case iro_Shr : set_Shr_left(node, left); break;
890 case iro_Shrs : set_Shrs_left(node, left); break;
891 case iro_Rot : set_Rot_left(node, left); break;
892 case iro_Cmp : set_Cmp_left(node, left); break;
898 get_binop_right (ir_node *node) {
899 assert (node->op == op_Add ||
900 node->op == op_Sub ||
901 node->op == op_Mul ||
902 node->op == op_Quot ||
903 node->op == op_DivMod ||
904 node->op == op_Div ||
905 node->op == op_Mod ||
906 node->op == op_And ||
908 node->op == op_Eor ||
909 node->op == op_Shl ||
910 node->op == op_Shr ||
911 node->op == op_Shrs ||
912 node->op == op_Rot ||
913 node->op == op_Cmp );
915 switch (get_irn_opcode (node)) {
916 case iro_Add : return get_Add_right(node); break;
917 case iro_Sub : return get_Sub_right(node); break;
918 case iro_Mul : return get_Mul_right(node); break;
919 case iro_Quot : return get_Quot_right(node); break;
920 case iro_DivMod: return get_DivMod_right(node); break;
921 case iro_Div : return get_Div_right(node); break;
922 case iro_Mod : return get_Mod_right(node); break;
923 case iro_And : return get_And_right(node); break;
924 case iro_Or : return get_Or_right(node); break;
925 case iro_Eor : return get_Eor_right(node); break;
926 case iro_Shl : return get_Shl_right(node); break;
927 case iro_Shr : return get_Shr_right(node); break;
928 case iro_Shrs : return get_Shrs_right(node); break;
929 case iro_Rot : return get_Rot_right(node); break;
930 case iro_Cmp : return get_Cmp_right(node); break;
931 default: return NULL;
936 set_binop_right (ir_node *node, ir_node *right) {
937 assert (node->op == op_Add ||
938 node->op == op_Sub ||
939 node->op == op_Mul ||
940 node->op == op_Quot ||
941 node->op == op_DivMod ||
942 node->op == op_Div ||
943 node->op == op_Mod ||
944 node->op == op_And ||
946 node->op == op_Eor ||
947 node->op == op_Shl ||
948 node->op == op_Shr ||
949 node->op == op_Shrs ||
950 node->op == op_Rot ||
951 node->op == op_Cmp );
953 switch (get_irn_opcode (node)) {
954 case iro_Add : set_Add_right(node, right); break;
955 case iro_Sub : set_Sub_right(node, right); break;
956 case iro_Mul : set_Mul_right(node, right); break;
957 case iro_Quot : set_Quot_right(node, right); break;
958 case iro_DivMod: set_DivMod_right(node, right); break;
959 case iro_Div : set_Div_right(node, right); break;
960 case iro_Mod : set_Mod_right(node, right); break;
961 case iro_And : set_And_right(node, right); break;
962 case iro_Or : set_Or_right(node, right); break;
963 case iro_Eor : set_Eor_right(node, right); break;
964 case iro_Shl : set_Shl_right(node, right); break;
965 case iro_Shr : set_Shr_right(node, right); break;
966 case iro_Shrs : set_Shrs_right(node, right); break;
967 case iro_Rot : set_Rot_right(node, right); break;
968 case iro_Cmp : set_Cmp_right(node, right); break;
974 get_Add_left (ir_node *node) {
975 assert (node->op == op_Add);
976 return get_irn_n(node, 0);
980 set_Add_left (ir_node *node, ir_node *left) {
981 assert (node->op == op_Add);
982 set_irn_n(node, 0, left);
986 get_Add_right (ir_node *node) {
987 assert (node->op == op_Add);
988 return get_irn_n(node, 1);
992 set_Add_right (ir_node *node, ir_node *right) {
993 assert (node->op == op_Add);
994 set_irn_n(node, 1, right);
998 get_Sub_left (ir_node *node) {
999 assert (node->op == op_Sub);
1000 return get_irn_n(node, 0);
1004 set_Sub_left (ir_node *node, ir_node *left) {
1005 assert (node->op == op_Sub);
1006 set_irn_n(node, 0, left);
1010 get_Sub_right (ir_node *node) {
1011 assert (node->op == op_Sub);
1012 return get_irn_n(node, 1);
1016 set_Sub_right (ir_node *node, ir_node *right) {
1017 assert (node->op == op_Sub);
1018 set_irn_n(node, 1, right);
1023 get_Minus_op (ir_node *node) {
1024 assert (node->op == op_Minus);
1025 return get_irn_n(node, 0);
1029 set_Minus_op (ir_node *node, ir_node *op) {
1030 assert (node->op == op_Minus);
1031 set_irn_n(node, 0, op);
1036 get_Mul_left (ir_node *node) {
1037 assert (node->op == op_Mul);
1038 return get_irn_n(node, 0);
1042 set_Mul_left (ir_node *node, ir_node *left) {
1043 assert (node->op == op_Mul);
1044 set_irn_n(node, 0, left);
1048 get_Mul_right (ir_node *node) {
1049 assert (node->op == op_Mul);
1050 return get_irn_n(node, 1);
1054 set_Mul_right (ir_node *node, ir_node *right) {
1055 assert (node->op == op_Mul);
1056 set_irn_n(node, 1, right);
1060 get_Quot_left (ir_node *node) {
1061 assert (node->op == op_Quot);
1062 return get_irn_n(node, 1);
1066 set_Quot_left (ir_node *node, ir_node *left) {
1067 assert (node->op == op_Quot);
1068 set_irn_n(node, 1, left);
1072 get_Quot_right (ir_node *node) {
1073 assert (node->op == op_Quot);
1074 return get_irn_n(node, 2);
1078 set_Quot_right (ir_node *node, ir_node *right) {
1079 assert (node->op == op_Quot);
1080 set_irn_n(node, 2, right);
1084 get_Quot_mem (ir_node *node) {
1085 assert (node->op == op_Quot);
1086 return get_irn_n(node, 0);
1090 set_Quot_mem (ir_node *node, ir_node *mem) {
1091 assert (node->op == op_Quot);
1092 set_irn_n(node, 0, mem);
1096 get_DivMod_left (ir_node *node) {
1097 assert (node->op == op_DivMod);
1098 return get_irn_n(node, 1);
1102 set_DivMod_left (ir_node *node, ir_node *left) {
1103 assert (node->op == op_DivMod);
1104 set_irn_n(node, 1, left);
1108 get_DivMod_right (ir_node *node) {
1109 assert (node->op == op_DivMod);
1110 return get_irn_n(node, 2);
1114 set_DivMod_right (ir_node *node, ir_node *right) {
1115 assert (node->op == op_DivMod);
1116 set_irn_n(node, 2, right);
1120 get_DivMod_mem (ir_node *node) {
1121 assert (node->op == op_DivMod);
1122 return get_irn_n(node, 0);
1126 set_DivMod_mem (ir_node *node, ir_node *mem) {
1127 assert (node->op == op_DivMod);
1128 set_irn_n(node, 0, mem);
1132 get_Div_left (ir_node *node) {
1133 assert (node->op == op_Div);
1134 return get_irn_n(node, 1);
1138 set_Div_left (ir_node *node, ir_node *left) {
1139 assert (node->op == op_Div);
1140 set_irn_n(node, 1, left);
1144 get_Div_right (ir_node *node) {
1145 assert (node->op == op_Div);
1146 return get_irn_n(node, 2);
1150 set_Div_right (ir_node *node, ir_node *right) {
1151 assert (node->op == op_Div);
1152 set_irn_n(node, 2, right);
1156 get_Div_mem (ir_node *node) {
1157 assert (node->op == op_Div);
1158 return get_irn_n(node, 0);
1162 set_Div_mem (ir_node *node, ir_node *mem) {
1163 assert (node->op == op_Div);
1164 set_irn_n(node, 0, mem);
1168 get_Mod_left (ir_node *node) {
1169 assert (node->op == op_Mod);
1170 return get_irn_n(node, 1);
1174 set_Mod_left (ir_node *node, ir_node *left) {
1175 assert (node->op == op_Mod);
1176 set_irn_n(node, 1, left);
1180 get_Mod_right (ir_node *node) {
1181 assert (node->op == op_Mod);
1182 return get_irn_n(node, 2);
1186 set_Mod_right (ir_node *node, ir_node *right) {
1187 assert (node->op == op_Mod);
1188 set_irn_n(node, 2, right);
1192 get_Mod_mem (ir_node *node) {
1193 assert (node->op == op_Mod);
1194 return get_irn_n(node, 0);
1198 set_Mod_mem (ir_node *node, ir_node *mem) {
1199 assert (node->op == op_Mod);
1200 set_irn_n(node, 0, mem);
1204 get_Abs_op (ir_node *node) {
1205 assert (node->op == op_Abs);
1206 return get_irn_n(node, 0);
1210 set_Abs_op (ir_node *node, ir_node *op) {
1211 assert (node->op == op_Abs);
1212 set_irn_n(node, 0, op);
1216 get_And_left (ir_node *node) {
1217 assert (node->op == op_And);
1218 return get_irn_n(node, 0);
1222 set_And_left (ir_node *node, ir_node *left) {
1223 assert (node->op == op_And);
1224 set_irn_n(node, 0, left);
1228 get_And_right (ir_node *node) {
1229 assert (node->op == op_And);
1230 return get_irn_n(node, 1);
1234 set_And_right (ir_node *node, ir_node *right) {
1235 assert (node->op == op_And);
1236 set_irn_n(node, 1, right);
1240 get_Or_left (ir_node *node) {
1241 assert (node->op == op_Or);
1242 return get_irn_n(node, 0);
1246 set_Or_left (ir_node *node, ir_node *left) {
1247 assert (node->op == op_Or);
1248 set_irn_n(node, 0, left);
1252 get_Or_right (ir_node *node) {
1253 assert (node->op == op_Or);
1254 return get_irn_n(node, 1);
1258 set_Or_right (ir_node *node, ir_node *right) {
1259 assert (node->op == op_Or);
1260 set_irn_n(node, 1, right);
1264 get_Eor_left (ir_node *node) {
1265 assert (node->op == op_Eor);
1266 return get_irn_n(node, 0);
1270 set_Eor_left (ir_node *node, ir_node *left) {
1271 assert (node->op == op_Eor);
1272 set_irn_n(node, 0, left);
1276 get_Eor_right (ir_node *node) {
1277 assert (node->op == op_Eor);
1278 return get_irn_n(node, 1);
1282 set_Eor_right (ir_node *node, ir_node *right) {
1283 assert (node->op == op_Eor);
1284 set_irn_n(node, 1, right);
1289 get_Not_op (ir_node *node) {
1290 assert (node->op == op_Not);
1291 return get_irn_n(node, 0);
1295 set_Not_op (ir_node *node, ir_node *op) {
1296 assert (node->op == op_Not);
1297 set_irn_n(node, 0, op);
1302 get_Shl_left (ir_node *node) {
1303 assert (node->op == op_Shl);
1304 return get_irn_n(node, 0);
1308 set_Shl_left (ir_node *node, ir_node *left) {
1309 assert (node->op == op_Shl);
1310 set_irn_n(node, 0, left);
1314 get_Shl_right (ir_node *node) {
1315 assert (node->op == op_Shl);
1316 return get_irn_n(node, 1);
1320 set_Shl_right (ir_node *node, ir_node *right) {
1321 assert (node->op == op_Shl);
1322 set_irn_n(node, 1, right);
1326 get_Shr_left (ir_node *node) {
1327 assert (node->op == op_Shr);
1328 return get_irn_n(node, 0);
1332 set_Shr_left (ir_node *node, ir_node *left) {
1333 assert (node->op == op_Shr);
1334 set_irn_n(node, 0, left);
1338 get_Shr_right (ir_node *node) {
1339 assert (node->op == op_Shr);
1340 return get_irn_n(node, 1);
1344 set_Shr_right (ir_node *node, ir_node *right) {
1345 assert (node->op == op_Shr);
1346 set_irn_n(node, 1, right);
1350 get_Shrs_left (ir_node *node) {
1351 assert (node->op == op_Shrs);
1352 return get_irn_n(node, 0);
1356 set_Shrs_left (ir_node *node, ir_node *left) {
1357 assert (node->op == op_Shrs);
1358 set_irn_n(node, 0, left);
1362 get_Shrs_right (ir_node *node) {
1363 assert (node->op == op_Shrs);
1364 return get_irn_n(node, 1);
1368 set_Shrs_right (ir_node *node, ir_node *right) {
1369 assert (node->op == op_Shrs);
1370 set_irn_n(node, 1, right);
1374 get_Rot_left (ir_node *node) {
1375 assert (node->op == op_Rot);
1376 return get_irn_n(node, 0);
1380 set_Rot_left (ir_node *node, ir_node *left) {
1381 assert (node->op == op_Rot);
1382 set_irn_n(node, 0, left);
1386 get_Rot_right (ir_node *node) {
1387 assert (node->op == op_Rot);
1388 return get_irn_n(node, 1);
1392 set_Rot_right (ir_node *node, ir_node *right) {
1393 assert (node->op == op_Rot);
1394 set_irn_n(node, 1, right);
1398 get_Cmp_left (ir_node *node) {
1399 assert (node->op == op_Cmp);
1400 return get_irn_n(node, 0);
1404 set_Cmp_left (ir_node *node, ir_node *left) {
1405 assert (node->op == op_Cmp);
1406 set_irn_n(node, 0, left);
1410 get_Cmp_right (ir_node *node) {
1411 assert (node->op == op_Cmp);
1412 return get_irn_n(node, 1);
1416 set_Cmp_right (ir_node *node, ir_node *right) {
1417 assert (node->op == op_Cmp);
1418 set_irn_n(node, 1, right);
1422 get_Conv_op (ir_node *node) {
1423 assert (node->op == op_Conv);
1424 return get_irn_n(node, 0);
1428 set_Conv_op (ir_node *node, ir_node *op) {
1429 assert (node->op == op_Conv);
1430 set_irn_n(node, 0, op);
1434 get_Phi_preds_arr (ir_node *node) {
1435 assert (node->op == op_Phi);
1436 return (ir_node **)&(get_irn_in(node)[1]);
1440 get_Phi_n_preds (ir_node *node) {
1441 assert (node->op == op_Phi);
1442 return (get_irn_arity(node));
1446 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1447 assert (node->op == op_Phi);
1452 get_Phi_pred (ir_node *node, int pos) {
1453 assert (node->op == op_Phi);
1454 return get_irn_n(node, pos);
1458 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1459 assert (node->op == op_Phi);
1460 set_irn_n(node, pos, pred);
1464 get_Load_mem (ir_node *node) {
1465 assert (node->op == op_Load);
1466 return get_irn_n(node, 0);
1470 set_Load_mem (ir_node *node, ir_node *mem) {
1471 assert (node->op == op_Load);
1472 set_irn_n(node, 0, mem);
1476 get_Load_ptr (ir_node *node) {
1477 assert (node->op == op_Load);
1478 return get_irn_n(node, 1);
1482 set_Load_ptr (ir_node *node, ir_node *ptr) {
1483 assert (node->op == op_Load);
1484 set_irn_n(node, 1, ptr);
1489 get_Store_mem (ir_node *node) {
1490 assert (node->op == op_Store);
1491 return get_irn_n(node, 0);
1495 set_Store_mem (ir_node *node, ir_node *mem) {
1496 assert (node->op == op_Store);
1497 set_irn_n(node, 0, mem);
1501 get_Store_ptr (ir_node *node) {
1502 assert (node->op == op_Store);
1503 return get_irn_n(node, 1);
1507 set_Store_ptr (ir_node *node, ir_node *ptr) {
1508 assert (node->op == op_Store);
1509 set_irn_n(node, 1, ptr);
1513 get_Store_value (ir_node *node) {
1514 assert (node->op == op_Store);
1515 return get_irn_n(node, 2);
1519 set_Store_value (ir_node *node, ir_node *value) {
1520 assert (node->op == op_Store);
1521 set_irn_n(node, 2, value);
1525 get_Alloc_mem (ir_node *node) {
1526 assert (node->op == op_Alloc);
1527 return get_irn_n(node, 0);
1531 set_Alloc_mem (ir_node *node, ir_node *mem) {
1532 assert (node->op == op_Alloc);
1533 set_irn_n(node, 0, mem);
1537 get_Alloc_size (ir_node *node) {
1538 assert (node->op == op_Alloc);
1539 return get_irn_n(node, 1);
1543 set_Alloc_size (ir_node *node, ir_node *size) {
1544 assert (node->op == op_Alloc);
1545 set_irn_n(node, 1, size);
1549 get_Alloc_type (ir_node *node) {
1550 assert (node->op == op_Alloc);
1551 return node->attr.a.type;
1555 set_Alloc_type (ir_node *node, type *type) {
1556 assert (node->op == op_Alloc);
1557 node->attr.a.type = type;
1561 get_Alloc_where (ir_node *node) {
1562 assert (node->op == op_Alloc);
1563 return node->attr.a.where;
1567 set_Alloc_where (ir_node *node, where_alloc where) {
1568 assert (node->op == op_Alloc);
1569 node->attr.a.where = where;
1574 get_Free_mem (ir_node *node) {
1575 assert (node->op == op_Free);
1576 return get_irn_n(node, 0);
1580 set_Free_mem (ir_node *node, ir_node *mem) {
1581 assert (node->op == op_Free);
1582 set_irn_n(node, 0, mem);
1586 get_Free_ptr (ir_node *node) {
1587 assert (node->op == op_Free);
1588 return get_irn_n(node, 1);
1592 set_Free_ptr (ir_node *node, ir_node *ptr) {
1593 assert (node->op == op_Free);
1594 set_irn_n(node, 1, ptr);
1598 get_Free_size (ir_node *node) {
1599 assert (node->op == op_Free);
1600 return get_irn_n(node, 2);
1604 set_Free_size (ir_node *node, ir_node *size) {
1605 assert (node->op == op_Free);
1606 set_irn_n(node, 2, size);
1610 get_Free_type (ir_node *node) {
1611 assert (node->op == op_Free);
1612 return node->attr.f;
1616 set_Free_type (ir_node *node, type *type) {
1617 assert (node->op == op_Free);
1618 node->attr.f = type;
1622 get_Sync_preds_arr (ir_node *node) {
1623 assert (node->op == op_Sync);
1624 return (ir_node **)&(get_irn_in(node)[1]);
1628 get_Sync_n_preds (ir_node *node) {
1629 assert (node->op == op_Sync);
1630 return (get_irn_arity(node));
1635 set_Sync_n_preds (ir_node *node, int n_preds) {
1636 assert (node->op == op_Sync);
1641 get_Sync_pred (ir_node *node, int pos) {
1642 assert (node->op == op_Sync);
1643 return get_irn_n(node, pos);
1647 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1648 assert (node->op == op_Sync);
1649 set_irn_n(node, pos, pred);
1653 get_Proj_pred (ir_node *node) {
1654 assert (node->op == op_Proj);
1655 return get_irn_n(node, 0);
1659 set_Proj_pred (ir_node *node, ir_node *pred) {
1660 assert (node->op == op_Proj);
1661 set_irn_n(node, 0, pred);
1665 get_Proj_proj (ir_node *node) {
1666 assert (node->op == op_Proj);
1667 return node->attr.proj;
1671 set_Proj_proj (ir_node *node, long proj) {
1672 assert (node->op == op_Proj);
1673 node->attr.proj = proj;
1677 get_Tuple_preds_arr (ir_node *node) {
1678 assert (node->op == op_Tuple);
1679 return (ir_node **)&(get_irn_in(node)[1]);
1683 get_Tuple_n_preds (ir_node *node) {
1684 assert (node->op == op_Tuple);
1685 return (get_irn_arity(node));
1690 set_Tuple_n_preds (ir_node *node, int n_preds) {
1691 assert (node->op == op_Tuple);
1696 get_Tuple_pred (ir_node *node, int pos) {
1697 assert (node->op == op_Tuple);
1698 return get_irn_n(node, pos);
1702 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1703 assert (node->op == op_Tuple);
1704 set_irn_n(node, pos, pred);
1708 get_Id_pred (ir_node *node) {
1709 assert (node->op == op_Id);
1710 return get_irn_n(node, 0);
1714 set_Id_pred (ir_node *node, ir_node *pred) {
1715 assert (node->op == op_Id);
1716 set_irn_n(node, 0, pred);
1719 /******************************************************************/
1720 /* Auxiliary routines */
1721 /******************************************************************/
1724 skip_Proj (ir_node *node) {
1725 /* don't assert node !!! */
1726 if (node && (node->op == op_Proj)) {
1727 return get_Proj_pred(node);
1734 skip_nop (ir_node *node) {
1735 /* don't assert node !!! */
1737 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1738 /* Don't use get_Id_pred: We get into an endless loop for
1739 self-referencing Ids. */
1740 assert (get_irn_arity (node) > 0);
1741 return node->in[0+1];
1748 is_Bad (ir_node *node) {
1750 if ((node) && get_irn_opcode(node) == iro_Bad)
1756 is_no_Block (ir_node *node) {
1758 return (get_irn_opcode(node) != iro_Block);
1761 /* Returns true if the operation manipulates control flow. */
1763 is_cfop(ir_node *node) {
1764 return ( (get_irn_opcode(node) == iro_Start)
1765 || (get_irn_opcode(node) == iro_Jmp)
1766 || (get_irn_opcode(node) == iro_Cond)
1767 || (get_irn_opcode(node) == iro_Return)
1768 || (get_irn_opcode(node) == iro_Raise)
1769 || (get_irn_opcode(node) == iro_Bad));
1772 /* Returns true if the operation can change the control flow because
1775 is_fragile_op(ir_node *node) {
1776 return ( (get_irn_opcode(node) == iro_Call)
1777 || (get_irn_opcode(node) == iro_Quot)
1778 || (get_irn_opcode(node) == iro_DivMod)
1779 || (get_irn_opcode(node) == iro_Div)
1780 || (get_irn_opcode(node) == iro_Mod)
1781 || (get_irn_opcode(node) == iro_Load)
1782 || (get_irn_opcode(node) == iro_Store)
1783 || (get_irn_opcode(node) == iro_Alloc)
1784 || (get_irn_opcode(node) == iro_Bad));