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;
497 void set_Block_exc (ir_node *block, exc_t exc)
499 block->attr.block.exc = exc;
502 exc_t get_Block_exc (ir_node *block)
504 return (block->attr.block.exc);
508 get_End_n_keepalives(ir_node *end) {
509 assert (end->op == op_End);
510 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
514 get_End_keepalive(ir_node *end, int pos) {
515 assert (end->op == op_End);
516 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
520 add_End_keepalive (ir_node *end, ir_node *ka) {
521 assert (end->op == op_End);
522 ARR_APP1 (ir_node *, end->in, ka);
526 free_End (ir_node *end) {
527 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
528 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
532 > Implementing the case construct (which is where the constant Proj node is
533 > important) involves far more than simply determining the constant values.
534 > We could argue that this is more properly a function of the translator from
535 > Firm to the target machine. That could be done if there was some way of
536 > projecting "default" out of the Cond node.
537 I know it's complicated.
538 Basically there are two proglems:
539 - determining the gaps between the projs
540 - determining the biggest case constant to konw the proj number for
542 I see several solutions:
543 1. Introduce a ProjDefault node. Solves both problems.
544 This means to extend all optimizations executed during construction.
545 2. Give the Cond node for switch two flavors:
546 a) there are no gaps in the projs (existing flavor)
547 b) gaps may exist, default proj is still the Proj with the largest
548 projection number. This covers also the gaps.
549 3. Fix the semantic of the Cond to that of 2b)
551 Solution 2 seems to be the best:
552 Computing the gaps in the Firm representation is not too hard, i.e.,
553 libfirm can implement a routine that transforms betweeen the two
554 flavours. This is also possible for 1) but 2) does not require to
555 change any existing optimization.
556 Further it should be far simpler to determine the biggest constant than
558 I don't want to choose 3) as 2a) seems to have advantages for
559 dataflow analysis and 3) does not allow to convert the representation to
563 get_Cond_selector (ir_node *node) {
564 assert (node->op == op_Cond);
565 return get_irn_n(node, 0);
569 set_Cond_selector (ir_node *node, ir_node *selector) {
570 assert (node->op == op_Cond);
571 set_irn_n(node, 0, selector);
575 get_Cond_kind (ir_node *node) {
576 assert (node->op == op_Cond);
577 return node->attr.c.kind;
581 set_Cond_kind (ir_node *node, cond_kind kind) {
582 assert (node->op == op_Cond);
583 node->attr.c.kind = kind;
587 get_Return_mem (ir_node *node) {
588 assert (node->op == op_Return);
589 return get_irn_n(node, 0);
593 set_Return_mem (ir_node *node, ir_node *mem) {
594 assert (node->op == op_Return);
595 set_irn_n(node, 0, mem);
599 get_Return_res_arr (ir_node *node)
601 assert ((node->op == op_Return));
602 if (get_Return_n_res(node) > 0)
603 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
609 get_Return_n_res (ir_node *node) {
610 assert (node->op == op_Return);
611 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
616 set_Return_n_res (ir_node *node, int results) {
617 assert (node->op == op_Return);
622 get_Return_res (ir_node *node, int pos) {
623 assert (node->op == op_Return);
624 assert (get_Return_n_res(node) > pos);
625 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
629 set_Return_res (ir_node *node, int pos, ir_node *res){
630 assert (node->op == op_Return);
631 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
635 get_Raise_mem (ir_node *node) {
636 assert (node->op == op_Return);
637 return get_irn_n(node, 0);
641 set_Raise_mem (ir_node *node, ir_node *mem) {
642 assert (node->op == op_Raise);
643 set_irn_n(node, 0, mem);
647 get_Raise_exo_ptr (ir_node *node) {
648 assert (node->op == op_Raise);
649 return get_irn_n(node, 1);
653 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
654 assert (node->op == op_Raise);
655 set_irn_n(node, 1, exo_ptr);
658 inline tarval *get_Const_tarval (ir_node *node) {
659 assert (node->op == op_Const);
660 return get_irn_const_attr(node);
664 set_Const_tarval (ir_node *node, tarval *con) {
665 assert (node->op == op_Const);
666 node->attr.con = con;
670 get_SymConst_kind (ir_node *node) {
671 assert (node->op == op_SymConst);
672 return node->attr.i.num;
676 set_SymConst_kind (ir_node *node, symconst_kind num) {
677 assert (node->op == op_SymConst);
678 node->attr.i.num = num;
682 get_SymConst_type (ir_node *node) {
683 assert ( (node->op == op_SymConst)
684 && ( get_SymConst_kind(node) == type_tag
685 || get_SymConst_kind(node) == size));
686 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
690 set_SymConst_type (ir_node *node, type *type) {
691 assert ( (node->op == op_SymConst)
692 && ( get_SymConst_kind(node) == type_tag
693 || get_SymConst_kind(node) == size));
694 node->attr.i.tori.typ = type;
698 get_SymConst_ptrinfo (ir_node *node) {
699 assert ( (node->op == op_SymConst)
700 && (get_SymConst_kind(node) == linkage_ptr_info));
701 return node->attr.i.tori.ptrinfo;
705 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
706 assert ( (node->op == op_SymConst)
707 && (get_SymConst_kind(node) == linkage_ptr_info));
708 node->attr.i.tori.ptrinfo = ptrinfo;
712 get_SymConst_type_or_id (ir_node *node) {
713 assert (node->op == op_SymConst);
714 return &(node->attr.i.tori);
718 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
719 assert (node->op == op_SymConst);
720 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
724 get_Sel_mem (ir_node *node) {
725 assert (node->op == op_Sel);
726 return get_irn_n(node, 0);
730 set_Sel_mem (ir_node *node, ir_node *mem) {
731 assert (node->op == op_Sel);
732 set_irn_n(node, 0, mem);
736 get_Sel_ptr (ir_node *node) {
737 assert (node->op == op_Sel);
738 return get_irn_n(node, 1);
742 set_Sel_ptr (ir_node *node, ir_node *ptr) {
743 assert (node->op == op_Sel);
744 set_irn_n(node, 1, ptr);
748 get_Sel_index_arr (ir_node *node)
750 assert ((node->op == op_Sel));
751 if (get_Sel_n_index(node) > 0)
752 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
758 get_Sel_n_index (ir_node *node) {
759 assert (node->op == op_Sel);
760 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
765 set_Sel_n_index (ir_node *node, int n_index) {
766 assert (node->op == op_Sel);
771 get_Sel_index (ir_node *node, int pos) {
772 assert (node->op == op_Sel);
773 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
777 set_Sel_index (ir_node *node, int pos, ir_node *index) {
778 assert (node->op == op_Sel);
779 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
783 get_Sel_entity (ir_node *node) {
784 assert (node->op == op_Sel);
785 return node->attr.s.ent;
789 set_Sel_entity (ir_node *node, entity *ent) {
790 assert (node->op == op_Sel);
791 node->attr.s.ent = ent;
795 get_Sel_linkage_type (ir_node *node) {
796 assert (node->op == op_Sel);
797 return node->attr.s.ltyp;
801 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
802 assert (node->op == op_Sel);
803 node->attr.s.ltyp = lt;
807 get_Call_mem (ir_node *node) {
808 assert (node->op == op_Call);
809 return get_irn_n(node, 0);
813 set_Call_mem (ir_node *node, ir_node *mem) {
814 assert (node->op == op_Call);
815 set_irn_n(node, 0, mem);
819 get_Call_ptr (ir_node *node) {
820 assert (node->op == op_Call);
821 return get_irn_n(node, 1);
825 set_Call_ptr (ir_node *node, ir_node *ptr) {
826 assert (node->op == op_Call);
827 set_irn_n(node, 1, ptr);
831 get_Call_param_arr (ir_node *node) {
832 assert (node->op == op_Call);
833 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
837 get_Call_n_params (ir_node *node) {
838 assert (node->op == op_Call);
839 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
843 get_Call_arity (ir_node *node) {
844 assert (node->op == op_Call);
845 return get_Call_n_params(node);
849 set_Call_arity (ir_node *node, ir_node *arity) {
850 assert (node->op == op_Call);
855 get_Call_param (ir_node *node, int pos) {
856 assert (node->op == op_Call);
857 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
861 set_Call_param (ir_node *node, int pos, ir_node *param) {
862 assert (node->op == op_Call);
863 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
867 get_Call_type (ir_node *node) {
868 assert (node->op == op_Call);
869 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
873 set_Call_type (ir_node *node, type *type) {
874 assert (node->op == op_Call);
875 assert (is_method_type(type));
876 node->attr.call.cld_tp = type;
879 /* For unary and binary arithmetic operations the access to the
880 operands can be factored out. Left is the first, right the
881 second arithmetic value as listed in tech report 0999-33.
882 unops are: Minus, Abs, Not, Conv
883 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
884 Shr, Shrs, Rotate, Cmp */
887 is_unop (ir_node *node) {
888 return ( node->op == op_Minus ||
889 node->op == op_Abs ||
890 node->op == op_Not ||
891 node->op == op_Conv );
895 get_unop_op (ir_node *node) {
896 assert ( node->op == op_Minus ||
897 node->op == op_Abs ||
898 node->op == op_Not ||
899 node->op == op_Conv );
900 switch (get_irn_opcode (node)) {
901 case iro_Minus: return get_Minus_op(node); break;
902 case iro_Abs: return get_Abs_op(node); break;
903 case iro_Not: return get_Not_op(node); break;
904 case iro_Conv: return get_Conv_op(node); break;
905 default: return NULL;
910 set_unop_op (ir_node *node, ir_node *op) {
911 assert (node->op == op_Minus ||
912 node->op == op_Abs ||
913 node->op == op_Not ||
914 node->op == op_Conv );
915 switch (get_irn_opcode (node)) {
916 case iro_Minus: set_Minus_op(node, op); break;
917 case iro_Abs: set_Abs_op(node, op); break;
918 case iro_Not: set_Not_op(node, op); break;
919 case iro_Conv: set_Conv_op(node, op); break;
926 is_binop (ir_node *node) {
927 return (node->op == op_Add ||
928 node->op == op_Sub ||
929 node->op == op_Mul ||
930 node->op == op_Quot ||
931 node->op == op_DivMod ||
932 node->op == op_Div ||
933 node->op == op_Mod ||
934 node->op == op_And ||
936 node->op == op_Eor ||
937 node->op == op_Shl ||
938 node->op == op_Shr ||
939 node->op == op_Shrs ||
940 node->op == op_Rot ||
941 node->op == op_Cmp );
945 get_binop_left (ir_node *node) {
946 assert (node->op == op_Add ||
947 node->op == op_Sub ||
948 node->op == op_Mul ||
949 node->op == op_Quot ||
950 node->op == op_DivMod ||
951 node->op == op_Div ||
952 node->op == op_Mod ||
953 node->op == op_And ||
955 node->op == op_Eor ||
956 node->op == op_Shl ||
957 node->op == op_Shr ||
958 node->op == op_Shrs ||
959 node->op == op_Rot ||
960 node->op == op_Cmp );
962 switch (get_irn_opcode (node)) {
963 case iro_Add : return get_Add_left(node); break;
964 case iro_Sub : return get_Sub_left(node); break;
965 case iro_Mul : return get_Mul_left(node); break;
966 case iro_Quot : return get_Quot_left(node); break;
967 case iro_DivMod: return get_DivMod_left(node); break;
968 case iro_Div : return get_Div_left(node); break;
969 case iro_Mod : return get_Mod_left(node); break;
970 case iro_And : return get_And_left(node); break;
971 case iro_Or : return get_Or_left(node); break;
972 case iro_Eor : return get_Eor_left(node); break;
973 case iro_Shl : return get_Shl_left(node); break;
974 case iro_Shr : return get_Shr_left(node); break;
975 case iro_Shrs : return get_Shrs_left(node); break;
976 case iro_Rot : return get_Rot_left(node); break;
977 case iro_Cmp : return get_Cmp_left(node); break;
978 default: return NULL;
983 set_binop_left (ir_node *node, ir_node *left) {
984 assert (node->op == op_Add ||
985 node->op == op_Sub ||
986 node->op == op_Mul ||
987 node->op == op_Quot ||
988 node->op == op_DivMod ||
989 node->op == op_Div ||
990 node->op == op_Mod ||
991 node->op == op_And ||
993 node->op == op_Eor ||
994 node->op == op_Shl ||
995 node->op == op_Shr ||
996 node->op == op_Shrs ||
997 node->op == op_Rot ||
998 node->op == op_Cmp );
1000 switch (get_irn_opcode (node)) {
1001 case iro_Add : set_Add_left(node, left); break;
1002 case iro_Sub : set_Sub_left(node, left); break;
1003 case iro_Mul : set_Mul_left(node, left); break;
1004 case iro_Quot : set_Quot_left(node, left); break;
1005 case iro_DivMod: set_DivMod_left(node, left); break;
1006 case iro_Div : set_Div_left(node, left); break;
1007 case iro_Mod : set_Mod_left(node, left); break;
1008 case iro_And : set_And_left(node, left); break;
1009 case iro_Or : set_Or_left(node, left); break;
1010 case iro_Eor : set_Eor_left(node, left); break;
1011 case iro_Shl : set_Shl_left(node, left); break;
1012 case iro_Shr : set_Shr_left(node, left); break;
1013 case iro_Shrs : set_Shrs_left(node, left); break;
1014 case iro_Rot : set_Rot_left(node, left); break;
1015 case iro_Cmp : set_Cmp_left(node, left); break;
1021 get_binop_right (ir_node *node) {
1022 assert (node->op == op_Add ||
1023 node->op == op_Sub ||
1024 node->op == op_Mul ||
1025 node->op == op_Quot ||
1026 node->op == op_DivMod ||
1027 node->op == op_Div ||
1028 node->op == op_Mod ||
1029 node->op == op_And ||
1030 node->op == op_Or ||
1031 node->op == op_Eor ||
1032 node->op == op_Shl ||
1033 node->op == op_Shr ||
1034 node->op == op_Shrs ||
1035 node->op == op_Rot ||
1036 node->op == op_Cmp );
1038 switch (get_irn_opcode (node)) {
1039 case iro_Add : return get_Add_right(node); break;
1040 case iro_Sub : return get_Sub_right(node); break;
1041 case iro_Mul : return get_Mul_right(node); break;
1042 case iro_Quot : return get_Quot_right(node); break;
1043 case iro_DivMod: return get_DivMod_right(node); break;
1044 case iro_Div : return get_Div_right(node); break;
1045 case iro_Mod : return get_Mod_right(node); break;
1046 case iro_And : return get_And_right(node); break;
1047 case iro_Or : return get_Or_right(node); break;
1048 case iro_Eor : return get_Eor_right(node); break;
1049 case iro_Shl : return get_Shl_right(node); break;
1050 case iro_Shr : return get_Shr_right(node); break;
1051 case iro_Shrs : return get_Shrs_right(node); break;
1052 case iro_Rot : return get_Rot_right(node); break;
1053 case iro_Cmp : return get_Cmp_right(node); break;
1054 default: return NULL;
1059 set_binop_right (ir_node *node, ir_node *right) {
1060 assert (node->op == op_Add ||
1061 node->op == op_Sub ||
1062 node->op == op_Mul ||
1063 node->op == op_Quot ||
1064 node->op == op_DivMod ||
1065 node->op == op_Div ||
1066 node->op == op_Mod ||
1067 node->op == op_And ||
1068 node->op == op_Or ||
1069 node->op == op_Eor ||
1070 node->op == op_Shl ||
1071 node->op == op_Shr ||
1072 node->op == op_Shrs ||
1073 node->op == op_Rot ||
1074 node->op == op_Cmp );
1076 switch (get_irn_opcode (node)) {
1077 case iro_Add : set_Add_right(node, right); break;
1078 case iro_Sub : set_Sub_right(node, right); break;
1079 case iro_Mul : set_Mul_right(node, right); break;
1080 case iro_Quot : set_Quot_right(node, right); break;
1081 case iro_DivMod: set_DivMod_right(node, right); break;
1082 case iro_Div : set_Div_right(node, right); break;
1083 case iro_Mod : set_Mod_right(node, right); break;
1084 case iro_And : set_And_right(node, right); break;
1085 case iro_Or : set_Or_right(node, right); break;
1086 case iro_Eor : set_Eor_right(node, right); break;
1087 case iro_Shl : set_Shl_right(node, right); break;
1088 case iro_Shr : set_Shr_right(node, right); break;
1089 case iro_Shrs : set_Shrs_right(node, right); break;
1090 case iro_Rot : set_Rot_right(node, right); break;
1091 case iro_Cmp : set_Cmp_right(node, right); break;
1097 get_Add_left (ir_node *node) {
1098 assert (node->op == op_Add);
1099 return get_irn_n(node, 0);
1103 set_Add_left (ir_node *node, ir_node *left) {
1104 assert (node->op == op_Add);
1105 set_irn_n(node, 0, left);
1109 get_Add_right (ir_node *node) {
1110 assert (node->op == op_Add);
1111 return get_irn_n(node, 1);
1115 set_Add_right (ir_node *node, ir_node *right) {
1116 assert (node->op == op_Add);
1117 set_irn_n(node, 1, right);
1121 get_Sub_left (ir_node *node) {
1122 assert (node->op == op_Sub);
1123 return get_irn_n(node, 0);
1127 set_Sub_left (ir_node *node, ir_node *left) {
1128 assert (node->op == op_Sub);
1129 set_irn_n(node, 0, left);
1133 get_Sub_right (ir_node *node) {
1134 assert (node->op == op_Sub);
1135 return get_irn_n(node, 1);
1139 set_Sub_right (ir_node *node, ir_node *right) {
1140 assert (node->op == op_Sub);
1141 set_irn_n(node, 1, right);
1146 get_Minus_op (ir_node *node) {
1147 assert (node->op == op_Minus);
1148 return get_irn_n(node, 0);
1152 set_Minus_op (ir_node *node, ir_node *op) {
1153 assert (node->op == op_Minus);
1154 set_irn_n(node, 0, op);
1159 get_Mul_left (ir_node *node) {
1160 assert (node->op == op_Mul);
1161 return get_irn_n(node, 0);
1165 set_Mul_left (ir_node *node, ir_node *left) {
1166 assert (node->op == op_Mul);
1167 set_irn_n(node, 0, left);
1171 get_Mul_right (ir_node *node) {
1172 assert (node->op == op_Mul);
1173 return get_irn_n(node, 1);
1177 set_Mul_right (ir_node *node, ir_node *right) {
1178 assert (node->op == op_Mul);
1179 set_irn_n(node, 1, right);
1183 get_Quot_left (ir_node *node) {
1184 assert (node->op == op_Quot);
1185 return get_irn_n(node, 1);
1189 set_Quot_left (ir_node *node, ir_node *left) {
1190 assert (node->op == op_Quot);
1191 set_irn_n(node, 1, left);
1195 get_Quot_right (ir_node *node) {
1196 assert (node->op == op_Quot);
1197 return get_irn_n(node, 2);
1201 set_Quot_right (ir_node *node, ir_node *right) {
1202 assert (node->op == op_Quot);
1203 set_irn_n(node, 2, right);
1207 get_Quot_mem (ir_node *node) {
1208 assert (node->op == op_Quot);
1209 return get_irn_n(node, 0);
1213 set_Quot_mem (ir_node *node, ir_node *mem) {
1214 assert (node->op == op_Quot);
1215 set_irn_n(node, 0, mem);
1219 get_DivMod_left (ir_node *node) {
1220 assert (node->op == op_DivMod);
1221 return get_irn_n(node, 1);
1225 set_DivMod_left (ir_node *node, ir_node *left) {
1226 assert (node->op == op_DivMod);
1227 set_irn_n(node, 1, left);
1231 get_DivMod_right (ir_node *node) {
1232 assert (node->op == op_DivMod);
1233 return get_irn_n(node, 2);
1237 set_DivMod_right (ir_node *node, ir_node *right) {
1238 assert (node->op == op_DivMod);
1239 set_irn_n(node, 2, right);
1243 get_DivMod_mem (ir_node *node) {
1244 assert (node->op == op_DivMod);
1245 return get_irn_n(node, 0);
1249 set_DivMod_mem (ir_node *node, ir_node *mem) {
1250 assert (node->op == op_DivMod);
1251 set_irn_n(node, 0, mem);
1255 get_Div_left (ir_node *node) {
1256 assert (node->op == op_Div);
1257 return get_irn_n(node, 1);
1261 set_Div_left (ir_node *node, ir_node *left) {
1262 assert (node->op == op_Div);
1263 set_irn_n(node, 1, left);
1267 get_Div_right (ir_node *node) {
1268 assert (node->op == op_Div);
1269 return get_irn_n(node, 2);
1273 set_Div_right (ir_node *node, ir_node *right) {
1274 assert (node->op == op_Div);
1275 set_irn_n(node, 2, right);
1279 get_Div_mem (ir_node *node) {
1280 assert (node->op == op_Div);
1281 return get_irn_n(node, 0);
1285 set_Div_mem (ir_node *node, ir_node *mem) {
1286 assert (node->op == op_Div);
1287 set_irn_n(node, 0, mem);
1291 get_Mod_left (ir_node *node) {
1292 assert (node->op == op_Mod);
1293 return get_irn_n(node, 1);
1297 set_Mod_left (ir_node *node, ir_node *left) {
1298 assert (node->op == op_Mod);
1299 set_irn_n(node, 1, left);
1303 get_Mod_right (ir_node *node) {
1304 assert (node->op == op_Mod);
1305 return get_irn_n(node, 2);
1309 set_Mod_right (ir_node *node, ir_node *right) {
1310 assert (node->op == op_Mod);
1311 set_irn_n(node, 2, right);
1315 get_Mod_mem (ir_node *node) {
1316 assert (node->op == op_Mod);
1317 return get_irn_n(node, 0);
1321 set_Mod_mem (ir_node *node, ir_node *mem) {
1322 assert (node->op == op_Mod);
1323 set_irn_n(node, 0, mem);
1327 get_Abs_op (ir_node *node) {
1328 assert (node->op == op_Abs);
1329 return get_irn_n(node, 0);
1333 set_Abs_op (ir_node *node, ir_node *op) {
1334 assert (node->op == op_Abs);
1335 set_irn_n(node, 0, op);
1339 get_And_left (ir_node *node) {
1340 assert (node->op == op_And);
1341 return get_irn_n(node, 0);
1345 set_And_left (ir_node *node, ir_node *left) {
1346 assert (node->op == op_And);
1347 set_irn_n(node, 0, left);
1351 get_And_right (ir_node *node) {
1352 assert (node->op == op_And);
1353 return get_irn_n(node, 1);
1357 set_And_right (ir_node *node, ir_node *right) {
1358 assert (node->op == op_And);
1359 set_irn_n(node, 1, right);
1363 get_Or_left (ir_node *node) {
1364 assert (node->op == op_Or);
1365 return get_irn_n(node, 0);
1369 set_Or_left (ir_node *node, ir_node *left) {
1370 assert (node->op == op_Or);
1371 set_irn_n(node, 0, left);
1375 get_Or_right (ir_node *node) {
1376 assert (node->op == op_Or);
1377 return get_irn_n(node, 1);
1381 set_Or_right (ir_node *node, ir_node *right) {
1382 assert (node->op == op_Or);
1383 set_irn_n(node, 1, right);
1387 get_Eor_left (ir_node *node) {
1388 assert (node->op == op_Eor);
1389 return get_irn_n(node, 0);
1393 set_Eor_left (ir_node *node, ir_node *left) {
1394 assert (node->op == op_Eor);
1395 set_irn_n(node, 0, left);
1399 get_Eor_right (ir_node *node) {
1400 assert (node->op == op_Eor);
1401 return get_irn_n(node, 1);
1405 set_Eor_right (ir_node *node, ir_node *right) {
1406 assert (node->op == op_Eor);
1407 set_irn_n(node, 1, right);
1412 get_Not_op (ir_node *node) {
1413 assert (node->op == op_Not);
1414 return get_irn_n(node, 0);
1418 set_Not_op (ir_node *node, ir_node *op) {
1419 assert (node->op == op_Not);
1420 set_irn_n(node, 0, op);
1425 get_Shl_left (ir_node *node) {
1426 assert (node->op == op_Shl);
1427 return get_irn_n(node, 0);
1431 set_Shl_left (ir_node *node, ir_node *left) {
1432 assert (node->op == op_Shl);
1433 set_irn_n(node, 0, left);
1437 get_Shl_right (ir_node *node) {
1438 assert (node->op == op_Shl);
1439 return get_irn_n(node, 1);
1443 set_Shl_right (ir_node *node, ir_node *right) {
1444 assert (node->op == op_Shl);
1445 set_irn_n(node, 1, right);
1449 get_Shr_left (ir_node *node) {
1450 assert (node->op == op_Shr);
1451 return get_irn_n(node, 0);
1455 set_Shr_left (ir_node *node, ir_node *left) {
1456 assert (node->op == op_Shr);
1457 set_irn_n(node, 0, left);
1461 get_Shr_right (ir_node *node) {
1462 assert (node->op == op_Shr);
1463 return get_irn_n(node, 1);
1467 set_Shr_right (ir_node *node, ir_node *right) {
1468 assert (node->op == op_Shr);
1469 set_irn_n(node, 1, right);
1473 get_Shrs_left (ir_node *node) {
1474 assert (node->op == op_Shrs);
1475 return get_irn_n(node, 0);
1479 set_Shrs_left (ir_node *node, ir_node *left) {
1480 assert (node->op == op_Shrs);
1481 set_irn_n(node, 0, left);
1485 get_Shrs_right (ir_node *node) {
1486 assert (node->op == op_Shrs);
1487 return get_irn_n(node, 1);
1491 set_Shrs_right (ir_node *node, ir_node *right) {
1492 assert (node->op == op_Shrs);
1493 set_irn_n(node, 1, right);
1497 get_Rot_left (ir_node *node) {
1498 assert (node->op == op_Rot);
1499 return get_irn_n(node, 0);
1503 set_Rot_left (ir_node *node, ir_node *left) {
1504 assert (node->op == op_Rot);
1505 set_irn_n(node, 0, left);
1509 get_Rot_right (ir_node *node) {
1510 assert (node->op == op_Rot);
1511 return get_irn_n(node, 1);
1515 set_Rot_right (ir_node *node, ir_node *right) {
1516 assert (node->op == op_Rot);
1517 set_irn_n(node, 1, right);
1521 get_Cmp_left (ir_node *node) {
1522 assert (node->op == op_Cmp);
1523 return get_irn_n(node, 0);
1527 set_Cmp_left (ir_node *node, ir_node *left) {
1528 assert (node->op == op_Cmp);
1529 set_irn_n(node, 0, left);
1533 get_Cmp_right (ir_node *node) {
1534 assert (node->op == op_Cmp);
1535 return get_irn_n(node, 1);
1539 set_Cmp_right (ir_node *node, ir_node *right) {
1540 assert (node->op == op_Cmp);
1541 set_irn_n(node, 1, right);
1545 get_Conv_op (ir_node *node) {
1546 assert (node->op == op_Conv);
1547 return get_irn_n(node, 0);
1551 set_Conv_op (ir_node *node, ir_node *op) {
1552 assert (node->op == op_Conv);
1553 set_irn_n(node, 0, op);
1557 get_Phi_preds_arr (ir_node *node) {
1558 assert (node->op == op_Phi);
1559 return (ir_node **)&(get_irn_in(node)[1]);
1563 get_Phi_n_preds (ir_node *node) {
1564 assert (node->op == op_Phi);
1565 return (get_irn_arity(node));
1569 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1570 assert (node->op == op_Phi);
1575 get_Phi_pred (ir_node *node, int pos) {
1576 assert (node->op == op_Phi);
1577 return get_irn_n(node, pos);
1581 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1582 assert (node->op == op_Phi);
1583 set_irn_n(node, pos, pred);
1587 get_Load_mem (ir_node *node) {
1588 assert (node->op == op_Load);
1589 return get_irn_n(node, 0);
1593 set_Load_mem (ir_node *node, ir_node *mem) {
1594 assert (node->op == op_Load);
1595 set_irn_n(node, 0, mem);
1599 get_Load_ptr (ir_node *node) {
1600 assert (node->op == op_Load);
1601 return get_irn_n(node, 1);
1605 set_Load_ptr (ir_node *node, ir_node *ptr) {
1606 assert (node->op == op_Load);
1607 set_irn_n(node, 1, ptr);
1612 get_Store_mem (ir_node *node) {
1613 assert (node->op == op_Store);
1614 return get_irn_n(node, 0);
1618 set_Store_mem (ir_node *node, ir_node *mem) {
1619 assert (node->op == op_Store);
1620 set_irn_n(node, 0, mem);
1624 get_Store_ptr (ir_node *node) {
1625 assert (node->op == op_Store);
1626 return get_irn_n(node, 1);
1630 set_Store_ptr (ir_node *node, ir_node *ptr) {
1631 assert (node->op == op_Store);
1632 set_irn_n(node, 1, ptr);
1636 get_Store_value (ir_node *node) {
1637 assert (node->op == op_Store);
1638 return get_irn_n(node, 2);
1642 set_Store_value (ir_node *node, ir_node *value) {
1643 assert (node->op == op_Store);
1644 set_irn_n(node, 2, value);
1648 get_Alloc_mem (ir_node *node) {
1649 assert (node->op == op_Alloc);
1650 return get_irn_n(node, 0);
1654 set_Alloc_mem (ir_node *node, ir_node *mem) {
1655 assert (node->op == op_Alloc);
1656 set_irn_n(node, 0, mem);
1660 get_Alloc_size (ir_node *node) {
1661 assert (node->op == op_Alloc);
1662 return get_irn_n(node, 1);
1666 set_Alloc_size (ir_node *node, ir_node *size) {
1667 assert (node->op == op_Alloc);
1668 set_irn_n(node, 1, size);
1672 get_Alloc_type (ir_node *node) {
1673 assert (node->op == op_Alloc);
1674 return node->attr.a.type = skip_tid(node->attr.a.type);
1678 set_Alloc_type (ir_node *node, type *type) {
1679 assert (node->op == op_Alloc);
1680 node->attr.a.type = type;
1684 get_Alloc_where (ir_node *node) {
1685 assert (node->op == op_Alloc);
1686 return node->attr.a.where;
1690 set_Alloc_where (ir_node *node, where_alloc where) {
1691 assert (node->op == op_Alloc);
1692 node->attr.a.where = where;
1697 get_Free_mem (ir_node *node) {
1698 assert (node->op == op_Free);
1699 return get_irn_n(node, 0);
1703 set_Free_mem (ir_node *node, ir_node *mem) {
1704 assert (node->op == op_Free);
1705 set_irn_n(node, 0, mem);
1709 get_Free_ptr (ir_node *node) {
1710 assert (node->op == op_Free);
1711 return get_irn_n(node, 1);
1715 set_Free_ptr (ir_node *node, ir_node *ptr) {
1716 assert (node->op == op_Free);
1717 set_irn_n(node, 1, ptr);
1721 get_Free_size (ir_node *node) {
1722 assert (node->op == op_Free);
1723 return get_irn_n(node, 2);
1727 set_Free_size (ir_node *node, ir_node *size) {
1728 assert (node->op == op_Free);
1729 set_irn_n(node, 2, size);
1733 get_Free_type (ir_node *node) {
1734 assert (node->op == op_Free);
1735 return node->attr.f = skip_tid(node->attr.f);
1739 set_Free_type (ir_node *node, type *type) {
1740 assert (node->op == op_Free);
1741 node->attr.f = type;
1745 get_Sync_preds_arr (ir_node *node) {
1746 assert (node->op == op_Sync);
1747 return (ir_node **)&(get_irn_in(node)[1]);
1751 get_Sync_n_preds (ir_node *node) {
1752 assert (node->op == op_Sync);
1753 return (get_irn_arity(node));
1758 set_Sync_n_preds (ir_node *node, int n_preds) {
1759 assert (node->op == op_Sync);
1764 get_Sync_pred (ir_node *node, int pos) {
1765 assert (node->op == op_Sync);
1766 return get_irn_n(node, pos);
1770 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1771 assert (node->op == op_Sync);
1772 set_irn_n(node, pos, pred);
1776 get_Proj_pred (ir_node *node) {
1777 assert (node->op == op_Proj);
1778 return get_irn_n(node, 0);
1782 set_Proj_pred (ir_node *node, ir_node *pred) {
1783 assert (node->op == op_Proj);
1784 set_irn_n(node, 0, pred);
1788 get_Proj_proj (ir_node *node) {
1789 assert (node->op == op_Proj);
1790 return node->attr.proj;
1794 set_Proj_proj (ir_node *node, long proj) {
1795 assert (node->op == op_Proj);
1796 node->attr.proj = proj;
1800 get_Tuple_preds_arr (ir_node *node) {
1801 assert (node->op == op_Tuple);
1802 return (ir_node **)&(get_irn_in(node)[1]);
1806 get_Tuple_n_preds (ir_node *node) {
1807 assert (node->op == op_Tuple);
1808 return (get_irn_arity(node));
1813 set_Tuple_n_preds (ir_node *node, int n_preds) {
1814 assert (node->op == op_Tuple);
1819 get_Tuple_pred (ir_node *node, int pos) {
1820 assert (node->op == op_Tuple);
1821 return get_irn_n(node, pos);
1825 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1826 assert (node->op == op_Tuple);
1827 set_irn_n(node, pos, pred);
1831 get_Id_pred (ir_node *node) {
1832 assert (node->op == op_Id);
1833 return get_irn_n(node, 0);
1837 set_Id_pred (ir_node *node, ir_node *pred) {
1838 assert (node->op == op_Id);
1839 set_irn_n(node, 0, pred);
1842 /******************************************************************/
1843 /* Auxiliary routines */
1844 /******************************************************************/
1847 skip_Proj (ir_node *node) {
1848 /* don't assert node !!! */
1849 if (node && (node->op == op_Proj)) {
1850 return get_Proj_pred(node);
1857 skip_Tuple (ir_node *node) {
1860 node = skip_nop(node);
1861 if (get_irn_op(node) == op_Proj) {
1862 pred = skip_nop(get_Proj_pred(node));
1863 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
1864 pred = skip_nop(skip_Tuple(pred));
1865 if (get_irn_op(pred) == op_Tuple)
1866 return get_Tuple_pred(pred, get_Proj_proj(node));
1872 skip_nop (ir_node *node) {
1873 /* don't assert node !!! */
1875 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1876 /* Don't use get_Id_pred: We get into an endless loop for
1877 self-referencing Ids. */
1878 assert (get_irn_arity (node) > 0);
1879 return node->in[0+1];
1886 skip_Id (ir_node *node) {
1887 return skip_nop(node);
1891 is_Bad (ir_node *node) {
1893 if ((node) && get_irn_opcode(node) == iro_Bad)
1899 is_no_Block (ir_node *node) {
1901 return (get_irn_opcode(node) != iro_Block);
1904 /* Returns true if the operation manipulates control flow. */
1906 is_cfop(ir_node *node) {
1907 return is_cfopcode(get_irn_op(node));
1910 /* Returns true if the operation can change the control flow because
1913 is_fragile_op(ir_node *node) {
1914 return ( (get_irn_opcode(node) == iro_Call)
1915 || (get_irn_opcode(node) == iro_Quot)
1916 || (get_irn_opcode(node) == iro_DivMod)
1917 || (get_irn_opcode(node) == iro_Div)
1918 || (get_irn_opcode(node) == iro_Mod)
1919 || (get_irn_opcode(node) == iro_Load)
1920 || (get_irn_opcode(node) == iro_Store)
1921 || (get_irn_opcode(node) == iro_Alloc)
1922 || (get_irn_opcode(node) == iro_Bad));
1926 /* Returns the memory operand of fragile operations. */
1927 ir_node *get_fragile_op_mem(ir_node *node) {
1928 assert(node && is_fragile_op(node));
1930 switch (get_irn_opcode (node)) {
1939 return get_irn_n(node, 0);