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);
88 res->kind = k_ir_node;
94 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
96 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
97 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
103 res->node_nr = get_irp_new_node_nr();
109 /* Copies all attributes stored in the old node to the new node.
110 Assumes both have the same opcode and sufficient size. */
112 copy_attrs (ir_node *old, ir_node *new) {
113 assert (get_irn_opcode(old) == get_irn_opcode(new));
114 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
117 /* IR-Nodes with attributes */
119 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
122 ir_node *np = XP_GETARG (ir_node *, 0);
125 XPS ("<null ir_node>");
129 XPF1 ("%I", get_irn_opident(np));
131 switch (get_irn_opcode (np)) { /* node label */
133 XPF1 ("%I", get_irn_mode(np)->name);
135 XPF1 ("%v", get_irn_const_attr);
138 if (get_irn_modecode (np) == irm_b) {
140 XP (pnc_name_arr[get_irn_proj_attr(np)]);
141 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
143 XP (pns_name_arr[get_irn_proj_attr(np)]);
145 XPF1 ("%I", get_irn_mode(np)->name);
147 XPF1 ("%d", get_irn_proj_attr(np));
151 XPF1 ("%I", get_irn_mode(np)->name);
153 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
154 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
156 case iro_Start: /* don't dump mode of these */
165 XPF1 ("%I", get_irn_mode(np)->name);
171 /** getting some parameters from ir_nodes **/
173 /* returns the number of predecessors without the block predecessor. */
175 get_irn_arity (ir_node *node)
178 return (ARR_LEN((node)->in)-1);
181 /* Returns the array with ins. This array is shifted with respect to the
182 array accessed by get_irn_n: The block operand is at position 0 not -1.
183 (@@@ This should be changed.)
184 The order of the predecessors in this array is not guaranteed, except that
185 lists of operands as predecessors of Block or arguments of a Call are
188 get_irn_in (ir_node *node)
195 set_irn_in (ir_node *node, int arity, ir_node **in) {
197 if (arity != get_irn_arity(node)) {
198 ir_node *block = node->in[0];
199 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
202 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
205 /* to iterate through the predecessors without touching the array */
206 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
207 to iterate includind the Block predecessor iterate from i = -1 to
209 If it is a block, the entry -1 is NULL. */
211 get_irn_n (ir_node *node, int n)
215 assert ((get_irn_arity (node) > n) && (-1 <= n));
216 res = skip_nop(node->in[n+1]);
217 if (res != node->in[n+1]) node->in[n+1] = res;
222 set_irn_n (ir_node *node, int n, ir_node *in)
225 assert (get_irn_arity (node) > n);
230 get_irn_mode (ir_node *node)
237 get_irn_modecode (ir_node *node)
240 return node->mode->code;
245 get_irn_modeident (ir_node *node)
248 return node->mode->name;
252 get_irn_op (ir_node *node)
258 /* should be private to the library: */
260 set_irn_op (ir_node *node, ir_op *op)
267 get_irn_opcode (ir_node *node)
270 return node->op->code;
274 get_irn_opname (ir_node *node)
277 return id_to_str(node->op->name);
281 get_irn_opident (ir_node *node)
284 return node->op->name;
288 get_irn_visited (ir_node *node)
291 return node->visited;
295 set_irn_visited (ir_node *node, unsigned long visited)
298 node->visited = visited;
302 mark_irn_visited (ir_node *node) {
304 node->visited = current_ir_graph->visited;
308 irn_not_visited (ir_node *node) {
310 return (node->visited < current_ir_graph->visited);
314 set_irn_link (ir_node *node, ir_node *link) {
320 get_irn_link (ir_node *node) {
325 /* Outputs a unique number for this node */
327 get_irn_node_nr(ir_node *node) {
330 return node->node_nr;
337 get_irn_const_attr (ir_node *node)
339 assert (node->op == op_Const);
340 return node->attr.con;
344 get_irn_proj_attr (ir_node *node)
346 assert (node->op == op_Proj);
347 return node->attr.proj;
351 get_irn_alloc_attr (ir_node *node)
353 assert (node->op == op_Alloc);
358 get_irn_free_attr (ir_node *node)
360 assert (node->op == op_Free);
361 return node->attr.f = skip_tid(node->attr.f);
365 get_irn_symconst_attr (ir_node *node)
367 assert (node->op == op_SymConst);
372 get_irn_call_attr (ir_node *node)
374 assert (node->op == op_Call);
375 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
379 get_irn_sel_attr (ir_node *node)
381 assert (node->op == op_Sel);
386 get_irn_phi_attr (ir_node *node)
388 assert (node->op == op_Phi);
389 return node->attr.phi0_pos;
393 get_irn_block_attr (ir_node *node)
395 assert (node->op == op_Block);
396 return node->attr.block;
399 /** manipulate fields of individual nodes **/
401 /* this works for all except Block */
403 get_nodes_Block (ir_node *node) {
404 assert (!(node->op == op_Block));
405 return get_irn_n(node, -1);
409 set_nodes_Block (ir_node *node, ir_node *block) {
410 assert (!(node->op == op_Block));
411 set_irn_n(node, -1, block);
414 /* Returns an array with the predecessors of the Block. Depending on
415 the implementation of the graph datastructure this can be a copy of
416 the internal representation of predecessors as well as the internal
417 array itself. Therefore writing to this array might obstruct the ir. */
419 get_Block_cfgpred_arr (ir_node *node)
421 assert ((node->op == op_Block));
422 return (ir_node **)&(get_irn_in(node)[1]);
427 get_Block_n_cfgpreds (ir_node *node) {
428 assert ((node->op == op_Block));
429 return (get_irn_arity(node));
434 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
435 assert ((node->op == op_Block));
440 get_Block_cfgpred (ir_node *node, int pos) {
441 assert (node->op == op_Block);
442 return get_irn_n(node, pos);
446 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
447 assert (node->op == op_Block);
448 set_irn_n(node, pos, pred);
452 get_Block_matured (ir_node *node) {
453 assert (node->op == op_Block);
454 return node->attr.block.matured;
458 set_Block_matured (ir_node *node, bool matured) {
459 assert (node->op == op_Block);
460 node->attr.block.matured = matured;
463 get_Block_block_visited (ir_node *node) {
464 assert (node->op == op_Block);
465 return node->attr.block.block_visited;
469 set_Block_block_visited (ir_node *node, unsigned long visit) {
470 assert (node->op == op_Block);
471 node->attr.block.block_visited = visit;
474 /* For this current_ir_graph must be set. */
475 inline void mark_Block_block_visited (ir_node *node) {
476 assert (node->op == op_Block);
477 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
480 inline int Block_not_block_visited(ir_node *node) {
481 assert (node->op == op_Block);
482 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
486 get_Block_graph_arr (ir_node *node, int pos) {
487 assert (node->op == op_Block);
488 return node->attr.block.graph_arr[pos+1];
492 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
493 assert (node->op == op_Block);
494 node->attr.block.graph_arr[pos+1] = value;
498 get_End_n_keepalives(ir_node *end) {
499 assert (end->op == op_End);
500 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
504 get_End_keepalive(ir_node *end, int pos) {
505 assert (end->op == op_End);
506 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
510 add_End_keepalive (ir_node *end, ir_node *ka) {
511 assert (end->op == op_End);
512 ARR_APP1 (ir_node *, end->in, ka);
516 free_End (ir_node *end) {
517 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
518 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
522 > Implementing the case construct (which is where the constant Proj node is
523 > important) involves far more than simply determining the constant values.
524 > We could argue that this is more properly a function of the translator from
525 > Firm to the target machine. That could be done if there was some way of
526 > projecting "default" out of the Cond node.
527 I know it's complicated.
528 Basically there are two proglems:
529 - determining the gaps between the projs
530 - determining the biggest case constant to konw the proj number for
532 I see several solutions:
533 1. Introduce a ProjDefault node. Solves both problems.
534 This means to extend all optimizations executed during construction.
535 2. Give the Cond node for switch two flavors:
536 a) there are no gaps in the projs (existing flavor)
537 b) gaps may exist, default proj is still the Proj with the largest
538 projection number. This covers also the gaps.
539 3. Fix the semantic of the Cond to that of 2b)
541 Solution 2 seems to be the best:
542 Computing the gaps in the Firm representation is not too hard, i.e.,
543 libfirm can implement a routine that transforms betweeen the two
544 flavours. This is also possible for 1) but 2) does not require to
545 change any existing optimization.
546 Further it should be far simpler to determine the biggest constant than
548 I don't want to choose 3) as 2a) seems to have advantages for
549 dataflow analysis and 3) does not allow to convert the representation to
553 get_Cond_selector (ir_node *node) {
554 assert (node->op == op_Cond);
555 return get_irn_n(node, 0);
559 set_Cond_selector (ir_node *node, ir_node *selector) {
560 assert (node->op == op_Cond);
561 set_irn_n(node, 0, selector);
565 get_Cond_kind (ir_node *node) {
566 assert (node->op == op_Cond);
567 return node->attr.c.kind;
571 set_Cond_kind (ir_node *node, cond_kind kind) {
572 assert (node->op == op_Cond);
573 node->attr.c.kind = kind;
577 get_Return_mem (ir_node *node) {
578 assert (node->op == op_Return);
579 return get_irn_n(node, 0);
583 set_Return_mem (ir_node *node, ir_node *mem) {
584 assert (node->op == op_Return);
585 set_irn_n(node, 0, mem);
589 get_Return_res_arr (ir_node *node)
591 assert ((node->op == op_Return));
592 if (get_Return_n_res(node) > 0)
593 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
599 get_Return_n_res (ir_node *node) {
600 assert (node->op == op_Return);
601 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
606 set_Return_n_res (ir_node *node, int results) {
607 assert (node->op == op_Return);
612 get_Return_res (ir_node *node, int pos) {
613 assert (node->op == op_Return);
614 assert (get_Return_n_res(node) > pos);
615 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
619 set_Return_res (ir_node *node, int pos, ir_node *res){
620 assert (node->op == op_Return);
621 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
625 get_Raise_mem (ir_node *node) {
626 assert (node->op == op_Return);
627 return get_irn_n(node, 0);
631 set_Raise_mem (ir_node *node, ir_node *mem) {
632 assert (node->op == op_Raise);
633 set_irn_n(node, 0, mem);
637 get_Raise_exo_ptr (ir_node *node) {
638 assert (node->op == op_Raise);
639 return get_irn_n(node, 1);
643 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
644 assert (node->op == op_Raise);
645 set_irn_n(node, 1, exo_ptr);
648 inline tarval *get_Const_tarval (ir_node *node) {
649 assert (node->op == op_Const);
650 return get_irn_const_attr(node);
654 set_Const_tarval (ir_node *node, tarval *con) {
655 assert (node->op == op_Const);
656 node->attr.con = con;
660 get_SymConst_kind (ir_node *node) {
661 assert (node->op == op_SymConst);
662 return node->attr.i.num;
666 set_SymConst_kind (ir_node *node, symconst_kind num) {
667 assert (node->op == op_SymConst);
668 node->attr.i.num = num;
672 get_SymConst_type (ir_node *node) {
673 assert ( (node->op == op_SymConst)
674 && ( get_SymConst_kind(node) == type_tag
675 || get_SymConst_kind(node) == size));
676 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
680 set_SymConst_type (ir_node *node, type *type) {
681 assert ( (node->op == op_SymConst)
682 && ( get_SymConst_kind(node) == type_tag
683 || get_SymConst_kind(node) == size));
684 node->attr.i.tori.typ = type;
688 get_SymConst_ptrinfo (ir_node *node) {
689 assert ( (node->op == op_SymConst)
690 && (get_SymConst_kind(node) == linkage_ptr_info));
691 return node->attr.i.tori.ptrinfo;
695 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
696 assert ( (node->op == op_SymConst)
697 && (get_SymConst_kind(node) == linkage_ptr_info));
698 node->attr.i.tori.ptrinfo = ptrinfo;
702 get_SymConst_type_or_id (ir_node *node) {
703 assert (node->op == op_SymConst);
704 return &(node->attr.i.tori);
708 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
709 assert (node->op == op_SymConst);
710 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
714 get_Sel_mem (ir_node *node) {
715 assert (node->op == op_Sel);
716 return get_irn_n(node, 0);
720 set_Sel_mem (ir_node *node, ir_node *mem) {
721 assert (node->op == op_Sel);
722 set_irn_n(node, 0, mem);
726 get_Sel_ptr (ir_node *node) {
727 assert (node->op == op_Sel);
728 return get_irn_n(node, 1);
732 set_Sel_ptr (ir_node *node, ir_node *ptr) {
733 assert (node->op == op_Sel);
734 set_irn_n(node, 1, ptr);
738 get_Sel_index_arr (ir_node *node)
740 assert ((node->op == op_Sel));
741 if (get_Sel_n_index(node) > 0)
742 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
748 get_Sel_n_index (ir_node *node) {
749 assert (node->op == op_Sel);
750 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
755 set_Sel_n_index (ir_node *node, int n_index) {
756 assert (node->op == op_Sel);
761 get_Sel_index (ir_node *node, int pos) {
762 assert (node->op == op_Sel);
763 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
767 set_Sel_index (ir_node *node, int pos, ir_node *index) {
768 assert (node->op == op_Sel);
769 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
773 get_Sel_entity (ir_node *node) {
774 assert (node->op == op_Sel);
775 return node->attr.s.ent;
779 set_Sel_entity (ir_node *node, entity *ent) {
780 assert (node->op == op_Sel);
781 node->attr.s.ent = ent;
785 get_Sel_linkage_type (ir_node *node) {
786 assert (node->op == op_Sel);
787 return node->attr.s.ltyp;
791 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
792 assert (node->op == op_Sel);
793 node->attr.s.ltyp = lt;
797 get_Call_mem (ir_node *node) {
798 assert (node->op == op_Call);
799 return get_irn_n(node, 0);
803 set_Call_mem (ir_node *node, ir_node *mem) {
804 assert (node->op == op_Call);
805 set_irn_n(node, 0, mem);
809 get_Call_ptr (ir_node *node) {
810 assert (node->op == op_Call);
811 return get_irn_n(node, 1);
815 set_Call_ptr (ir_node *node, ir_node *ptr) {
816 assert (node->op == op_Call);
817 set_irn_n(node, 1, ptr);
821 get_Call_param_arr (ir_node *node) {
822 assert (node->op == op_Call);
823 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
827 get_Call_n_params (ir_node *node) {
828 assert (node->op == op_Call);
829 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
833 get_Call_arity (ir_node *node) {
834 assert (node->op == op_Call);
835 return get_Call_n_params(node);
839 set_Call_arity (ir_node *node, ir_node *arity) {
840 assert (node->op == op_Call);
845 get_Call_param (ir_node *node, int pos) {
846 assert (node->op == op_Call);
847 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
851 set_Call_param (ir_node *node, int pos, ir_node *param) {
852 assert (node->op == op_Call);
853 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
857 get_Call_type (ir_node *node) {
858 assert (node->op == op_Call);
859 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
863 set_Call_type (ir_node *node, type *type) {
864 assert (node->op == op_Call);
865 assert (is_method_type(type));
866 node->attr.call.cld_tp = type;
869 /* For unary and binary arithmetic operations the access to the
870 operands can be factored out. Left is the first, right the
871 second arithmetic value as listed in tech report 0999-33.
872 unops are: Minus, Abs, Not, Conv
873 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
874 Shr, Shrs, Rotate, Cmp */
877 is_unop (ir_node *node) {
878 return ( node->op == op_Minus ||
879 node->op == op_Abs ||
880 node->op == op_Not ||
881 node->op == op_Conv );
885 get_unop_op (ir_node *node) {
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: return get_Minus_op(node); break;
892 case iro_Abs: return get_Abs_op(node); break;
893 case iro_Not: return get_Not_op(node); break;
894 case iro_Conv: return get_Conv_op(node); break;
895 default: return NULL;
900 set_unop_op (ir_node *node, ir_node *op) {
901 assert (node->op == op_Minus ||
902 node->op == op_Abs ||
903 node->op == op_Not ||
904 node->op == op_Conv );
905 switch (get_irn_opcode (node)) {
906 case iro_Minus: set_Minus_op(node, op); break;
907 case iro_Abs: set_Abs_op(node, op); break;
908 case iro_Not: set_Not_op(node, op); break;
909 case iro_Conv: set_Conv_op(node, op); break;
916 is_binop (ir_node *node) {
917 return (node->op == op_Add ||
918 node->op == op_Sub ||
919 node->op == op_Mul ||
920 node->op == op_Quot ||
921 node->op == op_DivMod ||
922 node->op == op_Div ||
923 node->op == op_Mod ||
924 node->op == op_And ||
926 node->op == op_Eor ||
927 node->op == op_Shl ||
928 node->op == op_Shr ||
929 node->op == op_Shrs ||
930 node->op == op_Rot ||
931 node->op == op_Cmp );
935 get_binop_left (ir_node *node) {
936 assert (node->op == op_Add ||
937 node->op == op_Sub ||
938 node->op == op_Mul ||
939 node->op == op_Quot ||
940 node->op == op_DivMod ||
941 node->op == op_Div ||
942 node->op == op_Mod ||
943 node->op == op_And ||
945 node->op == op_Eor ||
946 node->op == op_Shl ||
947 node->op == op_Shr ||
948 node->op == op_Shrs ||
949 node->op == op_Rot ||
950 node->op == op_Cmp );
952 switch (get_irn_opcode (node)) {
953 case iro_Add : return get_Add_left(node); break;
954 case iro_Sub : return get_Sub_left(node); break;
955 case iro_Mul : return get_Mul_left(node); break;
956 case iro_Quot : return get_Quot_left(node); break;
957 case iro_DivMod: return get_DivMod_left(node); break;
958 case iro_Div : return get_Div_left(node); break;
959 case iro_Mod : return get_Mod_left(node); break;
960 case iro_And : return get_And_left(node); break;
961 case iro_Or : return get_Or_left(node); break;
962 case iro_Eor : return get_Eor_left(node); break;
963 case iro_Shl : return get_Shl_left(node); break;
964 case iro_Shr : return get_Shr_left(node); break;
965 case iro_Shrs : return get_Shrs_left(node); break;
966 case iro_Rot : return get_Rot_left(node); break;
967 case iro_Cmp : return get_Cmp_left(node); break;
968 default: return NULL;
973 set_binop_left (ir_node *node, ir_node *left) {
974 assert (node->op == op_Add ||
975 node->op == op_Sub ||
976 node->op == op_Mul ||
977 node->op == op_Quot ||
978 node->op == op_DivMod ||
979 node->op == op_Div ||
980 node->op == op_Mod ||
981 node->op == op_And ||
983 node->op == op_Eor ||
984 node->op == op_Shl ||
985 node->op == op_Shr ||
986 node->op == op_Shrs ||
987 node->op == op_Rot ||
988 node->op == op_Cmp );
990 switch (get_irn_opcode (node)) {
991 case iro_Add : set_Add_left(node, left); break;
992 case iro_Sub : set_Sub_left(node, left); break;
993 case iro_Mul : set_Mul_left(node, left); break;
994 case iro_Quot : set_Quot_left(node, left); break;
995 case iro_DivMod: set_DivMod_left(node, left); break;
996 case iro_Div : set_Div_left(node, left); break;
997 case iro_Mod : set_Mod_left(node, left); break;
998 case iro_And : set_And_left(node, left); break;
999 case iro_Or : set_Or_left(node, left); break;
1000 case iro_Eor : set_Eor_left(node, left); break;
1001 case iro_Shl : set_Shl_left(node, left); break;
1002 case iro_Shr : set_Shr_left(node, left); break;
1003 case iro_Shrs : set_Shrs_left(node, left); break;
1004 case iro_Rot : set_Rot_left(node, left); break;
1005 case iro_Cmp : set_Cmp_left(node, left); break;
1011 get_binop_right (ir_node *node) {
1012 assert (node->op == op_Add ||
1013 node->op == op_Sub ||
1014 node->op == op_Mul ||
1015 node->op == op_Quot ||
1016 node->op == op_DivMod ||
1017 node->op == op_Div ||
1018 node->op == op_Mod ||
1019 node->op == op_And ||
1020 node->op == op_Or ||
1021 node->op == op_Eor ||
1022 node->op == op_Shl ||
1023 node->op == op_Shr ||
1024 node->op == op_Shrs ||
1025 node->op == op_Rot ||
1026 node->op == op_Cmp );
1028 switch (get_irn_opcode (node)) {
1029 case iro_Add : return get_Add_right(node); break;
1030 case iro_Sub : return get_Sub_right(node); break;
1031 case iro_Mul : return get_Mul_right(node); break;
1032 case iro_Quot : return get_Quot_right(node); break;
1033 case iro_DivMod: return get_DivMod_right(node); break;
1034 case iro_Div : return get_Div_right(node); break;
1035 case iro_Mod : return get_Mod_right(node); break;
1036 case iro_And : return get_And_right(node); break;
1037 case iro_Or : return get_Or_right(node); break;
1038 case iro_Eor : return get_Eor_right(node); break;
1039 case iro_Shl : return get_Shl_right(node); break;
1040 case iro_Shr : return get_Shr_right(node); break;
1041 case iro_Shrs : return get_Shrs_right(node); break;
1042 case iro_Rot : return get_Rot_right(node); break;
1043 case iro_Cmp : return get_Cmp_right(node); break;
1044 default: return NULL;
1049 set_binop_right (ir_node *node, ir_node *right) {
1050 assert (node->op == op_Add ||
1051 node->op == op_Sub ||
1052 node->op == op_Mul ||
1053 node->op == op_Quot ||
1054 node->op == op_DivMod ||
1055 node->op == op_Div ||
1056 node->op == op_Mod ||
1057 node->op == op_And ||
1058 node->op == op_Or ||
1059 node->op == op_Eor ||
1060 node->op == op_Shl ||
1061 node->op == op_Shr ||
1062 node->op == op_Shrs ||
1063 node->op == op_Rot ||
1064 node->op == op_Cmp );
1066 switch (get_irn_opcode (node)) {
1067 case iro_Add : set_Add_right(node, right); break;
1068 case iro_Sub : set_Sub_right(node, right); break;
1069 case iro_Mul : set_Mul_right(node, right); break;
1070 case iro_Quot : set_Quot_right(node, right); break;
1071 case iro_DivMod: set_DivMod_right(node, right); break;
1072 case iro_Div : set_Div_right(node, right); break;
1073 case iro_Mod : set_Mod_right(node, right); break;
1074 case iro_And : set_And_right(node, right); break;
1075 case iro_Or : set_Or_right(node, right); break;
1076 case iro_Eor : set_Eor_right(node, right); break;
1077 case iro_Shl : set_Shl_right(node, right); break;
1078 case iro_Shr : set_Shr_right(node, right); break;
1079 case iro_Shrs : set_Shrs_right(node, right); break;
1080 case iro_Rot : set_Rot_right(node, right); break;
1081 case iro_Cmp : set_Cmp_right(node, right); break;
1087 get_Add_left (ir_node *node) {
1088 assert (node->op == op_Add);
1089 return get_irn_n(node, 0);
1093 set_Add_left (ir_node *node, ir_node *left) {
1094 assert (node->op == op_Add);
1095 set_irn_n(node, 0, left);
1099 get_Add_right (ir_node *node) {
1100 assert (node->op == op_Add);
1101 return get_irn_n(node, 1);
1105 set_Add_right (ir_node *node, ir_node *right) {
1106 assert (node->op == op_Add);
1107 set_irn_n(node, 1, right);
1111 get_Sub_left (ir_node *node) {
1112 assert (node->op == op_Sub);
1113 return get_irn_n(node, 0);
1117 set_Sub_left (ir_node *node, ir_node *left) {
1118 assert (node->op == op_Sub);
1119 set_irn_n(node, 0, left);
1123 get_Sub_right (ir_node *node) {
1124 assert (node->op == op_Sub);
1125 return get_irn_n(node, 1);
1129 set_Sub_right (ir_node *node, ir_node *right) {
1130 assert (node->op == op_Sub);
1131 set_irn_n(node, 1, right);
1136 get_Minus_op (ir_node *node) {
1137 assert (node->op == op_Minus);
1138 return get_irn_n(node, 0);
1142 set_Minus_op (ir_node *node, ir_node *op) {
1143 assert (node->op == op_Minus);
1144 set_irn_n(node, 0, op);
1149 get_Mul_left (ir_node *node) {
1150 assert (node->op == op_Mul);
1151 return get_irn_n(node, 0);
1155 set_Mul_left (ir_node *node, ir_node *left) {
1156 assert (node->op == op_Mul);
1157 set_irn_n(node, 0, left);
1161 get_Mul_right (ir_node *node) {
1162 assert (node->op == op_Mul);
1163 return get_irn_n(node, 1);
1167 set_Mul_right (ir_node *node, ir_node *right) {
1168 assert (node->op == op_Mul);
1169 set_irn_n(node, 1, right);
1173 get_Quot_left (ir_node *node) {
1174 assert (node->op == op_Quot);
1175 return get_irn_n(node, 1);
1179 set_Quot_left (ir_node *node, ir_node *left) {
1180 assert (node->op == op_Quot);
1181 set_irn_n(node, 1, left);
1185 get_Quot_right (ir_node *node) {
1186 assert (node->op == op_Quot);
1187 return get_irn_n(node, 2);
1191 set_Quot_right (ir_node *node, ir_node *right) {
1192 assert (node->op == op_Quot);
1193 set_irn_n(node, 2, right);
1197 get_Quot_mem (ir_node *node) {
1198 assert (node->op == op_Quot);
1199 return get_irn_n(node, 0);
1203 set_Quot_mem (ir_node *node, ir_node *mem) {
1204 assert (node->op == op_Quot);
1205 set_irn_n(node, 0, mem);
1209 get_DivMod_left (ir_node *node) {
1210 assert (node->op == op_DivMod);
1211 return get_irn_n(node, 1);
1215 set_DivMod_left (ir_node *node, ir_node *left) {
1216 assert (node->op == op_DivMod);
1217 set_irn_n(node, 1, left);
1221 get_DivMod_right (ir_node *node) {
1222 assert (node->op == op_DivMod);
1223 return get_irn_n(node, 2);
1227 set_DivMod_right (ir_node *node, ir_node *right) {
1228 assert (node->op == op_DivMod);
1229 set_irn_n(node, 2, right);
1233 get_DivMod_mem (ir_node *node) {
1234 assert (node->op == op_DivMod);
1235 return get_irn_n(node, 0);
1239 set_DivMod_mem (ir_node *node, ir_node *mem) {
1240 assert (node->op == op_DivMod);
1241 set_irn_n(node, 0, mem);
1245 get_Div_left (ir_node *node) {
1246 assert (node->op == op_Div);
1247 return get_irn_n(node, 1);
1251 set_Div_left (ir_node *node, ir_node *left) {
1252 assert (node->op == op_Div);
1253 set_irn_n(node, 1, left);
1257 get_Div_right (ir_node *node) {
1258 assert (node->op == op_Div);
1259 return get_irn_n(node, 2);
1263 set_Div_right (ir_node *node, ir_node *right) {
1264 assert (node->op == op_Div);
1265 set_irn_n(node, 2, right);
1269 get_Div_mem (ir_node *node) {
1270 assert (node->op == op_Div);
1271 return get_irn_n(node, 0);
1275 set_Div_mem (ir_node *node, ir_node *mem) {
1276 assert (node->op == op_Div);
1277 set_irn_n(node, 0, mem);
1281 get_Mod_left (ir_node *node) {
1282 assert (node->op == op_Mod);
1283 return get_irn_n(node, 1);
1287 set_Mod_left (ir_node *node, ir_node *left) {
1288 assert (node->op == op_Mod);
1289 set_irn_n(node, 1, left);
1293 get_Mod_right (ir_node *node) {
1294 assert (node->op == op_Mod);
1295 return get_irn_n(node, 2);
1299 set_Mod_right (ir_node *node, ir_node *right) {
1300 assert (node->op == op_Mod);
1301 set_irn_n(node, 2, right);
1305 get_Mod_mem (ir_node *node) {
1306 assert (node->op == op_Mod);
1307 return get_irn_n(node, 0);
1311 set_Mod_mem (ir_node *node, ir_node *mem) {
1312 assert (node->op == op_Mod);
1313 set_irn_n(node, 0, mem);
1317 get_Abs_op (ir_node *node) {
1318 assert (node->op == op_Abs);
1319 return get_irn_n(node, 0);
1323 set_Abs_op (ir_node *node, ir_node *op) {
1324 assert (node->op == op_Abs);
1325 set_irn_n(node, 0, op);
1329 get_And_left (ir_node *node) {
1330 assert (node->op == op_And);
1331 return get_irn_n(node, 0);
1335 set_And_left (ir_node *node, ir_node *left) {
1336 assert (node->op == op_And);
1337 set_irn_n(node, 0, left);
1341 get_And_right (ir_node *node) {
1342 assert (node->op == op_And);
1343 return get_irn_n(node, 1);
1347 set_And_right (ir_node *node, ir_node *right) {
1348 assert (node->op == op_And);
1349 set_irn_n(node, 1, right);
1353 get_Or_left (ir_node *node) {
1354 assert (node->op == op_Or);
1355 return get_irn_n(node, 0);
1359 set_Or_left (ir_node *node, ir_node *left) {
1360 assert (node->op == op_Or);
1361 set_irn_n(node, 0, left);
1365 get_Or_right (ir_node *node) {
1366 assert (node->op == op_Or);
1367 return get_irn_n(node, 1);
1371 set_Or_right (ir_node *node, ir_node *right) {
1372 assert (node->op == op_Or);
1373 set_irn_n(node, 1, right);
1377 get_Eor_left (ir_node *node) {
1378 assert (node->op == op_Eor);
1379 return get_irn_n(node, 0);
1383 set_Eor_left (ir_node *node, ir_node *left) {
1384 assert (node->op == op_Eor);
1385 set_irn_n(node, 0, left);
1389 get_Eor_right (ir_node *node) {
1390 assert (node->op == op_Eor);
1391 return get_irn_n(node, 1);
1395 set_Eor_right (ir_node *node, ir_node *right) {
1396 assert (node->op == op_Eor);
1397 set_irn_n(node, 1, right);
1402 get_Not_op (ir_node *node) {
1403 assert (node->op == op_Not);
1404 return get_irn_n(node, 0);
1408 set_Not_op (ir_node *node, ir_node *op) {
1409 assert (node->op == op_Not);
1410 set_irn_n(node, 0, op);
1415 get_Shl_left (ir_node *node) {
1416 assert (node->op == op_Shl);
1417 return get_irn_n(node, 0);
1421 set_Shl_left (ir_node *node, ir_node *left) {
1422 assert (node->op == op_Shl);
1423 set_irn_n(node, 0, left);
1427 get_Shl_right (ir_node *node) {
1428 assert (node->op == op_Shl);
1429 return get_irn_n(node, 1);
1433 set_Shl_right (ir_node *node, ir_node *right) {
1434 assert (node->op == op_Shl);
1435 set_irn_n(node, 1, right);
1439 get_Shr_left (ir_node *node) {
1440 assert (node->op == op_Shr);
1441 return get_irn_n(node, 0);
1445 set_Shr_left (ir_node *node, ir_node *left) {
1446 assert (node->op == op_Shr);
1447 set_irn_n(node, 0, left);
1451 get_Shr_right (ir_node *node) {
1452 assert (node->op == op_Shr);
1453 return get_irn_n(node, 1);
1457 set_Shr_right (ir_node *node, ir_node *right) {
1458 assert (node->op == op_Shr);
1459 set_irn_n(node, 1, right);
1463 get_Shrs_left (ir_node *node) {
1464 assert (node->op == op_Shrs);
1465 return get_irn_n(node, 0);
1469 set_Shrs_left (ir_node *node, ir_node *left) {
1470 assert (node->op == op_Shrs);
1471 set_irn_n(node, 0, left);
1475 get_Shrs_right (ir_node *node) {
1476 assert (node->op == op_Shrs);
1477 return get_irn_n(node, 1);
1481 set_Shrs_right (ir_node *node, ir_node *right) {
1482 assert (node->op == op_Shrs);
1483 set_irn_n(node, 1, right);
1487 get_Rot_left (ir_node *node) {
1488 assert (node->op == op_Rot);
1489 return get_irn_n(node, 0);
1493 set_Rot_left (ir_node *node, ir_node *left) {
1494 assert (node->op == op_Rot);
1495 set_irn_n(node, 0, left);
1499 get_Rot_right (ir_node *node) {
1500 assert (node->op == op_Rot);
1501 return get_irn_n(node, 1);
1505 set_Rot_right (ir_node *node, ir_node *right) {
1506 assert (node->op == op_Rot);
1507 set_irn_n(node, 1, right);
1511 get_Cmp_left (ir_node *node) {
1512 assert (node->op == op_Cmp);
1513 return get_irn_n(node, 0);
1517 set_Cmp_left (ir_node *node, ir_node *left) {
1518 assert (node->op == op_Cmp);
1519 set_irn_n(node, 0, left);
1523 get_Cmp_right (ir_node *node) {
1524 assert (node->op == op_Cmp);
1525 return get_irn_n(node, 1);
1529 set_Cmp_right (ir_node *node, ir_node *right) {
1530 assert (node->op == op_Cmp);
1531 set_irn_n(node, 1, right);
1535 get_Conv_op (ir_node *node) {
1536 assert (node->op == op_Conv);
1537 return get_irn_n(node, 0);
1541 set_Conv_op (ir_node *node, ir_node *op) {
1542 assert (node->op == op_Conv);
1543 set_irn_n(node, 0, op);
1547 get_Phi_preds_arr (ir_node *node) {
1548 assert (node->op == op_Phi);
1549 return (ir_node **)&(get_irn_in(node)[1]);
1553 get_Phi_n_preds (ir_node *node) {
1554 assert (node->op == op_Phi);
1555 return (get_irn_arity(node));
1559 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1560 assert (node->op == op_Phi);
1565 get_Phi_pred (ir_node *node, int pos) {
1566 assert (node->op == op_Phi);
1567 return get_irn_n(node, pos);
1571 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1572 assert (node->op == op_Phi);
1573 set_irn_n(node, pos, pred);
1577 get_Load_mem (ir_node *node) {
1578 assert (node->op == op_Load);
1579 return get_irn_n(node, 0);
1583 set_Load_mem (ir_node *node, ir_node *mem) {
1584 assert (node->op == op_Load);
1585 set_irn_n(node, 0, mem);
1589 get_Load_ptr (ir_node *node) {
1590 assert (node->op == op_Load);
1591 return get_irn_n(node, 1);
1595 set_Load_ptr (ir_node *node, ir_node *ptr) {
1596 assert (node->op == op_Load);
1597 set_irn_n(node, 1, ptr);
1602 get_Store_mem (ir_node *node) {
1603 assert (node->op == op_Store);
1604 return get_irn_n(node, 0);
1608 set_Store_mem (ir_node *node, ir_node *mem) {
1609 assert (node->op == op_Store);
1610 set_irn_n(node, 0, mem);
1614 get_Store_ptr (ir_node *node) {
1615 assert (node->op == op_Store);
1616 return get_irn_n(node, 1);
1620 set_Store_ptr (ir_node *node, ir_node *ptr) {
1621 assert (node->op == op_Store);
1622 set_irn_n(node, 1, ptr);
1626 get_Store_value (ir_node *node) {
1627 assert (node->op == op_Store);
1628 return get_irn_n(node, 2);
1632 set_Store_value (ir_node *node, ir_node *value) {
1633 assert (node->op == op_Store);
1634 set_irn_n(node, 2, value);
1638 get_Alloc_mem (ir_node *node) {
1639 assert (node->op == op_Alloc);
1640 return get_irn_n(node, 0);
1644 set_Alloc_mem (ir_node *node, ir_node *mem) {
1645 assert (node->op == op_Alloc);
1646 set_irn_n(node, 0, mem);
1650 get_Alloc_size (ir_node *node) {
1651 assert (node->op == op_Alloc);
1652 return get_irn_n(node, 1);
1656 set_Alloc_size (ir_node *node, ir_node *size) {
1657 assert (node->op == op_Alloc);
1658 set_irn_n(node, 1, size);
1662 get_Alloc_type (ir_node *node) {
1663 assert (node->op == op_Alloc);
1664 return node->attr.a.type = skip_tid(node->attr.a.type);
1668 set_Alloc_type (ir_node *node, type *type) {
1669 assert (node->op == op_Alloc);
1670 node->attr.a.type = type;
1674 get_Alloc_where (ir_node *node) {
1675 assert (node->op == op_Alloc);
1676 return node->attr.a.where;
1680 set_Alloc_where (ir_node *node, where_alloc where) {
1681 assert (node->op == op_Alloc);
1682 node->attr.a.where = where;
1687 get_Free_mem (ir_node *node) {
1688 assert (node->op == op_Free);
1689 return get_irn_n(node, 0);
1693 set_Free_mem (ir_node *node, ir_node *mem) {
1694 assert (node->op == op_Free);
1695 set_irn_n(node, 0, mem);
1699 get_Free_ptr (ir_node *node) {
1700 assert (node->op == op_Free);
1701 return get_irn_n(node, 1);
1705 set_Free_ptr (ir_node *node, ir_node *ptr) {
1706 assert (node->op == op_Free);
1707 set_irn_n(node, 1, ptr);
1711 get_Free_size (ir_node *node) {
1712 assert (node->op == op_Free);
1713 return get_irn_n(node, 2);
1717 set_Free_size (ir_node *node, ir_node *size) {
1718 assert (node->op == op_Free);
1719 set_irn_n(node, 2, size);
1723 get_Free_type (ir_node *node) {
1724 assert (node->op == op_Free);
1725 return node->attr.f = skip_tid(node->attr.f);
1729 set_Free_type (ir_node *node, type *type) {
1730 assert (node->op == op_Free);
1731 node->attr.f = type;
1735 get_Sync_preds_arr (ir_node *node) {
1736 assert (node->op == op_Sync);
1737 return (ir_node **)&(get_irn_in(node)[1]);
1741 get_Sync_n_preds (ir_node *node) {
1742 assert (node->op == op_Sync);
1743 return (get_irn_arity(node));
1748 set_Sync_n_preds (ir_node *node, int n_preds) {
1749 assert (node->op == op_Sync);
1754 get_Sync_pred (ir_node *node, int pos) {
1755 assert (node->op == op_Sync);
1756 return get_irn_n(node, pos);
1760 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1761 assert (node->op == op_Sync);
1762 set_irn_n(node, pos, pred);
1766 get_Proj_pred (ir_node *node) {
1767 assert (node->op == op_Proj);
1768 return get_irn_n(node, 0);
1772 set_Proj_pred (ir_node *node, ir_node *pred) {
1773 assert (node->op == op_Proj);
1774 set_irn_n(node, 0, pred);
1778 get_Proj_proj (ir_node *node) {
1779 assert (node->op == op_Proj);
1780 return node->attr.proj;
1784 set_Proj_proj (ir_node *node, long proj) {
1785 assert (node->op == op_Proj);
1786 node->attr.proj = proj;
1790 get_Tuple_preds_arr (ir_node *node) {
1791 assert (node->op == op_Tuple);
1792 return (ir_node **)&(get_irn_in(node)[1]);
1796 get_Tuple_n_preds (ir_node *node) {
1797 assert (node->op == op_Tuple);
1798 return (get_irn_arity(node));
1803 set_Tuple_n_preds (ir_node *node, int n_preds) {
1804 assert (node->op == op_Tuple);
1809 get_Tuple_pred (ir_node *node, int pos) {
1810 assert (node->op == op_Tuple);
1811 return get_irn_n(node, pos);
1815 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1816 assert (node->op == op_Tuple);
1817 set_irn_n(node, pos, pred);
1821 get_Id_pred (ir_node *node) {
1822 assert (node->op == op_Id);
1823 return get_irn_n(node, 0);
1827 set_Id_pred (ir_node *node, ir_node *pred) {
1828 assert (node->op == op_Id);
1829 set_irn_n(node, 0, pred);
1832 /******************************************************************/
1833 /* Auxiliary routines */
1834 /******************************************************************/
1837 skip_Proj (ir_node *node) {
1838 /* don't assert node !!! */
1839 if (node && (node->op == op_Proj)) {
1840 return get_Proj_pred(node);
1847 skip_Tuple (ir_node *node) {
1850 node = skip_nop(node);
1851 if (get_irn_op(node) == op_Proj) {
1852 pred = skip_nop(get_Proj_pred(node));
1853 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
1854 pred = skip_nop(skip_Tuple(pred));
1855 if (get_irn_op(pred) == op_Tuple)
1856 return get_Tuple_pred(pred, get_Proj_proj(node));
1862 skip_nop (ir_node *node) {
1863 /* don't assert node !!! */
1865 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1866 /* Don't use get_Id_pred: We get into an endless loop for
1867 self-referencing Ids. */
1868 assert (get_irn_arity (node) > 0);
1869 return node->in[0+1];
1876 skip_Id (ir_node *node) {
1877 return skip_nop(node);
1881 is_Bad (ir_node *node) {
1883 if ((node) && get_irn_opcode(node) == iro_Bad)
1889 is_no_Block (ir_node *node) {
1891 return (get_irn_opcode(node) != iro_Block);
1894 /* Returns true if the operation manipulates control flow. */
1896 is_cfop(ir_node *node) {
1897 return is_cfopcode(get_irn_op(node));
1900 /* Returns true if the operation can change the control flow because
1903 is_fragile_op(ir_node *node) {
1904 return ( (get_irn_opcode(node) == iro_Call)
1905 || (get_irn_opcode(node) == iro_Quot)
1906 || (get_irn_opcode(node) == iro_DivMod)
1907 || (get_irn_opcode(node) == iro_Div)
1908 || (get_irn_opcode(node) == iro_Mod)
1909 || (get_irn_opcode(node) == iro_Load)
1910 || (get_irn_opcode(node) == iro_Store)
1911 || (get_irn_opcode(node) == iro_Alloc)
1912 || (get_irn_opcode(node) == iro_Bad));
1916 /* Returns the memory operand of fragile operations. */
1917 ir_node *get_fragile_op_mem(ir_node *node) {
1918 assert(node && is_fragile_op(node));
1920 switch (get_irn_opcode (node)) {
1929 return get_irn_n(node, 0);