1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
11 #include "irgraph_t.h"
20 /* some constants fixing the positions of nodes predecessors
22 #define CALL_PARAM_OFFSET 2
23 #define SEL_INDEX_OFFSET 2
24 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
26 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
27 "Gt", "Ge", "Lg", "Leg", "Uo",
28 "Ue", "Ul", "Ule", "Ug", "Uge",
31 inline char *get_pnc_string(int pnc) {
32 return pnc_name_arr[pnc];
37 get_negated_pnc(int pnc) {
39 case False: return True; break;
40 case Eq: return Ne; break;
41 case Lt: return Uge; break;
42 case Le: return Ug; break;
43 case Gt: return Ule; break;
44 case Ge: return Ul; break;
45 case Lg: return Ue; break;
46 case Leg: return Uo; break;
47 case Uo: return Leg; break;
48 case Ue: return Lg; break;
49 case Ul: return Ge; break;
50 case Ule: return Gt; break;
51 case Ug: return Le; break;
52 case Uge: return Lt; break;
53 case Ne: return Eq; break;
54 case True: return False; break;
56 return 99; /* to shut up gcc */
59 static char *pns_name_arr [] = {"initial_exec", "global_store",
60 "frame_base", "globals", "args"};
62 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
69 /* irnode constructor */
70 /* create a new irnode in irg, with an op, mode, arity and */
71 /* some incoming irnodes */
72 /* this constructor is used in every specified irnode constructor */
74 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
75 int arity, ir_node **in)
78 int node_size = offsetof (ir_node, attr) + op->attr_size;
80 res = (ir_node *) obstack_alloc (irg->obst, node_size);
82 res->kind = k_ir_node;
88 res->in = NEW_ARR_F (ir_node *, 1);
90 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
91 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
96 res->node_nr = get_irp_new_node_nr();
102 /* Copies all attributes stored in the old node to the new node.
103 Assumes both have the same opcode and sufficient size. */
105 copy_attrs (ir_node *old, ir_node *new) {
106 assert (get_irn_opcode(old) == get_irn_opcode(new));
107 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
110 /* IR-Nodes with attributes */
112 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
115 ir_node *np = XP_GETARG (ir_node *, 0);
118 XPS ("<null ir_node>");
122 XPF1 ("%I", get_irn_opident(np));
124 switch (get_irn_opcode (np)) { /* node label */
126 XPF1 ("%I", get_irn_mode(np)->name);
128 XPF1 ("%v", get_irn_const_attr);
131 if (get_irn_modecode (np) == irm_b) {
133 XP (pnc_name_arr[get_irn_proj_attr(np)]);
134 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
136 XP (pns_name_arr[get_irn_proj_attr(np)]);
138 XPF1 ("%I", get_irn_mode(np)->name);
140 XPF1 ("%d", get_irn_proj_attr(np));
144 XPF1 ("%I", get_irn_mode(np)->name);
146 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
147 XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np)));
149 case iro_Start: /* don't dump mode of these */
158 XPF1 ("%I", get_irn_mode(np)->name);
165 /** getting some parameters from ir_nodes **/
167 /* returns the number of predecessors without the block predecessor. */
169 get_irn_arity (ir_node *node)
172 return (ARR_LEN((node)->in)-1);
175 /* Returns the array with ins. This array is shifted with respect to the
176 array accessed by get_irn_n: The block operand is at position 0 not -1.
177 (@@@ This should be changed.)
178 The order of the predecessors in this array is not guaranteed, except that
179 lists of operands as predecessors of Block or arguments of a Call are
182 get_irn_in (ir_node *node)
188 /* to iterate through the predecessors without touching the array */
189 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
190 to iterate includind the Block predecessor iterate from i = -1 to
192 If it is a block, the entry -1 is NULL. */
194 get_irn_n (ir_node *node, int n)
197 assert (get_irn_arity (node) > n);
198 return skip_nop(node->in[n+1]);
202 set_irn_n (ir_node *node, int n, ir_node *in)
205 assert (get_irn_arity (node) > n);
210 get_irn_mode (ir_node *node)
217 get_irn_modecode (ir_node *node)
220 return node->mode->code;
225 get_irn_modeident (ir_node *node)
228 return node->mode->name;
232 get_irn_op (ir_node *node)
238 /* should be private to the library: */
240 set_irn_op (ir_node *node, ir_op *op)
247 get_irn_opcode (ir_node *node)
250 return node->op->code;
254 get_irn_opname (ir_node *node)
257 return id_to_str(node->op->name);
261 get_irn_opident (ir_node *node)
264 return node->op->name;
268 get_irn_visited (ir_node *node)
271 return node->visited;
275 set_irn_visited (ir_node *node, unsigned long visited)
278 node->visited = visited;
281 set_irn_link (ir_node *node, ir_node *link) {
287 get_irn_link (ir_node *node) {
293 /* Outputs a unique number for this node */
295 get_irn_node_nr(ir_node *node) {
297 return node->node_nr;
302 get_irn_const_attr (ir_node *node)
304 assert (node->op == op_Const);
305 return node->attr.con;
309 get_irn_proj_attr (ir_node *node)
311 assert (node->op == op_Proj);
312 return node->attr.proj;
316 get_irn_alloc_attr (ir_node *node)
318 assert (node->op == op_Alloc);
323 get_irn_free_attr (ir_node *node)
325 assert (node->op == op_Free);
330 get_irn_symconst_attr (ir_node *node)
332 assert (node->op == op_SymConst);
337 get_irn_call_attr (ir_node *node)
339 assert (node->op == op_Call);
340 return node->attr.call;
344 get_irn_sel_attr (ir_node *node)
346 assert (node->op == op_Sel);
351 get_irn_phi_attr (ir_node *node)
353 assert (node->op == op_Phi);
354 return node->attr.phi0_pos;
358 get_irn_block_attr (ir_node *node)
360 assert (node->op == op_Block);
361 return node->attr.block;
364 /** manipulate fields of individual nodes **/
366 /* this works for all except Block */
368 get_nodes_Block (ir_node *node) {
369 assert (!(node->op == op_Block));
370 return get_irn_n(node, -1);
374 set_nodes_Block (ir_node *node, ir_node *block) {
375 assert (!(node->op == op_Block));
376 set_irn_n(node, -1, block);
379 /* Returns an array with the predecessors of the Block. Depending on
380 the implementation of the graph datastructure this can be a copy of
381 the internal representation of predecessors as well as the internal
382 array itself. Therefore writing to this array might obstruct the ir. */
384 get_Block_cfgpred_arr (ir_node *node)
386 assert ((node->op == op_Block));
387 return (ir_node **)&(get_irn_in(node)[1]);
392 get_Block_n_cfgpreds (ir_node *node) {
393 assert ((node->op == op_Block));
394 return (get_irn_arity(node));
399 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
400 assert ((node->op == op_Block));
405 get_Block_cfgpred (ir_node *node, int pos) {
406 assert (node->op == op_Block);
407 return get_irn_n(node, pos);
411 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
412 assert (node->op == op_Block);
413 set_irn_n(node, pos, pred);
417 get_Block_matured (ir_node *node) {
418 assert (node->op == op_Block);
419 return node->attr.block.matured;
423 set_Block_matured (ir_node *node, bool matured) {
424 assert (node->op == op_Block);
425 node->attr.block.matured = matured;
428 get_Block_block_visited (ir_node *node) {
429 assert (node->op == op_Block);
430 return node->attr.block.block_visited;
434 set_Block_block_visited (ir_node *node, unsigned long visit) {
435 assert (node->op == op_Block);
436 node->attr.block.block_visited = visit;
440 get_Block_graph_arr (ir_node *node, int pos) {
441 assert (node->op == op_Block);
442 return node->attr.block.graph_arr[pos+1];
446 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
447 assert (node->op == op_Block);
448 node->attr.block.graph_arr[pos+1] = value;
452 get_Cond_selector (ir_node *node) {
453 assert (node->op == op_Cond);
454 return get_irn_n(node, 0);
458 set_Cond_selector (ir_node *node, ir_node *selector) {
459 assert (node->op == op_Cond);
460 set_irn_n(node, 0, selector);
464 get_Return_mem (ir_node *node) {
465 assert (node->op == op_Return);
466 return get_irn_n(node, 0);
470 set_Return_mem (ir_node *node, ir_node *mem) {
471 assert (node->op == op_Return);
472 set_irn_n(node, 0, mem);
476 get_Return_res_arr (ir_node *node)
478 assert ((node->op == op_Return));
479 if (get_Return_n_res(node) > 0)
480 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
486 get_Return_n_res (ir_node *node) {
487 assert (node->op == op_Return);
488 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
493 set_Return_n_res (ir_node *node, int results) {
494 assert (node->op == op_Return);
499 get_Return_res (ir_node *node, int pos) {
500 assert (node->op == op_Return);
501 assert (get_Return_n_res(node) > pos);
502 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
506 set_Return_res (ir_node *node, int pos, ir_node *res){
507 assert (node->op == op_Return);
508 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
512 get_Raise_mem (ir_node *node) {
513 assert (node->op == op_Return);
514 return get_irn_n(node, 0);
518 set_Raise_mem (ir_node *node, ir_node *mem) {
519 assert (node->op == op_Raise);
520 set_irn_n(node, 0, mem);
524 get_Raise_exo_ptr (ir_node *node) {
525 assert (node->op == op_Raise);
526 return get_irn_n(node, 1);
530 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
531 assert (node->op == op_Raise);
532 set_irn_n(node, 1, exo_ptr);
535 inline tarval *get_Const_tarval (ir_node *node) {
536 assert (node->op == op_Const);
537 return get_irn_const_attr(node);
541 set_Const_tarval (ir_node *node, tarval *con) {
542 assert (node->op == op_Const);
543 node->attr.con = con;
547 get_SymConst_kind (ir_node *node) {
548 assert (node->op == op_SymConst);
549 return node->attr.i.num;
553 set_SymConst_kind (ir_node *node, symconst_kind num) {
554 assert (node->op == op_SymConst);
555 node->attr.i.num = num;
559 get_SymConst_type (ir_node *node) {
560 assert ( (node->op == op_SymConst)
561 && ( get_SymConst_kind(node) == type_tag
562 || get_SymConst_kind(node) == size));
563 return node->attr.i.tori.typ;
567 set_SymConst_type (ir_node *node, type *type) {
568 assert ( (node->op == op_SymConst)
569 && ( get_SymConst_kind(node) == type_tag
570 || get_SymConst_kind(node) == size));
571 node->attr.i.tori.typ = type;
575 get_SymConst_ptrinfo (ir_node *node) {
576 assert ( (node->op == op_SymConst)
577 && (get_SymConst_kind(node) == linkage_ptr_info));
578 return node->attr.i.tori.ptrinfo;
582 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
583 assert ( (node->op == op_SymConst)
584 && (get_SymConst_kind(node) == linkage_ptr_info));
585 node->attr.i.tori.ptrinfo = ptrinfo;
589 get_SymConst_type_or_id (ir_node *node) {
590 assert (node->op == op_SymConst);
591 return &(node->attr.i.tori);
595 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
596 assert (node->op == op_SymConst);
597 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
601 get_Sel_mem (ir_node *node) {
602 assert (node->op == op_Sel);
603 return get_irn_n(node, 0);
607 set_Sel_mem (ir_node *node, ir_node *mem) {
608 assert (node->op == op_Sel);
609 set_irn_n(node, 0, mem);
613 get_Sel_ptr (ir_node *node) {
614 assert (node->op == op_Sel);
615 return get_irn_n(node, 1);
619 set_Sel_ptr (ir_node *node, ir_node *ptr) {
620 assert (node->op == op_Sel);
621 set_irn_n(node, 1, ptr);
625 get_Sel_index_arr (ir_node *node)
627 assert ((node->op == op_Sel));
628 if (get_Sel_n_index(node) > 0)
629 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
635 get_Sel_n_index (ir_node *node) {
636 assert (node->op == op_Sel);
637 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
642 set_Sel_n_index (ir_node *node, int n_index) {
643 assert (node->op == op_Sel);
648 get_Sel_index (ir_node *node, int pos) {
649 assert (node->op == op_Sel);
650 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
654 set_Sel_index (ir_node *node, int pos, ir_node *index) {
655 assert (node->op == op_Sel);
656 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
660 get_Sel_entity (ir_node *node) {
661 assert (node->op == op_Sel);
662 return node->attr.s.ent;
666 set_Sel_entity (ir_node *node, entity *ent) {
667 assert (node->op == op_Sel);
668 node->attr.s.ent = ent;
672 get_Sel_linkage_type (ir_node *node) {
673 assert (node->op == op_Sel);
674 return node->attr.s.ltyp;
678 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
679 assert (node->op == op_Sel);
680 node->attr.s.ltyp = lt;
684 get_Call_mem (ir_node *node) {
685 assert (node->op == op_Call);
686 return get_irn_n(node, 0);
690 set_Call_mem (ir_node *node, ir_node *mem) {
691 assert (node->op == op_Call);
692 set_irn_n(node, 0, mem);
696 get_Call_ptr (ir_node *node) {
697 assert (node->op == op_Call);
698 return get_irn_n(node, 1);
702 set_Call_ptr (ir_node *node, ir_node *ptr) {
703 assert (node->op == op_Call);
704 set_irn_n(node, 1, ptr);
708 get_Call_param_arr (ir_node *node) {
709 assert (node->op == op_Call);
710 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
714 get_Call_n_params (ir_node *node) {
715 assert (node->op == op_Call);
716 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
720 get_Call_arity (ir_node *node) {
721 return get_Call_n_params(node);
725 set_Call_arity (ir_node *node, ir_node *arity) {
726 assert (node->op == op_Call);
731 get_Call_param (ir_node *node, int pos) {
732 assert (node->op == op_Call);
733 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
737 set_Call_param (ir_node *node, int pos, ir_node *param) {
738 assert (node->op == op_Call);
739 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
743 get_Call_type (ir_node *node) {
744 assert (node->op == op_Call);
745 return node->attr.call;
749 set_Call_type (ir_node *node, type_method *type) {
750 assert (node->op == op_Call);
751 node->attr.call = type;
754 /* For unary and binary arithmetic operations the access to the
755 operands can be factored out. Left is the first, right the
756 second arithmetic value as listed in tech report 0999-33.
757 unops are: Minus, Abs, Not, Conv
758 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
759 Shr, Shrs, Rotate, Cmp */
762 is_unop (ir_node *node) {
763 return ( node->op == op_Minus ||
764 node->op == op_Abs ||
765 node->op == op_Not ||
766 node->op == op_Conv );
770 get_unop_op (ir_node *node) {
771 assert ( node->op == op_Minus ||
772 node->op == op_Abs ||
773 node->op == op_Not ||
774 node->op == op_Conv );
775 switch (get_irn_opcode (node)) {
776 case iro_Minus: return get_Minus_op(node); break;
777 case iro_Abs: return get_Abs_op(node); break;
778 case iro_Not: return get_Not_op(node); break;
779 case iro_Conv: return get_Conv_op(node); break;
780 default: return NULL;
785 set_unop_op (ir_node *node, ir_node *op) {
786 assert (node->op == op_Minus ||
787 node->op == op_Abs ||
788 node->op == op_Not ||
789 node->op == op_Conv );
790 switch (get_irn_opcode (node)) {
791 case iro_Minus: set_Minus_op(node, op); break;
792 case iro_Abs: set_Abs_op(node, op); break;
793 case iro_Not: set_Not_op(node, op); break;
794 case iro_Conv: set_Conv_op(node, op); break;
801 is_binop (ir_node *node) {
802 return (node->op == op_Add ||
803 node->op == op_Sub ||
804 node->op == op_Mul ||
805 node->op == op_Quot ||
806 node->op == op_DivMod ||
807 node->op == op_Div ||
808 node->op == op_Mod ||
809 node->op == op_And ||
811 node->op == op_Eor ||
812 node->op == op_Shl ||
813 node->op == op_Shr ||
814 node->op == op_Shrs ||
815 node->op == op_Rot ||
816 node->op == op_Cmp );
820 get_binop_left (ir_node *node) {
821 assert (node->op == op_Add ||
822 node->op == op_Sub ||
823 node->op == op_Mul ||
824 node->op == op_Quot ||
825 node->op == op_DivMod ||
826 node->op == op_Div ||
827 node->op == op_Mod ||
828 node->op == op_And ||
830 node->op == op_Eor ||
831 node->op == op_Shl ||
832 node->op == op_Shr ||
833 node->op == op_Shrs ||
834 node->op == op_Rot ||
835 node->op == op_Cmp );
837 switch (get_irn_opcode (node)) {
838 case iro_Add : return get_Add_left(node); break;
839 case iro_Sub : return get_Sub_left(node); break;
840 case iro_Mul : return get_Mul_left(node); break;
841 case iro_Quot : return get_Quot_left(node); break;
842 case iro_DivMod: return get_DivMod_left(node); break;
843 case iro_Div : return get_Div_left(node); break;
844 case iro_Mod : return get_Mod_left(node); break;
845 case iro_And : return get_And_left(node); break;
846 case iro_Or : return get_Or_left(node); break;
847 case iro_Eor : return get_Eor_left(node); break;
848 case iro_Shl : return get_Shl_left(node); break;
849 case iro_Shr : return get_Shr_left(node); break;
850 case iro_Shrs : return get_Shrs_left(node); break;
851 case iro_Rot : return get_Rot_left(node); break;
852 case iro_Cmp : return get_Cmp_left(node); break;
853 default: return NULL;
858 set_binop_left (ir_node *node, ir_node *left) {
859 assert (node->op == op_Add ||
860 node->op == op_Sub ||
861 node->op == op_Mul ||
862 node->op == op_Quot ||
863 node->op == op_DivMod ||
864 node->op == op_Div ||
865 node->op == op_Mod ||
866 node->op == op_And ||
868 node->op == op_Eor ||
869 node->op == op_Shl ||
870 node->op == op_Shr ||
871 node->op == op_Shrs ||
872 node->op == op_Rot ||
873 node->op == op_Cmp );
875 switch (get_irn_opcode (node)) {
876 case iro_Add : set_Add_left(node, left); break;
877 case iro_Sub : set_Sub_left(node, left); break;
878 case iro_Mul : set_Mul_left(node, left); break;
879 case iro_Quot : set_Quot_left(node, left); break;
880 case iro_DivMod: set_DivMod_left(node, left); break;
881 case iro_Div : set_Div_left(node, left); break;
882 case iro_Mod : set_Mod_left(node, left); break;
883 case iro_And : set_And_left(node, left); break;
884 case iro_Or : set_Or_left(node, left); break;
885 case iro_Eor : set_Eor_left(node, left); break;
886 case iro_Shl : set_Shl_left(node, left); break;
887 case iro_Shr : set_Shr_left(node, left); break;
888 case iro_Shrs : set_Shrs_left(node, left); break;
889 case iro_Rot : set_Rot_left(node, left); break;
890 case iro_Cmp : set_Cmp_left(node, left); break;
896 get_binop_right (ir_node *node) {
897 assert (node->op == op_Add ||
898 node->op == op_Sub ||
899 node->op == op_Mul ||
900 node->op == op_Quot ||
901 node->op == op_DivMod ||
902 node->op == op_Div ||
903 node->op == op_Mod ||
904 node->op == op_And ||
906 node->op == op_Eor ||
907 node->op == op_Shl ||
908 node->op == op_Shr ||
909 node->op == op_Shrs ||
910 node->op == op_Rot ||
911 node->op == op_Cmp );
913 switch (get_irn_opcode (node)) {
914 case iro_Add : return get_Add_right(node); break;
915 case iro_Sub : return get_Sub_right(node); break;
916 case iro_Mul : return get_Mul_right(node); break;
917 case iro_Quot : return get_Quot_right(node); break;
918 case iro_DivMod: return get_DivMod_right(node); break;
919 case iro_Div : return get_Div_right(node); break;
920 case iro_Mod : return get_Mod_right(node); break;
921 case iro_And : return get_And_right(node); break;
922 case iro_Or : return get_Or_right(node); break;
923 case iro_Eor : return get_Eor_right(node); break;
924 case iro_Shl : return get_Shl_right(node); break;
925 case iro_Shr : return get_Shr_right(node); break;
926 case iro_Shrs : return get_Shrs_right(node); break;
927 case iro_Rot : return get_Rot_right(node); break;
928 case iro_Cmp : return get_Cmp_right(node); break;
929 default: return NULL;
934 set_binop_right (ir_node *node, ir_node *right) {
935 assert (node->op == op_Add ||
936 node->op == op_Sub ||
937 node->op == op_Mul ||
938 node->op == op_Quot ||
939 node->op == op_DivMod ||
940 node->op == op_Div ||
941 node->op == op_Mod ||
942 node->op == op_And ||
944 node->op == op_Eor ||
945 node->op == op_Shl ||
946 node->op == op_Shr ||
947 node->op == op_Shrs ||
948 node->op == op_Rot ||
949 node->op == op_Cmp );
951 switch (get_irn_opcode (node)) {
952 case iro_Add : set_Add_right(node, right); break;
953 case iro_Sub : set_Sub_right(node, right); break;
954 case iro_Mul : set_Mul_right(node, right); break;
955 case iro_Quot : set_Quot_right(node, right); break;
956 case iro_DivMod: set_DivMod_right(node, right); break;
957 case iro_Div : set_Div_right(node, right); break;
958 case iro_Mod : set_Mod_right(node, right); break;
959 case iro_And : set_And_right(node, right); break;
960 case iro_Or : set_Or_right(node, right); break;
961 case iro_Eor : set_Eor_right(node, right); break;
962 case iro_Shl : set_Shl_right(node, right); break;
963 case iro_Shr : set_Shr_right(node, right); break;
964 case iro_Shrs : set_Shrs_right(node, right); break;
965 case iro_Rot : set_Rot_right(node, right); break;
966 case iro_Cmp : set_Cmp_right(node, right); break;
972 get_Add_left (ir_node *node) {
973 assert (node->op == op_Add);
974 return get_irn_n(node, 0);
978 set_Add_left (ir_node *node, ir_node *left) {
979 assert (node->op == op_Add);
980 set_irn_n(node, 0, left);
984 get_Add_right (ir_node *node) {
985 assert (node->op == op_Add);
986 return get_irn_n(node, 1);
990 set_Add_right (ir_node *node, ir_node *right) {
991 assert (node->op == op_Add);
992 set_irn_n(node, 1, right);
996 get_Sub_left (ir_node *node) {
997 assert (node->op == op_Sub);
998 return get_irn_n(node, 0);
1002 set_Sub_left (ir_node *node, ir_node *left) {
1003 assert (node->op == op_Sub);
1004 set_irn_n(node, 0, left);
1008 get_Sub_right (ir_node *node) {
1009 assert (node->op == op_Sub);
1010 return get_irn_n(node, 1);
1014 set_Sub_right (ir_node *node, ir_node *right) {
1015 assert (node->op == op_Sub);
1016 set_irn_n(node, 1, right);
1021 get_Minus_op (ir_node *node) {
1022 assert (node->op == op_Minus);
1023 return get_irn_n(node, 0);
1027 set_Minus_op (ir_node *node, ir_node *op) {
1028 assert (node->op == op_Minus);
1029 set_irn_n(node, 0, op);
1034 get_Mul_left (ir_node *node) {
1035 assert (node->op == op_Mul);
1036 return get_irn_n(node, 0);
1040 set_Mul_left (ir_node *node, ir_node *left) {
1041 assert (node->op == op_Mul);
1042 set_irn_n(node, 0, left);
1046 get_Mul_right (ir_node *node) {
1047 assert (node->op == op_Mul);
1048 return get_irn_n(node, 1);
1052 set_Mul_right (ir_node *node, ir_node *right) {
1053 assert (node->op == op_Mul);
1054 set_irn_n(node, 1, right);
1058 get_Quot_left (ir_node *node) {
1059 assert (node->op == op_Quot);
1060 return get_irn_n(node, 1);
1064 set_Quot_left (ir_node *node, ir_node *left) {
1065 assert (node->op == op_Quot);
1066 set_irn_n(node, 1, left);
1070 get_Quot_right (ir_node *node) {
1071 assert (node->op == op_Quot);
1072 return get_irn_n(node, 2);
1076 set_Quot_right (ir_node *node, ir_node *right) {
1077 assert (node->op == op_Quot);
1078 set_irn_n(node, 2, right);
1082 get_Quot_mem (ir_node *node) {
1083 assert (node->op == op_Quot);
1084 return get_irn_n(node, 0);
1088 set_Quot_mem (ir_node *node, ir_node *mem) {
1089 assert (node->op == op_Quot);
1090 set_irn_n(node, 0, mem);
1094 get_DivMod_left (ir_node *node) {
1095 assert (node->op == op_DivMod);
1096 return get_irn_n(node, 1);
1100 set_DivMod_left (ir_node *node, ir_node *left) {
1101 assert (node->op == op_DivMod);
1102 set_irn_n(node, 1, left);
1106 get_DivMod_right (ir_node *node) {
1107 assert (node->op == op_DivMod);
1108 return get_irn_n(node, 2);
1112 set_DivMod_right (ir_node *node, ir_node *right) {
1113 assert (node->op == op_DivMod);
1114 set_irn_n(node, 2, right);
1118 get_DivMod_mem (ir_node *node) {
1119 assert (node->op == op_DivMod);
1120 return get_irn_n(node, 0);
1124 set_DivMod_mem (ir_node *node, ir_node *mem) {
1125 assert (node->op == op_DivMod);
1126 set_irn_n(node, 0, mem);
1130 get_Div_left (ir_node *node) {
1131 assert (node->op == op_Div);
1132 return get_irn_n(node, 1);
1136 set_Div_left (ir_node *node, ir_node *left) {
1137 assert (node->op == op_Div);
1138 set_irn_n(node, 1, left);
1142 get_Div_right (ir_node *node) {
1143 assert (node->op == op_Div);
1144 return get_irn_n(node, 2);
1148 set_Div_right (ir_node *node, ir_node *right) {
1149 assert (node->op == op_Div);
1150 set_irn_n(node, 2, right);
1154 get_Div_mem (ir_node *node) {
1155 assert (node->op == op_Div);
1156 return get_irn_n(node, 0);
1160 set_Div_mem (ir_node *node, ir_node *mem) {
1161 assert (node->op == op_Div);
1162 set_irn_n(node, 0, mem);
1166 get_Mod_left (ir_node *node) {
1167 assert (node->op == op_Mod);
1168 return get_irn_n(node, 1);
1172 set_Mod_left (ir_node *node, ir_node *left) {
1173 assert (node->op == op_Mod);
1174 set_irn_n(node, 1, left);
1178 get_Mod_right (ir_node *node) {
1179 assert (node->op == op_Mod);
1180 return get_irn_n(node, 2);
1184 set_Mod_right (ir_node *node, ir_node *right) {
1185 assert (node->op == op_Mod);
1186 set_irn_n(node, 2, right);
1190 get_Mod_mem (ir_node *node) {
1191 assert (node->op == op_Mod);
1192 return get_irn_n(node, 0);
1196 set_Mod_mem (ir_node *node, ir_node *mem) {
1197 assert (node->op == op_Mod);
1198 set_irn_n(node, 0, mem);
1202 get_Abs_op (ir_node *node) {
1203 assert (node->op == op_Abs);
1204 return get_irn_n(node, 0);
1208 set_Abs_op (ir_node *node, ir_node *op) {
1209 assert (node->op == op_Abs);
1210 set_irn_n(node, 0, op);
1214 get_And_left (ir_node *node) {
1215 assert (node->op == op_And);
1216 return get_irn_n(node, 0);
1220 set_And_left (ir_node *node, ir_node *left) {
1221 assert (node->op == op_And);
1222 set_irn_n(node, 0, left);
1226 get_And_right (ir_node *node) {
1227 assert (node->op == op_And);
1228 return get_irn_n(node, 1);
1232 set_And_right (ir_node *node, ir_node *right) {
1233 assert (node->op == op_And);
1234 set_irn_n(node, 1, right);
1238 get_Or_left (ir_node *node) {
1239 assert (node->op == op_Or);
1240 return get_irn_n(node, 0);
1244 set_Or_left (ir_node *node, ir_node *left) {
1245 assert (node->op == op_Or);
1246 set_irn_n(node, 0, left);
1250 get_Or_right (ir_node *node) {
1251 assert (node->op == op_Or);
1252 return get_irn_n(node, 1);
1256 set_Or_right (ir_node *node, ir_node *right) {
1257 assert (node->op == op_Or);
1258 set_irn_n(node, 1, right);
1262 get_Eor_left (ir_node *node) {
1263 assert (node->op == op_Eor);
1264 return get_irn_n(node, 0);
1268 set_Eor_left (ir_node *node, ir_node *left) {
1269 assert (node->op == op_Eor);
1270 set_irn_n(node, 0, left);
1274 get_Eor_right (ir_node *node) {
1275 assert (node->op == op_Eor);
1276 return get_irn_n(node, 1);
1280 set_Eor_right (ir_node *node, ir_node *right) {
1281 assert (node->op == op_Eor);
1282 set_irn_n(node, 1, right);
1287 get_Not_op (ir_node *node) {
1288 assert (node->op == op_Not);
1289 return get_irn_n(node, 0);
1293 set_Not_op (ir_node *node, ir_node *op) {
1294 assert (node->op == op_Not);
1295 set_irn_n(node, 0, op);
1300 get_Shl_left (ir_node *node) {
1301 assert (node->op == op_Shl);
1302 return get_irn_n(node, 0);
1306 set_Shl_left (ir_node *node, ir_node *left) {
1307 assert (node->op == op_Shl);
1308 set_irn_n(node, 0, left);
1312 get_Shl_right (ir_node *node) {
1313 assert (node->op == op_Shl);
1314 return get_irn_n(node, 1);
1318 set_Shl_right (ir_node *node, ir_node *right) {
1319 assert (node->op == op_Shl);
1320 set_irn_n(node, 1, right);
1324 get_Shr_left (ir_node *node) {
1325 assert (node->op == op_Shr);
1326 return get_irn_n(node, 0);
1330 set_Shr_left (ir_node *node, ir_node *left) {
1331 assert (node->op == op_Shr);
1332 set_irn_n(node, 0, left);
1336 get_Shr_right (ir_node *node) {
1337 assert (node->op == op_Shr);
1338 return get_irn_n(node, 1);
1342 set_Shr_right (ir_node *node, ir_node *right) {
1343 assert (node->op == op_Shr);
1344 set_irn_n(node, 1, right);
1348 get_Shrs_left (ir_node *node) {
1349 assert (node->op == op_Shrs);
1350 return get_irn_n(node, 0);
1354 set_Shrs_left (ir_node *node, ir_node *left) {
1355 assert (node->op == op_Shrs);
1356 set_irn_n(node, 0, left);
1360 get_Shrs_right (ir_node *node) {
1361 assert (node->op == op_Shrs);
1362 return get_irn_n(node, 1);
1366 set_Shrs_right (ir_node *node, ir_node *right) {
1367 assert (node->op == op_Shrs);
1368 set_irn_n(node, 1, right);
1372 get_Rot_left (ir_node *node) {
1373 assert (node->op == op_Rot);
1374 return get_irn_n(node, 0);
1378 set_Rot_left (ir_node *node, ir_node *left) {
1379 assert (node->op == op_Rot);
1380 set_irn_n(node, 0, left);
1384 get_Rot_right (ir_node *node) {
1385 assert (node->op == op_Rot);
1386 return get_irn_n(node, 1);
1390 set_Rot_right (ir_node *node, ir_node *right) {
1391 assert (node->op == op_Rot);
1392 set_irn_n(node, 1, right);
1396 get_Cmp_left (ir_node *node) {
1397 assert (node->op == op_Cmp);
1398 return get_irn_n(node, 0);
1402 set_Cmp_left (ir_node *node, ir_node *left) {
1403 assert (node->op == op_Cmp);
1404 set_irn_n(node, 0, left);
1408 get_Cmp_right (ir_node *node) {
1409 assert (node->op == op_Cmp);
1410 return get_irn_n(node, 1);
1414 set_Cmp_right (ir_node *node, ir_node *right) {
1415 assert (node->op == op_Cmp);
1416 set_irn_n(node, 1, right);
1420 get_Conv_op (ir_node *node) {
1421 assert (node->op == op_Conv);
1422 return get_irn_n(node, 0);
1426 set_Conv_op (ir_node *node, ir_node *op) {
1427 assert (node->op == op_Conv);
1428 set_irn_n(node, 0, op);
1432 get_Phi_preds_arr (ir_node *node) {
1433 assert (node->op == op_Phi);
1434 return (ir_node **)&(get_irn_in(node)[1]);
1438 get_Phi_n_preds (ir_node *node) {
1439 assert (node->op == op_Phi);
1440 return (get_irn_arity(node));
1444 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1445 assert (node->op == op_Phi);
1450 get_Phi_pred (ir_node *node, int pos) {
1451 assert (node->op == op_Phi);
1452 return get_irn_n(node, pos);
1456 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1457 assert (node->op == op_Phi);
1458 set_irn_n(node, pos, pred);
1462 get_Load_mem (ir_node *node) {
1463 assert (node->op == op_Load);
1464 return get_irn_n(node, 0);
1468 set_Load_mem (ir_node *node, ir_node *mem) {
1469 assert (node->op == op_Load);
1470 set_irn_n(node, 0, mem);
1474 get_Load_ptr (ir_node *node) {
1475 assert (node->op == op_Load);
1476 return get_irn_n(node, 1);
1480 set_Load_ptr (ir_node *node, ir_node *ptr) {
1481 assert (node->op == op_Load);
1482 set_irn_n(node, 1, ptr);
1487 get_Store_mem (ir_node *node) {
1488 assert (node->op == op_Store);
1489 return get_irn_n(node, 0);
1493 set_Store_mem (ir_node *node, ir_node *mem) {
1494 assert (node->op == op_Store);
1495 set_irn_n(node, 0, mem);
1499 get_Store_ptr (ir_node *node) {
1500 assert (node->op == op_Store);
1501 return get_irn_n(node, 1);
1505 set_Store_ptr (ir_node *node, ir_node *ptr) {
1506 assert (node->op == op_Store);
1507 set_irn_n(node, 1, ptr);
1511 get_Store_value (ir_node *node) {
1512 assert (node->op == op_Store);
1513 return get_irn_n(node, 2);
1517 set_Store_value (ir_node *node, ir_node *value) {
1518 assert (node->op == op_Store);
1519 set_irn_n(node, 2, value);
1523 get_Alloc_mem (ir_node *node) {
1524 assert (node->op == op_Alloc);
1525 return get_irn_n(node, 0);
1529 set_Alloc_mem (ir_node *node, ir_node *mem) {
1530 assert (node->op == op_Alloc);
1531 set_irn_n(node, 0, mem);
1535 get_Alloc_size (ir_node *node) {
1536 assert (node->op == op_Alloc);
1537 return get_irn_n(node, 1);
1541 set_Alloc_size (ir_node *node, ir_node *size) {
1542 assert (node->op == op_Alloc);
1543 set_irn_n(node, 1, size);
1547 get_Alloc_type (ir_node *node) {
1548 assert (node->op == op_Alloc);
1549 return node->attr.a.type;
1553 set_Alloc_type (ir_node *node, type *type) {
1554 assert (node->op == op_Alloc);
1555 node->attr.a.type = type;
1559 get_Alloc_where (ir_node *node) {
1560 assert (node->op == op_Alloc);
1561 return node->attr.a.where;
1565 set_Alloc_where (ir_node *node, where_alloc where) {
1566 assert (node->op == op_Alloc);
1567 node->attr.a.where = where;
1572 get_Free_mem (ir_node *node) {
1573 assert (node->op == op_Free);
1574 return get_irn_n(node, 0);
1578 set_Free_mem (ir_node *node, ir_node *mem) {
1579 assert (node->op == op_Free);
1580 set_irn_n(node, 0, mem);
1584 get_Free_ptr (ir_node *node) {
1585 assert (node->op == op_Free);
1586 return get_irn_n(node, 1);
1590 set_Free_ptr (ir_node *node, ir_node *ptr) {
1591 assert (node->op == op_Free);
1592 set_irn_n(node, 1, ptr);
1596 get_Free_size (ir_node *node) {
1597 assert (node->op == op_Free);
1598 return get_irn_n(node, 2);
1602 set_Free_size (ir_node *node, ir_node *size) {
1603 assert (node->op == op_Free);
1604 set_irn_n(node, 2, size);
1608 get_Free_type (ir_node *node) {
1609 assert (node->op == op_Free);
1610 return node->attr.f;
1614 set_Free_type (ir_node *node, type *type) {
1615 assert (node->op == op_Free);
1616 node->attr.f = type;
1620 get_Sync_preds_arr (ir_node *node) {
1621 assert (node->op == op_Sync);
1622 return (ir_node **)&(get_irn_in(node)[1]);
1626 get_Sync_n_preds (ir_node *node) {
1627 assert (node->op == op_Sync);
1628 return (get_irn_arity(node));
1633 set_Sync_n_preds (ir_node *node, int n_preds) {
1634 assert (node->op == op_Sync);
1639 get_Sync_pred (ir_node *node, int pos) {
1640 assert (node->op == op_Sync);
1641 return get_irn_n(node, pos);
1645 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1646 assert (node->op == op_Sync);
1647 set_irn_n(node, pos, pred);
1651 get_Proj_pred (ir_node *node) {
1652 assert (node->op == op_Proj);
1653 return get_irn_n(node, 0);
1657 set_Proj_pred (ir_node *node, ir_node *pred) {
1658 assert (node->op == op_Proj);
1659 set_irn_n(node, 0, pred);
1663 get_Proj_proj (ir_node *node) {
1664 assert (node->op == op_Proj);
1665 return node->attr.proj;
1669 set_Proj_proj (ir_node *node, long proj) {
1670 assert (node->op == op_Proj);
1671 node->attr.proj = proj;
1675 get_Tuple_preds_arr (ir_node *node) {
1676 assert (node->op == op_Tuple);
1677 return (ir_node **)&(get_irn_in(node)[1]);
1681 get_Tuple_n_preds (ir_node *node) {
1682 assert (node->op == op_Tuple);
1683 return (get_irn_arity(node));
1688 set_Tuple_n_preds (ir_node *node, int n_preds) {
1689 assert (node->op == op_Tuple);
1694 get_Tuple_pred (ir_node *node, int pos) {
1695 assert (node->op == op_Tuple);
1696 return get_irn_n(node, pos);
1700 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1701 assert (node->op == op_Tuple);
1702 set_irn_n(node, pos, pred);
1706 get_Id_pred (ir_node *node) {
1707 assert (node->op == op_Id);
1708 return get_irn_n(node, 0);
1712 set_Id_pred (ir_node *node, ir_node *pred) {
1713 assert (node->op == op_Id);
1714 set_irn_n(node, 0, pred);
1717 /******************************************************************/
1718 /* Auxiliary routines */
1719 /******************************************************************/
1722 skip_Proj (ir_node *node) {
1723 /* don't assert node !!! */
1724 if (node && (node->op == op_Proj)) {
1725 return get_Proj_pred(node);
1732 skip_nop (ir_node *node) {
1733 /* don't assert node !!! */
1735 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1736 /* Don't use get_Id_pred: We get into an endless loop for
1737 self-referencing Ids. */
1738 assert (get_irn_arity (node) > 0);
1739 return node->in[0+1];
1746 is_Bad (ir_node *node) {
1748 if ((node) && get_irn_opcode(node) == iro_Bad)
1754 is_no_Block (ir_node *node) {
1756 return (get_irn_opcode(node) != iro_Block);
1759 /* Returns true if the operation manipulates control flow. */
1761 is_cfop(ir_node *node) {
1762 return ( (get_irn_opcode(node) == iro_Start)
1763 || (get_irn_opcode(node) == iro_Jmp)
1764 || (get_irn_opcode(node) == iro_Cond)
1765 || (get_irn_opcode(node) == iro_Return)
1766 || (get_irn_opcode(node) == iro_Raise)
1767 || (get_irn_opcode(node) == iro_Bad));
1770 /* Returns true if the operation can change the control flow because
1773 is_fragile_op(ir_node *node) {
1774 return ( (get_irn_opcode(node) == iro_Call)
1775 || (get_irn_opcode(node) == iro_Quot)
1776 || (get_irn_opcode(node) == iro_DivMod)
1777 || (get_irn_opcode(node) == iro_Div)
1778 || (get_irn_opcode(node) == iro_Mod)
1779 || (get_irn_opcode(node) == iro_Load)
1780 || (get_irn_opcode(node) == iro_Store)
1781 || (get_irn_opcode(node) == iro_Alloc)
1782 || (get_irn_opcode(node) == iro_Bad));