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);
166 /** getting some parameters from ir_nodes **/
168 /* returns the number of predecessors without the block predecessor. */
170 get_irn_arity (ir_node *node)
173 return (ARR_LEN((node)->in)-1);
176 /* Returns the array with ins. This array is shifted with respect to the
177 array accessed by get_irn_n: The block operand is at position 0 not -1.
178 (@@@ This should be changed.)
179 The order of the predecessors in this array is not guaranteed, except that
180 lists of operands as predecessors of Block or arguments of a Call are
183 get_irn_in (ir_node *node)
189 /* to iterate through the predecessors without touching the array */
190 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
191 to iterate includind the Block predecessor iterate from i = -1 to
193 If it is a block, the entry -1 is NULL. */
195 get_irn_n (ir_node *node, int n)
198 assert (get_irn_arity (node) > n);
199 return skip_nop(node->in[n+1]);
203 set_irn_n (ir_node *node, int n, ir_node *in)
206 assert (get_irn_arity (node) > n);
211 get_irn_mode (ir_node *node)
218 get_irn_modecode (ir_node *node)
221 return node->mode->code;
226 get_irn_modeident (ir_node *node)
229 return node->mode->name;
233 get_irn_op (ir_node *node)
239 /* should be private to the library: */
241 set_irn_op (ir_node *node, ir_op *op)
248 get_irn_opcode (ir_node *node)
251 return node->op->code;
255 get_irn_opname (ir_node *node)
258 return id_to_str(node->op->name);
262 get_irn_opident (ir_node *node)
265 return node->op->name;
269 get_irn_visited (ir_node *node)
272 return node->visited;
276 set_irn_visited (ir_node *node, unsigned long visited)
279 node->visited = visited;
282 set_irn_link (ir_node *node, ir_node *link) {
288 get_irn_link (ir_node *node) {
294 /* Outputs a unique number for this node */
296 get_irn_node_nr(ir_node *node) {
298 return node->node_nr;
303 get_irn_const_attr (ir_node *node)
305 assert (node->op == op_Const);
306 return node->attr.con;
310 get_irn_proj_attr (ir_node *node)
312 assert (node->op == op_Proj);
313 return node->attr.proj;
317 get_irn_alloc_attr (ir_node *node)
319 assert (node->op == op_Alloc);
324 get_irn_free_attr (ir_node *node)
326 assert (node->op == op_Free);
331 get_irn_symconst_attr (ir_node *node)
333 assert (node->op == op_SymConst);
338 get_irn_call_attr (ir_node *node)
340 assert (node->op == op_Call);
341 return node->attr.call;
345 get_irn_sel_attr (ir_node *node)
347 assert (node->op == op_Sel);
352 get_irn_phi_attr (ir_node *node)
354 assert (node->op == op_Phi);
355 return node->attr.phi0_pos;
359 get_irn_block_attr (ir_node *node)
361 assert (node->op == op_Block);
362 return node->attr.block;
365 /** manipulate fields of individual nodes **/
367 /* this works for all except Block */
369 get_nodes_Block (ir_node *node) {
370 assert (!(node->op == op_Block));
371 return get_irn_n(node, -1);
375 set_nodes_Block (ir_node *node, ir_node *block) {
376 assert (!(node->op == op_Block));
377 set_irn_n(node, -1, block);
380 /* Returns an array with the predecessors of the Block. Depending on
381 the implementation of the graph datastructure this can be a copy of
382 the internal representation of predecessors as well as the internal
383 array itself. Therefore writing to this array might obstruct the ir. */
385 get_Block_cfgpred_arr (ir_node *node)
387 assert ((node->op == op_Block));
388 return (ir_node **)&(get_irn_in(node)[1]);
393 get_Block_n_cfgpreds (ir_node *node) {
394 assert ((node->op == op_Block));
395 return (get_irn_arity(node));
400 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
401 assert ((node->op == op_Block));
406 get_Block_cfgpred (ir_node *node, int pos) {
407 assert (node->op == op_Block);
408 return get_irn_n(node, pos);
412 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
413 assert (node->op == op_Block);
414 set_irn_n(node, pos, pred);
418 get_Block_matured (ir_node *node) {
419 assert (node->op == op_Block);
420 return node->attr.block.matured;
424 set_Block_matured (ir_node *node, bool matured) {
425 assert (node->op == op_Block);
426 node->attr.block.matured = matured;
429 get_Block_block_visited (ir_node *node) {
430 assert (node->op == op_Block);
431 return node->attr.block.block_visited;
435 set_Block_block_visited (ir_node *node, unsigned long visit) {
436 assert (node->op == op_Block);
437 node->attr.block.block_visited = visit;
441 get_Block_graph_arr (ir_node *node, int pos) {
442 assert (node->op == op_Block);
443 return node->attr.block.graph_arr[pos+1];
447 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
448 assert (node->op == op_Block);
449 node->attr.block.graph_arr[pos+1] = value;
452 > Implementing the case construct (which is where the constant Proj node is
453 > important) involves far more than simply determining the constant values.
454 > We could argue that this is more properly a function of the translator from
455 > Firm to the target machine. That could be done if there was some way of
456 > projecting "default" out of the Cond node.
457 I know it's complicated.
458 Basically there are two proglems:
459 - determining the gaps between the projs
460 - determining the biggest case constant to konw the proj number for
462 I see several solutions:
463 1. Introduce a ProjDefault node. Solves both problems.
464 This means to extend all optimizations executed during construction.
465 2. Give the Cond node for switch two flavors:
466 a) there are no gaps in the projs (existing flavor)
467 b) gaps may exist, default proj is still the Proj with the largest
468 projection number. This covers also the gaps.
469 3. Fix the semantic of the Cond to that of 2b)
471 Solution 2 seems to be the best:
472 Computing the gaps in the Firm representation is not too hard, i.e.,
473 libfirm can implement a routine that transforms betweeen the two
474 flavours. This is also possible for 1) but 2) does not require to
475 change any existing optimization.
476 Further it should be far simpler to determine the biggest constant than
478 I don't want to choose 3) as 2a) seems to have advantages for
479 dataflow analysis and 3) does not allow to convert the representation to
483 get_Cond_selector (ir_node *node) {
484 assert (node->op == op_Cond);
485 return get_irn_n(node, 0);
489 set_Cond_selector (ir_node *node, ir_node *selector) {
490 assert (node->op == op_Cond);
491 set_irn_n(node, 0, selector);
495 get_Return_mem (ir_node *node) {
496 assert (node->op == op_Return);
497 return get_irn_n(node, 0);
501 set_Return_mem (ir_node *node, ir_node *mem) {
502 assert (node->op == op_Return);
503 set_irn_n(node, 0, mem);
507 get_Return_res_arr (ir_node *node)
509 assert ((node->op == op_Return));
510 if (get_Return_n_res(node) > 0)
511 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
517 get_Return_n_res (ir_node *node) {
518 assert (node->op == op_Return);
519 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
524 set_Return_n_res (ir_node *node, int results) {
525 assert (node->op == op_Return);
530 get_Return_res (ir_node *node, int pos) {
531 assert (node->op == op_Return);
532 assert (get_Return_n_res(node) > pos);
533 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
537 set_Return_res (ir_node *node, int pos, ir_node *res){
538 assert (node->op == op_Return);
539 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
543 get_Raise_mem (ir_node *node) {
544 assert (node->op == op_Return);
545 return get_irn_n(node, 0);
549 set_Raise_mem (ir_node *node, ir_node *mem) {
550 assert (node->op == op_Raise);
551 set_irn_n(node, 0, mem);
555 get_Raise_exo_ptr (ir_node *node) {
556 assert (node->op == op_Raise);
557 return get_irn_n(node, 1);
561 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
562 assert (node->op == op_Raise);
563 set_irn_n(node, 1, exo_ptr);
566 inline tarval *get_Const_tarval (ir_node *node) {
567 assert (node->op == op_Const);
568 return get_irn_const_attr(node);
572 set_Const_tarval (ir_node *node, tarval *con) {
573 assert (node->op == op_Const);
574 node->attr.con = con;
578 get_SymConst_kind (ir_node *node) {
579 assert (node->op == op_SymConst);
580 return node->attr.i.num;
584 set_SymConst_kind (ir_node *node, symconst_kind num) {
585 assert (node->op == op_SymConst);
586 node->attr.i.num = num;
590 get_SymConst_type (ir_node *node) {
591 assert ( (node->op == op_SymConst)
592 && ( get_SymConst_kind(node) == type_tag
593 || get_SymConst_kind(node) == size));
594 return node->attr.i.tori.typ;
598 set_SymConst_type (ir_node *node, type *type) {
599 assert ( (node->op == op_SymConst)
600 && ( get_SymConst_kind(node) == type_tag
601 || get_SymConst_kind(node) == size));
602 node->attr.i.tori.typ = type;
606 get_SymConst_ptrinfo (ir_node *node) {
607 assert ( (node->op == op_SymConst)
608 && (get_SymConst_kind(node) == linkage_ptr_info));
609 return node->attr.i.tori.ptrinfo;
613 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
614 assert ( (node->op == op_SymConst)
615 && (get_SymConst_kind(node) == linkage_ptr_info));
616 node->attr.i.tori.ptrinfo = ptrinfo;
620 get_SymConst_type_or_id (ir_node *node) {
621 assert (node->op == op_SymConst);
622 return &(node->attr.i.tori);
626 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
627 assert (node->op == op_SymConst);
628 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
632 get_Sel_mem (ir_node *node) {
633 assert (node->op == op_Sel);
634 return get_irn_n(node, 0);
638 set_Sel_mem (ir_node *node, ir_node *mem) {
639 assert (node->op == op_Sel);
640 set_irn_n(node, 0, mem);
644 get_Sel_ptr (ir_node *node) {
645 assert (node->op == op_Sel);
646 return get_irn_n(node, 1);
650 set_Sel_ptr (ir_node *node, ir_node *ptr) {
651 assert (node->op == op_Sel);
652 set_irn_n(node, 1, ptr);
656 get_Sel_index_arr (ir_node *node)
658 assert ((node->op == op_Sel));
659 if (get_Sel_n_index(node) > 0)
660 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
666 get_Sel_n_index (ir_node *node) {
667 assert (node->op == op_Sel);
668 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
673 set_Sel_n_index (ir_node *node, int n_index) {
674 assert (node->op == op_Sel);
679 get_Sel_index (ir_node *node, int pos) {
680 assert (node->op == op_Sel);
681 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
685 set_Sel_index (ir_node *node, int pos, ir_node *index) {
686 assert (node->op == op_Sel);
687 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
691 get_Sel_entity (ir_node *node) {
692 assert (node->op == op_Sel);
693 return node->attr.s.ent;
697 set_Sel_entity (ir_node *node, entity *ent) {
698 assert (node->op == op_Sel);
699 node->attr.s.ent = ent;
703 get_Sel_linkage_type (ir_node *node) {
704 assert (node->op == op_Sel);
705 return node->attr.s.ltyp;
709 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
710 assert (node->op == op_Sel);
711 node->attr.s.ltyp = lt;
715 get_Call_mem (ir_node *node) {
716 assert (node->op == op_Call);
717 return get_irn_n(node, 0);
721 set_Call_mem (ir_node *node, ir_node *mem) {
722 assert (node->op == op_Call);
723 set_irn_n(node, 0, mem);
727 get_Call_ptr (ir_node *node) {
728 assert (node->op == op_Call);
729 return get_irn_n(node, 1);
733 set_Call_ptr (ir_node *node, ir_node *ptr) {
734 assert (node->op == op_Call);
735 set_irn_n(node, 1, ptr);
739 get_Call_param_arr (ir_node *node) {
740 assert (node->op == op_Call);
741 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
745 get_Call_n_params (ir_node *node) {
746 assert (node->op == op_Call);
747 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
751 get_Call_arity (ir_node *node) {
752 return get_Call_n_params(node);
756 set_Call_arity (ir_node *node, ir_node *arity) {
757 assert (node->op == op_Call);
762 get_Call_param (ir_node *node, int pos) {
763 assert (node->op == op_Call);
764 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
768 set_Call_param (ir_node *node, int pos, ir_node *param) {
769 assert (node->op == op_Call);
770 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
774 get_Call_type (ir_node *node) {
775 assert (node->op == op_Call);
776 return node->attr.call;
780 set_Call_type (ir_node *node, type *type) {
781 assert (node->op == op_Call);
782 assert (is_method_type(type));
783 node->attr.call = type;
786 /* For unary and binary arithmetic operations the access to the
787 operands can be factored out. Left is the first, right the
788 second arithmetic value as listed in tech report 0999-33.
789 unops are: Minus, Abs, Not, Conv
790 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
791 Shr, Shrs, Rotate, Cmp */
794 is_unop (ir_node *node) {
795 return ( node->op == op_Minus ||
796 node->op == op_Abs ||
797 node->op == op_Not ||
798 node->op == op_Conv );
802 get_unop_op (ir_node *node) {
803 assert ( node->op == op_Minus ||
804 node->op == op_Abs ||
805 node->op == op_Not ||
806 node->op == op_Conv );
807 switch (get_irn_opcode (node)) {
808 case iro_Minus: return get_Minus_op(node); break;
809 case iro_Abs: return get_Abs_op(node); break;
810 case iro_Not: return get_Not_op(node); break;
811 case iro_Conv: return get_Conv_op(node); break;
812 default: return NULL;
817 set_unop_op (ir_node *node, ir_node *op) {
818 assert (node->op == op_Minus ||
819 node->op == op_Abs ||
820 node->op == op_Not ||
821 node->op == op_Conv );
822 switch (get_irn_opcode (node)) {
823 case iro_Minus: set_Minus_op(node, op); break;
824 case iro_Abs: set_Abs_op(node, op); break;
825 case iro_Not: set_Not_op(node, op); break;
826 case iro_Conv: set_Conv_op(node, op); break;
833 is_binop (ir_node *node) {
834 return (node->op == op_Add ||
835 node->op == op_Sub ||
836 node->op == op_Mul ||
837 node->op == op_Quot ||
838 node->op == op_DivMod ||
839 node->op == op_Div ||
840 node->op == op_Mod ||
841 node->op == op_And ||
843 node->op == op_Eor ||
844 node->op == op_Shl ||
845 node->op == op_Shr ||
846 node->op == op_Shrs ||
847 node->op == op_Rot ||
848 node->op == op_Cmp );
852 get_binop_left (ir_node *node) {
853 assert (node->op == op_Add ||
854 node->op == op_Sub ||
855 node->op == op_Mul ||
856 node->op == op_Quot ||
857 node->op == op_DivMod ||
858 node->op == op_Div ||
859 node->op == op_Mod ||
860 node->op == op_And ||
862 node->op == op_Eor ||
863 node->op == op_Shl ||
864 node->op == op_Shr ||
865 node->op == op_Shrs ||
866 node->op == op_Rot ||
867 node->op == op_Cmp );
869 switch (get_irn_opcode (node)) {
870 case iro_Add : return get_Add_left(node); break;
871 case iro_Sub : return get_Sub_left(node); break;
872 case iro_Mul : return get_Mul_left(node); break;
873 case iro_Quot : return get_Quot_left(node); break;
874 case iro_DivMod: return get_DivMod_left(node); break;
875 case iro_Div : return get_Div_left(node); break;
876 case iro_Mod : return get_Mod_left(node); break;
877 case iro_And : return get_And_left(node); break;
878 case iro_Or : return get_Or_left(node); break;
879 case iro_Eor : return get_Eor_left(node); break;
880 case iro_Shl : return get_Shl_left(node); break;
881 case iro_Shr : return get_Shr_left(node); break;
882 case iro_Shrs : return get_Shrs_left(node); break;
883 case iro_Rot : return get_Rot_left(node); break;
884 case iro_Cmp : return get_Cmp_left(node); break;
885 default: return NULL;
890 set_binop_left (ir_node *node, ir_node *left) {
891 assert (node->op == op_Add ||
892 node->op == op_Sub ||
893 node->op == op_Mul ||
894 node->op == op_Quot ||
895 node->op == op_DivMod ||
896 node->op == op_Div ||
897 node->op == op_Mod ||
898 node->op == op_And ||
900 node->op == op_Eor ||
901 node->op == op_Shl ||
902 node->op == op_Shr ||
903 node->op == op_Shrs ||
904 node->op == op_Rot ||
905 node->op == op_Cmp );
907 switch (get_irn_opcode (node)) {
908 case iro_Add : set_Add_left(node, left); break;
909 case iro_Sub : set_Sub_left(node, left); break;
910 case iro_Mul : set_Mul_left(node, left); break;
911 case iro_Quot : set_Quot_left(node, left); break;
912 case iro_DivMod: set_DivMod_left(node, left); break;
913 case iro_Div : set_Div_left(node, left); break;
914 case iro_Mod : set_Mod_left(node, left); break;
915 case iro_And : set_And_left(node, left); break;
916 case iro_Or : set_Or_left(node, left); break;
917 case iro_Eor : set_Eor_left(node, left); break;
918 case iro_Shl : set_Shl_left(node, left); break;
919 case iro_Shr : set_Shr_left(node, left); break;
920 case iro_Shrs : set_Shrs_left(node, left); break;
921 case iro_Rot : set_Rot_left(node, left); break;
922 case iro_Cmp : set_Cmp_left(node, left); break;
928 get_binop_right (ir_node *node) {
929 assert (node->op == op_Add ||
930 node->op == op_Sub ||
931 node->op == op_Mul ||
932 node->op == op_Quot ||
933 node->op == op_DivMod ||
934 node->op == op_Div ||
935 node->op == op_Mod ||
936 node->op == op_And ||
938 node->op == op_Eor ||
939 node->op == op_Shl ||
940 node->op == op_Shr ||
941 node->op == op_Shrs ||
942 node->op == op_Rot ||
943 node->op == op_Cmp );
945 switch (get_irn_opcode (node)) {
946 case iro_Add : return get_Add_right(node); break;
947 case iro_Sub : return get_Sub_right(node); break;
948 case iro_Mul : return get_Mul_right(node); break;
949 case iro_Quot : return get_Quot_right(node); break;
950 case iro_DivMod: return get_DivMod_right(node); break;
951 case iro_Div : return get_Div_right(node); break;
952 case iro_Mod : return get_Mod_right(node); break;
953 case iro_And : return get_And_right(node); break;
954 case iro_Or : return get_Or_right(node); break;
955 case iro_Eor : return get_Eor_right(node); break;
956 case iro_Shl : return get_Shl_right(node); break;
957 case iro_Shr : return get_Shr_right(node); break;
958 case iro_Shrs : return get_Shrs_right(node); break;
959 case iro_Rot : return get_Rot_right(node); break;
960 case iro_Cmp : return get_Cmp_right(node); break;
961 default: return NULL;
966 set_binop_right (ir_node *node, ir_node *right) {
967 assert (node->op == op_Add ||
968 node->op == op_Sub ||
969 node->op == op_Mul ||
970 node->op == op_Quot ||
971 node->op == op_DivMod ||
972 node->op == op_Div ||
973 node->op == op_Mod ||
974 node->op == op_And ||
976 node->op == op_Eor ||
977 node->op == op_Shl ||
978 node->op == op_Shr ||
979 node->op == op_Shrs ||
980 node->op == op_Rot ||
981 node->op == op_Cmp );
983 switch (get_irn_opcode (node)) {
984 case iro_Add : set_Add_right(node, right); break;
985 case iro_Sub : set_Sub_right(node, right); break;
986 case iro_Mul : set_Mul_right(node, right); break;
987 case iro_Quot : set_Quot_right(node, right); break;
988 case iro_DivMod: set_DivMod_right(node, right); break;
989 case iro_Div : set_Div_right(node, right); break;
990 case iro_Mod : set_Mod_right(node, right); break;
991 case iro_And : set_And_right(node, right); break;
992 case iro_Or : set_Or_right(node, right); break;
993 case iro_Eor : set_Eor_right(node, right); break;
994 case iro_Shl : set_Shl_right(node, right); break;
995 case iro_Shr : set_Shr_right(node, right); break;
996 case iro_Shrs : set_Shrs_right(node, right); break;
997 case iro_Rot : set_Rot_right(node, right); break;
998 case iro_Cmp : set_Cmp_right(node, right); break;
1004 get_Add_left (ir_node *node) {
1005 assert (node->op == op_Add);
1006 return get_irn_n(node, 0);
1010 set_Add_left (ir_node *node, ir_node *left) {
1011 assert (node->op == op_Add);
1012 set_irn_n(node, 0, left);
1016 get_Add_right (ir_node *node) {
1017 assert (node->op == op_Add);
1018 return get_irn_n(node, 1);
1022 set_Add_right (ir_node *node, ir_node *right) {
1023 assert (node->op == op_Add);
1024 set_irn_n(node, 1, right);
1028 get_Sub_left (ir_node *node) {
1029 assert (node->op == op_Sub);
1030 return get_irn_n(node, 0);
1034 set_Sub_left (ir_node *node, ir_node *left) {
1035 assert (node->op == op_Sub);
1036 set_irn_n(node, 0, left);
1040 get_Sub_right (ir_node *node) {
1041 assert (node->op == op_Sub);
1042 return get_irn_n(node, 1);
1046 set_Sub_right (ir_node *node, ir_node *right) {
1047 assert (node->op == op_Sub);
1048 set_irn_n(node, 1, right);
1053 get_Minus_op (ir_node *node) {
1054 assert (node->op == op_Minus);
1055 return get_irn_n(node, 0);
1059 set_Minus_op (ir_node *node, ir_node *op) {
1060 assert (node->op == op_Minus);
1061 set_irn_n(node, 0, op);
1066 get_Mul_left (ir_node *node) {
1067 assert (node->op == op_Mul);
1068 return get_irn_n(node, 0);
1072 set_Mul_left (ir_node *node, ir_node *left) {
1073 assert (node->op == op_Mul);
1074 set_irn_n(node, 0, left);
1078 get_Mul_right (ir_node *node) {
1079 assert (node->op == op_Mul);
1080 return get_irn_n(node, 1);
1084 set_Mul_right (ir_node *node, ir_node *right) {
1085 assert (node->op == op_Mul);
1086 set_irn_n(node, 1, right);
1090 get_Quot_left (ir_node *node) {
1091 assert (node->op == op_Quot);
1092 return get_irn_n(node, 1);
1096 set_Quot_left (ir_node *node, ir_node *left) {
1097 assert (node->op == op_Quot);
1098 set_irn_n(node, 1, left);
1102 get_Quot_right (ir_node *node) {
1103 assert (node->op == op_Quot);
1104 return get_irn_n(node, 2);
1108 set_Quot_right (ir_node *node, ir_node *right) {
1109 assert (node->op == op_Quot);
1110 set_irn_n(node, 2, right);
1114 get_Quot_mem (ir_node *node) {
1115 assert (node->op == op_Quot);
1116 return get_irn_n(node, 0);
1120 set_Quot_mem (ir_node *node, ir_node *mem) {
1121 assert (node->op == op_Quot);
1122 set_irn_n(node, 0, mem);
1126 get_DivMod_left (ir_node *node) {
1127 assert (node->op == op_DivMod);
1128 return get_irn_n(node, 1);
1132 set_DivMod_left (ir_node *node, ir_node *left) {
1133 assert (node->op == op_DivMod);
1134 set_irn_n(node, 1, left);
1138 get_DivMod_right (ir_node *node) {
1139 assert (node->op == op_DivMod);
1140 return get_irn_n(node, 2);
1144 set_DivMod_right (ir_node *node, ir_node *right) {
1145 assert (node->op == op_DivMod);
1146 set_irn_n(node, 2, right);
1150 get_DivMod_mem (ir_node *node) {
1151 assert (node->op == op_DivMod);
1152 return get_irn_n(node, 0);
1156 set_DivMod_mem (ir_node *node, ir_node *mem) {
1157 assert (node->op == op_DivMod);
1158 set_irn_n(node, 0, mem);
1162 get_Div_left (ir_node *node) {
1163 assert (node->op == op_Div);
1164 return get_irn_n(node, 1);
1168 set_Div_left (ir_node *node, ir_node *left) {
1169 assert (node->op == op_Div);
1170 set_irn_n(node, 1, left);
1174 get_Div_right (ir_node *node) {
1175 assert (node->op == op_Div);
1176 return get_irn_n(node, 2);
1180 set_Div_right (ir_node *node, ir_node *right) {
1181 assert (node->op == op_Div);
1182 set_irn_n(node, 2, right);
1186 get_Div_mem (ir_node *node) {
1187 assert (node->op == op_Div);
1188 return get_irn_n(node, 0);
1192 set_Div_mem (ir_node *node, ir_node *mem) {
1193 assert (node->op == op_Div);
1194 set_irn_n(node, 0, mem);
1198 get_Mod_left (ir_node *node) {
1199 assert (node->op == op_Mod);
1200 return get_irn_n(node, 1);
1204 set_Mod_left (ir_node *node, ir_node *left) {
1205 assert (node->op == op_Mod);
1206 set_irn_n(node, 1, left);
1210 get_Mod_right (ir_node *node) {
1211 assert (node->op == op_Mod);
1212 return get_irn_n(node, 2);
1216 set_Mod_right (ir_node *node, ir_node *right) {
1217 assert (node->op == op_Mod);
1218 set_irn_n(node, 2, right);
1222 get_Mod_mem (ir_node *node) {
1223 assert (node->op == op_Mod);
1224 return get_irn_n(node, 0);
1228 set_Mod_mem (ir_node *node, ir_node *mem) {
1229 assert (node->op == op_Mod);
1230 set_irn_n(node, 0, mem);
1234 get_Abs_op (ir_node *node) {
1235 assert (node->op == op_Abs);
1236 return get_irn_n(node, 0);
1240 set_Abs_op (ir_node *node, ir_node *op) {
1241 assert (node->op == op_Abs);
1242 set_irn_n(node, 0, op);
1246 get_And_left (ir_node *node) {
1247 assert (node->op == op_And);
1248 return get_irn_n(node, 0);
1252 set_And_left (ir_node *node, ir_node *left) {
1253 assert (node->op == op_And);
1254 set_irn_n(node, 0, left);
1258 get_And_right (ir_node *node) {
1259 assert (node->op == op_And);
1260 return get_irn_n(node, 1);
1264 set_And_right (ir_node *node, ir_node *right) {
1265 assert (node->op == op_And);
1266 set_irn_n(node, 1, right);
1270 get_Or_left (ir_node *node) {
1271 assert (node->op == op_Or);
1272 return get_irn_n(node, 0);
1276 set_Or_left (ir_node *node, ir_node *left) {
1277 assert (node->op == op_Or);
1278 set_irn_n(node, 0, left);
1282 get_Or_right (ir_node *node) {
1283 assert (node->op == op_Or);
1284 return get_irn_n(node, 1);
1288 set_Or_right (ir_node *node, ir_node *right) {
1289 assert (node->op == op_Or);
1290 set_irn_n(node, 1, right);
1294 get_Eor_left (ir_node *node) {
1295 assert (node->op == op_Eor);
1296 return get_irn_n(node, 0);
1300 set_Eor_left (ir_node *node, ir_node *left) {
1301 assert (node->op == op_Eor);
1302 set_irn_n(node, 0, left);
1306 get_Eor_right (ir_node *node) {
1307 assert (node->op == op_Eor);
1308 return get_irn_n(node, 1);
1312 set_Eor_right (ir_node *node, ir_node *right) {
1313 assert (node->op == op_Eor);
1314 set_irn_n(node, 1, right);
1319 get_Not_op (ir_node *node) {
1320 assert (node->op == op_Not);
1321 return get_irn_n(node, 0);
1325 set_Not_op (ir_node *node, ir_node *op) {
1326 assert (node->op == op_Not);
1327 set_irn_n(node, 0, op);
1332 get_Shl_left (ir_node *node) {
1333 assert (node->op == op_Shl);
1334 return get_irn_n(node, 0);
1338 set_Shl_left (ir_node *node, ir_node *left) {
1339 assert (node->op == op_Shl);
1340 set_irn_n(node, 0, left);
1344 get_Shl_right (ir_node *node) {
1345 assert (node->op == op_Shl);
1346 return get_irn_n(node, 1);
1350 set_Shl_right (ir_node *node, ir_node *right) {
1351 assert (node->op == op_Shl);
1352 set_irn_n(node, 1, right);
1356 get_Shr_left (ir_node *node) {
1357 assert (node->op == op_Shr);
1358 return get_irn_n(node, 0);
1362 set_Shr_left (ir_node *node, ir_node *left) {
1363 assert (node->op == op_Shr);
1364 set_irn_n(node, 0, left);
1368 get_Shr_right (ir_node *node) {
1369 assert (node->op == op_Shr);
1370 return get_irn_n(node, 1);
1374 set_Shr_right (ir_node *node, ir_node *right) {
1375 assert (node->op == op_Shr);
1376 set_irn_n(node, 1, right);
1380 get_Shrs_left (ir_node *node) {
1381 assert (node->op == op_Shrs);
1382 return get_irn_n(node, 0);
1386 set_Shrs_left (ir_node *node, ir_node *left) {
1387 assert (node->op == op_Shrs);
1388 set_irn_n(node, 0, left);
1392 get_Shrs_right (ir_node *node) {
1393 assert (node->op == op_Shrs);
1394 return get_irn_n(node, 1);
1398 set_Shrs_right (ir_node *node, ir_node *right) {
1399 assert (node->op == op_Shrs);
1400 set_irn_n(node, 1, right);
1404 get_Rot_left (ir_node *node) {
1405 assert (node->op == op_Rot);
1406 return get_irn_n(node, 0);
1410 set_Rot_left (ir_node *node, ir_node *left) {
1411 assert (node->op == op_Rot);
1412 set_irn_n(node, 0, left);
1416 get_Rot_right (ir_node *node) {
1417 assert (node->op == op_Rot);
1418 return get_irn_n(node, 1);
1422 set_Rot_right (ir_node *node, ir_node *right) {
1423 assert (node->op == op_Rot);
1424 set_irn_n(node, 1, right);
1428 get_Cmp_left (ir_node *node) {
1429 assert (node->op == op_Cmp);
1430 return get_irn_n(node, 0);
1434 set_Cmp_left (ir_node *node, ir_node *left) {
1435 assert (node->op == op_Cmp);
1436 set_irn_n(node, 0, left);
1440 get_Cmp_right (ir_node *node) {
1441 assert (node->op == op_Cmp);
1442 return get_irn_n(node, 1);
1446 set_Cmp_right (ir_node *node, ir_node *right) {
1447 assert (node->op == op_Cmp);
1448 set_irn_n(node, 1, right);
1452 get_Conv_op (ir_node *node) {
1453 assert (node->op == op_Conv);
1454 return get_irn_n(node, 0);
1458 set_Conv_op (ir_node *node, ir_node *op) {
1459 assert (node->op == op_Conv);
1460 set_irn_n(node, 0, op);
1464 get_Phi_preds_arr (ir_node *node) {
1465 assert (node->op == op_Phi);
1466 return (ir_node **)&(get_irn_in(node)[1]);
1470 get_Phi_n_preds (ir_node *node) {
1471 assert (node->op == op_Phi);
1472 return (get_irn_arity(node));
1476 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1477 assert (node->op == op_Phi);
1482 get_Phi_pred (ir_node *node, int pos) {
1483 assert (node->op == op_Phi);
1484 return get_irn_n(node, pos);
1488 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1489 assert (node->op == op_Phi);
1490 set_irn_n(node, pos, pred);
1494 get_Load_mem (ir_node *node) {
1495 assert (node->op == op_Load);
1496 return get_irn_n(node, 0);
1500 set_Load_mem (ir_node *node, ir_node *mem) {
1501 assert (node->op == op_Load);
1502 set_irn_n(node, 0, mem);
1506 get_Load_ptr (ir_node *node) {
1507 assert (node->op == op_Load);
1508 return get_irn_n(node, 1);
1512 set_Load_ptr (ir_node *node, ir_node *ptr) {
1513 assert (node->op == op_Load);
1514 set_irn_n(node, 1, ptr);
1519 get_Store_mem (ir_node *node) {
1520 assert (node->op == op_Store);
1521 return get_irn_n(node, 0);
1525 set_Store_mem (ir_node *node, ir_node *mem) {
1526 assert (node->op == op_Store);
1527 set_irn_n(node, 0, mem);
1531 get_Store_ptr (ir_node *node) {
1532 assert (node->op == op_Store);
1533 return get_irn_n(node, 1);
1537 set_Store_ptr (ir_node *node, ir_node *ptr) {
1538 assert (node->op == op_Store);
1539 set_irn_n(node, 1, ptr);
1543 get_Store_value (ir_node *node) {
1544 assert (node->op == op_Store);
1545 return get_irn_n(node, 2);
1549 set_Store_value (ir_node *node, ir_node *value) {
1550 assert (node->op == op_Store);
1551 set_irn_n(node, 2, value);
1555 get_Alloc_mem (ir_node *node) {
1556 assert (node->op == op_Alloc);
1557 return get_irn_n(node, 0);
1561 set_Alloc_mem (ir_node *node, ir_node *mem) {
1562 assert (node->op == op_Alloc);
1563 set_irn_n(node, 0, mem);
1567 get_Alloc_size (ir_node *node) {
1568 assert (node->op == op_Alloc);
1569 return get_irn_n(node, 1);
1573 set_Alloc_size (ir_node *node, ir_node *size) {
1574 assert (node->op == op_Alloc);
1575 set_irn_n(node, 1, size);
1579 get_Alloc_type (ir_node *node) {
1580 assert (node->op == op_Alloc);
1581 return node->attr.a.type;
1585 set_Alloc_type (ir_node *node, type *type) {
1586 assert (node->op == op_Alloc);
1587 node->attr.a.type = type;
1591 get_Alloc_where (ir_node *node) {
1592 assert (node->op == op_Alloc);
1593 return node->attr.a.where;
1597 set_Alloc_where (ir_node *node, where_alloc where) {
1598 assert (node->op == op_Alloc);
1599 node->attr.a.where = where;
1604 get_Free_mem (ir_node *node) {
1605 assert (node->op == op_Free);
1606 return get_irn_n(node, 0);
1610 set_Free_mem (ir_node *node, ir_node *mem) {
1611 assert (node->op == op_Free);
1612 set_irn_n(node, 0, mem);
1616 get_Free_ptr (ir_node *node) {
1617 assert (node->op == op_Free);
1618 return get_irn_n(node, 1);
1622 set_Free_ptr (ir_node *node, ir_node *ptr) {
1623 assert (node->op == op_Free);
1624 set_irn_n(node, 1, ptr);
1628 get_Free_size (ir_node *node) {
1629 assert (node->op == op_Free);
1630 return get_irn_n(node, 2);
1634 set_Free_size (ir_node *node, ir_node *size) {
1635 assert (node->op == op_Free);
1636 set_irn_n(node, 2, size);
1640 get_Free_type (ir_node *node) {
1641 assert (node->op == op_Free);
1642 return node->attr.f;
1646 set_Free_type (ir_node *node, type *type) {
1647 assert (node->op == op_Free);
1648 node->attr.f = type;
1652 get_Sync_preds_arr (ir_node *node) {
1653 assert (node->op == op_Sync);
1654 return (ir_node **)&(get_irn_in(node)[1]);
1658 get_Sync_n_preds (ir_node *node) {
1659 assert (node->op == op_Sync);
1660 return (get_irn_arity(node));
1665 set_Sync_n_preds (ir_node *node, int n_preds) {
1666 assert (node->op == op_Sync);
1671 get_Sync_pred (ir_node *node, int pos) {
1672 assert (node->op == op_Sync);
1673 return get_irn_n(node, pos);
1677 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1678 assert (node->op == op_Sync);
1679 set_irn_n(node, pos, pred);
1683 get_Proj_pred (ir_node *node) {
1684 assert (node->op == op_Proj);
1685 return get_irn_n(node, 0);
1689 set_Proj_pred (ir_node *node, ir_node *pred) {
1690 assert (node->op == op_Proj);
1691 set_irn_n(node, 0, pred);
1695 get_Proj_proj (ir_node *node) {
1696 assert (node->op == op_Proj);
1697 return node->attr.proj;
1701 set_Proj_proj (ir_node *node, long proj) {
1702 assert (node->op == op_Proj);
1703 node->attr.proj = proj;
1707 get_Tuple_preds_arr (ir_node *node) {
1708 assert (node->op == op_Tuple);
1709 return (ir_node **)&(get_irn_in(node)[1]);
1713 get_Tuple_n_preds (ir_node *node) {
1714 assert (node->op == op_Tuple);
1715 return (get_irn_arity(node));
1720 set_Tuple_n_preds (ir_node *node, int n_preds) {
1721 assert (node->op == op_Tuple);
1726 get_Tuple_pred (ir_node *node, int pos) {
1727 assert (node->op == op_Tuple);
1728 return get_irn_n(node, pos);
1732 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1733 assert (node->op == op_Tuple);
1734 set_irn_n(node, pos, pred);
1738 get_Id_pred (ir_node *node) {
1739 assert (node->op == op_Id);
1740 return get_irn_n(node, 0);
1744 set_Id_pred (ir_node *node, ir_node *pred) {
1745 assert (node->op == op_Id);
1746 set_irn_n(node, 0, pred);
1749 /******************************************************************/
1750 /* Auxiliary routines */
1751 /******************************************************************/
1754 skip_Proj (ir_node *node) {
1755 /* don't assert node !!! */
1756 if (node && (node->op == op_Proj)) {
1757 return get_Proj_pred(node);
1764 skip_nop (ir_node *node) {
1765 /* don't assert node !!! */
1767 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1768 /* Don't use get_Id_pred: We get into an endless loop for
1769 self-referencing Ids. */
1770 assert (get_irn_arity (node) > 0);
1771 return node->in[0+1];
1778 is_Bad (ir_node *node) {
1780 if ((node) && get_irn_opcode(node) == iro_Bad)
1786 is_no_Block (ir_node *node) {
1788 return (get_irn_opcode(node) != iro_Block);
1791 /* Returns true if the operation manipulates control flow. */
1793 is_cfop(ir_node *node) {
1794 return ( (get_irn_opcode(node) == iro_Start)
1795 || (get_irn_opcode(node) == iro_Jmp)
1796 || (get_irn_opcode(node) == iro_Cond)
1797 || (get_irn_opcode(node) == iro_Return)
1798 || (get_irn_opcode(node) == iro_Raise)
1799 || (get_irn_opcode(node) == iro_Bad));
1802 /* Returns true if the operation can change the control flow because
1805 is_fragile_op(ir_node *node) {
1806 return ( (get_irn_opcode(node) == iro_Call)
1807 || (get_irn_opcode(node) == iro_Quot)
1808 || (get_irn_opcode(node) == iro_DivMod)
1809 || (get_irn_opcode(node) == iro_Div)
1810 || (get_irn_opcode(node) == iro_Mod)
1811 || (get_irn_opcode(node) == iro_Load)
1812 || (get_irn_opcode(node) == iro_Store)
1813 || (get_irn_opcode(node) == iro_Alloc)
1814 || (get_irn_opcode(node) == iro_Bad));