1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier
15 #include "irgraph_t.h"
18 #include "typegmod_t.h"
25 /* some constants fixing the positions of nodes predecessors
27 #define CALL_PARAM_OFFSET 2
28 #define SEL_INDEX_OFFSET 2
29 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */
30 #define END_KEEPALIVE_OFFSET 0
32 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
33 "Gt", "Ge", "Lg", "Leg", "Uo",
34 "Ue", "Ul", "Ule", "Ug", "Uge",
37 inline char *get_pnc_string(int pnc) {
38 return pnc_name_arr[pnc];
43 get_negated_pnc(int pnc) {
45 case False: return True; break;
46 case Eq: return Ne; break;
47 case Lt: return Uge; break;
48 case Le: return Ug; break;
49 case Gt: return Ule; break;
50 case Ge: return Ul; break;
51 case Lg: return Ue; break;
52 case Leg: return Uo; break;
53 case Uo: return Leg; break;
54 case Ue: return Lg; break;
55 case Ul: return Ge; break;
56 case Ule: return Gt; break;
57 case Ug: return Le; break;
58 case Uge: return Lt; break;
59 case Ne: return Eq; break;
60 case True: return False; break;
62 return 99; /* to shut up gcc */
65 static char *pns_name_arr [] = {"initial_exec", "global_store",
66 "frame_base", "globals", "args"};
68 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
75 /* irnode constructor */
76 /* create a new irnode in irg, with an op, mode, arity and */
77 /* some incoming irnodes */
78 /* this constructor is used in every specified irnode constructor */
80 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
81 int arity, ir_node **in)
84 int node_size = offsetof (ir_node, attr) + op->attr_size;
86 res = (ir_node *) obstack_alloc (irg->obst, node_size);
90 fprintf (stdout, "%s: res(%p) = %p\n", __PRETTY_FUNCTION__, op, res);
92 res->kind = k_ir_node;
98 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
100 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
101 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
107 res->node_nr = get_irp_new_node_nr();
113 /* Copies all attributes stored in the old node to the new node.
114 Assumes both have the same opcode and sufficient size. */
116 copy_attrs (ir_node *old, ir_node *new) {
117 assert (get_irn_opcode(old) == get_irn_opcode(new));
118 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
121 /* IR-Nodes with attributes */
123 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
126 ir_node *np = XP_GETARG (ir_node *, 0);
129 XPS ("<null ir_node>");
133 XPF1 ("%I", get_irn_opident(np));
135 switch (get_irn_opcode (np)) { /* node label */
137 XPF1 ("%I", get_irn_mode(np)->name);
139 XPF1 ("%v", get_irn_const_attr);
142 if (get_irn_modecode (np) == irm_b) {
144 XP (pnc_name_arr[get_irn_proj_attr(np)]);
145 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
147 XP (pns_name_arr[get_irn_proj_attr(np)]);
149 XPF1 ("%I", get_irn_mode(np)->name);
151 XPF1 ("%d", get_irn_proj_attr(np));
155 XPF1 ("%I", get_irn_mode(np)->name);
157 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
158 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
160 case iro_Start: /* don't dump mode of these */
169 XPF1 ("%I", get_irn_mode(np)->name);
175 /** getting some parameters from ir_nodes **/
177 /* returns the number of predecessors without the block predecessor. */
179 get_irn_arity (ir_node *node)
182 return (ARR_LEN((node)->in)-1);
185 /* Returns the array with ins. This array is shifted with respect to the
186 array accessed by get_irn_n: The block operand is at position 0 not -1.
187 (@@@ This should be changed.)
188 The order of the predecessors in this array is not guaranteed, except that
189 lists of operands as predecessors of Block or arguments of a Call are
192 get_irn_in (ir_node *node)
199 set_irn_in (ir_node *node, int arity, ir_node **in) {
201 if (arity != get_irn_arity(node)) {
202 ir_node *block = node->in[0];
203 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
206 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
209 /* to iterate through the predecessors without touching the array */
210 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
211 to iterate includind the Block predecessor iterate from i = -1 to
213 If it is a block, the entry -1 is NULL. */
215 get_irn_n (ir_node *node, int n)
219 assert ((get_irn_arity (node) > n) && (-1 <= n));
220 res = skip_nop(node->in[n+1]);
221 if (res != node->in[n+1]) node->in[n+1] = res;
226 set_irn_n (ir_node *node, int n, ir_node *in)
229 assert (get_irn_arity (node) > n);
234 get_irn_mode (ir_node *node)
241 get_irn_modecode (ir_node *node)
244 return node->mode->code;
249 get_irn_modeident (ir_node *node)
252 return node->mode->name;
256 get_irn_op (ir_node *node)
262 /* should be private to the library: */
264 set_irn_op (ir_node *node, ir_op *op)
271 get_irn_opcode (ir_node *node)
274 return node->op->code;
278 get_irn_opname (ir_node *node)
281 return id_to_str(node->op->name);
285 get_irn_opident (ir_node *node)
288 return node->op->name;
292 get_irn_visited (ir_node *node)
295 return node->visited;
299 set_irn_visited (ir_node *node, unsigned long visited)
302 node->visited = visited;
306 mark_irn_visited (ir_node *node) {
308 node->visited = current_ir_graph->visited;
312 set_irn_link (ir_node *node, ir_node *link) {
318 get_irn_link (ir_node *node) {
324 /* Outputs a unique number for this node */
326 get_irn_node_nr(ir_node *node) {
328 return node->node_nr;
333 get_irn_const_attr (ir_node *node)
335 assert (node->op == op_Const);
336 return node->attr.con;
340 get_irn_proj_attr (ir_node *node)
342 assert (node->op == op_Proj);
343 return node->attr.proj;
347 get_irn_alloc_attr (ir_node *node)
349 assert (node->op == op_Alloc);
354 get_irn_free_attr (ir_node *node)
356 assert (node->op == op_Free);
357 return node->attr.f = skip_tid(node->attr.f);
361 get_irn_symconst_attr (ir_node *node)
363 assert (node->op == op_SymConst);
368 get_irn_call_attr (ir_node *node)
370 assert (node->op == op_Call);
371 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
375 get_irn_sel_attr (ir_node *node)
377 assert (node->op == op_Sel);
382 get_irn_phi_attr (ir_node *node)
384 assert (node->op == op_Phi);
385 return node->attr.phi0_pos;
389 get_irn_block_attr (ir_node *node)
391 assert (node->op == op_Block);
392 return node->attr.block;
395 /** manipulate fields of individual nodes **/
397 /* this works for all except Block */
399 get_nodes_Block (ir_node *node) {
400 assert (!(node->op == op_Block));
401 return get_irn_n(node, -1);
405 set_nodes_Block (ir_node *node, ir_node *block) {
406 assert (!(node->op == op_Block));
407 set_irn_n(node, -1, block);
410 /* Returns an array with the predecessors of the Block. Depending on
411 the implementation of the graph datastructure this can be a copy of
412 the internal representation of predecessors as well as the internal
413 array itself. Therefore writing to this array might obstruct the ir. */
415 get_Block_cfgpred_arr (ir_node *node)
417 assert ((node->op == op_Block));
418 return (ir_node **)&(get_irn_in(node)[1]);
423 get_Block_n_cfgpreds (ir_node *node) {
424 assert ((node->op == op_Block));
425 return (get_irn_arity(node));
430 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
431 assert ((node->op == op_Block));
436 get_Block_cfgpred (ir_node *node, int pos) {
437 assert (node->op == op_Block);
438 return get_irn_n(node, pos);
442 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
443 assert (node->op == op_Block);
444 set_irn_n(node, pos, pred);
448 get_Block_matured (ir_node *node) {
449 assert (node->op == op_Block);
450 return node->attr.block.matured;
454 set_Block_matured (ir_node *node, bool matured) {
455 assert (node->op == op_Block);
456 node->attr.block.matured = matured;
459 get_Block_block_visited (ir_node *node) {
460 assert (node->op == op_Block);
461 return node->attr.block.block_visited;
465 set_Block_block_visited (ir_node *node, unsigned long visit) {
466 assert (node->op == op_Block);
467 node->attr.block.block_visited = visit;
471 get_Block_graph_arr (ir_node *node, int pos) {
472 assert (node->op == op_Block);
473 return node->attr.block.graph_arr[pos+1];
477 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
478 assert (node->op == op_Block);
479 node->attr.block.graph_arr[pos+1] = value;
483 get_End_n_keepalives(ir_node *end) {
484 assert (end->op == op_End);
485 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
489 get_End_keepalive(ir_node *end, int pos) {
490 assert (end->op == op_End);
491 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
495 add_End_keepalive (ir_node *end, ir_node *ka) {
496 assert (end->op == op_End);
497 ARR_APP1 (ir_node *, end->in, ka);
501 free_End (ir_node *end) {
502 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
503 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
507 > Implementing the case construct (which is where the constant Proj node is
508 > important) involves far more than simply determining the constant values.
509 > We could argue that this is more properly a function of the translator from
510 > Firm to the target machine. That could be done if there was some way of
511 > projecting "default" out of the Cond node.
512 I know it's complicated.
513 Basically there are two proglems:
514 - determining the gaps between the projs
515 - determining the biggest case constant to konw the proj number for
517 I see several solutions:
518 1. Introduce a ProjDefault node. Solves both problems.
519 This means to extend all optimizations executed during construction.
520 2. Give the Cond node for switch two flavors:
521 a) there are no gaps in the projs (existing flavor)
522 b) gaps may exist, default proj is still the Proj with the largest
523 projection number. This covers also the gaps.
524 3. Fix the semantic of the Cond to that of 2b)
526 Solution 2 seems to be the best:
527 Computing the gaps in the Firm representation is not too hard, i.e.,
528 libfirm can implement a routine that transforms betweeen the two
529 flavours. This is also possible for 1) but 2) does not require to
530 change any existing optimization.
531 Further it should be far simpler to determine the biggest constant than
533 I don't want to choose 3) as 2a) seems to have advantages for
534 dataflow analysis and 3) does not allow to convert the representation to
538 get_Cond_selector (ir_node *node) {
539 assert (node->op == op_Cond);
540 return get_irn_n(node, 0);
544 set_Cond_selector (ir_node *node, ir_node *selector) {
545 assert (node->op == op_Cond);
546 set_irn_n(node, 0, selector);
550 get_Cond_kind (ir_node *node) {
551 assert (node->op == op_Cond);
552 return node->attr.c.kind;
556 set_Cond_kind (ir_node *node, cond_kind kind) {
557 assert (node->op == op_Cond);
558 node->attr.c.kind = kind;
562 get_Return_mem (ir_node *node) {
563 assert (node->op == op_Return);
564 return get_irn_n(node, 0);
568 set_Return_mem (ir_node *node, ir_node *mem) {
569 assert (node->op == op_Return);
570 set_irn_n(node, 0, mem);
574 get_Return_res_arr (ir_node *node)
576 assert ((node->op == op_Return));
577 if (get_Return_n_res(node) > 0)
578 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
584 get_Return_n_res (ir_node *node) {
585 assert (node->op == op_Return);
586 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
591 set_Return_n_res (ir_node *node, int results) {
592 assert (node->op == op_Return);
597 get_Return_res (ir_node *node, int pos) {
598 assert (node->op == op_Return);
599 assert (get_Return_n_res(node) > pos);
600 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
604 set_Return_res (ir_node *node, int pos, ir_node *res){
605 assert (node->op == op_Return);
606 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
610 get_Raise_mem (ir_node *node) {
611 assert (node->op == op_Return);
612 return get_irn_n(node, 0);
616 set_Raise_mem (ir_node *node, ir_node *mem) {
617 assert (node->op == op_Raise);
618 set_irn_n(node, 0, mem);
622 get_Raise_exo_ptr (ir_node *node) {
623 assert (node->op == op_Raise);
624 return get_irn_n(node, 1);
628 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
629 assert (node->op == op_Raise);
630 set_irn_n(node, 1, exo_ptr);
633 inline tarval *get_Const_tarval (ir_node *node) {
634 assert (node->op == op_Const);
635 return get_irn_const_attr(node);
639 set_Const_tarval (ir_node *node, tarval *con) {
640 assert (node->op == op_Const);
641 node->attr.con = con;
645 get_SymConst_kind (ir_node *node) {
646 assert (node->op == op_SymConst);
647 return node->attr.i.num;
651 set_SymConst_kind (ir_node *node, symconst_kind num) {
652 assert (node->op == op_SymConst);
653 node->attr.i.num = num;
657 get_SymConst_type (ir_node *node) {
658 assert ( (node->op == op_SymConst)
659 && ( get_SymConst_kind(node) == type_tag
660 || get_SymConst_kind(node) == size));
661 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
665 set_SymConst_type (ir_node *node, type *type) {
666 assert ( (node->op == op_SymConst)
667 && ( get_SymConst_kind(node) == type_tag
668 || get_SymConst_kind(node) == size));
669 node->attr.i.tori.typ = type;
673 get_SymConst_ptrinfo (ir_node *node) {
674 assert ( (node->op == op_SymConst)
675 && (get_SymConst_kind(node) == linkage_ptr_info));
676 return node->attr.i.tori.ptrinfo;
680 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
681 assert ( (node->op == op_SymConst)
682 && (get_SymConst_kind(node) == linkage_ptr_info));
683 node->attr.i.tori.ptrinfo = ptrinfo;
687 get_SymConst_type_or_id (ir_node *node) {
688 assert (node->op == op_SymConst);
689 return &(node->attr.i.tori);
693 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
694 assert (node->op == op_SymConst);
695 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
699 get_Sel_mem (ir_node *node) {
700 assert (node->op == op_Sel);
701 return get_irn_n(node, 0);
705 set_Sel_mem (ir_node *node, ir_node *mem) {
706 assert (node->op == op_Sel);
707 set_irn_n(node, 0, mem);
711 get_Sel_ptr (ir_node *node) {
712 assert (node->op == op_Sel);
713 return get_irn_n(node, 1);
717 set_Sel_ptr (ir_node *node, ir_node *ptr) {
718 assert (node->op == op_Sel);
719 set_irn_n(node, 1, ptr);
723 get_Sel_index_arr (ir_node *node)
725 assert ((node->op == op_Sel));
726 if (get_Sel_n_index(node) > 0)
727 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
733 get_Sel_n_index (ir_node *node) {
734 assert (node->op == op_Sel);
735 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
740 set_Sel_n_index (ir_node *node, int n_index) {
741 assert (node->op == op_Sel);
746 get_Sel_index (ir_node *node, int pos) {
747 assert (node->op == op_Sel);
748 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
752 set_Sel_index (ir_node *node, int pos, ir_node *index) {
753 assert (node->op == op_Sel);
754 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
758 get_Sel_entity (ir_node *node) {
759 assert (node->op == op_Sel);
760 return node->attr.s.ent;
764 set_Sel_entity (ir_node *node, entity *ent) {
765 assert (node->op == op_Sel);
766 node->attr.s.ent = ent;
770 get_Sel_linkage_type (ir_node *node) {
771 assert (node->op == op_Sel);
772 return node->attr.s.ltyp;
776 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
777 assert (node->op == op_Sel);
778 node->attr.s.ltyp = lt;
782 get_Call_mem (ir_node *node) {
783 assert (node->op == op_Call);
784 return get_irn_n(node, 0);
788 set_Call_mem (ir_node *node, ir_node *mem) {
789 assert (node->op == op_Call);
790 set_irn_n(node, 0, mem);
794 get_Call_ptr (ir_node *node) {
795 assert (node->op == op_Call);
796 return get_irn_n(node, 1);
800 set_Call_ptr (ir_node *node, ir_node *ptr) {
801 assert (node->op == op_Call);
802 set_irn_n(node, 1, ptr);
806 get_Call_param_arr (ir_node *node) {
807 assert (node->op == op_Call);
808 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
812 get_Call_n_params (ir_node *node) {
813 assert (node->op == op_Call);
814 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
818 get_Call_arity (ir_node *node) {
819 assert (node->op == op_Call);
820 return get_Call_n_params(node);
824 set_Call_arity (ir_node *node, ir_node *arity) {
825 assert (node->op == op_Call);
830 get_Call_param (ir_node *node, int pos) {
831 assert (node->op == op_Call);
832 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
836 set_Call_param (ir_node *node, int pos, ir_node *param) {
837 assert (node->op == op_Call);
838 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
842 get_Call_type (ir_node *node) {
843 assert (node->op == op_Call);
844 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
848 set_Call_type (ir_node *node, type *type) {
849 assert (node->op == op_Call);
850 assert (is_method_type(type));
851 node->attr.call.cld_tp = type;
854 /* For unary and binary arithmetic operations the access to the
855 operands can be factored out. Left is the first, right the
856 second arithmetic value as listed in tech report 0999-33.
857 unops are: Minus, Abs, Not, Conv
858 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
859 Shr, Shrs, Rotate, Cmp */
862 is_unop (ir_node *node) {
863 return ( node->op == op_Minus ||
864 node->op == op_Abs ||
865 node->op == op_Not ||
866 node->op == op_Conv );
870 get_unop_op (ir_node *node) {
871 assert ( node->op == op_Minus ||
872 node->op == op_Abs ||
873 node->op == op_Not ||
874 node->op == op_Conv );
875 switch (get_irn_opcode (node)) {
876 case iro_Minus: return get_Minus_op(node); break;
877 case iro_Abs: return get_Abs_op(node); break;
878 case iro_Not: return get_Not_op(node); break;
879 case iro_Conv: return get_Conv_op(node); break;
880 default: return NULL;
885 set_unop_op (ir_node *node, ir_node *op) {
886 assert (node->op == op_Minus ||
887 node->op == op_Abs ||
888 node->op == op_Not ||
889 node->op == op_Conv );
890 switch (get_irn_opcode (node)) {
891 case iro_Minus: set_Minus_op(node, op); break;
892 case iro_Abs: set_Abs_op(node, op); break;
893 case iro_Not: set_Not_op(node, op); break;
894 case iro_Conv: set_Conv_op(node, op); break;
901 is_binop (ir_node *node) {
902 return (node->op == op_Add ||
903 node->op == op_Sub ||
904 node->op == op_Mul ||
905 node->op == op_Quot ||
906 node->op == op_DivMod ||
907 node->op == op_Div ||
908 node->op == op_Mod ||
909 node->op == op_And ||
911 node->op == op_Eor ||
912 node->op == op_Shl ||
913 node->op == op_Shr ||
914 node->op == op_Shrs ||
915 node->op == op_Rot ||
916 node->op == op_Cmp );
920 get_binop_left (ir_node *node) {
921 assert (node->op == op_Add ||
922 node->op == op_Sub ||
923 node->op == op_Mul ||
924 node->op == op_Quot ||
925 node->op == op_DivMod ||
926 node->op == op_Div ||
927 node->op == op_Mod ||
928 node->op == op_And ||
930 node->op == op_Eor ||
931 node->op == op_Shl ||
932 node->op == op_Shr ||
933 node->op == op_Shrs ||
934 node->op == op_Rot ||
935 node->op == op_Cmp );
937 switch (get_irn_opcode (node)) {
938 case iro_Add : return get_Add_left(node); break;
939 case iro_Sub : return get_Sub_left(node); break;
940 case iro_Mul : return get_Mul_left(node); break;
941 case iro_Quot : return get_Quot_left(node); break;
942 case iro_DivMod: return get_DivMod_left(node); break;
943 case iro_Div : return get_Div_left(node); break;
944 case iro_Mod : return get_Mod_left(node); break;
945 case iro_And : return get_And_left(node); break;
946 case iro_Or : return get_Or_left(node); break;
947 case iro_Eor : return get_Eor_left(node); break;
948 case iro_Shl : return get_Shl_left(node); break;
949 case iro_Shr : return get_Shr_left(node); break;
950 case iro_Shrs : return get_Shrs_left(node); break;
951 case iro_Rot : return get_Rot_left(node); break;
952 case iro_Cmp : return get_Cmp_left(node); break;
953 default: return NULL;
958 set_binop_left (ir_node *node, ir_node *left) {
959 assert (node->op == op_Add ||
960 node->op == op_Sub ||
961 node->op == op_Mul ||
962 node->op == op_Quot ||
963 node->op == op_DivMod ||
964 node->op == op_Div ||
965 node->op == op_Mod ||
966 node->op == op_And ||
968 node->op == op_Eor ||
969 node->op == op_Shl ||
970 node->op == op_Shr ||
971 node->op == op_Shrs ||
972 node->op == op_Rot ||
973 node->op == op_Cmp );
975 switch (get_irn_opcode (node)) {
976 case iro_Add : set_Add_left(node, left); break;
977 case iro_Sub : set_Sub_left(node, left); break;
978 case iro_Mul : set_Mul_left(node, left); break;
979 case iro_Quot : set_Quot_left(node, left); break;
980 case iro_DivMod: set_DivMod_left(node, left); break;
981 case iro_Div : set_Div_left(node, left); break;
982 case iro_Mod : set_Mod_left(node, left); break;
983 case iro_And : set_And_left(node, left); break;
984 case iro_Or : set_Or_left(node, left); break;
985 case iro_Eor : set_Eor_left(node, left); break;
986 case iro_Shl : set_Shl_left(node, left); break;
987 case iro_Shr : set_Shr_left(node, left); break;
988 case iro_Shrs : set_Shrs_left(node, left); break;
989 case iro_Rot : set_Rot_left(node, left); break;
990 case iro_Cmp : set_Cmp_left(node, left); break;
996 get_binop_right (ir_node *node) {
997 assert (node->op == op_Add ||
998 node->op == op_Sub ||
999 node->op == op_Mul ||
1000 node->op == op_Quot ||
1001 node->op == op_DivMod ||
1002 node->op == op_Div ||
1003 node->op == op_Mod ||
1004 node->op == op_And ||
1005 node->op == op_Or ||
1006 node->op == op_Eor ||
1007 node->op == op_Shl ||
1008 node->op == op_Shr ||
1009 node->op == op_Shrs ||
1010 node->op == op_Rot ||
1011 node->op == op_Cmp );
1013 switch (get_irn_opcode (node)) {
1014 case iro_Add : return get_Add_right(node); break;
1015 case iro_Sub : return get_Sub_right(node); break;
1016 case iro_Mul : return get_Mul_right(node); break;
1017 case iro_Quot : return get_Quot_right(node); break;
1018 case iro_DivMod: return get_DivMod_right(node); break;
1019 case iro_Div : return get_Div_right(node); break;
1020 case iro_Mod : return get_Mod_right(node); break;
1021 case iro_And : return get_And_right(node); break;
1022 case iro_Or : return get_Or_right(node); break;
1023 case iro_Eor : return get_Eor_right(node); break;
1024 case iro_Shl : return get_Shl_right(node); break;
1025 case iro_Shr : return get_Shr_right(node); break;
1026 case iro_Shrs : return get_Shrs_right(node); break;
1027 case iro_Rot : return get_Rot_right(node); break;
1028 case iro_Cmp : return get_Cmp_right(node); break;
1029 default: return NULL;
1034 set_binop_right (ir_node *node, ir_node *right) {
1035 assert (node->op == op_Add ||
1036 node->op == op_Sub ||
1037 node->op == op_Mul ||
1038 node->op == op_Quot ||
1039 node->op == op_DivMod ||
1040 node->op == op_Div ||
1041 node->op == op_Mod ||
1042 node->op == op_And ||
1043 node->op == op_Or ||
1044 node->op == op_Eor ||
1045 node->op == op_Shl ||
1046 node->op == op_Shr ||
1047 node->op == op_Shrs ||
1048 node->op == op_Rot ||
1049 node->op == op_Cmp );
1051 switch (get_irn_opcode (node)) {
1052 case iro_Add : set_Add_right(node, right); break;
1053 case iro_Sub : set_Sub_right(node, right); break;
1054 case iro_Mul : set_Mul_right(node, right); break;
1055 case iro_Quot : set_Quot_right(node, right); break;
1056 case iro_DivMod: set_DivMod_right(node, right); break;
1057 case iro_Div : set_Div_right(node, right); break;
1058 case iro_Mod : set_Mod_right(node, right); break;
1059 case iro_And : set_And_right(node, right); break;
1060 case iro_Or : set_Or_right(node, right); break;
1061 case iro_Eor : set_Eor_right(node, right); break;
1062 case iro_Shl : set_Shl_right(node, right); break;
1063 case iro_Shr : set_Shr_right(node, right); break;
1064 case iro_Shrs : set_Shrs_right(node, right); break;
1065 case iro_Rot : set_Rot_right(node, right); break;
1066 case iro_Cmp : set_Cmp_right(node, right); break;
1072 get_Add_left (ir_node *node) {
1073 assert (node->op == op_Add);
1074 return get_irn_n(node, 0);
1078 set_Add_left (ir_node *node, ir_node *left) {
1079 assert (node->op == op_Add);
1080 set_irn_n(node, 0, left);
1084 get_Add_right (ir_node *node) {
1085 assert (node->op == op_Add);
1086 return get_irn_n(node, 1);
1090 set_Add_right (ir_node *node, ir_node *right) {
1091 assert (node->op == op_Add);
1092 set_irn_n(node, 1, right);
1096 get_Sub_left (ir_node *node) {
1097 assert (node->op == op_Sub);
1098 return get_irn_n(node, 0);
1102 set_Sub_left (ir_node *node, ir_node *left) {
1103 assert (node->op == op_Sub);
1104 set_irn_n(node, 0, left);
1108 get_Sub_right (ir_node *node) {
1109 assert (node->op == op_Sub);
1110 return get_irn_n(node, 1);
1114 set_Sub_right (ir_node *node, ir_node *right) {
1115 assert (node->op == op_Sub);
1116 set_irn_n(node, 1, right);
1121 get_Minus_op (ir_node *node) {
1122 assert (node->op == op_Minus);
1123 return get_irn_n(node, 0);
1127 set_Minus_op (ir_node *node, ir_node *op) {
1128 assert (node->op == op_Minus);
1129 set_irn_n(node, 0, op);
1134 get_Mul_left (ir_node *node) {
1135 assert (node->op == op_Mul);
1136 return get_irn_n(node, 0);
1140 set_Mul_left (ir_node *node, ir_node *left) {
1141 assert (node->op == op_Mul);
1142 set_irn_n(node, 0, left);
1146 get_Mul_right (ir_node *node) {
1147 assert (node->op == op_Mul);
1148 return get_irn_n(node, 1);
1152 set_Mul_right (ir_node *node, ir_node *right) {
1153 assert (node->op == op_Mul);
1154 set_irn_n(node, 1, right);
1158 get_Quot_left (ir_node *node) {
1159 assert (node->op == op_Quot);
1160 return get_irn_n(node, 1);
1164 set_Quot_left (ir_node *node, ir_node *left) {
1165 assert (node->op == op_Quot);
1166 set_irn_n(node, 1, left);
1170 get_Quot_right (ir_node *node) {
1171 assert (node->op == op_Quot);
1172 return get_irn_n(node, 2);
1176 set_Quot_right (ir_node *node, ir_node *right) {
1177 assert (node->op == op_Quot);
1178 set_irn_n(node, 2, right);
1182 get_Quot_mem (ir_node *node) {
1183 assert (node->op == op_Quot);
1184 return get_irn_n(node, 0);
1188 set_Quot_mem (ir_node *node, ir_node *mem) {
1189 assert (node->op == op_Quot);
1190 set_irn_n(node, 0, mem);
1194 get_DivMod_left (ir_node *node) {
1195 assert (node->op == op_DivMod);
1196 return get_irn_n(node, 1);
1200 set_DivMod_left (ir_node *node, ir_node *left) {
1201 assert (node->op == op_DivMod);
1202 set_irn_n(node, 1, left);
1206 get_DivMod_right (ir_node *node) {
1207 assert (node->op == op_DivMod);
1208 return get_irn_n(node, 2);
1212 set_DivMod_right (ir_node *node, ir_node *right) {
1213 assert (node->op == op_DivMod);
1214 set_irn_n(node, 2, right);
1218 get_DivMod_mem (ir_node *node) {
1219 assert (node->op == op_DivMod);
1220 return get_irn_n(node, 0);
1224 set_DivMod_mem (ir_node *node, ir_node *mem) {
1225 assert (node->op == op_DivMod);
1226 set_irn_n(node, 0, mem);
1230 get_Div_left (ir_node *node) {
1231 assert (node->op == op_Div);
1232 return get_irn_n(node, 1);
1236 set_Div_left (ir_node *node, ir_node *left) {
1237 assert (node->op == op_Div);
1238 set_irn_n(node, 1, left);
1242 get_Div_right (ir_node *node) {
1243 assert (node->op == op_Div);
1244 return get_irn_n(node, 2);
1248 set_Div_right (ir_node *node, ir_node *right) {
1249 assert (node->op == op_Div);
1250 set_irn_n(node, 2, right);
1254 get_Div_mem (ir_node *node) {
1255 assert (node->op == op_Div);
1256 return get_irn_n(node, 0);
1260 set_Div_mem (ir_node *node, ir_node *mem) {
1261 assert (node->op == op_Div);
1262 set_irn_n(node, 0, mem);
1266 get_Mod_left (ir_node *node) {
1267 assert (node->op == op_Mod);
1268 return get_irn_n(node, 1);
1272 set_Mod_left (ir_node *node, ir_node *left) {
1273 assert (node->op == op_Mod);
1274 set_irn_n(node, 1, left);
1278 get_Mod_right (ir_node *node) {
1279 assert (node->op == op_Mod);
1280 return get_irn_n(node, 2);
1284 set_Mod_right (ir_node *node, ir_node *right) {
1285 assert (node->op == op_Mod);
1286 set_irn_n(node, 2, right);
1290 get_Mod_mem (ir_node *node) {
1291 assert (node->op == op_Mod);
1292 return get_irn_n(node, 0);
1296 set_Mod_mem (ir_node *node, ir_node *mem) {
1297 assert (node->op == op_Mod);
1298 set_irn_n(node, 0, mem);
1302 get_Abs_op (ir_node *node) {
1303 assert (node->op == op_Abs);
1304 return get_irn_n(node, 0);
1308 set_Abs_op (ir_node *node, ir_node *op) {
1309 assert (node->op == op_Abs);
1310 set_irn_n(node, 0, op);
1314 get_And_left (ir_node *node) {
1315 assert (node->op == op_And);
1316 return get_irn_n(node, 0);
1320 set_And_left (ir_node *node, ir_node *left) {
1321 assert (node->op == op_And);
1322 set_irn_n(node, 0, left);
1326 get_And_right (ir_node *node) {
1327 assert (node->op == op_And);
1328 return get_irn_n(node, 1);
1332 set_And_right (ir_node *node, ir_node *right) {
1333 assert (node->op == op_And);
1334 set_irn_n(node, 1, right);
1338 get_Or_left (ir_node *node) {
1339 assert (node->op == op_Or);
1340 return get_irn_n(node, 0);
1344 set_Or_left (ir_node *node, ir_node *left) {
1345 assert (node->op == op_Or);
1346 set_irn_n(node, 0, left);
1350 get_Or_right (ir_node *node) {
1351 assert (node->op == op_Or);
1352 return get_irn_n(node, 1);
1356 set_Or_right (ir_node *node, ir_node *right) {
1357 assert (node->op == op_Or);
1358 set_irn_n(node, 1, right);
1362 get_Eor_left (ir_node *node) {
1363 assert (node->op == op_Eor);
1364 return get_irn_n(node, 0);
1368 set_Eor_left (ir_node *node, ir_node *left) {
1369 assert (node->op == op_Eor);
1370 set_irn_n(node, 0, left);
1374 get_Eor_right (ir_node *node) {
1375 assert (node->op == op_Eor);
1376 return get_irn_n(node, 1);
1380 set_Eor_right (ir_node *node, ir_node *right) {
1381 assert (node->op == op_Eor);
1382 set_irn_n(node, 1, right);
1387 get_Not_op (ir_node *node) {
1388 assert (node->op == op_Not);
1389 return get_irn_n(node, 0);
1393 set_Not_op (ir_node *node, ir_node *op) {
1394 assert (node->op == op_Not);
1395 set_irn_n(node, 0, op);
1400 get_Shl_left (ir_node *node) {
1401 assert (node->op == op_Shl);
1402 return get_irn_n(node, 0);
1406 set_Shl_left (ir_node *node, ir_node *left) {
1407 assert (node->op == op_Shl);
1408 set_irn_n(node, 0, left);
1412 get_Shl_right (ir_node *node) {
1413 assert (node->op == op_Shl);
1414 return get_irn_n(node, 1);
1418 set_Shl_right (ir_node *node, ir_node *right) {
1419 assert (node->op == op_Shl);
1420 set_irn_n(node, 1, right);
1424 get_Shr_left (ir_node *node) {
1425 assert (node->op == op_Shr);
1426 return get_irn_n(node, 0);
1430 set_Shr_left (ir_node *node, ir_node *left) {
1431 assert (node->op == op_Shr);
1432 set_irn_n(node, 0, left);
1436 get_Shr_right (ir_node *node) {
1437 assert (node->op == op_Shr);
1438 return get_irn_n(node, 1);
1442 set_Shr_right (ir_node *node, ir_node *right) {
1443 assert (node->op == op_Shr);
1444 set_irn_n(node, 1, right);
1448 get_Shrs_left (ir_node *node) {
1449 assert (node->op == op_Shrs);
1450 return get_irn_n(node, 0);
1454 set_Shrs_left (ir_node *node, ir_node *left) {
1455 assert (node->op == op_Shrs);
1456 set_irn_n(node, 0, left);
1460 get_Shrs_right (ir_node *node) {
1461 assert (node->op == op_Shrs);
1462 return get_irn_n(node, 1);
1466 set_Shrs_right (ir_node *node, ir_node *right) {
1467 assert (node->op == op_Shrs);
1468 set_irn_n(node, 1, right);
1472 get_Rot_left (ir_node *node) {
1473 assert (node->op == op_Rot);
1474 return get_irn_n(node, 0);
1478 set_Rot_left (ir_node *node, ir_node *left) {
1479 assert (node->op == op_Rot);
1480 set_irn_n(node, 0, left);
1484 get_Rot_right (ir_node *node) {
1485 assert (node->op == op_Rot);
1486 return get_irn_n(node, 1);
1490 set_Rot_right (ir_node *node, ir_node *right) {
1491 assert (node->op == op_Rot);
1492 set_irn_n(node, 1, right);
1496 get_Cmp_left (ir_node *node) {
1497 assert (node->op == op_Cmp);
1498 return get_irn_n(node, 0);
1502 set_Cmp_left (ir_node *node, ir_node *left) {
1503 assert (node->op == op_Cmp);
1504 set_irn_n(node, 0, left);
1508 get_Cmp_right (ir_node *node) {
1509 assert (node->op == op_Cmp);
1510 return get_irn_n(node, 1);
1514 set_Cmp_right (ir_node *node, ir_node *right) {
1515 assert (node->op == op_Cmp);
1516 set_irn_n(node, 1, right);
1520 get_Conv_op (ir_node *node) {
1521 assert (node->op == op_Conv);
1522 return get_irn_n(node, 0);
1526 set_Conv_op (ir_node *node, ir_node *op) {
1527 assert (node->op == op_Conv);
1528 set_irn_n(node, 0, op);
1532 get_Phi_preds_arr (ir_node *node) {
1533 assert (node->op == op_Phi);
1534 return (ir_node **)&(get_irn_in(node)[1]);
1538 get_Phi_n_preds (ir_node *node) {
1539 assert (node->op == op_Phi);
1540 return (get_irn_arity(node));
1544 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1545 assert (node->op == op_Phi);
1550 get_Phi_pred (ir_node *node, int pos) {
1551 assert (node->op == op_Phi);
1552 return get_irn_n(node, pos);
1556 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1557 assert (node->op == op_Phi);
1558 set_irn_n(node, pos, pred);
1562 get_Load_mem (ir_node *node) {
1563 assert (node->op == op_Load);
1564 return get_irn_n(node, 0);
1568 set_Load_mem (ir_node *node, ir_node *mem) {
1569 assert (node->op == op_Load);
1570 set_irn_n(node, 0, mem);
1574 get_Load_ptr (ir_node *node) {
1575 assert (node->op == op_Load);
1576 return get_irn_n(node, 1);
1580 set_Load_ptr (ir_node *node, ir_node *ptr) {
1581 assert (node->op == op_Load);
1582 set_irn_n(node, 1, ptr);
1587 get_Store_mem (ir_node *node) {
1588 assert (node->op == op_Store);
1589 return get_irn_n(node, 0);
1593 set_Store_mem (ir_node *node, ir_node *mem) {
1594 assert (node->op == op_Store);
1595 set_irn_n(node, 0, mem);
1599 get_Store_ptr (ir_node *node) {
1600 assert (node->op == op_Store);
1601 return get_irn_n(node, 1);
1605 set_Store_ptr (ir_node *node, ir_node *ptr) {
1606 assert (node->op == op_Store);
1607 set_irn_n(node, 1, ptr);
1611 get_Store_value (ir_node *node) {
1612 assert (node->op == op_Store);
1613 return get_irn_n(node, 2);
1617 set_Store_value (ir_node *node, ir_node *value) {
1618 assert (node->op == op_Store);
1619 set_irn_n(node, 2, value);
1623 get_Alloc_mem (ir_node *node) {
1624 assert (node->op == op_Alloc);
1625 return get_irn_n(node, 0);
1629 set_Alloc_mem (ir_node *node, ir_node *mem) {
1630 assert (node->op == op_Alloc);
1631 set_irn_n(node, 0, mem);
1635 get_Alloc_size (ir_node *node) {
1636 assert (node->op == op_Alloc);
1637 return get_irn_n(node, 1);
1641 set_Alloc_size (ir_node *node, ir_node *size) {
1642 assert (node->op == op_Alloc);
1643 set_irn_n(node, 1, size);
1647 get_Alloc_type (ir_node *node) {
1648 assert (node->op == op_Alloc);
1649 return node->attr.a.type = skip_tid(node->attr.a.type);
1653 set_Alloc_type (ir_node *node, type *type) {
1654 assert (node->op == op_Alloc);
1655 node->attr.a.type = type;
1659 get_Alloc_where (ir_node *node) {
1660 assert (node->op == op_Alloc);
1661 return node->attr.a.where;
1665 set_Alloc_where (ir_node *node, where_alloc where) {
1666 assert (node->op == op_Alloc);
1667 node->attr.a.where = where;
1672 get_Free_mem (ir_node *node) {
1673 assert (node->op == op_Free);
1674 return get_irn_n(node, 0);
1678 set_Free_mem (ir_node *node, ir_node *mem) {
1679 assert (node->op == op_Free);
1680 set_irn_n(node, 0, mem);
1684 get_Free_ptr (ir_node *node) {
1685 assert (node->op == op_Free);
1686 return get_irn_n(node, 1);
1690 set_Free_ptr (ir_node *node, ir_node *ptr) {
1691 assert (node->op == op_Free);
1692 set_irn_n(node, 1, ptr);
1696 get_Free_size (ir_node *node) {
1697 assert (node->op == op_Free);
1698 return get_irn_n(node, 2);
1702 set_Free_size (ir_node *node, ir_node *size) {
1703 assert (node->op == op_Free);
1704 set_irn_n(node, 2, size);
1708 get_Free_type (ir_node *node) {
1709 assert (node->op == op_Free);
1710 return node->attr.f = skip_tid(node->attr.f);
1714 set_Free_type (ir_node *node, type *type) {
1715 assert (node->op == op_Free);
1716 node->attr.f = type;
1720 get_Sync_preds_arr (ir_node *node) {
1721 assert (node->op == op_Sync);
1722 return (ir_node **)&(get_irn_in(node)[1]);
1726 get_Sync_n_preds (ir_node *node) {
1727 assert (node->op == op_Sync);
1728 return (get_irn_arity(node));
1733 set_Sync_n_preds (ir_node *node, int n_preds) {
1734 assert (node->op == op_Sync);
1739 get_Sync_pred (ir_node *node, int pos) {
1740 assert (node->op == op_Sync);
1741 return get_irn_n(node, pos);
1745 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1746 assert (node->op == op_Sync);
1747 set_irn_n(node, pos, pred);
1751 get_Proj_pred (ir_node *node) {
1752 assert (node->op == op_Proj);
1753 return get_irn_n(node, 0);
1757 set_Proj_pred (ir_node *node, ir_node *pred) {
1758 assert (node->op == op_Proj);
1759 set_irn_n(node, 0, pred);
1763 get_Proj_proj (ir_node *node) {
1764 assert (node->op == op_Proj);
1765 return node->attr.proj;
1769 set_Proj_proj (ir_node *node, long proj) {
1770 assert (node->op == op_Proj);
1771 node->attr.proj = proj;
1775 get_Tuple_preds_arr (ir_node *node) {
1776 assert (node->op == op_Tuple);
1777 return (ir_node **)&(get_irn_in(node)[1]);
1781 get_Tuple_n_preds (ir_node *node) {
1782 assert (node->op == op_Tuple);
1783 return (get_irn_arity(node));
1788 set_Tuple_n_preds (ir_node *node, int n_preds) {
1789 assert (node->op == op_Tuple);
1794 get_Tuple_pred (ir_node *node, int pos) {
1795 assert (node->op == op_Tuple);
1796 return get_irn_n(node, pos);
1800 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1801 assert (node->op == op_Tuple);
1802 set_irn_n(node, pos, pred);
1806 get_Id_pred (ir_node *node) {
1807 assert (node->op == op_Id);
1808 return get_irn_n(node, 0);
1812 set_Id_pred (ir_node *node, ir_node *pred) {
1813 assert (node->op == op_Id);
1814 set_irn_n(node, 0, pred);
1817 /******************************************************************/
1818 /* Auxiliary routines */
1819 /******************************************************************/
1822 skip_Proj (ir_node *node) {
1823 /* don't assert node !!! */
1824 if (node && (node->op == op_Proj)) {
1825 return get_Proj_pred(node);
1832 skip_Tuple (ir_node *node) {
1833 if ((node->op == op_Proj) && (get_irn_op(get_Proj_pred(node)) == op_Tuple))
1834 return get_Tuple_pred(get_Proj_pred(node), get_Proj_proj(node));
1840 skip_nop (ir_node *node) {
1841 /* don't assert node !!! */
1843 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1844 /* Don't use get_Id_pred: We get into an endless loop for
1845 self-referencing Ids. */
1846 assert (get_irn_arity (node) > 0);
1847 return node->in[0+1];
1854 skip_Id (ir_node *node) {
1855 return skip_nop(node);
1859 is_Bad (ir_node *node) {
1861 if ((node) && get_irn_opcode(node) == iro_Bad)
1867 is_no_Block (ir_node *node) {
1869 return (get_irn_opcode(node) != iro_Block);
1872 /* Returns true if the operation manipulates control flow. */
1874 is_cfop(ir_node *node) {
1875 return is_cfopcode(get_irn_op(node));
1878 /* Returns true if the operation can change the control flow because
1881 is_fragile_op(ir_node *node) {
1882 return ( (get_irn_opcode(node) == iro_Call)
1883 || (get_irn_opcode(node) == iro_Quot)
1884 || (get_irn_opcode(node) == iro_DivMod)
1885 || (get_irn_opcode(node) == iro_Div)
1886 || (get_irn_opcode(node) == iro_Mod)
1887 || (get_irn_opcode(node) == iro_Load)
1888 || (get_irn_opcode(node) == iro_Store)
1889 || (get_irn_opcode(node) == iro_Alloc)
1890 || (get_irn_opcode(node) == iro_Bad));
1894 /* Returns the memory operand of fragile operations. */
1895 ir_node *get_fragile_op_mem(ir_node *node) {
1896 assert(node && is_fragile_op(node));
1898 switch (get_irn_opcode (node)) {
1907 return get_irn_n(node, 0);