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;
470 /* For this current_ir_graph must be set. */
471 inline void mark_Block_block_visited (ir_node *node) {
472 assert (node->op == op_Block);
473 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
478 get_Block_graph_arr (ir_node *node, int pos) {
479 assert (node->op == op_Block);
480 return node->attr.block.graph_arr[pos+1];
484 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
485 assert (node->op == op_Block);
486 node->attr.block.graph_arr[pos+1] = value;
490 get_End_n_keepalives(ir_node *end) {
491 assert (end->op == op_End);
492 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
496 get_End_keepalive(ir_node *end, int pos) {
497 assert (end->op == op_End);
498 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
502 add_End_keepalive (ir_node *end, ir_node *ka) {
503 assert (end->op == op_End);
504 ARR_APP1 (ir_node *, end->in, ka);
508 free_End (ir_node *end) {
509 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
510 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
514 > Implementing the case construct (which is where the constant Proj node is
515 > important) involves far more than simply determining the constant values.
516 > We could argue that this is more properly a function of the translator from
517 > Firm to the target machine. That could be done if there was some way of
518 > projecting "default" out of the Cond node.
519 I know it's complicated.
520 Basically there are two proglems:
521 - determining the gaps between the projs
522 - determining the biggest case constant to konw the proj number for
524 I see several solutions:
525 1. Introduce a ProjDefault node. Solves both problems.
526 This means to extend all optimizations executed during construction.
527 2. Give the Cond node for switch two flavors:
528 a) there are no gaps in the projs (existing flavor)
529 b) gaps may exist, default proj is still the Proj with the largest
530 projection number. This covers also the gaps.
531 3. Fix the semantic of the Cond to that of 2b)
533 Solution 2 seems to be the best:
534 Computing the gaps in the Firm representation is not too hard, i.e.,
535 libfirm can implement a routine that transforms betweeen the two
536 flavours. This is also possible for 1) but 2) does not require to
537 change any existing optimization.
538 Further it should be far simpler to determine the biggest constant than
540 I don't want to choose 3) as 2a) seems to have advantages for
541 dataflow analysis and 3) does not allow to convert the representation to
545 get_Cond_selector (ir_node *node) {
546 assert (node->op == op_Cond);
547 return get_irn_n(node, 0);
551 set_Cond_selector (ir_node *node, ir_node *selector) {
552 assert (node->op == op_Cond);
553 set_irn_n(node, 0, selector);
557 get_Cond_kind (ir_node *node) {
558 assert (node->op == op_Cond);
559 return node->attr.c.kind;
563 set_Cond_kind (ir_node *node, cond_kind kind) {
564 assert (node->op == op_Cond);
565 node->attr.c.kind = kind;
569 get_Return_mem (ir_node *node) {
570 assert (node->op == op_Return);
571 return get_irn_n(node, 0);
575 set_Return_mem (ir_node *node, ir_node *mem) {
576 assert (node->op == op_Return);
577 set_irn_n(node, 0, mem);
581 get_Return_res_arr (ir_node *node)
583 assert ((node->op == op_Return));
584 if (get_Return_n_res(node) > 0)
585 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
591 get_Return_n_res (ir_node *node) {
592 assert (node->op == op_Return);
593 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
598 set_Return_n_res (ir_node *node, int results) {
599 assert (node->op == op_Return);
604 get_Return_res (ir_node *node, int pos) {
605 assert (node->op == op_Return);
606 assert (get_Return_n_res(node) > pos);
607 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
611 set_Return_res (ir_node *node, int pos, ir_node *res){
612 assert (node->op == op_Return);
613 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
617 get_Raise_mem (ir_node *node) {
618 assert (node->op == op_Return);
619 return get_irn_n(node, 0);
623 set_Raise_mem (ir_node *node, ir_node *mem) {
624 assert (node->op == op_Raise);
625 set_irn_n(node, 0, mem);
629 get_Raise_exo_ptr (ir_node *node) {
630 assert (node->op == op_Raise);
631 return get_irn_n(node, 1);
635 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
636 assert (node->op == op_Raise);
637 set_irn_n(node, 1, exo_ptr);
640 inline tarval *get_Const_tarval (ir_node *node) {
641 assert (node->op == op_Const);
642 return get_irn_const_attr(node);
646 set_Const_tarval (ir_node *node, tarval *con) {
647 assert (node->op == op_Const);
648 node->attr.con = con;
652 get_SymConst_kind (ir_node *node) {
653 assert (node->op == op_SymConst);
654 return node->attr.i.num;
658 set_SymConst_kind (ir_node *node, symconst_kind num) {
659 assert (node->op == op_SymConst);
660 node->attr.i.num = num;
664 get_SymConst_type (ir_node *node) {
665 assert ( (node->op == op_SymConst)
666 && ( get_SymConst_kind(node) == type_tag
667 || get_SymConst_kind(node) == size));
668 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
672 set_SymConst_type (ir_node *node, type *type) {
673 assert ( (node->op == op_SymConst)
674 && ( get_SymConst_kind(node) == type_tag
675 || get_SymConst_kind(node) == size));
676 node->attr.i.tori.typ = type;
680 get_SymConst_ptrinfo (ir_node *node) {
681 assert ( (node->op == op_SymConst)
682 && (get_SymConst_kind(node) == linkage_ptr_info));
683 return node->attr.i.tori.ptrinfo;
687 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
688 assert ( (node->op == op_SymConst)
689 && (get_SymConst_kind(node) == linkage_ptr_info));
690 node->attr.i.tori.ptrinfo = ptrinfo;
694 get_SymConst_type_or_id (ir_node *node) {
695 assert (node->op == op_SymConst);
696 return &(node->attr.i.tori);
700 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
701 assert (node->op == op_SymConst);
702 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
706 get_Sel_mem (ir_node *node) {
707 assert (node->op == op_Sel);
708 return get_irn_n(node, 0);
712 set_Sel_mem (ir_node *node, ir_node *mem) {
713 assert (node->op == op_Sel);
714 set_irn_n(node, 0, mem);
718 get_Sel_ptr (ir_node *node) {
719 assert (node->op == op_Sel);
720 return get_irn_n(node, 1);
724 set_Sel_ptr (ir_node *node, ir_node *ptr) {
725 assert (node->op == op_Sel);
726 set_irn_n(node, 1, ptr);
730 get_Sel_index_arr (ir_node *node)
732 assert ((node->op == op_Sel));
733 if (get_Sel_n_index(node) > 0)
734 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
740 get_Sel_n_index (ir_node *node) {
741 assert (node->op == op_Sel);
742 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
747 set_Sel_n_index (ir_node *node, int n_index) {
748 assert (node->op == op_Sel);
753 get_Sel_index (ir_node *node, int pos) {
754 assert (node->op == op_Sel);
755 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
759 set_Sel_index (ir_node *node, int pos, ir_node *index) {
760 assert (node->op == op_Sel);
761 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
765 get_Sel_entity (ir_node *node) {
766 assert (node->op == op_Sel);
767 return node->attr.s.ent;
771 set_Sel_entity (ir_node *node, entity *ent) {
772 assert (node->op == op_Sel);
773 node->attr.s.ent = ent;
777 get_Sel_linkage_type (ir_node *node) {
778 assert (node->op == op_Sel);
779 return node->attr.s.ltyp;
783 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
784 assert (node->op == op_Sel);
785 node->attr.s.ltyp = lt;
789 get_Call_mem (ir_node *node) {
790 assert (node->op == op_Call);
791 return get_irn_n(node, 0);
795 set_Call_mem (ir_node *node, ir_node *mem) {
796 assert (node->op == op_Call);
797 set_irn_n(node, 0, mem);
801 get_Call_ptr (ir_node *node) {
802 assert (node->op == op_Call);
803 return get_irn_n(node, 1);
807 set_Call_ptr (ir_node *node, ir_node *ptr) {
808 assert (node->op == op_Call);
809 set_irn_n(node, 1, ptr);
813 get_Call_param_arr (ir_node *node) {
814 assert (node->op == op_Call);
815 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
819 get_Call_n_params (ir_node *node) {
820 assert (node->op == op_Call);
821 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
825 get_Call_arity (ir_node *node) {
826 assert (node->op == op_Call);
827 return get_Call_n_params(node);
831 set_Call_arity (ir_node *node, ir_node *arity) {
832 assert (node->op == op_Call);
837 get_Call_param (ir_node *node, int pos) {
838 assert (node->op == op_Call);
839 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
843 set_Call_param (ir_node *node, int pos, ir_node *param) {
844 assert (node->op == op_Call);
845 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
849 get_Call_type (ir_node *node) {
850 assert (node->op == op_Call);
851 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
855 set_Call_type (ir_node *node, type *type) {
856 assert (node->op == op_Call);
857 assert (is_method_type(type));
858 node->attr.call.cld_tp = type;
861 /* For unary and binary arithmetic operations the access to the
862 operands can be factored out. Left is the first, right the
863 second arithmetic value as listed in tech report 0999-33.
864 unops are: Minus, Abs, Not, Conv
865 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
866 Shr, Shrs, Rotate, Cmp */
869 is_unop (ir_node *node) {
870 return ( node->op == op_Minus ||
871 node->op == op_Abs ||
872 node->op == op_Not ||
873 node->op == op_Conv );
877 get_unop_op (ir_node *node) {
878 assert ( node->op == op_Minus ||
879 node->op == op_Abs ||
880 node->op == op_Not ||
881 node->op == op_Conv );
882 switch (get_irn_opcode (node)) {
883 case iro_Minus: return get_Minus_op(node); break;
884 case iro_Abs: return get_Abs_op(node); break;
885 case iro_Not: return get_Not_op(node); break;
886 case iro_Conv: return get_Conv_op(node); break;
887 default: return NULL;
892 set_unop_op (ir_node *node, ir_node *op) {
893 assert (node->op == op_Minus ||
894 node->op == op_Abs ||
895 node->op == op_Not ||
896 node->op == op_Conv );
897 switch (get_irn_opcode (node)) {
898 case iro_Minus: set_Minus_op(node, op); break;
899 case iro_Abs: set_Abs_op(node, op); break;
900 case iro_Not: set_Not_op(node, op); break;
901 case iro_Conv: set_Conv_op(node, op); break;
908 is_binop (ir_node *node) {
909 return (node->op == op_Add ||
910 node->op == op_Sub ||
911 node->op == op_Mul ||
912 node->op == op_Quot ||
913 node->op == op_DivMod ||
914 node->op == op_Div ||
915 node->op == op_Mod ||
916 node->op == op_And ||
918 node->op == op_Eor ||
919 node->op == op_Shl ||
920 node->op == op_Shr ||
921 node->op == op_Shrs ||
922 node->op == op_Rot ||
923 node->op == op_Cmp );
927 get_binop_left (ir_node *node) {
928 assert (node->op == op_Add ||
929 node->op == op_Sub ||
930 node->op == op_Mul ||
931 node->op == op_Quot ||
932 node->op == op_DivMod ||
933 node->op == op_Div ||
934 node->op == op_Mod ||
935 node->op == op_And ||
937 node->op == op_Eor ||
938 node->op == op_Shl ||
939 node->op == op_Shr ||
940 node->op == op_Shrs ||
941 node->op == op_Rot ||
942 node->op == op_Cmp );
944 switch (get_irn_opcode (node)) {
945 case iro_Add : return get_Add_left(node); break;
946 case iro_Sub : return get_Sub_left(node); break;
947 case iro_Mul : return get_Mul_left(node); break;
948 case iro_Quot : return get_Quot_left(node); break;
949 case iro_DivMod: return get_DivMod_left(node); break;
950 case iro_Div : return get_Div_left(node); break;
951 case iro_Mod : return get_Mod_left(node); break;
952 case iro_And : return get_And_left(node); break;
953 case iro_Or : return get_Or_left(node); break;
954 case iro_Eor : return get_Eor_left(node); break;
955 case iro_Shl : return get_Shl_left(node); break;
956 case iro_Shr : return get_Shr_left(node); break;
957 case iro_Shrs : return get_Shrs_left(node); break;
958 case iro_Rot : return get_Rot_left(node); break;
959 case iro_Cmp : return get_Cmp_left(node); break;
960 default: return NULL;
965 set_binop_left (ir_node *node, ir_node *left) {
966 assert (node->op == op_Add ||
967 node->op == op_Sub ||
968 node->op == op_Mul ||
969 node->op == op_Quot ||
970 node->op == op_DivMod ||
971 node->op == op_Div ||
972 node->op == op_Mod ||
973 node->op == op_And ||
975 node->op == op_Eor ||
976 node->op == op_Shl ||
977 node->op == op_Shr ||
978 node->op == op_Shrs ||
979 node->op == op_Rot ||
980 node->op == op_Cmp );
982 switch (get_irn_opcode (node)) {
983 case iro_Add : set_Add_left(node, left); break;
984 case iro_Sub : set_Sub_left(node, left); break;
985 case iro_Mul : set_Mul_left(node, left); break;
986 case iro_Quot : set_Quot_left(node, left); break;
987 case iro_DivMod: set_DivMod_left(node, left); break;
988 case iro_Div : set_Div_left(node, left); break;
989 case iro_Mod : set_Mod_left(node, left); break;
990 case iro_And : set_And_left(node, left); break;
991 case iro_Or : set_Or_left(node, left); break;
992 case iro_Eor : set_Eor_left(node, left); break;
993 case iro_Shl : set_Shl_left(node, left); break;
994 case iro_Shr : set_Shr_left(node, left); break;
995 case iro_Shrs : set_Shrs_left(node, left); break;
996 case iro_Rot : set_Rot_left(node, left); break;
997 case iro_Cmp : set_Cmp_left(node, left); break;
1003 get_binop_right (ir_node *node) {
1004 assert (node->op == op_Add ||
1005 node->op == op_Sub ||
1006 node->op == op_Mul ||
1007 node->op == op_Quot ||
1008 node->op == op_DivMod ||
1009 node->op == op_Div ||
1010 node->op == op_Mod ||
1011 node->op == op_And ||
1012 node->op == op_Or ||
1013 node->op == op_Eor ||
1014 node->op == op_Shl ||
1015 node->op == op_Shr ||
1016 node->op == op_Shrs ||
1017 node->op == op_Rot ||
1018 node->op == op_Cmp );
1020 switch (get_irn_opcode (node)) {
1021 case iro_Add : return get_Add_right(node); break;
1022 case iro_Sub : return get_Sub_right(node); break;
1023 case iro_Mul : return get_Mul_right(node); break;
1024 case iro_Quot : return get_Quot_right(node); break;
1025 case iro_DivMod: return get_DivMod_right(node); break;
1026 case iro_Div : return get_Div_right(node); break;
1027 case iro_Mod : return get_Mod_right(node); break;
1028 case iro_And : return get_And_right(node); break;
1029 case iro_Or : return get_Or_right(node); break;
1030 case iro_Eor : return get_Eor_right(node); break;
1031 case iro_Shl : return get_Shl_right(node); break;
1032 case iro_Shr : return get_Shr_right(node); break;
1033 case iro_Shrs : return get_Shrs_right(node); break;
1034 case iro_Rot : return get_Rot_right(node); break;
1035 case iro_Cmp : return get_Cmp_right(node); break;
1036 default: return NULL;
1041 set_binop_right (ir_node *node, ir_node *right) {
1042 assert (node->op == op_Add ||
1043 node->op == op_Sub ||
1044 node->op == op_Mul ||
1045 node->op == op_Quot ||
1046 node->op == op_DivMod ||
1047 node->op == op_Div ||
1048 node->op == op_Mod ||
1049 node->op == op_And ||
1050 node->op == op_Or ||
1051 node->op == op_Eor ||
1052 node->op == op_Shl ||
1053 node->op == op_Shr ||
1054 node->op == op_Shrs ||
1055 node->op == op_Rot ||
1056 node->op == op_Cmp );
1058 switch (get_irn_opcode (node)) {
1059 case iro_Add : set_Add_right(node, right); break;
1060 case iro_Sub : set_Sub_right(node, right); break;
1061 case iro_Mul : set_Mul_right(node, right); break;
1062 case iro_Quot : set_Quot_right(node, right); break;
1063 case iro_DivMod: set_DivMod_right(node, right); break;
1064 case iro_Div : set_Div_right(node, right); break;
1065 case iro_Mod : set_Mod_right(node, right); break;
1066 case iro_And : set_And_right(node, right); break;
1067 case iro_Or : set_Or_right(node, right); break;
1068 case iro_Eor : set_Eor_right(node, right); break;
1069 case iro_Shl : set_Shl_right(node, right); break;
1070 case iro_Shr : set_Shr_right(node, right); break;
1071 case iro_Shrs : set_Shrs_right(node, right); break;
1072 case iro_Rot : set_Rot_right(node, right); break;
1073 case iro_Cmp : set_Cmp_right(node, right); break;
1079 get_Add_left (ir_node *node) {
1080 assert (node->op == op_Add);
1081 return get_irn_n(node, 0);
1085 set_Add_left (ir_node *node, ir_node *left) {
1086 assert (node->op == op_Add);
1087 set_irn_n(node, 0, left);
1091 get_Add_right (ir_node *node) {
1092 assert (node->op == op_Add);
1093 return get_irn_n(node, 1);
1097 set_Add_right (ir_node *node, ir_node *right) {
1098 assert (node->op == op_Add);
1099 set_irn_n(node, 1, right);
1103 get_Sub_left (ir_node *node) {
1104 assert (node->op == op_Sub);
1105 return get_irn_n(node, 0);
1109 set_Sub_left (ir_node *node, ir_node *left) {
1110 assert (node->op == op_Sub);
1111 set_irn_n(node, 0, left);
1115 get_Sub_right (ir_node *node) {
1116 assert (node->op == op_Sub);
1117 return get_irn_n(node, 1);
1121 set_Sub_right (ir_node *node, ir_node *right) {
1122 assert (node->op == op_Sub);
1123 set_irn_n(node, 1, right);
1128 get_Minus_op (ir_node *node) {
1129 assert (node->op == op_Minus);
1130 return get_irn_n(node, 0);
1134 set_Minus_op (ir_node *node, ir_node *op) {
1135 assert (node->op == op_Minus);
1136 set_irn_n(node, 0, op);
1141 get_Mul_left (ir_node *node) {
1142 assert (node->op == op_Mul);
1143 return get_irn_n(node, 0);
1147 set_Mul_left (ir_node *node, ir_node *left) {
1148 assert (node->op == op_Mul);
1149 set_irn_n(node, 0, left);
1153 get_Mul_right (ir_node *node) {
1154 assert (node->op == op_Mul);
1155 return get_irn_n(node, 1);
1159 set_Mul_right (ir_node *node, ir_node *right) {
1160 assert (node->op == op_Mul);
1161 set_irn_n(node, 1, right);
1165 get_Quot_left (ir_node *node) {
1166 assert (node->op == op_Quot);
1167 return get_irn_n(node, 1);
1171 set_Quot_left (ir_node *node, ir_node *left) {
1172 assert (node->op == op_Quot);
1173 set_irn_n(node, 1, left);
1177 get_Quot_right (ir_node *node) {
1178 assert (node->op == op_Quot);
1179 return get_irn_n(node, 2);
1183 set_Quot_right (ir_node *node, ir_node *right) {
1184 assert (node->op == op_Quot);
1185 set_irn_n(node, 2, right);
1189 get_Quot_mem (ir_node *node) {
1190 assert (node->op == op_Quot);
1191 return get_irn_n(node, 0);
1195 set_Quot_mem (ir_node *node, ir_node *mem) {
1196 assert (node->op == op_Quot);
1197 set_irn_n(node, 0, mem);
1201 get_DivMod_left (ir_node *node) {
1202 assert (node->op == op_DivMod);
1203 return get_irn_n(node, 1);
1207 set_DivMod_left (ir_node *node, ir_node *left) {
1208 assert (node->op == op_DivMod);
1209 set_irn_n(node, 1, left);
1213 get_DivMod_right (ir_node *node) {
1214 assert (node->op == op_DivMod);
1215 return get_irn_n(node, 2);
1219 set_DivMod_right (ir_node *node, ir_node *right) {
1220 assert (node->op == op_DivMod);
1221 set_irn_n(node, 2, right);
1225 get_DivMod_mem (ir_node *node) {
1226 assert (node->op == op_DivMod);
1227 return get_irn_n(node, 0);
1231 set_DivMod_mem (ir_node *node, ir_node *mem) {
1232 assert (node->op == op_DivMod);
1233 set_irn_n(node, 0, mem);
1237 get_Div_left (ir_node *node) {
1238 assert (node->op == op_Div);
1239 return get_irn_n(node, 1);
1243 set_Div_left (ir_node *node, ir_node *left) {
1244 assert (node->op == op_Div);
1245 set_irn_n(node, 1, left);
1249 get_Div_right (ir_node *node) {
1250 assert (node->op == op_Div);
1251 return get_irn_n(node, 2);
1255 set_Div_right (ir_node *node, ir_node *right) {
1256 assert (node->op == op_Div);
1257 set_irn_n(node, 2, right);
1261 get_Div_mem (ir_node *node) {
1262 assert (node->op == op_Div);
1263 return get_irn_n(node, 0);
1267 set_Div_mem (ir_node *node, ir_node *mem) {
1268 assert (node->op == op_Div);
1269 set_irn_n(node, 0, mem);
1273 get_Mod_left (ir_node *node) {
1274 assert (node->op == op_Mod);
1275 return get_irn_n(node, 1);
1279 set_Mod_left (ir_node *node, ir_node *left) {
1280 assert (node->op == op_Mod);
1281 set_irn_n(node, 1, left);
1285 get_Mod_right (ir_node *node) {
1286 assert (node->op == op_Mod);
1287 return get_irn_n(node, 2);
1291 set_Mod_right (ir_node *node, ir_node *right) {
1292 assert (node->op == op_Mod);
1293 set_irn_n(node, 2, right);
1297 get_Mod_mem (ir_node *node) {
1298 assert (node->op == op_Mod);
1299 return get_irn_n(node, 0);
1303 set_Mod_mem (ir_node *node, ir_node *mem) {
1304 assert (node->op == op_Mod);
1305 set_irn_n(node, 0, mem);
1309 get_Abs_op (ir_node *node) {
1310 assert (node->op == op_Abs);
1311 return get_irn_n(node, 0);
1315 set_Abs_op (ir_node *node, ir_node *op) {
1316 assert (node->op == op_Abs);
1317 set_irn_n(node, 0, op);
1321 get_And_left (ir_node *node) {
1322 assert (node->op == op_And);
1323 return get_irn_n(node, 0);
1327 set_And_left (ir_node *node, ir_node *left) {
1328 assert (node->op == op_And);
1329 set_irn_n(node, 0, left);
1333 get_And_right (ir_node *node) {
1334 assert (node->op == op_And);
1335 return get_irn_n(node, 1);
1339 set_And_right (ir_node *node, ir_node *right) {
1340 assert (node->op == op_And);
1341 set_irn_n(node, 1, right);
1345 get_Or_left (ir_node *node) {
1346 assert (node->op == op_Or);
1347 return get_irn_n(node, 0);
1351 set_Or_left (ir_node *node, ir_node *left) {
1352 assert (node->op == op_Or);
1353 set_irn_n(node, 0, left);
1357 get_Or_right (ir_node *node) {
1358 assert (node->op == op_Or);
1359 return get_irn_n(node, 1);
1363 set_Or_right (ir_node *node, ir_node *right) {
1364 assert (node->op == op_Or);
1365 set_irn_n(node, 1, right);
1369 get_Eor_left (ir_node *node) {
1370 assert (node->op == op_Eor);
1371 return get_irn_n(node, 0);
1375 set_Eor_left (ir_node *node, ir_node *left) {
1376 assert (node->op == op_Eor);
1377 set_irn_n(node, 0, left);
1381 get_Eor_right (ir_node *node) {
1382 assert (node->op == op_Eor);
1383 return get_irn_n(node, 1);
1387 set_Eor_right (ir_node *node, ir_node *right) {
1388 assert (node->op == op_Eor);
1389 set_irn_n(node, 1, right);
1394 get_Not_op (ir_node *node) {
1395 assert (node->op == op_Not);
1396 return get_irn_n(node, 0);
1400 set_Not_op (ir_node *node, ir_node *op) {
1401 assert (node->op == op_Not);
1402 set_irn_n(node, 0, op);
1407 get_Shl_left (ir_node *node) {
1408 assert (node->op == op_Shl);
1409 return get_irn_n(node, 0);
1413 set_Shl_left (ir_node *node, ir_node *left) {
1414 assert (node->op == op_Shl);
1415 set_irn_n(node, 0, left);
1419 get_Shl_right (ir_node *node) {
1420 assert (node->op == op_Shl);
1421 return get_irn_n(node, 1);
1425 set_Shl_right (ir_node *node, ir_node *right) {
1426 assert (node->op == op_Shl);
1427 set_irn_n(node, 1, right);
1431 get_Shr_left (ir_node *node) {
1432 assert (node->op == op_Shr);
1433 return get_irn_n(node, 0);
1437 set_Shr_left (ir_node *node, ir_node *left) {
1438 assert (node->op == op_Shr);
1439 set_irn_n(node, 0, left);
1443 get_Shr_right (ir_node *node) {
1444 assert (node->op == op_Shr);
1445 return get_irn_n(node, 1);
1449 set_Shr_right (ir_node *node, ir_node *right) {
1450 assert (node->op == op_Shr);
1451 set_irn_n(node, 1, right);
1455 get_Shrs_left (ir_node *node) {
1456 assert (node->op == op_Shrs);
1457 return get_irn_n(node, 0);
1461 set_Shrs_left (ir_node *node, ir_node *left) {
1462 assert (node->op == op_Shrs);
1463 set_irn_n(node, 0, left);
1467 get_Shrs_right (ir_node *node) {
1468 assert (node->op == op_Shrs);
1469 return get_irn_n(node, 1);
1473 set_Shrs_right (ir_node *node, ir_node *right) {
1474 assert (node->op == op_Shrs);
1475 set_irn_n(node, 1, right);
1479 get_Rot_left (ir_node *node) {
1480 assert (node->op == op_Rot);
1481 return get_irn_n(node, 0);
1485 set_Rot_left (ir_node *node, ir_node *left) {
1486 assert (node->op == op_Rot);
1487 set_irn_n(node, 0, left);
1491 get_Rot_right (ir_node *node) {
1492 assert (node->op == op_Rot);
1493 return get_irn_n(node, 1);
1497 set_Rot_right (ir_node *node, ir_node *right) {
1498 assert (node->op == op_Rot);
1499 set_irn_n(node, 1, right);
1503 get_Cmp_left (ir_node *node) {
1504 assert (node->op == op_Cmp);
1505 return get_irn_n(node, 0);
1509 set_Cmp_left (ir_node *node, ir_node *left) {
1510 assert (node->op == op_Cmp);
1511 set_irn_n(node, 0, left);
1515 get_Cmp_right (ir_node *node) {
1516 assert (node->op == op_Cmp);
1517 return get_irn_n(node, 1);
1521 set_Cmp_right (ir_node *node, ir_node *right) {
1522 assert (node->op == op_Cmp);
1523 set_irn_n(node, 1, right);
1527 get_Conv_op (ir_node *node) {
1528 assert (node->op == op_Conv);
1529 return get_irn_n(node, 0);
1533 set_Conv_op (ir_node *node, ir_node *op) {
1534 assert (node->op == op_Conv);
1535 set_irn_n(node, 0, op);
1539 get_Phi_preds_arr (ir_node *node) {
1540 assert (node->op == op_Phi);
1541 return (ir_node **)&(get_irn_in(node)[1]);
1545 get_Phi_n_preds (ir_node *node) {
1546 assert (node->op == op_Phi);
1547 return (get_irn_arity(node));
1551 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1552 assert (node->op == op_Phi);
1557 get_Phi_pred (ir_node *node, int pos) {
1558 assert (node->op == op_Phi);
1559 return get_irn_n(node, pos);
1563 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1564 assert (node->op == op_Phi);
1565 set_irn_n(node, pos, pred);
1569 get_Load_mem (ir_node *node) {
1570 assert (node->op == op_Load);
1571 return get_irn_n(node, 0);
1575 set_Load_mem (ir_node *node, ir_node *mem) {
1576 assert (node->op == op_Load);
1577 set_irn_n(node, 0, mem);
1581 get_Load_ptr (ir_node *node) {
1582 assert (node->op == op_Load);
1583 return get_irn_n(node, 1);
1587 set_Load_ptr (ir_node *node, ir_node *ptr) {
1588 assert (node->op == op_Load);
1589 set_irn_n(node, 1, ptr);
1594 get_Store_mem (ir_node *node) {
1595 assert (node->op == op_Store);
1596 return get_irn_n(node, 0);
1600 set_Store_mem (ir_node *node, ir_node *mem) {
1601 assert (node->op == op_Store);
1602 set_irn_n(node, 0, mem);
1606 get_Store_ptr (ir_node *node) {
1607 assert (node->op == op_Store);
1608 return get_irn_n(node, 1);
1612 set_Store_ptr (ir_node *node, ir_node *ptr) {
1613 assert (node->op == op_Store);
1614 set_irn_n(node, 1, ptr);
1618 get_Store_value (ir_node *node) {
1619 assert (node->op == op_Store);
1620 return get_irn_n(node, 2);
1624 set_Store_value (ir_node *node, ir_node *value) {
1625 assert (node->op == op_Store);
1626 set_irn_n(node, 2, value);
1630 get_Alloc_mem (ir_node *node) {
1631 assert (node->op == op_Alloc);
1632 return get_irn_n(node, 0);
1636 set_Alloc_mem (ir_node *node, ir_node *mem) {
1637 assert (node->op == op_Alloc);
1638 set_irn_n(node, 0, mem);
1642 get_Alloc_size (ir_node *node) {
1643 assert (node->op == op_Alloc);
1644 return get_irn_n(node, 1);
1648 set_Alloc_size (ir_node *node, ir_node *size) {
1649 assert (node->op == op_Alloc);
1650 set_irn_n(node, 1, size);
1654 get_Alloc_type (ir_node *node) {
1655 assert (node->op == op_Alloc);
1656 return node->attr.a.type = skip_tid(node->attr.a.type);
1660 set_Alloc_type (ir_node *node, type *type) {
1661 assert (node->op == op_Alloc);
1662 node->attr.a.type = type;
1666 get_Alloc_where (ir_node *node) {
1667 assert (node->op == op_Alloc);
1668 return node->attr.a.where;
1672 set_Alloc_where (ir_node *node, where_alloc where) {
1673 assert (node->op == op_Alloc);
1674 node->attr.a.where = where;
1679 get_Free_mem (ir_node *node) {
1680 assert (node->op == op_Free);
1681 return get_irn_n(node, 0);
1685 set_Free_mem (ir_node *node, ir_node *mem) {
1686 assert (node->op == op_Free);
1687 set_irn_n(node, 0, mem);
1691 get_Free_ptr (ir_node *node) {
1692 assert (node->op == op_Free);
1693 return get_irn_n(node, 1);
1697 set_Free_ptr (ir_node *node, ir_node *ptr) {
1698 assert (node->op == op_Free);
1699 set_irn_n(node, 1, ptr);
1703 get_Free_size (ir_node *node) {
1704 assert (node->op == op_Free);
1705 return get_irn_n(node, 2);
1709 set_Free_size (ir_node *node, ir_node *size) {
1710 assert (node->op == op_Free);
1711 set_irn_n(node, 2, size);
1715 get_Free_type (ir_node *node) {
1716 assert (node->op == op_Free);
1717 return node->attr.f = skip_tid(node->attr.f);
1721 set_Free_type (ir_node *node, type *type) {
1722 assert (node->op == op_Free);
1723 node->attr.f = type;
1727 get_Sync_preds_arr (ir_node *node) {
1728 assert (node->op == op_Sync);
1729 return (ir_node **)&(get_irn_in(node)[1]);
1733 get_Sync_n_preds (ir_node *node) {
1734 assert (node->op == op_Sync);
1735 return (get_irn_arity(node));
1740 set_Sync_n_preds (ir_node *node, int n_preds) {
1741 assert (node->op == op_Sync);
1746 get_Sync_pred (ir_node *node, int pos) {
1747 assert (node->op == op_Sync);
1748 return get_irn_n(node, pos);
1752 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1753 assert (node->op == op_Sync);
1754 set_irn_n(node, pos, pred);
1758 get_Proj_pred (ir_node *node) {
1759 assert (node->op == op_Proj);
1760 return get_irn_n(node, 0);
1764 set_Proj_pred (ir_node *node, ir_node *pred) {
1765 assert (node->op == op_Proj);
1766 set_irn_n(node, 0, pred);
1770 get_Proj_proj (ir_node *node) {
1771 assert (node->op == op_Proj);
1772 return node->attr.proj;
1776 set_Proj_proj (ir_node *node, long proj) {
1777 assert (node->op == op_Proj);
1778 node->attr.proj = proj;
1782 get_Tuple_preds_arr (ir_node *node) {
1783 assert (node->op == op_Tuple);
1784 return (ir_node **)&(get_irn_in(node)[1]);
1788 get_Tuple_n_preds (ir_node *node) {
1789 assert (node->op == op_Tuple);
1790 return (get_irn_arity(node));
1795 set_Tuple_n_preds (ir_node *node, int n_preds) {
1796 assert (node->op == op_Tuple);
1801 get_Tuple_pred (ir_node *node, int pos) {
1802 assert (node->op == op_Tuple);
1803 return get_irn_n(node, pos);
1807 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1808 assert (node->op == op_Tuple);
1809 set_irn_n(node, pos, pred);
1813 get_Id_pred (ir_node *node) {
1814 assert (node->op == op_Id);
1815 return get_irn_n(node, 0);
1819 set_Id_pred (ir_node *node, ir_node *pred) {
1820 assert (node->op == op_Id);
1821 set_irn_n(node, 0, pred);
1824 /******************************************************************/
1825 /* Auxiliary routines */
1826 /******************************************************************/
1829 skip_Proj (ir_node *node) {
1830 /* don't assert node !!! */
1831 if (node && (node->op == op_Proj)) {
1832 return get_Proj_pred(node);
1839 skip_Tuple (ir_node *node) {
1841 if (get_irn_op(node) == op_Proj) {
1842 pred = skip_nop(get_Proj_pred(node));
1843 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
1844 pred = skip_nop(skip_Tuple(pred));
1845 if (get_irn_op(pred) == op_Tuple)
1846 return get_Tuple_pred(pred, get_Proj_proj(node));
1852 skip_nop (ir_node *node) {
1853 /* don't assert node !!! */
1855 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1856 /* Don't use get_Id_pred: We get into an endless loop for
1857 self-referencing Ids. */
1858 assert (get_irn_arity (node) > 0);
1859 return node->in[0+1];
1866 skip_Id (ir_node *node) {
1867 return skip_nop(node);
1871 is_Bad (ir_node *node) {
1873 if ((node) && get_irn_opcode(node) == iro_Bad)
1879 is_no_Block (ir_node *node) {
1881 return (get_irn_opcode(node) != iro_Block);
1884 /* Returns true if the operation manipulates control flow. */
1886 is_cfop(ir_node *node) {
1887 return is_cfopcode(get_irn_op(node));
1890 /* Returns true if the operation can change the control flow because
1893 is_fragile_op(ir_node *node) {
1894 return ( (get_irn_opcode(node) == iro_Call)
1895 || (get_irn_opcode(node) == iro_Quot)
1896 || (get_irn_opcode(node) == iro_DivMod)
1897 || (get_irn_opcode(node) == iro_Div)
1898 || (get_irn_opcode(node) == iro_Mod)
1899 || (get_irn_opcode(node) == iro_Load)
1900 || (get_irn_opcode(node) == iro_Store)
1901 || (get_irn_opcode(node) == iro_Alloc)
1902 || (get_irn_opcode(node) == iro_Bad));
1906 /* Returns the memory operand of fragile operations. */
1907 ir_node *get_fragile_op_mem(ir_node *node) {
1908 assert(node && is_fragile_op(node));
1910 switch (get_irn_opcode (node)) {
1919 return get_irn_n(node, 0);