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 */
31 static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le",
32 "Gt", "Ge", "Lg", "Leg", "Uo",
33 "Ue", "Ul", "Ule", "Ug", "Uge",
36 inline char *get_pnc_string(int pnc) {
37 return pnc_name_arr[pnc];
42 get_negated_pnc(int pnc) {
44 case False: return True; break;
45 case Eq: return Ne; break;
46 case Lt: return Uge; break;
47 case Le: return Ug; break;
48 case Gt: return Ule; break;
49 case Ge: return Ul; break;
50 case Lg: return Ue; break;
51 case Leg: return Uo; break;
52 case Uo: return Leg; break;
53 case Ue: return Lg; break;
54 case Ul: return Ge; break;
55 case Ule: return Gt; break;
56 case Ug: return Le; break;
57 case Uge: return Lt; break;
58 case Ne: return Eq; break;
59 case True: return False; break;
61 return 99; /* to shut up gcc */
64 static char *pns_name_arr [] = {"initial_exec", "global_store",
65 "frame_base", "globals", "args"};
67 static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"};
74 /* irnode constructor */
75 /* create a new irnode in irg, with an op, mode, arity and */
76 /* some incoming irnodes */
77 /* this constructor is used in every specified irnode constructor */
79 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
80 int arity, ir_node **in)
83 int node_size = offsetof (ir_node, attr) + op->attr_size;
85 res = (ir_node *) obstack_alloc (irg->obst, node_size);
89 fprintf (stdout, "%s: res(%p) = %p\n", __PRETTY_FUNCTION__, op, res);
91 res->kind = k_ir_node;
97 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
99 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
100 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
106 res->node_nr = get_irp_new_node_nr();
112 /* Copies all attributes stored in the old node to the new node.
113 Assumes both have the same opcode and sufficient size. */
115 copy_attrs (ir_node *old, ir_node *new) {
116 assert (get_irn_opcode(old) == get_irn_opcode(new));
117 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
120 /* IR-Nodes with attributes */
122 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
125 ir_node *np = XP_GETARG (ir_node *, 0);
128 XPS ("<null ir_node>");
132 XPF1 ("%I", get_irn_opident(np));
134 switch (get_irn_opcode (np)) { /* node label */
136 XPF1 ("%I", get_irn_mode(np)->name);
138 XPF1 ("%v", get_irn_const_attr);
141 if (get_irn_modecode (np) == irm_b) {
143 XP (pnc_name_arr[get_irn_proj_attr(np)]);
144 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
146 XP (pns_name_arr[get_irn_proj_attr(np)]);
148 XPF1 ("%I", get_irn_mode(np)->name);
150 XPF1 ("%d", get_irn_proj_attr(np));
154 XPF1 ("%I", get_irn_mode(np)->name);
156 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
157 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
159 case iro_Start: /* don't dump mode of these */
168 XPF1 ("%I", get_irn_mode(np)->name);
174 /** getting some parameters from ir_nodes **/
176 /* returns the number of predecessors without the block predecessor. */
178 get_irn_arity (ir_node *node)
181 return (ARR_LEN((node)->in)-1);
184 /* Returns the array with ins. This array is shifted with respect to the
185 array accessed by get_irn_n: The block operand is at position 0 not -1.
186 (@@@ This should be changed.)
187 The order of the predecessors in this array is not guaranteed, except that
188 lists of operands as predecessors of Block or arguments of a Call are
191 get_irn_in (ir_node *node)
198 set_irn_in (ir_node *node, int arity, ir_node **in) {
200 if (arity != get_irn_arity(node)) {
201 ir_node *block = node->in[0];
202 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
205 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
208 /* to iterate through the predecessors without touching the array */
209 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
210 to iterate includind the Block predecessor iterate from i = -1 to
212 If it is a block, the entry -1 is NULL. */
214 get_irn_n (ir_node *node, int n)
218 assert ((get_irn_arity (node) > n) && (-1 <= n));
219 res = skip_nop(node->in[n+1]);
220 if (res != node->in[n+1]) node->in[n+1] = res;
225 set_irn_n (ir_node *node, int n, ir_node *in)
228 assert (get_irn_arity (node) > n);
233 get_irn_mode (ir_node *node)
240 get_irn_modecode (ir_node *node)
243 return node->mode->code;
248 get_irn_modeident (ir_node *node)
251 return node->mode->name;
255 get_irn_op (ir_node *node)
261 /* should be private to the library: */
263 set_irn_op (ir_node *node, ir_op *op)
270 get_irn_opcode (ir_node *node)
273 return node->op->code;
277 get_irn_opname (ir_node *node)
280 return id_to_str(node->op->name);
284 get_irn_opident (ir_node *node)
287 return node->op->name;
291 get_irn_visited (ir_node *node)
294 return node->visited;
298 set_irn_visited (ir_node *node, unsigned long visited)
301 node->visited = visited;
304 set_irn_link (ir_node *node, ir_node *link) {
310 get_irn_link (ir_node *node) {
316 /* Outputs a unique number for this node */
318 get_irn_node_nr(ir_node *node) {
320 return node->node_nr;
325 get_irn_const_attr (ir_node *node)
327 assert (node->op == op_Const);
328 return node->attr.con;
332 get_irn_proj_attr (ir_node *node)
334 assert (node->op == op_Proj);
335 return node->attr.proj;
339 get_irn_alloc_attr (ir_node *node)
341 assert (node->op == op_Alloc);
346 get_irn_free_attr (ir_node *node)
348 assert (node->op == op_Free);
349 return node->attr.f = skip_tid(node->attr.f);
353 get_irn_symconst_attr (ir_node *node)
355 assert (node->op == op_SymConst);
360 get_irn_call_attr (ir_node *node)
362 assert (node->op == op_Call);
363 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
367 get_irn_sel_attr (ir_node *node)
369 assert (node->op == op_Sel);
374 get_irn_phi_attr (ir_node *node)
376 assert (node->op == op_Phi);
377 return node->attr.phi0_pos;
381 get_irn_block_attr (ir_node *node)
383 assert (node->op == op_Block);
384 return node->attr.block;
387 /** manipulate fields of individual nodes **/
389 /* this works for all except Block */
391 get_nodes_Block (ir_node *node) {
392 assert (!(node->op == op_Block));
393 return get_irn_n(node, -1);
397 set_nodes_Block (ir_node *node, ir_node *block) {
398 assert (!(node->op == op_Block));
399 set_irn_n(node, -1, block);
402 /* Returns an array with the predecessors of the Block. Depending on
403 the implementation of the graph datastructure this can be a copy of
404 the internal representation of predecessors as well as the internal
405 array itself. Therefore writing to this array might obstruct the ir. */
407 get_Block_cfgpred_arr (ir_node *node)
409 assert ((node->op == op_Block));
410 return (ir_node **)&(get_irn_in(node)[1]);
415 get_Block_n_cfgpreds (ir_node *node) {
416 assert ((node->op == op_Block));
417 return (get_irn_arity(node));
422 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
423 assert ((node->op == op_Block));
428 get_Block_cfgpred (ir_node *node, int pos) {
429 assert (node->op == op_Block);
430 return get_irn_n(node, pos);
434 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
435 assert (node->op == op_Block);
436 set_irn_n(node, pos, pred);
440 get_Block_matured (ir_node *node) {
441 assert (node->op == op_Block);
442 return node->attr.block.matured;
446 set_Block_matured (ir_node *node, bool matured) {
447 assert (node->op == op_Block);
448 node->attr.block.matured = matured;
451 get_Block_block_visited (ir_node *node) {
452 assert (node->op == op_Block);
453 return node->attr.block.block_visited;
457 set_Block_block_visited (ir_node *node, unsigned long visit) {
458 assert (node->op == op_Block);
459 node->attr.block.block_visited = visit;
463 get_Block_graph_arr (ir_node *node, int pos) {
464 assert (node->op == op_Block);
465 return node->attr.block.graph_arr[pos+1];
469 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
470 assert (node->op == op_Block);
471 node->attr.block.graph_arr[pos+1] = value;
475 add_End_keepalive (ir_node *end, ir_node *ka) {
476 assert (end->op == op_End);
477 ARR_APP1 (ir_node *, end->in, ka);
481 free_End (ir_node *end) {
482 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
483 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
487 > Implementing the case construct (which is where the constant Proj node is
488 > important) involves far more than simply determining the constant values.
489 > We could argue that this is more properly a function of the translator from
490 > Firm to the target machine. That could be done if there was some way of
491 > projecting "default" out of the Cond node.
492 I know it's complicated.
493 Basically there are two proglems:
494 - determining the gaps between the projs
495 - determining the biggest case constant to konw the proj number for
497 I see several solutions:
498 1. Introduce a ProjDefault node. Solves both problems.
499 This means to extend all optimizations executed during construction.
500 2. Give the Cond node for switch two flavors:
501 a) there are no gaps in the projs (existing flavor)
502 b) gaps may exist, default proj is still the Proj with the largest
503 projection number. This covers also the gaps.
504 3. Fix the semantic of the Cond to that of 2b)
506 Solution 2 seems to be the best:
507 Computing the gaps in the Firm representation is not too hard, i.e.,
508 libfirm can implement a routine that transforms betweeen the two
509 flavours. This is also possible for 1) but 2) does not require to
510 change any existing optimization.
511 Further it should be far simpler to determine the biggest constant than
513 I don't want to choose 3) as 2a) seems to have advantages for
514 dataflow analysis and 3) does not allow to convert the representation to
518 get_Cond_selector (ir_node *node) {
519 assert (node->op == op_Cond);
520 return get_irn_n(node, 0);
524 set_Cond_selector (ir_node *node, ir_node *selector) {
525 assert (node->op == op_Cond);
526 set_irn_n(node, 0, selector);
530 get_Cond_kind (ir_node *node) {
531 assert (node->op == op_Cond);
532 return node->attr.c.kind;
536 set_Cond_kind (ir_node *node, cond_kind kind) {
537 assert (node->op == op_Cond);
538 node->attr.c.kind = kind;
542 get_Return_mem (ir_node *node) {
543 assert (node->op == op_Return);
544 return get_irn_n(node, 0);
548 set_Return_mem (ir_node *node, ir_node *mem) {
549 assert (node->op == op_Return);
550 set_irn_n(node, 0, mem);
554 get_Return_res_arr (ir_node *node)
556 assert ((node->op == op_Return));
557 if (get_Return_n_res(node) > 0)
558 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
564 get_Return_n_res (ir_node *node) {
565 assert (node->op == op_Return);
566 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
571 set_Return_n_res (ir_node *node, int results) {
572 assert (node->op == op_Return);
577 get_Return_res (ir_node *node, int pos) {
578 assert (node->op == op_Return);
579 assert (get_Return_n_res(node) > pos);
580 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
584 set_Return_res (ir_node *node, int pos, ir_node *res){
585 assert (node->op == op_Return);
586 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
590 get_Raise_mem (ir_node *node) {
591 assert (node->op == op_Return);
592 return get_irn_n(node, 0);
596 set_Raise_mem (ir_node *node, ir_node *mem) {
597 assert (node->op == op_Raise);
598 set_irn_n(node, 0, mem);
602 get_Raise_exo_ptr (ir_node *node) {
603 assert (node->op == op_Raise);
604 return get_irn_n(node, 1);
608 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
609 assert (node->op == op_Raise);
610 set_irn_n(node, 1, exo_ptr);
613 inline tarval *get_Const_tarval (ir_node *node) {
614 assert (node->op == op_Const);
615 return get_irn_const_attr(node);
619 set_Const_tarval (ir_node *node, tarval *con) {
620 assert (node->op == op_Const);
621 node->attr.con = con;
625 get_SymConst_kind (ir_node *node) {
626 assert (node->op == op_SymConst);
627 return node->attr.i.num;
631 set_SymConst_kind (ir_node *node, symconst_kind num) {
632 assert (node->op == op_SymConst);
633 node->attr.i.num = num;
637 get_SymConst_type (ir_node *node) {
638 assert ( (node->op == op_SymConst)
639 && ( get_SymConst_kind(node) == type_tag
640 || get_SymConst_kind(node) == size));
641 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
645 set_SymConst_type (ir_node *node, type *type) {
646 assert ( (node->op == op_SymConst)
647 && ( get_SymConst_kind(node) == type_tag
648 || get_SymConst_kind(node) == size));
649 node->attr.i.tori.typ = type;
653 get_SymConst_ptrinfo (ir_node *node) {
654 assert ( (node->op == op_SymConst)
655 && (get_SymConst_kind(node) == linkage_ptr_info));
656 return node->attr.i.tori.ptrinfo;
660 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
661 assert ( (node->op == op_SymConst)
662 && (get_SymConst_kind(node) == linkage_ptr_info));
663 node->attr.i.tori.ptrinfo = ptrinfo;
667 get_SymConst_type_or_id (ir_node *node) {
668 assert (node->op == op_SymConst);
669 return &(node->attr.i.tori);
673 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
674 assert (node->op == op_SymConst);
675 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
679 get_Sel_mem (ir_node *node) {
680 assert (node->op == op_Sel);
681 return get_irn_n(node, 0);
685 set_Sel_mem (ir_node *node, ir_node *mem) {
686 assert (node->op == op_Sel);
687 set_irn_n(node, 0, mem);
691 get_Sel_ptr (ir_node *node) {
692 assert (node->op == op_Sel);
693 return get_irn_n(node, 1);
697 set_Sel_ptr (ir_node *node, ir_node *ptr) {
698 assert (node->op == op_Sel);
699 set_irn_n(node, 1, ptr);
703 get_Sel_index_arr (ir_node *node)
705 assert ((node->op == op_Sel));
706 if (get_Sel_n_index(node) > 0)
707 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
713 get_Sel_n_index (ir_node *node) {
714 assert (node->op == op_Sel);
715 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
720 set_Sel_n_index (ir_node *node, int n_index) {
721 assert (node->op == op_Sel);
726 get_Sel_index (ir_node *node, int pos) {
727 assert (node->op == op_Sel);
728 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
732 set_Sel_index (ir_node *node, int pos, ir_node *index) {
733 assert (node->op == op_Sel);
734 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
738 get_Sel_entity (ir_node *node) {
739 assert (node->op == op_Sel);
740 return node->attr.s.ent;
744 set_Sel_entity (ir_node *node, entity *ent) {
745 assert (node->op == op_Sel);
746 node->attr.s.ent = ent;
750 get_Sel_linkage_type (ir_node *node) {
751 assert (node->op == op_Sel);
752 return node->attr.s.ltyp;
756 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
757 assert (node->op == op_Sel);
758 node->attr.s.ltyp = lt;
762 get_Call_mem (ir_node *node) {
763 assert (node->op == op_Call);
764 return get_irn_n(node, 0);
768 set_Call_mem (ir_node *node, ir_node *mem) {
769 assert (node->op == op_Call);
770 set_irn_n(node, 0, mem);
774 get_Call_ptr (ir_node *node) {
775 assert (node->op == op_Call);
776 return get_irn_n(node, 1);
780 set_Call_ptr (ir_node *node, ir_node *ptr) {
781 assert (node->op == op_Call);
782 set_irn_n(node, 1, ptr);
786 get_Call_param_arr (ir_node *node) {
787 assert (node->op == op_Call);
788 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
792 get_Call_n_params (ir_node *node) {
793 assert (node->op == op_Call);
794 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
798 get_Call_arity (ir_node *node) {
799 return get_Call_n_params(node);
803 set_Call_arity (ir_node *node, ir_node *arity) {
804 assert (node->op == op_Call);
809 get_Call_param (ir_node *node, int pos) {
810 assert (node->op == op_Call);
811 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
815 set_Call_param (ir_node *node, int pos, ir_node *param) {
816 assert (node->op == op_Call);
817 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
821 get_Call_type (ir_node *node) {
822 assert (node->op == op_Call);
823 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
827 set_Call_type (ir_node *node, type *type) {
828 assert (node->op == op_Call);
829 assert (is_method_type(type));
830 node->attr.call.cld_tp = type;
833 /* For unary and binary arithmetic operations the access to the
834 operands can be factored out. Left is the first, right the
835 second arithmetic value as listed in tech report 0999-33.
836 unops are: Minus, Abs, Not, Conv
837 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
838 Shr, Shrs, Rotate, Cmp */
841 is_unop (ir_node *node) {
842 return ( node->op == op_Minus ||
843 node->op == op_Abs ||
844 node->op == op_Not ||
845 node->op == op_Conv );
849 get_unop_op (ir_node *node) {
850 assert ( node->op == op_Minus ||
851 node->op == op_Abs ||
852 node->op == op_Not ||
853 node->op == op_Conv );
854 switch (get_irn_opcode (node)) {
855 case iro_Minus: return get_Minus_op(node); break;
856 case iro_Abs: return get_Abs_op(node); break;
857 case iro_Not: return get_Not_op(node); break;
858 case iro_Conv: return get_Conv_op(node); break;
859 default: return NULL;
864 set_unop_op (ir_node *node, ir_node *op) {
865 assert (node->op == op_Minus ||
866 node->op == op_Abs ||
867 node->op == op_Not ||
868 node->op == op_Conv );
869 switch (get_irn_opcode (node)) {
870 case iro_Minus: set_Minus_op(node, op); break;
871 case iro_Abs: set_Abs_op(node, op); break;
872 case iro_Not: set_Not_op(node, op); break;
873 case iro_Conv: set_Conv_op(node, op); break;
880 is_binop (ir_node *node) {
881 return (node->op == op_Add ||
882 node->op == op_Sub ||
883 node->op == op_Mul ||
884 node->op == op_Quot ||
885 node->op == op_DivMod ||
886 node->op == op_Div ||
887 node->op == op_Mod ||
888 node->op == op_And ||
890 node->op == op_Eor ||
891 node->op == op_Shl ||
892 node->op == op_Shr ||
893 node->op == op_Shrs ||
894 node->op == op_Rot ||
895 node->op == op_Cmp );
899 get_binop_left (ir_node *node) {
900 assert (node->op == op_Add ||
901 node->op == op_Sub ||
902 node->op == op_Mul ||
903 node->op == op_Quot ||
904 node->op == op_DivMod ||
905 node->op == op_Div ||
906 node->op == op_Mod ||
907 node->op == op_And ||
909 node->op == op_Eor ||
910 node->op == op_Shl ||
911 node->op == op_Shr ||
912 node->op == op_Shrs ||
913 node->op == op_Rot ||
914 node->op == op_Cmp );
916 switch (get_irn_opcode (node)) {
917 case iro_Add : return get_Add_left(node); break;
918 case iro_Sub : return get_Sub_left(node); break;
919 case iro_Mul : return get_Mul_left(node); break;
920 case iro_Quot : return get_Quot_left(node); break;
921 case iro_DivMod: return get_DivMod_left(node); break;
922 case iro_Div : return get_Div_left(node); break;
923 case iro_Mod : return get_Mod_left(node); break;
924 case iro_And : return get_And_left(node); break;
925 case iro_Or : return get_Or_left(node); break;
926 case iro_Eor : return get_Eor_left(node); break;
927 case iro_Shl : return get_Shl_left(node); break;
928 case iro_Shr : return get_Shr_left(node); break;
929 case iro_Shrs : return get_Shrs_left(node); break;
930 case iro_Rot : return get_Rot_left(node); break;
931 case iro_Cmp : return get_Cmp_left(node); break;
932 default: return NULL;
937 set_binop_left (ir_node *node, ir_node *left) {
938 assert (node->op == op_Add ||
939 node->op == op_Sub ||
940 node->op == op_Mul ||
941 node->op == op_Quot ||
942 node->op == op_DivMod ||
943 node->op == op_Div ||
944 node->op == op_Mod ||
945 node->op == op_And ||
947 node->op == op_Eor ||
948 node->op == op_Shl ||
949 node->op == op_Shr ||
950 node->op == op_Shrs ||
951 node->op == op_Rot ||
952 node->op == op_Cmp );
954 switch (get_irn_opcode (node)) {
955 case iro_Add : set_Add_left(node, left); break;
956 case iro_Sub : set_Sub_left(node, left); break;
957 case iro_Mul : set_Mul_left(node, left); break;
958 case iro_Quot : set_Quot_left(node, left); break;
959 case iro_DivMod: set_DivMod_left(node, left); break;
960 case iro_Div : set_Div_left(node, left); break;
961 case iro_Mod : set_Mod_left(node, left); break;
962 case iro_And : set_And_left(node, left); break;
963 case iro_Or : set_Or_left(node, left); break;
964 case iro_Eor : set_Eor_left(node, left); break;
965 case iro_Shl : set_Shl_left(node, left); break;
966 case iro_Shr : set_Shr_left(node, left); break;
967 case iro_Shrs : set_Shrs_left(node, left); break;
968 case iro_Rot : set_Rot_left(node, left); break;
969 case iro_Cmp : set_Cmp_left(node, left); break;
975 get_binop_right (ir_node *node) {
976 assert (node->op == op_Add ||
977 node->op == op_Sub ||
978 node->op == op_Mul ||
979 node->op == op_Quot ||
980 node->op == op_DivMod ||
981 node->op == op_Div ||
982 node->op == op_Mod ||
983 node->op == op_And ||
985 node->op == op_Eor ||
986 node->op == op_Shl ||
987 node->op == op_Shr ||
988 node->op == op_Shrs ||
989 node->op == op_Rot ||
990 node->op == op_Cmp );
992 switch (get_irn_opcode (node)) {
993 case iro_Add : return get_Add_right(node); break;
994 case iro_Sub : return get_Sub_right(node); break;
995 case iro_Mul : return get_Mul_right(node); break;
996 case iro_Quot : return get_Quot_right(node); break;
997 case iro_DivMod: return get_DivMod_right(node); break;
998 case iro_Div : return get_Div_right(node); break;
999 case iro_Mod : return get_Mod_right(node); break;
1000 case iro_And : return get_And_right(node); break;
1001 case iro_Or : return get_Or_right(node); break;
1002 case iro_Eor : return get_Eor_right(node); break;
1003 case iro_Shl : return get_Shl_right(node); break;
1004 case iro_Shr : return get_Shr_right(node); break;
1005 case iro_Shrs : return get_Shrs_right(node); break;
1006 case iro_Rot : return get_Rot_right(node); break;
1007 case iro_Cmp : return get_Cmp_right(node); break;
1008 default: return NULL;
1013 set_binop_right (ir_node *node, ir_node *right) {
1014 assert (node->op == op_Add ||
1015 node->op == op_Sub ||
1016 node->op == op_Mul ||
1017 node->op == op_Quot ||
1018 node->op == op_DivMod ||
1019 node->op == op_Div ||
1020 node->op == op_Mod ||
1021 node->op == op_And ||
1022 node->op == op_Or ||
1023 node->op == op_Eor ||
1024 node->op == op_Shl ||
1025 node->op == op_Shr ||
1026 node->op == op_Shrs ||
1027 node->op == op_Rot ||
1028 node->op == op_Cmp );
1030 switch (get_irn_opcode (node)) {
1031 case iro_Add : set_Add_right(node, right); break;
1032 case iro_Sub : set_Sub_right(node, right); break;
1033 case iro_Mul : set_Mul_right(node, right); break;
1034 case iro_Quot : set_Quot_right(node, right); break;
1035 case iro_DivMod: set_DivMod_right(node, right); break;
1036 case iro_Div : set_Div_right(node, right); break;
1037 case iro_Mod : set_Mod_right(node, right); break;
1038 case iro_And : set_And_right(node, right); break;
1039 case iro_Or : set_Or_right(node, right); break;
1040 case iro_Eor : set_Eor_right(node, right); break;
1041 case iro_Shl : set_Shl_right(node, right); break;
1042 case iro_Shr : set_Shr_right(node, right); break;
1043 case iro_Shrs : set_Shrs_right(node, right); break;
1044 case iro_Rot : set_Rot_right(node, right); break;
1045 case iro_Cmp : set_Cmp_right(node, right); break;
1051 get_Add_left (ir_node *node) {
1052 assert (node->op == op_Add);
1053 return get_irn_n(node, 0);
1057 set_Add_left (ir_node *node, ir_node *left) {
1058 assert (node->op == op_Add);
1059 set_irn_n(node, 0, left);
1063 get_Add_right (ir_node *node) {
1064 assert (node->op == op_Add);
1065 return get_irn_n(node, 1);
1069 set_Add_right (ir_node *node, ir_node *right) {
1070 assert (node->op == op_Add);
1071 set_irn_n(node, 1, right);
1075 get_Sub_left (ir_node *node) {
1076 assert (node->op == op_Sub);
1077 return get_irn_n(node, 0);
1081 set_Sub_left (ir_node *node, ir_node *left) {
1082 assert (node->op == op_Sub);
1083 set_irn_n(node, 0, left);
1087 get_Sub_right (ir_node *node) {
1088 assert (node->op == op_Sub);
1089 return get_irn_n(node, 1);
1093 set_Sub_right (ir_node *node, ir_node *right) {
1094 assert (node->op == op_Sub);
1095 set_irn_n(node, 1, right);
1100 get_Minus_op (ir_node *node) {
1101 assert (node->op == op_Minus);
1102 return get_irn_n(node, 0);
1106 set_Minus_op (ir_node *node, ir_node *op) {
1107 assert (node->op == op_Minus);
1108 set_irn_n(node, 0, op);
1113 get_Mul_left (ir_node *node) {
1114 assert (node->op == op_Mul);
1115 return get_irn_n(node, 0);
1119 set_Mul_left (ir_node *node, ir_node *left) {
1120 assert (node->op == op_Mul);
1121 set_irn_n(node, 0, left);
1125 get_Mul_right (ir_node *node) {
1126 assert (node->op == op_Mul);
1127 return get_irn_n(node, 1);
1131 set_Mul_right (ir_node *node, ir_node *right) {
1132 assert (node->op == op_Mul);
1133 set_irn_n(node, 1, right);
1137 get_Quot_left (ir_node *node) {
1138 assert (node->op == op_Quot);
1139 return get_irn_n(node, 1);
1143 set_Quot_left (ir_node *node, ir_node *left) {
1144 assert (node->op == op_Quot);
1145 set_irn_n(node, 1, left);
1149 get_Quot_right (ir_node *node) {
1150 assert (node->op == op_Quot);
1151 return get_irn_n(node, 2);
1155 set_Quot_right (ir_node *node, ir_node *right) {
1156 assert (node->op == op_Quot);
1157 set_irn_n(node, 2, right);
1161 get_Quot_mem (ir_node *node) {
1162 assert (node->op == op_Quot);
1163 return get_irn_n(node, 0);
1167 set_Quot_mem (ir_node *node, ir_node *mem) {
1168 assert (node->op == op_Quot);
1169 set_irn_n(node, 0, mem);
1173 get_DivMod_left (ir_node *node) {
1174 assert (node->op == op_DivMod);
1175 return get_irn_n(node, 1);
1179 set_DivMod_left (ir_node *node, ir_node *left) {
1180 assert (node->op == op_DivMod);
1181 set_irn_n(node, 1, left);
1185 get_DivMod_right (ir_node *node) {
1186 assert (node->op == op_DivMod);
1187 return get_irn_n(node, 2);
1191 set_DivMod_right (ir_node *node, ir_node *right) {
1192 assert (node->op == op_DivMod);
1193 set_irn_n(node, 2, right);
1197 get_DivMod_mem (ir_node *node) {
1198 assert (node->op == op_DivMod);
1199 return get_irn_n(node, 0);
1203 set_DivMod_mem (ir_node *node, ir_node *mem) {
1204 assert (node->op == op_DivMod);
1205 set_irn_n(node, 0, mem);
1209 get_Div_left (ir_node *node) {
1210 assert (node->op == op_Div);
1211 return get_irn_n(node, 1);
1215 set_Div_left (ir_node *node, ir_node *left) {
1216 assert (node->op == op_Div);
1217 set_irn_n(node, 1, left);
1221 get_Div_right (ir_node *node) {
1222 assert (node->op == op_Div);
1223 return get_irn_n(node, 2);
1227 set_Div_right (ir_node *node, ir_node *right) {
1228 assert (node->op == op_Div);
1229 set_irn_n(node, 2, right);
1233 get_Div_mem (ir_node *node) {
1234 assert (node->op == op_Div);
1235 return get_irn_n(node, 0);
1239 set_Div_mem (ir_node *node, ir_node *mem) {
1240 assert (node->op == op_Div);
1241 set_irn_n(node, 0, mem);
1245 get_Mod_left (ir_node *node) {
1246 assert (node->op == op_Mod);
1247 return get_irn_n(node, 1);
1251 set_Mod_left (ir_node *node, ir_node *left) {
1252 assert (node->op == op_Mod);
1253 set_irn_n(node, 1, left);
1257 get_Mod_right (ir_node *node) {
1258 assert (node->op == op_Mod);
1259 return get_irn_n(node, 2);
1263 set_Mod_right (ir_node *node, ir_node *right) {
1264 assert (node->op == op_Mod);
1265 set_irn_n(node, 2, right);
1269 get_Mod_mem (ir_node *node) {
1270 assert (node->op == op_Mod);
1271 return get_irn_n(node, 0);
1275 set_Mod_mem (ir_node *node, ir_node *mem) {
1276 assert (node->op == op_Mod);
1277 set_irn_n(node, 0, mem);
1281 get_Abs_op (ir_node *node) {
1282 assert (node->op == op_Abs);
1283 return get_irn_n(node, 0);
1287 set_Abs_op (ir_node *node, ir_node *op) {
1288 assert (node->op == op_Abs);
1289 set_irn_n(node, 0, op);
1293 get_And_left (ir_node *node) {
1294 assert (node->op == op_And);
1295 return get_irn_n(node, 0);
1299 set_And_left (ir_node *node, ir_node *left) {
1300 assert (node->op == op_And);
1301 set_irn_n(node, 0, left);
1305 get_And_right (ir_node *node) {
1306 assert (node->op == op_And);
1307 return get_irn_n(node, 1);
1311 set_And_right (ir_node *node, ir_node *right) {
1312 assert (node->op == op_And);
1313 set_irn_n(node, 1, right);
1317 get_Or_left (ir_node *node) {
1318 assert (node->op == op_Or);
1319 return get_irn_n(node, 0);
1323 set_Or_left (ir_node *node, ir_node *left) {
1324 assert (node->op == op_Or);
1325 set_irn_n(node, 0, left);
1329 get_Or_right (ir_node *node) {
1330 assert (node->op == op_Or);
1331 return get_irn_n(node, 1);
1335 set_Or_right (ir_node *node, ir_node *right) {
1336 assert (node->op == op_Or);
1337 set_irn_n(node, 1, right);
1341 get_Eor_left (ir_node *node) {
1342 assert (node->op == op_Eor);
1343 return get_irn_n(node, 0);
1347 set_Eor_left (ir_node *node, ir_node *left) {
1348 assert (node->op == op_Eor);
1349 set_irn_n(node, 0, left);
1353 get_Eor_right (ir_node *node) {
1354 assert (node->op == op_Eor);
1355 return get_irn_n(node, 1);
1359 set_Eor_right (ir_node *node, ir_node *right) {
1360 assert (node->op == op_Eor);
1361 set_irn_n(node, 1, right);
1366 get_Not_op (ir_node *node) {
1367 assert (node->op == op_Not);
1368 return get_irn_n(node, 0);
1372 set_Not_op (ir_node *node, ir_node *op) {
1373 assert (node->op == op_Not);
1374 set_irn_n(node, 0, op);
1379 get_Shl_left (ir_node *node) {
1380 assert (node->op == op_Shl);
1381 return get_irn_n(node, 0);
1385 set_Shl_left (ir_node *node, ir_node *left) {
1386 assert (node->op == op_Shl);
1387 set_irn_n(node, 0, left);
1391 get_Shl_right (ir_node *node) {
1392 assert (node->op == op_Shl);
1393 return get_irn_n(node, 1);
1397 set_Shl_right (ir_node *node, ir_node *right) {
1398 assert (node->op == op_Shl);
1399 set_irn_n(node, 1, right);
1403 get_Shr_left (ir_node *node) {
1404 assert (node->op == op_Shr);
1405 return get_irn_n(node, 0);
1409 set_Shr_left (ir_node *node, ir_node *left) {
1410 assert (node->op == op_Shr);
1411 set_irn_n(node, 0, left);
1415 get_Shr_right (ir_node *node) {
1416 assert (node->op == op_Shr);
1417 return get_irn_n(node, 1);
1421 set_Shr_right (ir_node *node, ir_node *right) {
1422 assert (node->op == op_Shr);
1423 set_irn_n(node, 1, right);
1427 get_Shrs_left (ir_node *node) {
1428 assert (node->op == op_Shrs);
1429 return get_irn_n(node, 0);
1433 set_Shrs_left (ir_node *node, ir_node *left) {
1434 assert (node->op == op_Shrs);
1435 set_irn_n(node, 0, left);
1439 get_Shrs_right (ir_node *node) {
1440 assert (node->op == op_Shrs);
1441 return get_irn_n(node, 1);
1445 set_Shrs_right (ir_node *node, ir_node *right) {
1446 assert (node->op == op_Shrs);
1447 set_irn_n(node, 1, right);
1451 get_Rot_left (ir_node *node) {
1452 assert (node->op == op_Rot);
1453 return get_irn_n(node, 0);
1457 set_Rot_left (ir_node *node, ir_node *left) {
1458 assert (node->op == op_Rot);
1459 set_irn_n(node, 0, left);
1463 get_Rot_right (ir_node *node) {
1464 assert (node->op == op_Rot);
1465 return get_irn_n(node, 1);
1469 set_Rot_right (ir_node *node, ir_node *right) {
1470 assert (node->op == op_Rot);
1471 set_irn_n(node, 1, right);
1475 get_Cmp_left (ir_node *node) {
1476 assert (node->op == op_Cmp);
1477 return get_irn_n(node, 0);
1481 set_Cmp_left (ir_node *node, ir_node *left) {
1482 assert (node->op == op_Cmp);
1483 set_irn_n(node, 0, left);
1487 get_Cmp_right (ir_node *node) {
1488 assert (node->op == op_Cmp);
1489 return get_irn_n(node, 1);
1493 set_Cmp_right (ir_node *node, ir_node *right) {
1494 assert (node->op == op_Cmp);
1495 set_irn_n(node, 1, right);
1499 get_Conv_op (ir_node *node) {
1500 assert (node->op == op_Conv);
1501 return get_irn_n(node, 0);
1505 set_Conv_op (ir_node *node, ir_node *op) {
1506 assert (node->op == op_Conv);
1507 set_irn_n(node, 0, op);
1511 get_Phi_preds_arr (ir_node *node) {
1512 assert (node->op == op_Phi);
1513 return (ir_node **)&(get_irn_in(node)[1]);
1517 get_Phi_n_preds (ir_node *node) {
1518 assert (node->op == op_Phi);
1519 return (get_irn_arity(node));
1523 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1524 assert (node->op == op_Phi);
1529 get_Phi_pred (ir_node *node, int pos) {
1530 assert (node->op == op_Phi);
1531 return get_irn_n(node, pos);
1535 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1536 assert (node->op == op_Phi);
1537 set_irn_n(node, pos, pred);
1541 get_Load_mem (ir_node *node) {
1542 assert (node->op == op_Load);
1543 return get_irn_n(node, 0);
1547 set_Load_mem (ir_node *node, ir_node *mem) {
1548 assert (node->op == op_Load);
1549 set_irn_n(node, 0, mem);
1553 get_Load_ptr (ir_node *node) {
1554 assert (node->op == op_Load);
1555 return get_irn_n(node, 1);
1559 set_Load_ptr (ir_node *node, ir_node *ptr) {
1560 assert (node->op == op_Load);
1561 set_irn_n(node, 1, ptr);
1566 get_Store_mem (ir_node *node) {
1567 assert (node->op == op_Store);
1568 return get_irn_n(node, 0);
1572 set_Store_mem (ir_node *node, ir_node *mem) {
1573 assert (node->op == op_Store);
1574 set_irn_n(node, 0, mem);
1578 get_Store_ptr (ir_node *node) {
1579 assert (node->op == op_Store);
1580 return get_irn_n(node, 1);
1584 set_Store_ptr (ir_node *node, ir_node *ptr) {
1585 assert (node->op == op_Store);
1586 set_irn_n(node, 1, ptr);
1590 get_Store_value (ir_node *node) {
1591 assert (node->op == op_Store);
1592 return get_irn_n(node, 2);
1596 set_Store_value (ir_node *node, ir_node *value) {
1597 assert (node->op == op_Store);
1598 set_irn_n(node, 2, value);
1602 get_Alloc_mem (ir_node *node) {
1603 assert (node->op == op_Alloc);
1604 return get_irn_n(node, 0);
1608 set_Alloc_mem (ir_node *node, ir_node *mem) {
1609 assert (node->op == op_Alloc);
1610 set_irn_n(node, 0, mem);
1614 get_Alloc_size (ir_node *node) {
1615 assert (node->op == op_Alloc);
1616 return get_irn_n(node, 1);
1620 set_Alloc_size (ir_node *node, ir_node *size) {
1621 assert (node->op == op_Alloc);
1622 set_irn_n(node, 1, size);
1626 get_Alloc_type (ir_node *node) {
1627 assert (node->op == op_Alloc);
1628 return node->attr.a.type = skip_tid(node->attr.a.type);
1632 set_Alloc_type (ir_node *node, type *type) {
1633 assert (node->op == op_Alloc);
1634 node->attr.a.type = type;
1638 get_Alloc_where (ir_node *node) {
1639 assert (node->op == op_Alloc);
1640 return node->attr.a.where;
1644 set_Alloc_where (ir_node *node, where_alloc where) {
1645 assert (node->op == op_Alloc);
1646 node->attr.a.where = where;
1651 get_Free_mem (ir_node *node) {
1652 assert (node->op == op_Free);
1653 return get_irn_n(node, 0);
1657 set_Free_mem (ir_node *node, ir_node *mem) {
1658 assert (node->op == op_Free);
1659 set_irn_n(node, 0, mem);
1663 get_Free_ptr (ir_node *node) {
1664 assert (node->op == op_Free);
1665 return get_irn_n(node, 1);
1669 set_Free_ptr (ir_node *node, ir_node *ptr) {
1670 assert (node->op == op_Free);
1671 set_irn_n(node, 1, ptr);
1675 get_Free_size (ir_node *node) {
1676 assert (node->op == op_Free);
1677 return get_irn_n(node, 2);
1681 set_Free_size (ir_node *node, ir_node *size) {
1682 assert (node->op == op_Free);
1683 set_irn_n(node, 2, size);
1687 get_Free_type (ir_node *node) {
1688 assert (node->op == op_Free);
1689 return node->attr.f = skip_tid(node->attr.f);
1693 set_Free_type (ir_node *node, type *type) {
1694 assert (node->op == op_Free);
1695 node->attr.f = type;
1699 get_Sync_preds_arr (ir_node *node) {
1700 assert (node->op == op_Sync);
1701 return (ir_node **)&(get_irn_in(node)[1]);
1705 get_Sync_n_preds (ir_node *node) {
1706 assert (node->op == op_Sync);
1707 return (get_irn_arity(node));
1712 set_Sync_n_preds (ir_node *node, int n_preds) {
1713 assert (node->op == op_Sync);
1718 get_Sync_pred (ir_node *node, int pos) {
1719 assert (node->op == op_Sync);
1720 return get_irn_n(node, pos);
1724 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1725 assert (node->op == op_Sync);
1726 set_irn_n(node, pos, pred);
1730 get_Proj_pred (ir_node *node) {
1731 assert (node->op == op_Proj);
1732 return get_irn_n(node, 0);
1736 set_Proj_pred (ir_node *node, ir_node *pred) {
1737 assert (node->op == op_Proj);
1738 set_irn_n(node, 0, pred);
1742 get_Proj_proj (ir_node *node) {
1743 assert (node->op == op_Proj);
1744 return node->attr.proj;
1748 set_Proj_proj (ir_node *node, long proj) {
1749 assert (node->op == op_Proj);
1750 node->attr.proj = proj;
1754 get_Tuple_preds_arr (ir_node *node) {
1755 assert (node->op == op_Tuple);
1756 return (ir_node **)&(get_irn_in(node)[1]);
1760 get_Tuple_n_preds (ir_node *node) {
1761 assert (node->op == op_Tuple);
1762 return (get_irn_arity(node));
1767 set_Tuple_n_preds (ir_node *node, int n_preds) {
1768 assert (node->op == op_Tuple);
1773 get_Tuple_pred (ir_node *node, int pos) {
1774 assert (node->op == op_Tuple);
1775 return get_irn_n(node, pos);
1779 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1780 assert (node->op == op_Tuple);
1781 set_irn_n(node, pos, pred);
1785 get_Id_pred (ir_node *node) {
1786 assert (node->op == op_Id);
1787 return get_irn_n(node, 0);
1791 set_Id_pred (ir_node *node, ir_node *pred) {
1792 assert (node->op == op_Id);
1793 set_irn_n(node, 0, pred);
1796 /******************************************************************/
1797 /* Auxiliary routines */
1798 /******************************************************************/
1801 skip_Proj (ir_node *node) {
1802 /* don't assert node !!! */
1803 if (node && (node->op == op_Proj)) {
1804 return get_Proj_pred(node);
1811 skip_Tuple (ir_node *node) {
1812 if ((node->op == op_Proj) && (get_irn_op(get_Proj_pred(node)) == op_Tuple))
1813 return get_Tuple_pred(get_Proj_pred(node), get_Proj_proj(node));
1819 skip_nop (ir_node *node) {
1820 /* don't assert node !!! */
1822 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1823 /* Don't use get_Id_pred: We get into an endless loop for
1824 self-referencing Ids. */
1825 assert (get_irn_arity (node) > 0);
1826 return node->in[0+1];
1833 skip_Id (ir_node *node) {
1834 return skip_nop(node);
1838 is_Bad (ir_node *node) {
1840 if ((node) && get_irn_opcode(node) == iro_Bad)
1846 is_no_Block (ir_node *node) {
1848 return (get_irn_opcode(node) != iro_Block);
1851 /* Returns true if the operation manipulates control flow. */
1853 is_cfop(ir_node *node) {
1854 return is_cfopcode(get_irn_op(node));
1857 /* Returns true if the operation can change the control flow because
1860 is_fragile_op(ir_node *node) {
1861 return ( (get_irn_opcode(node) == iro_Call)
1862 || (get_irn_opcode(node) == iro_Quot)
1863 || (get_irn_opcode(node) == iro_DivMod)
1864 || (get_irn_opcode(node) == iro_Div)
1865 || (get_irn_opcode(node) == iro_Mod)
1866 || (get_irn_opcode(node) == iro_Load)
1867 || (get_irn_opcode(node) == iro_Store)
1868 || (get_irn_opcode(node) == iro_Alloc)
1869 || (get_irn_opcode(node) == iro_Bad));
1873 /* Returns the memory operand of fragile operations. */
1874 ir_node *get_fragile_op_mem(ir_node *node) {
1875 assert(node && is_fragile_op(node));
1877 switch (get_irn_opcode (node)) {
1886 return get_irn_n(node, 0);