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 (dbg_info *db, 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);
100 set_irn_dbg_info(res, db);
104 res->node_nr = get_irp_new_node_nr();
110 /* Copies all attributes stored in the old node to the new node.
111 Assumes both have the same opcode and sufficient size. */
113 copy_attrs (ir_node *old, ir_node *new) {
114 assert (get_irn_opcode(old) == get_irn_opcode(new));
115 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
118 /* IR-Nodes with attributes */
120 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
123 ir_node *np = XP_GETARG (ir_node *, 0);
126 XPS ("<null ir_node>");
130 XPF1 ("%I", get_irn_opident(np));
132 switch (get_irn_opcode (np)) { /* node label */
134 XPF1 ("%I", get_irn_mode(np)->name);
136 XPF1 ("%v", get_irn_const_attr);
139 if (get_irn_modecode (np) == irm_b) {
141 XP (pnc_name_arr[get_irn_proj_attr(np)]);
142 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
144 XP (pns_name_arr[get_irn_proj_attr(np)]);
146 XPF1 ("%I", get_irn_mode(np)->name);
148 XPF1 ("%d", get_irn_proj_attr(np));
152 XPF1 ("%I", get_irn_mode(np)->name);
154 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
155 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
157 case iro_Start: /* don't dump mode of these */
166 XPF1 ("%I", get_irn_mode(np)->name);
172 /** getting some parameters from ir_nodes **/
174 /* returns the number of predecessors without the block predecessor. */
176 get_irn_arity (ir_node *node)
179 return (ARR_LEN((node)->in)-1);
182 /* Returns the array with ins. This array is shifted with respect to the
183 array accessed by get_irn_n: The block operand is at position 0 not -1.
184 (@@@ This should be changed.)
185 The order of the predecessors in this array is not guaranteed, except that
186 lists of operands as predecessors of Block or arguments of a Call are
189 get_irn_in (ir_node *node)
196 set_irn_in (ir_node *node, int arity, ir_node **in) {
198 if (arity != get_irn_arity(node)) {
199 ir_node *block = node->in[0];
200 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
203 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
206 /* to iterate through the predecessors without touching the array */
207 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
208 to iterate includind the Block predecessor iterate from i = -1 to
210 If it is a block, the entry -1 is NULL. */
212 get_irn_n (ir_node *node, int n)
216 assert ((get_irn_arity (node) > n) && (-1 <= n));
217 res = skip_nop(node->in[n+1]);
218 if (res != node->in[n+1]) node->in[n+1] = res;
223 set_irn_n (ir_node *node, int n, ir_node *in)
226 assert (get_irn_arity (node) > n);
231 get_irn_mode (ir_node *node)
238 get_irn_modecode (ir_node *node)
241 return node->mode->code;
246 get_irn_modeident (ir_node *node)
249 return node->mode->name;
253 get_irn_op (ir_node *node)
259 /* should be private to the library: */
261 set_irn_op (ir_node *node, ir_op *op)
268 get_irn_opcode (ir_node *node)
271 return node->op->code;
275 get_irn_opname (ir_node *node)
278 return id_to_str(node->op->name);
282 get_irn_opident (ir_node *node)
285 return node->op->name;
289 get_irn_visited (ir_node *node)
292 return node->visited;
296 set_irn_visited (ir_node *node, unsigned long visited)
299 node->visited = visited;
303 mark_irn_visited (ir_node *node) {
305 node->visited = current_ir_graph->visited;
309 irn_not_visited (ir_node *node) {
311 return (node->visited < current_ir_graph->visited);
315 set_irn_link (ir_node *node, ir_node *link) {
321 get_irn_link (ir_node *node) {
326 /* Outputs a unique number for this node */
328 get_irn_node_nr(ir_node *node) {
331 return node->node_nr;
338 get_irn_const_attr (ir_node *node)
340 assert (node->op == op_Const);
341 return node->attr.con;
345 get_irn_proj_attr (ir_node *node)
347 assert (node->op == op_Proj);
348 return node->attr.proj;
352 get_irn_alloc_attr (ir_node *node)
354 assert (node->op == op_Alloc);
359 get_irn_free_attr (ir_node *node)
361 assert (node->op == op_Free);
362 return node->attr.f = skip_tid(node->attr.f);
366 get_irn_symconst_attr (ir_node *node)
368 assert (node->op == op_SymConst);
373 get_irn_call_attr (ir_node *node)
375 assert (node->op == op_Call);
376 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
380 get_irn_sel_attr (ir_node *node)
382 assert (node->op == op_Sel);
387 get_irn_phi_attr (ir_node *node)
389 assert (node->op == op_Phi);
390 return node->attr.phi0_pos;
394 get_irn_block_attr (ir_node *node)
396 assert (node->op == op_Block);
397 return node->attr.block;
400 /** manipulate fields of individual nodes **/
402 /* this works for all except Block */
404 get_nodes_Block (ir_node *node) {
405 assert (!(node->op == op_Block));
406 return get_irn_n(node, -1);
410 set_nodes_Block (ir_node *node, ir_node *block) {
411 assert (!(node->op == op_Block));
412 set_irn_n(node, -1, block);
415 /* Returns an array with the predecessors of the Block. Depending on
416 the implementation of the graph datastructure this can be a copy of
417 the internal representation of predecessors as well as the internal
418 array itself. Therefore writing to this array might obstruct the ir. */
420 get_Block_cfgpred_arr (ir_node *node)
422 assert ((node->op == op_Block));
423 return (ir_node **)&(get_irn_in(node)[1]);
428 get_Block_n_cfgpreds (ir_node *node) {
429 assert ((node->op == op_Block));
430 return (get_irn_arity(node));
435 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
436 assert ((node->op == op_Block));
441 get_Block_cfgpred (ir_node *node, int pos) {
442 assert (node->op == op_Block);
443 return get_irn_n(node, pos);
447 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
448 assert (node->op == op_Block);
449 set_irn_n(node, pos, pred);
453 get_Block_matured (ir_node *node) {
454 assert (node->op == op_Block);
455 return node->attr.block.matured;
459 set_Block_matured (ir_node *node, bool matured) {
460 assert (node->op == op_Block);
461 node->attr.block.matured = matured;
464 get_Block_block_visited (ir_node *node) {
465 assert (node->op == op_Block);
466 return node->attr.block.block_visited;
470 set_Block_block_visited (ir_node *node, unsigned long visit) {
471 assert (node->op == op_Block);
472 node->attr.block.block_visited = visit;
475 /* For this current_ir_graph must be set. */
476 inline void mark_Block_block_visited (ir_node *node) {
477 assert (node->op == op_Block);
478 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
481 inline int Block_not_block_visited(ir_node *node) {
482 assert (node->op == op_Block);
483 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
487 get_Block_graph_arr (ir_node *node, int pos) {
488 assert (node->op == op_Block);
489 return node->attr.block.graph_arr[pos+1];
493 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
494 assert (node->op == op_Block);
495 node->attr.block.graph_arr[pos+1] = value;
498 void set_Block_exc (ir_node *block, exc_t exc)
500 block->attr.block.exc = exc;
503 exc_t get_Block_exc (ir_node *block)
505 return (block->attr.block.exc);
509 get_End_n_keepalives(ir_node *end) {
510 assert (end->op == op_End);
511 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
515 get_End_keepalive(ir_node *end, int pos) {
516 assert (end->op == op_End);
517 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
521 add_End_keepalive (ir_node *end, ir_node *ka) {
522 assert (end->op == op_End);
523 ARR_APP1 (ir_node *, end->in, ka);
527 free_End (ir_node *end) {
528 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
529 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
533 > Implementing the case construct (which is where the constant Proj node is
534 > important) involves far more than simply determining the constant values.
535 > We could argue that this is more properly a function of the translator from
536 > Firm to the target machine. That could be done if there was some way of
537 > projecting "default" out of the Cond node.
538 I know it's complicated.
539 Basically there are two proglems:
540 - determining the gaps between the projs
541 - determining the biggest case constant to konw the proj number for
543 I see several solutions:
544 1. Introduce a ProjDefault node. Solves both problems.
545 This means to extend all optimizations executed during construction.
546 2. Give the Cond node for switch two flavors:
547 a) there are no gaps in the projs (existing flavor)
548 b) gaps may exist, default proj is still the Proj with the largest
549 projection number. This covers also the gaps.
550 3. Fix the semantic of the Cond to that of 2b)
552 Solution 2 seems to be the best:
553 Computing the gaps in the Firm representation is not too hard, i.e.,
554 libfirm can implement a routine that transforms betweeen the two
555 flavours. This is also possible for 1) but 2) does not require to
556 change any existing optimization.
557 Further it should be far simpler to determine the biggest constant than
559 I don't want to choose 3) as 2a) seems to have advantages for
560 dataflow analysis and 3) does not allow to convert the representation to
564 get_Cond_selector (ir_node *node) {
565 assert (node->op == op_Cond);
566 return get_irn_n(node, 0);
570 set_Cond_selector (ir_node *node, ir_node *selector) {
571 assert (node->op == op_Cond);
572 set_irn_n(node, 0, selector);
576 get_Cond_kind (ir_node *node) {
577 assert (node->op == op_Cond);
578 return node->attr.c.kind;
582 set_Cond_kind (ir_node *node, cond_kind kind) {
583 assert (node->op == op_Cond);
584 node->attr.c.kind = kind;
588 get_Return_mem (ir_node *node) {
589 assert (node->op == op_Return);
590 return get_irn_n(node, 0);
594 set_Return_mem (ir_node *node, ir_node *mem) {
595 assert (node->op == op_Return);
596 set_irn_n(node, 0, mem);
600 get_Return_res_arr (ir_node *node)
602 assert ((node->op == op_Return));
603 if (get_Return_n_res(node) > 0)
604 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
610 get_Return_n_res (ir_node *node) {
611 assert (node->op == op_Return);
612 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
617 set_Return_n_res (ir_node *node, int results) {
618 assert (node->op == op_Return);
623 get_Return_res (ir_node *node, int pos) {
624 assert (node->op == op_Return);
625 assert (get_Return_n_res(node) > pos);
626 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
630 set_Return_res (ir_node *node, int pos, ir_node *res){
631 assert (node->op == op_Return);
632 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
636 get_Raise_mem (ir_node *node) {
637 assert (node->op == op_Return);
638 return get_irn_n(node, 0);
642 set_Raise_mem (ir_node *node, ir_node *mem) {
643 assert (node->op == op_Raise);
644 set_irn_n(node, 0, mem);
648 get_Raise_exo_ptr (ir_node *node) {
649 assert (node->op == op_Raise);
650 return get_irn_n(node, 1);
654 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
655 assert (node->op == op_Raise);
656 set_irn_n(node, 1, exo_ptr);
659 inline tarval *get_Const_tarval (ir_node *node) {
660 assert (node->op == op_Const);
661 return get_irn_const_attr(node);
665 set_Const_tarval (ir_node *node, tarval *con) {
666 assert (node->op == op_Const);
667 node->attr.con = con;
671 get_SymConst_kind (ir_node *node) {
672 assert (node->op == op_SymConst);
673 return node->attr.i.num;
677 set_SymConst_kind (ir_node *node, symconst_kind num) {
678 assert (node->op == op_SymConst);
679 node->attr.i.num = num;
683 get_SymConst_type (ir_node *node) {
684 assert ( (node->op == op_SymConst)
685 && ( get_SymConst_kind(node) == type_tag
686 || get_SymConst_kind(node) == size));
687 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
691 set_SymConst_type (ir_node *node, type *type) {
692 assert ( (node->op == op_SymConst)
693 && ( get_SymConst_kind(node) == type_tag
694 || get_SymConst_kind(node) == size));
695 node->attr.i.tori.typ = type;
699 get_SymConst_ptrinfo (ir_node *node) {
700 assert ( (node->op == op_SymConst)
701 && (get_SymConst_kind(node) == linkage_ptr_info));
702 return node->attr.i.tori.ptrinfo;
706 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
707 assert ( (node->op == op_SymConst)
708 && (get_SymConst_kind(node) == linkage_ptr_info));
709 node->attr.i.tori.ptrinfo = ptrinfo;
713 get_SymConst_type_or_id (ir_node *node) {
714 assert (node->op == op_SymConst);
715 return &(node->attr.i.tori);
719 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
720 assert (node->op == op_SymConst);
721 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
725 get_Sel_mem (ir_node *node) {
726 assert (node->op == op_Sel);
727 return get_irn_n(node, 0);
731 set_Sel_mem (ir_node *node, ir_node *mem) {
732 assert (node->op == op_Sel);
733 set_irn_n(node, 0, mem);
737 get_Sel_ptr (ir_node *node) {
738 assert (node->op == op_Sel);
739 return get_irn_n(node, 1);
743 set_Sel_ptr (ir_node *node, ir_node *ptr) {
744 assert (node->op == op_Sel);
745 set_irn_n(node, 1, ptr);
749 get_Sel_index_arr (ir_node *node)
751 assert ((node->op == op_Sel));
752 if (get_Sel_n_index(node) > 0)
753 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
759 get_Sel_n_index (ir_node *node) {
760 assert (node->op == op_Sel);
761 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
766 set_Sel_n_index (ir_node *node, int n_index) {
767 assert (node->op == op_Sel);
772 get_Sel_index (ir_node *node, int pos) {
773 assert (node->op == op_Sel);
774 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
778 set_Sel_index (ir_node *node, int pos, ir_node *index) {
779 assert (node->op == op_Sel);
780 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
784 get_Sel_entity (ir_node *node) {
785 assert (node->op == op_Sel);
786 return node->attr.s.ent;
790 set_Sel_entity (ir_node *node, entity *ent) {
791 assert (node->op == op_Sel);
792 node->attr.s.ent = ent;
796 get_Sel_linkage_type (ir_node *node) {
797 assert (node->op == op_Sel);
798 return node->attr.s.ltyp;
802 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
803 assert (node->op == op_Sel);
804 node->attr.s.ltyp = lt;
808 get_Call_mem (ir_node *node) {
809 assert (node->op == op_Call);
810 return get_irn_n(node, 0);
814 set_Call_mem (ir_node *node, ir_node *mem) {
815 assert (node->op == op_Call);
816 set_irn_n(node, 0, mem);
820 get_Call_ptr (ir_node *node) {
821 assert (node->op == op_Call);
822 return get_irn_n(node, 1);
826 set_Call_ptr (ir_node *node, ir_node *ptr) {
827 assert (node->op == op_Call);
828 set_irn_n(node, 1, ptr);
832 get_Call_param_arr (ir_node *node) {
833 assert (node->op == op_Call);
834 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
838 get_Call_n_params (ir_node *node) {
839 assert (node->op == op_Call);
840 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
844 get_Call_arity (ir_node *node) {
845 assert (node->op == op_Call);
846 return get_Call_n_params(node);
850 set_Call_arity (ir_node *node, ir_node *arity) {
851 assert (node->op == op_Call);
856 get_Call_param (ir_node *node, int pos) {
857 assert (node->op == op_Call);
858 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
862 set_Call_param (ir_node *node, int pos, ir_node *param) {
863 assert (node->op == op_Call);
864 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
868 get_Call_type (ir_node *node) {
869 assert (node->op == op_Call);
870 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
874 set_Call_type (ir_node *node, type *type) {
875 assert (node->op == op_Call);
876 assert (is_method_type(type));
877 node->attr.call.cld_tp = type;
880 /* For unary and binary arithmetic operations the access to the
881 operands can be factored out. Left is the first, right the
882 second arithmetic value as listed in tech report 0999-33.
883 unops are: Minus, Abs, Not, Conv
884 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
885 Shr, Shrs, Rotate, Cmp */
888 is_unop (ir_node *node) {
889 return ( node->op == op_Minus ||
890 node->op == op_Abs ||
891 node->op == op_Not ||
892 node->op == op_Conv );
896 get_unop_op (ir_node *node) {
897 assert ( node->op == op_Minus ||
898 node->op == op_Abs ||
899 node->op == op_Not ||
900 node->op == op_Conv );
901 switch (get_irn_opcode (node)) {
902 case iro_Minus: return get_Minus_op(node); break;
903 case iro_Abs: return get_Abs_op(node); break;
904 case iro_Not: return get_Not_op(node); break;
905 case iro_Conv: return get_Conv_op(node); break;
906 default: return NULL;
911 set_unop_op (ir_node *node, ir_node *op) {
912 assert (node->op == op_Minus ||
913 node->op == op_Abs ||
914 node->op == op_Not ||
915 node->op == op_Conv );
916 switch (get_irn_opcode (node)) {
917 case iro_Minus: set_Minus_op(node, op); break;
918 case iro_Abs: set_Abs_op(node, op); break;
919 case iro_Not: set_Not_op(node, op); break;
920 case iro_Conv: set_Conv_op(node, op); break;
927 is_binop (ir_node *node) {
928 return (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 );
946 get_binop_left (ir_node *node) {
947 assert (node->op == op_Add ||
948 node->op == op_Sub ||
949 node->op == op_Mul ||
950 node->op == op_Quot ||
951 node->op == op_DivMod ||
952 node->op == op_Div ||
953 node->op == op_Mod ||
954 node->op == op_And ||
956 node->op == op_Eor ||
957 node->op == op_Shl ||
958 node->op == op_Shr ||
959 node->op == op_Shrs ||
960 node->op == op_Rot ||
961 node->op == op_Cmp );
963 switch (get_irn_opcode (node)) {
964 case iro_Add : return get_Add_left(node); break;
965 case iro_Sub : return get_Sub_left(node); break;
966 case iro_Mul : return get_Mul_left(node); break;
967 case iro_Quot : return get_Quot_left(node); break;
968 case iro_DivMod: return get_DivMod_left(node); break;
969 case iro_Div : return get_Div_left(node); break;
970 case iro_Mod : return get_Mod_left(node); break;
971 case iro_And : return get_And_left(node); break;
972 case iro_Or : return get_Or_left(node); break;
973 case iro_Eor : return get_Eor_left(node); break;
974 case iro_Shl : return get_Shl_left(node); break;
975 case iro_Shr : return get_Shr_left(node); break;
976 case iro_Shrs : return get_Shrs_left(node); break;
977 case iro_Rot : return get_Rot_left(node); break;
978 case iro_Cmp : return get_Cmp_left(node); break;
979 default: return NULL;
984 set_binop_left (ir_node *node, ir_node *left) {
985 assert (node->op == op_Add ||
986 node->op == op_Sub ||
987 node->op == op_Mul ||
988 node->op == op_Quot ||
989 node->op == op_DivMod ||
990 node->op == op_Div ||
991 node->op == op_Mod ||
992 node->op == op_And ||
994 node->op == op_Eor ||
995 node->op == op_Shl ||
996 node->op == op_Shr ||
997 node->op == op_Shrs ||
998 node->op == op_Rot ||
999 node->op == op_Cmp );
1001 switch (get_irn_opcode (node)) {
1002 case iro_Add : set_Add_left(node, left); break;
1003 case iro_Sub : set_Sub_left(node, left); break;
1004 case iro_Mul : set_Mul_left(node, left); break;
1005 case iro_Quot : set_Quot_left(node, left); break;
1006 case iro_DivMod: set_DivMod_left(node, left); break;
1007 case iro_Div : set_Div_left(node, left); break;
1008 case iro_Mod : set_Mod_left(node, left); break;
1009 case iro_And : set_And_left(node, left); break;
1010 case iro_Or : set_Or_left(node, left); break;
1011 case iro_Eor : set_Eor_left(node, left); break;
1012 case iro_Shl : set_Shl_left(node, left); break;
1013 case iro_Shr : set_Shr_left(node, left); break;
1014 case iro_Shrs : set_Shrs_left(node, left); break;
1015 case iro_Rot : set_Rot_left(node, left); break;
1016 case iro_Cmp : set_Cmp_left(node, left); break;
1022 get_binop_right (ir_node *node) {
1023 assert (node->op == op_Add ||
1024 node->op == op_Sub ||
1025 node->op == op_Mul ||
1026 node->op == op_Quot ||
1027 node->op == op_DivMod ||
1028 node->op == op_Div ||
1029 node->op == op_Mod ||
1030 node->op == op_And ||
1031 node->op == op_Or ||
1032 node->op == op_Eor ||
1033 node->op == op_Shl ||
1034 node->op == op_Shr ||
1035 node->op == op_Shrs ||
1036 node->op == op_Rot ||
1037 node->op == op_Cmp );
1039 switch (get_irn_opcode (node)) {
1040 case iro_Add : return get_Add_right(node); break;
1041 case iro_Sub : return get_Sub_right(node); break;
1042 case iro_Mul : return get_Mul_right(node); break;
1043 case iro_Quot : return get_Quot_right(node); break;
1044 case iro_DivMod: return get_DivMod_right(node); break;
1045 case iro_Div : return get_Div_right(node); break;
1046 case iro_Mod : return get_Mod_right(node); break;
1047 case iro_And : return get_And_right(node); break;
1048 case iro_Or : return get_Or_right(node); break;
1049 case iro_Eor : return get_Eor_right(node); break;
1050 case iro_Shl : return get_Shl_right(node); break;
1051 case iro_Shr : return get_Shr_right(node); break;
1052 case iro_Shrs : return get_Shrs_right(node); break;
1053 case iro_Rot : return get_Rot_right(node); break;
1054 case iro_Cmp : return get_Cmp_right(node); break;
1055 default: return NULL;
1060 set_binop_right (ir_node *node, ir_node *right) {
1061 assert (node->op == op_Add ||
1062 node->op == op_Sub ||
1063 node->op == op_Mul ||
1064 node->op == op_Quot ||
1065 node->op == op_DivMod ||
1066 node->op == op_Div ||
1067 node->op == op_Mod ||
1068 node->op == op_And ||
1069 node->op == op_Or ||
1070 node->op == op_Eor ||
1071 node->op == op_Shl ||
1072 node->op == op_Shr ||
1073 node->op == op_Shrs ||
1074 node->op == op_Rot ||
1075 node->op == op_Cmp );
1077 switch (get_irn_opcode (node)) {
1078 case iro_Add : set_Add_right(node, right); break;
1079 case iro_Sub : set_Sub_right(node, right); break;
1080 case iro_Mul : set_Mul_right(node, right); break;
1081 case iro_Quot : set_Quot_right(node, right); break;
1082 case iro_DivMod: set_DivMod_right(node, right); break;
1083 case iro_Div : set_Div_right(node, right); break;
1084 case iro_Mod : set_Mod_right(node, right); break;
1085 case iro_And : set_And_right(node, right); break;
1086 case iro_Or : set_Or_right(node, right); break;
1087 case iro_Eor : set_Eor_right(node, right); break;
1088 case iro_Shl : set_Shl_right(node, right); break;
1089 case iro_Shr : set_Shr_right(node, right); break;
1090 case iro_Shrs : set_Shrs_right(node, right); break;
1091 case iro_Rot : set_Rot_right(node, right); break;
1092 case iro_Cmp : set_Cmp_right(node, right); break;
1098 get_Add_left (ir_node *node) {
1099 assert (node->op == op_Add);
1100 return get_irn_n(node, 0);
1104 set_Add_left (ir_node *node, ir_node *left) {
1105 assert (node->op == op_Add);
1106 set_irn_n(node, 0, left);
1110 get_Add_right (ir_node *node) {
1111 assert (node->op == op_Add);
1112 return get_irn_n(node, 1);
1116 set_Add_right (ir_node *node, ir_node *right) {
1117 assert (node->op == op_Add);
1118 set_irn_n(node, 1, right);
1122 get_Sub_left (ir_node *node) {
1123 assert (node->op == op_Sub);
1124 return get_irn_n(node, 0);
1128 set_Sub_left (ir_node *node, ir_node *left) {
1129 assert (node->op == op_Sub);
1130 set_irn_n(node, 0, left);
1134 get_Sub_right (ir_node *node) {
1135 assert (node->op == op_Sub);
1136 return get_irn_n(node, 1);
1140 set_Sub_right (ir_node *node, ir_node *right) {
1141 assert (node->op == op_Sub);
1142 set_irn_n(node, 1, right);
1147 get_Minus_op (ir_node *node) {
1148 assert (node->op == op_Minus);
1149 return get_irn_n(node, 0);
1153 set_Minus_op (ir_node *node, ir_node *op) {
1154 assert (node->op == op_Minus);
1155 set_irn_n(node, 0, op);
1160 get_Mul_left (ir_node *node) {
1161 assert (node->op == op_Mul);
1162 return get_irn_n(node, 0);
1166 set_Mul_left (ir_node *node, ir_node *left) {
1167 assert (node->op == op_Mul);
1168 set_irn_n(node, 0, left);
1172 get_Mul_right (ir_node *node) {
1173 assert (node->op == op_Mul);
1174 return get_irn_n(node, 1);
1178 set_Mul_right (ir_node *node, ir_node *right) {
1179 assert (node->op == op_Mul);
1180 set_irn_n(node, 1, right);
1184 get_Quot_left (ir_node *node) {
1185 assert (node->op == op_Quot);
1186 return get_irn_n(node, 1);
1190 set_Quot_left (ir_node *node, ir_node *left) {
1191 assert (node->op == op_Quot);
1192 set_irn_n(node, 1, left);
1196 get_Quot_right (ir_node *node) {
1197 assert (node->op == op_Quot);
1198 return get_irn_n(node, 2);
1202 set_Quot_right (ir_node *node, ir_node *right) {
1203 assert (node->op == op_Quot);
1204 set_irn_n(node, 2, right);
1208 get_Quot_mem (ir_node *node) {
1209 assert (node->op == op_Quot);
1210 return get_irn_n(node, 0);
1214 set_Quot_mem (ir_node *node, ir_node *mem) {
1215 assert (node->op == op_Quot);
1216 set_irn_n(node, 0, mem);
1220 get_DivMod_left (ir_node *node) {
1221 assert (node->op == op_DivMod);
1222 return get_irn_n(node, 1);
1226 set_DivMod_left (ir_node *node, ir_node *left) {
1227 assert (node->op == op_DivMod);
1228 set_irn_n(node, 1, left);
1232 get_DivMod_right (ir_node *node) {
1233 assert (node->op == op_DivMod);
1234 return get_irn_n(node, 2);
1238 set_DivMod_right (ir_node *node, ir_node *right) {
1239 assert (node->op == op_DivMod);
1240 set_irn_n(node, 2, right);
1244 get_DivMod_mem (ir_node *node) {
1245 assert (node->op == op_DivMod);
1246 return get_irn_n(node, 0);
1250 set_DivMod_mem (ir_node *node, ir_node *mem) {
1251 assert (node->op == op_DivMod);
1252 set_irn_n(node, 0, mem);
1256 get_Div_left (ir_node *node) {
1257 assert (node->op == op_Div);
1258 return get_irn_n(node, 1);
1262 set_Div_left (ir_node *node, ir_node *left) {
1263 assert (node->op == op_Div);
1264 set_irn_n(node, 1, left);
1268 get_Div_right (ir_node *node) {
1269 assert (node->op == op_Div);
1270 return get_irn_n(node, 2);
1274 set_Div_right (ir_node *node, ir_node *right) {
1275 assert (node->op == op_Div);
1276 set_irn_n(node, 2, right);
1280 get_Div_mem (ir_node *node) {
1281 assert (node->op == op_Div);
1282 return get_irn_n(node, 0);
1286 set_Div_mem (ir_node *node, ir_node *mem) {
1287 assert (node->op == op_Div);
1288 set_irn_n(node, 0, mem);
1292 get_Mod_left (ir_node *node) {
1293 assert (node->op == op_Mod);
1294 return get_irn_n(node, 1);
1298 set_Mod_left (ir_node *node, ir_node *left) {
1299 assert (node->op == op_Mod);
1300 set_irn_n(node, 1, left);
1304 get_Mod_right (ir_node *node) {
1305 assert (node->op == op_Mod);
1306 return get_irn_n(node, 2);
1310 set_Mod_right (ir_node *node, ir_node *right) {
1311 assert (node->op == op_Mod);
1312 set_irn_n(node, 2, right);
1316 get_Mod_mem (ir_node *node) {
1317 assert (node->op == op_Mod);
1318 return get_irn_n(node, 0);
1322 set_Mod_mem (ir_node *node, ir_node *mem) {
1323 assert (node->op == op_Mod);
1324 set_irn_n(node, 0, mem);
1328 get_Abs_op (ir_node *node) {
1329 assert (node->op == op_Abs);
1330 return get_irn_n(node, 0);
1334 set_Abs_op (ir_node *node, ir_node *op) {
1335 assert (node->op == op_Abs);
1336 set_irn_n(node, 0, op);
1340 get_And_left (ir_node *node) {
1341 assert (node->op == op_And);
1342 return get_irn_n(node, 0);
1346 set_And_left (ir_node *node, ir_node *left) {
1347 assert (node->op == op_And);
1348 set_irn_n(node, 0, left);
1352 get_And_right (ir_node *node) {
1353 assert (node->op == op_And);
1354 return get_irn_n(node, 1);
1358 set_And_right (ir_node *node, ir_node *right) {
1359 assert (node->op == op_And);
1360 set_irn_n(node, 1, right);
1364 get_Or_left (ir_node *node) {
1365 assert (node->op == op_Or);
1366 return get_irn_n(node, 0);
1370 set_Or_left (ir_node *node, ir_node *left) {
1371 assert (node->op == op_Or);
1372 set_irn_n(node, 0, left);
1376 get_Or_right (ir_node *node) {
1377 assert (node->op == op_Or);
1378 return get_irn_n(node, 1);
1382 set_Or_right (ir_node *node, ir_node *right) {
1383 assert (node->op == op_Or);
1384 set_irn_n(node, 1, right);
1388 get_Eor_left (ir_node *node) {
1389 assert (node->op == op_Eor);
1390 return get_irn_n(node, 0);
1394 set_Eor_left (ir_node *node, ir_node *left) {
1395 assert (node->op == op_Eor);
1396 set_irn_n(node, 0, left);
1400 get_Eor_right (ir_node *node) {
1401 assert (node->op == op_Eor);
1402 return get_irn_n(node, 1);
1406 set_Eor_right (ir_node *node, ir_node *right) {
1407 assert (node->op == op_Eor);
1408 set_irn_n(node, 1, right);
1413 get_Not_op (ir_node *node) {
1414 assert (node->op == op_Not);
1415 return get_irn_n(node, 0);
1419 set_Not_op (ir_node *node, ir_node *op) {
1420 assert (node->op == op_Not);
1421 set_irn_n(node, 0, op);
1426 get_Shl_left (ir_node *node) {
1427 assert (node->op == op_Shl);
1428 return get_irn_n(node, 0);
1432 set_Shl_left (ir_node *node, ir_node *left) {
1433 assert (node->op == op_Shl);
1434 set_irn_n(node, 0, left);
1438 get_Shl_right (ir_node *node) {
1439 assert (node->op == op_Shl);
1440 return get_irn_n(node, 1);
1444 set_Shl_right (ir_node *node, ir_node *right) {
1445 assert (node->op == op_Shl);
1446 set_irn_n(node, 1, right);
1450 get_Shr_left (ir_node *node) {
1451 assert (node->op == op_Shr);
1452 return get_irn_n(node, 0);
1456 set_Shr_left (ir_node *node, ir_node *left) {
1457 assert (node->op == op_Shr);
1458 set_irn_n(node, 0, left);
1462 get_Shr_right (ir_node *node) {
1463 assert (node->op == op_Shr);
1464 return get_irn_n(node, 1);
1468 set_Shr_right (ir_node *node, ir_node *right) {
1469 assert (node->op == op_Shr);
1470 set_irn_n(node, 1, right);
1474 get_Shrs_left (ir_node *node) {
1475 assert (node->op == op_Shrs);
1476 return get_irn_n(node, 0);
1480 set_Shrs_left (ir_node *node, ir_node *left) {
1481 assert (node->op == op_Shrs);
1482 set_irn_n(node, 0, left);
1486 get_Shrs_right (ir_node *node) {
1487 assert (node->op == op_Shrs);
1488 return get_irn_n(node, 1);
1492 set_Shrs_right (ir_node *node, ir_node *right) {
1493 assert (node->op == op_Shrs);
1494 set_irn_n(node, 1, right);
1498 get_Rot_left (ir_node *node) {
1499 assert (node->op == op_Rot);
1500 return get_irn_n(node, 0);
1504 set_Rot_left (ir_node *node, ir_node *left) {
1505 assert (node->op == op_Rot);
1506 set_irn_n(node, 0, left);
1510 get_Rot_right (ir_node *node) {
1511 assert (node->op == op_Rot);
1512 return get_irn_n(node, 1);
1516 set_Rot_right (ir_node *node, ir_node *right) {
1517 assert (node->op == op_Rot);
1518 set_irn_n(node, 1, right);
1522 get_Cmp_left (ir_node *node) {
1523 assert (node->op == op_Cmp);
1524 return get_irn_n(node, 0);
1528 set_Cmp_left (ir_node *node, ir_node *left) {
1529 assert (node->op == op_Cmp);
1530 set_irn_n(node, 0, left);
1534 get_Cmp_right (ir_node *node) {
1535 assert (node->op == op_Cmp);
1536 return get_irn_n(node, 1);
1540 set_Cmp_right (ir_node *node, ir_node *right) {
1541 assert (node->op == op_Cmp);
1542 set_irn_n(node, 1, right);
1546 get_Conv_op (ir_node *node) {
1547 assert (node->op == op_Conv);
1548 return get_irn_n(node, 0);
1552 set_Conv_op (ir_node *node, ir_node *op) {
1553 assert (node->op == op_Conv);
1554 set_irn_n(node, 0, op);
1558 get_Phi_preds_arr (ir_node *node) {
1559 assert (node->op == op_Phi);
1560 return (ir_node **)&(get_irn_in(node)[1]);
1564 get_Phi_n_preds (ir_node *node) {
1565 assert (node->op == op_Phi);
1566 return (get_irn_arity(node));
1570 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1571 assert (node->op == op_Phi);
1576 get_Phi_pred (ir_node *node, int pos) {
1577 assert (node->op == op_Phi);
1578 return get_irn_n(node, pos);
1582 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1583 assert (node->op == op_Phi);
1584 set_irn_n(node, pos, pred);
1588 get_Load_mem (ir_node *node) {
1589 assert (node->op == op_Load);
1590 return get_irn_n(node, 0);
1594 set_Load_mem (ir_node *node, ir_node *mem) {
1595 assert (node->op == op_Load);
1596 set_irn_n(node, 0, mem);
1600 get_Load_ptr (ir_node *node) {
1601 assert (node->op == op_Load);
1602 return get_irn_n(node, 1);
1606 set_Load_ptr (ir_node *node, ir_node *ptr) {
1607 assert (node->op == op_Load);
1608 set_irn_n(node, 1, ptr);
1613 get_Store_mem (ir_node *node) {
1614 assert (node->op == op_Store);
1615 return get_irn_n(node, 0);
1619 set_Store_mem (ir_node *node, ir_node *mem) {
1620 assert (node->op == op_Store);
1621 set_irn_n(node, 0, mem);
1625 get_Store_ptr (ir_node *node) {
1626 assert (node->op == op_Store);
1627 return get_irn_n(node, 1);
1631 set_Store_ptr (ir_node *node, ir_node *ptr) {
1632 assert (node->op == op_Store);
1633 set_irn_n(node, 1, ptr);
1637 get_Store_value (ir_node *node) {
1638 assert (node->op == op_Store);
1639 return get_irn_n(node, 2);
1643 set_Store_value (ir_node *node, ir_node *value) {
1644 assert (node->op == op_Store);
1645 set_irn_n(node, 2, value);
1649 get_Alloc_mem (ir_node *node) {
1650 assert (node->op == op_Alloc);
1651 return get_irn_n(node, 0);
1655 set_Alloc_mem (ir_node *node, ir_node *mem) {
1656 assert (node->op == op_Alloc);
1657 set_irn_n(node, 0, mem);
1661 get_Alloc_size (ir_node *node) {
1662 assert (node->op == op_Alloc);
1663 return get_irn_n(node, 1);
1667 set_Alloc_size (ir_node *node, ir_node *size) {
1668 assert (node->op == op_Alloc);
1669 set_irn_n(node, 1, size);
1673 get_Alloc_type (ir_node *node) {
1674 assert (node->op == op_Alloc);
1675 return node->attr.a.type = skip_tid(node->attr.a.type);
1679 set_Alloc_type (ir_node *node, type *type) {
1680 assert (node->op == op_Alloc);
1681 node->attr.a.type = type;
1685 get_Alloc_where (ir_node *node) {
1686 assert (node->op == op_Alloc);
1687 return node->attr.a.where;
1691 set_Alloc_where (ir_node *node, where_alloc where) {
1692 assert (node->op == op_Alloc);
1693 node->attr.a.where = where;
1698 get_Free_mem (ir_node *node) {
1699 assert (node->op == op_Free);
1700 return get_irn_n(node, 0);
1704 set_Free_mem (ir_node *node, ir_node *mem) {
1705 assert (node->op == op_Free);
1706 set_irn_n(node, 0, mem);
1710 get_Free_ptr (ir_node *node) {
1711 assert (node->op == op_Free);
1712 return get_irn_n(node, 1);
1716 set_Free_ptr (ir_node *node, ir_node *ptr) {
1717 assert (node->op == op_Free);
1718 set_irn_n(node, 1, ptr);
1722 get_Free_size (ir_node *node) {
1723 assert (node->op == op_Free);
1724 return get_irn_n(node, 2);
1728 set_Free_size (ir_node *node, ir_node *size) {
1729 assert (node->op == op_Free);
1730 set_irn_n(node, 2, size);
1734 get_Free_type (ir_node *node) {
1735 assert (node->op == op_Free);
1736 return node->attr.f = skip_tid(node->attr.f);
1740 set_Free_type (ir_node *node, type *type) {
1741 assert (node->op == op_Free);
1742 node->attr.f = type;
1746 get_Sync_preds_arr (ir_node *node) {
1747 assert (node->op == op_Sync);
1748 return (ir_node **)&(get_irn_in(node)[1]);
1752 get_Sync_n_preds (ir_node *node) {
1753 assert (node->op == op_Sync);
1754 return (get_irn_arity(node));
1759 set_Sync_n_preds (ir_node *node, int n_preds) {
1760 assert (node->op == op_Sync);
1765 get_Sync_pred (ir_node *node, int pos) {
1766 assert (node->op == op_Sync);
1767 return get_irn_n(node, pos);
1771 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1772 assert (node->op == op_Sync);
1773 set_irn_n(node, pos, pred);
1777 get_Proj_pred (ir_node *node) {
1778 assert (node->op == op_Proj);
1779 return get_irn_n(node, 0);
1783 set_Proj_pred (ir_node *node, ir_node *pred) {
1784 assert (node->op == op_Proj);
1785 set_irn_n(node, 0, pred);
1789 get_Proj_proj (ir_node *node) {
1790 assert (node->op == op_Proj);
1791 return node->attr.proj;
1795 set_Proj_proj (ir_node *node, long proj) {
1796 assert (node->op == op_Proj);
1797 node->attr.proj = proj;
1801 get_Tuple_preds_arr (ir_node *node) {
1802 assert (node->op == op_Tuple);
1803 return (ir_node **)&(get_irn_in(node)[1]);
1807 get_Tuple_n_preds (ir_node *node) {
1808 assert (node->op == op_Tuple);
1809 return (get_irn_arity(node));
1814 set_Tuple_n_preds (ir_node *node, int n_preds) {
1815 assert (node->op == op_Tuple);
1820 get_Tuple_pred (ir_node *node, int pos) {
1821 assert (node->op == op_Tuple);
1822 return get_irn_n(node, pos);
1826 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1827 assert (node->op == op_Tuple);
1828 set_irn_n(node, pos, pred);
1832 get_Id_pred (ir_node *node) {
1833 assert (node->op == op_Id);
1834 return get_irn_n(node, 0);
1838 set_Id_pred (ir_node *node, ir_node *pred) {
1839 assert (node->op == op_Id);
1840 set_irn_n(node, 0, pred);
1843 /******************************************************************/
1844 /* Auxiliary routines */
1845 /******************************************************************/
1848 skip_Proj (ir_node *node) {
1849 /* don't assert node !!! */
1850 if (node && (node->op == op_Proj)) {
1851 return get_Proj_pred(node);
1858 skip_Tuple (ir_node *node) {
1861 node = skip_nop(node);
1862 if (get_irn_op(node) == op_Proj) {
1863 pred = skip_nop(get_Proj_pred(node));
1864 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
1865 pred = skip_nop(skip_Tuple(pred));
1866 if (get_irn_op(pred) == op_Tuple)
1867 return get_Tuple_pred(pred, get_Proj_proj(node));
1873 skip_nop (ir_node *node) {
1874 /* don't assert node !!! */
1876 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1877 /* Don't use get_Id_pred: We get into an endless loop for
1878 self-referencing Ids. */
1879 assert (get_irn_arity (node) > 0);
1880 return node->in[0+1];
1887 skip_Id (ir_node *node) {
1888 return skip_nop(node);
1892 is_Bad (ir_node *node) {
1894 if ((node) && get_irn_opcode(node) == iro_Bad)
1900 is_no_Block (ir_node *node) {
1902 return (get_irn_opcode(node) != iro_Block);
1905 /* Returns true if the operation manipulates control flow. */
1907 is_cfop(ir_node *node) {
1908 return is_cfopcode(get_irn_op(node));
1911 /* Returns true if the operation can change the control flow because
1914 is_fragile_op(ir_node *node) {
1915 return ( (get_irn_opcode(node) == iro_Call)
1916 || (get_irn_opcode(node) == iro_Quot)
1917 || (get_irn_opcode(node) == iro_DivMod)
1918 || (get_irn_opcode(node) == iro_Div)
1919 || (get_irn_opcode(node) == iro_Mod)
1920 || (get_irn_opcode(node) == iro_Load)
1921 || (get_irn_opcode(node) == iro_Store)
1922 || (get_irn_opcode(node) == iro_Alloc)
1923 || (get_irn_opcode(node) == iro_Bad));
1927 /* Returns the memory operand of fragile operations. */
1928 ir_node *get_fragile_op_mem(ir_node *node) {
1929 assert(node && is_fragile_op(node));
1931 switch (get_irn_opcode (node)) {
1940 return get_irn_n(node, 0);