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) {
326 /* Outputs a unique number for this node */
328 get_irn_node_nr(ir_node *node) {
330 return node->node_nr;
335 get_irn_const_attr (ir_node *node)
337 assert (node->op == op_Const);
338 return node->attr.con;
342 get_irn_proj_attr (ir_node *node)
344 assert (node->op == op_Proj);
345 return node->attr.proj;
349 get_irn_alloc_attr (ir_node *node)
351 assert (node->op == op_Alloc);
356 get_irn_free_attr (ir_node *node)
358 assert (node->op == op_Free);
359 return node->attr.f = skip_tid(node->attr.f);
363 get_irn_symconst_attr (ir_node *node)
365 assert (node->op == op_SymConst);
370 get_irn_call_attr (ir_node *node)
372 assert (node->op == op_Call);
373 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
377 get_irn_sel_attr (ir_node *node)
379 assert (node->op == op_Sel);
384 get_irn_phi_attr (ir_node *node)
386 assert (node->op == op_Phi);
387 return node->attr.phi0_pos;
391 get_irn_block_attr (ir_node *node)
393 assert (node->op == op_Block);
394 return node->attr.block;
397 /** manipulate fields of individual nodes **/
399 /* this works for all except Block */
401 get_nodes_Block (ir_node *node) {
402 assert (!(node->op == op_Block));
403 return get_irn_n(node, -1);
407 set_nodes_Block (ir_node *node, ir_node *block) {
408 assert (!(node->op == op_Block));
409 set_irn_n(node, -1, block);
412 /* Returns an array with the predecessors of the Block. Depending on
413 the implementation of the graph datastructure this can be a copy of
414 the internal representation of predecessors as well as the internal
415 array itself. Therefore writing to this array might obstruct the ir. */
417 get_Block_cfgpred_arr (ir_node *node)
419 assert ((node->op == op_Block));
420 return (ir_node **)&(get_irn_in(node)[1]);
425 get_Block_n_cfgpreds (ir_node *node) {
426 assert ((node->op == op_Block));
427 return (get_irn_arity(node));
432 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
433 assert ((node->op == op_Block));
438 get_Block_cfgpred (ir_node *node, int pos) {
439 assert (node->op == op_Block);
440 return get_irn_n(node, pos);
444 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
445 assert (node->op == op_Block);
446 set_irn_n(node, pos, pred);
450 get_Block_matured (ir_node *node) {
451 assert (node->op == op_Block);
452 return node->attr.block.matured;
456 set_Block_matured (ir_node *node, bool matured) {
457 assert (node->op == op_Block);
458 node->attr.block.matured = matured;
461 get_Block_block_visited (ir_node *node) {
462 assert (node->op == op_Block);
463 return node->attr.block.block_visited;
467 set_Block_block_visited (ir_node *node, unsigned long visit) {
468 assert (node->op == op_Block);
469 node->attr.block.block_visited = visit;
472 /* For this current_ir_graph must be set. */
473 inline void mark_Block_block_visited (ir_node *node) {
474 assert (node->op == op_Block);
475 node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
478 inline int Block_not_block_visited(ir_node *node) {
479 assert (node->op == op_Block);
480 return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
484 get_Block_graph_arr (ir_node *node, int pos) {
485 assert (node->op == op_Block);
486 return node->attr.block.graph_arr[pos+1];
490 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
491 assert (node->op == op_Block);
492 node->attr.block.graph_arr[pos+1] = value;
496 get_End_n_keepalives(ir_node *end) {
497 assert (end->op == op_End);
498 return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
502 get_End_keepalive(ir_node *end, int pos) {
503 assert (end->op == op_End);
504 return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
508 add_End_keepalive (ir_node *end, ir_node *ka) {
509 assert (end->op == op_End);
510 ARR_APP1 (ir_node *, end->in, ka);
514 free_End (ir_node *end) {
515 /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */
516 end->in = NULL; /* @@@ make sure we get an error if we use the in array afterwards ... */
520 > Implementing the case construct (which is where the constant Proj node is
521 > important) involves far more than simply determining the constant values.
522 > We could argue that this is more properly a function of the translator from
523 > Firm to the target machine. That could be done if there was some way of
524 > projecting "default" out of the Cond node.
525 I know it's complicated.
526 Basically there are two proglems:
527 - determining the gaps between the projs
528 - determining the biggest case constant to konw the proj number for
530 I see several solutions:
531 1. Introduce a ProjDefault node. Solves both problems.
532 This means to extend all optimizations executed during construction.
533 2. Give the Cond node for switch two flavors:
534 a) there are no gaps in the projs (existing flavor)
535 b) gaps may exist, default proj is still the Proj with the largest
536 projection number. This covers also the gaps.
537 3. Fix the semantic of the Cond to that of 2b)
539 Solution 2 seems to be the best:
540 Computing the gaps in the Firm representation is not too hard, i.e.,
541 libfirm can implement a routine that transforms betweeen the two
542 flavours. This is also possible for 1) but 2) does not require to
543 change any existing optimization.
544 Further it should be far simpler to determine the biggest constant than
546 I don't want to choose 3) as 2a) seems to have advantages for
547 dataflow analysis and 3) does not allow to convert the representation to
551 get_Cond_selector (ir_node *node) {
552 assert (node->op == op_Cond);
553 return get_irn_n(node, 0);
557 set_Cond_selector (ir_node *node, ir_node *selector) {
558 assert (node->op == op_Cond);
559 set_irn_n(node, 0, selector);
563 get_Cond_kind (ir_node *node) {
564 assert (node->op == op_Cond);
565 return node->attr.c.kind;
569 set_Cond_kind (ir_node *node, cond_kind kind) {
570 assert (node->op == op_Cond);
571 node->attr.c.kind = kind;
575 get_Return_mem (ir_node *node) {
576 assert (node->op == op_Return);
577 return get_irn_n(node, 0);
581 set_Return_mem (ir_node *node, ir_node *mem) {
582 assert (node->op == op_Return);
583 set_irn_n(node, 0, mem);
587 get_Return_res_arr (ir_node *node)
589 assert ((node->op == op_Return));
590 if (get_Return_n_res(node) > 0)
591 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
597 get_Return_n_res (ir_node *node) {
598 assert (node->op == op_Return);
599 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
604 set_Return_n_res (ir_node *node, int results) {
605 assert (node->op == op_Return);
610 get_Return_res (ir_node *node, int pos) {
611 assert (node->op == op_Return);
612 assert (get_Return_n_res(node) > pos);
613 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
617 set_Return_res (ir_node *node, int pos, ir_node *res){
618 assert (node->op == op_Return);
619 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
623 get_Raise_mem (ir_node *node) {
624 assert (node->op == op_Return);
625 return get_irn_n(node, 0);
629 set_Raise_mem (ir_node *node, ir_node *mem) {
630 assert (node->op == op_Raise);
631 set_irn_n(node, 0, mem);
635 get_Raise_exo_ptr (ir_node *node) {
636 assert (node->op == op_Raise);
637 return get_irn_n(node, 1);
641 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
642 assert (node->op == op_Raise);
643 set_irn_n(node, 1, exo_ptr);
646 inline tarval *get_Const_tarval (ir_node *node) {
647 assert (node->op == op_Const);
648 return get_irn_const_attr(node);
652 set_Const_tarval (ir_node *node, tarval *con) {
653 assert (node->op == op_Const);
654 node->attr.con = con;
658 get_SymConst_kind (ir_node *node) {
659 assert (node->op == op_SymConst);
660 return node->attr.i.num;
664 set_SymConst_kind (ir_node *node, symconst_kind num) {
665 assert (node->op == op_SymConst);
666 node->attr.i.num = num;
670 get_SymConst_type (ir_node *node) {
671 assert ( (node->op == op_SymConst)
672 && ( get_SymConst_kind(node) == type_tag
673 || get_SymConst_kind(node) == size));
674 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
678 set_SymConst_type (ir_node *node, type *type) {
679 assert ( (node->op == op_SymConst)
680 && ( get_SymConst_kind(node) == type_tag
681 || get_SymConst_kind(node) == size));
682 node->attr.i.tori.typ = type;
686 get_SymConst_ptrinfo (ir_node *node) {
687 assert ( (node->op == op_SymConst)
688 && (get_SymConst_kind(node) == linkage_ptr_info));
689 return node->attr.i.tori.ptrinfo;
693 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
694 assert ( (node->op == op_SymConst)
695 && (get_SymConst_kind(node) == linkage_ptr_info));
696 node->attr.i.tori.ptrinfo = ptrinfo;
700 get_SymConst_type_or_id (ir_node *node) {
701 assert (node->op == op_SymConst);
702 return &(node->attr.i.tori);
706 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
707 assert (node->op == op_SymConst);
708 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
712 get_Sel_mem (ir_node *node) {
713 assert (node->op == op_Sel);
714 return get_irn_n(node, 0);
718 set_Sel_mem (ir_node *node, ir_node *mem) {
719 assert (node->op == op_Sel);
720 set_irn_n(node, 0, mem);
724 get_Sel_ptr (ir_node *node) {
725 assert (node->op == op_Sel);
726 return get_irn_n(node, 1);
730 set_Sel_ptr (ir_node *node, ir_node *ptr) {
731 assert (node->op == op_Sel);
732 set_irn_n(node, 1, ptr);
736 get_Sel_index_arr (ir_node *node)
738 assert ((node->op == op_Sel));
739 if (get_Sel_n_index(node) > 0)
740 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
746 get_Sel_n_index (ir_node *node) {
747 assert (node->op == op_Sel);
748 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
753 set_Sel_n_index (ir_node *node, int n_index) {
754 assert (node->op == op_Sel);
759 get_Sel_index (ir_node *node, int pos) {
760 assert (node->op == op_Sel);
761 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
765 set_Sel_index (ir_node *node, int pos, ir_node *index) {
766 assert (node->op == op_Sel);
767 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
771 get_Sel_entity (ir_node *node) {
772 assert (node->op == op_Sel);
773 return node->attr.s.ent;
777 set_Sel_entity (ir_node *node, entity *ent) {
778 assert (node->op == op_Sel);
779 node->attr.s.ent = ent;
783 get_Sel_linkage_type (ir_node *node) {
784 assert (node->op == op_Sel);
785 return node->attr.s.ltyp;
789 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
790 assert (node->op == op_Sel);
791 node->attr.s.ltyp = lt;
795 get_Call_mem (ir_node *node) {
796 assert (node->op == op_Call);
797 return get_irn_n(node, 0);
801 set_Call_mem (ir_node *node, ir_node *mem) {
802 assert (node->op == op_Call);
803 set_irn_n(node, 0, mem);
807 get_Call_ptr (ir_node *node) {
808 assert (node->op == op_Call);
809 return get_irn_n(node, 1);
813 set_Call_ptr (ir_node *node, ir_node *ptr) {
814 assert (node->op == op_Call);
815 set_irn_n(node, 1, ptr);
819 get_Call_param_arr (ir_node *node) {
820 assert (node->op == op_Call);
821 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
825 get_Call_n_params (ir_node *node) {
826 assert (node->op == op_Call);
827 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
831 get_Call_arity (ir_node *node) {
832 assert (node->op == op_Call);
833 return get_Call_n_params(node);
837 set_Call_arity (ir_node *node, ir_node *arity) {
838 assert (node->op == op_Call);
843 get_Call_param (ir_node *node, int pos) {
844 assert (node->op == op_Call);
845 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
849 set_Call_param (ir_node *node, int pos, ir_node *param) {
850 assert (node->op == op_Call);
851 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
855 get_Call_type (ir_node *node) {
856 assert (node->op == op_Call);
857 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
861 set_Call_type (ir_node *node, type *type) {
862 assert (node->op == op_Call);
863 assert (is_method_type(type));
864 node->attr.call.cld_tp = type;
867 /* For unary and binary arithmetic operations the access to the
868 operands can be factored out. Left is the first, right the
869 second arithmetic value as listed in tech report 0999-33.
870 unops are: Minus, Abs, Not, Conv
871 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
872 Shr, Shrs, Rotate, Cmp */
875 is_unop (ir_node *node) {
876 return ( node->op == op_Minus ||
877 node->op == op_Abs ||
878 node->op == op_Not ||
879 node->op == op_Conv );
883 get_unop_op (ir_node *node) {
884 assert ( node->op == op_Minus ||
885 node->op == op_Abs ||
886 node->op == op_Not ||
887 node->op == op_Conv );
888 switch (get_irn_opcode (node)) {
889 case iro_Minus: return get_Minus_op(node); break;
890 case iro_Abs: return get_Abs_op(node); break;
891 case iro_Not: return get_Not_op(node); break;
892 case iro_Conv: return get_Conv_op(node); break;
893 default: return NULL;
898 set_unop_op (ir_node *node, ir_node *op) {
899 assert (node->op == op_Minus ||
900 node->op == op_Abs ||
901 node->op == op_Not ||
902 node->op == op_Conv );
903 switch (get_irn_opcode (node)) {
904 case iro_Minus: set_Minus_op(node, op); break;
905 case iro_Abs: set_Abs_op(node, op); break;
906 case iro_Not: set_Not_op(node, op); break;
907 case iro_Conv: set_Conv_op(node, op); break;
914 is_binop (ir_node *node) {
915 return (node->op == op_Add ||
916 node->op == op_Sub ||
917 node->op == op_Mul ||
918 node->op == op_Quot ||
919 node->op == op_DivMod ||
920 node->op == op_Div ||
921 node->op == op_Mod ||
922 node->op == op_And ||
924 node->op == op_Eor ||
925 node->op == op_Shl ||
926 node->op == op_Shr ||
927 node->op == op_Shrs ||
928 node->op == op_Rot ||
929 node->op == op_Cmp );
933 get_binop_left (ir_node *node) {
934 assert (node->op == op_Add ||
935 node->op == op_Sub ||
936 node->op == op_Mul ||
937 node->op == op_Quot ||
938 node->op == op_DivMod ||
939 node->op == op_Div ||
940 node->op == op_Mod ||
941 node->op == op_And ||
943 node->op == op_Eor ||
944 node->op == op_Shl ||
945 node->op == op_Shr ||
946 node->op == op_Shrs ||
947 node->op == op_Rot ||
948 node->op == op_Cmp );
950 switch (get_irn_opcode (node)) {
951 case iro_Add : return get_Add_left(node); break;
952 case iro_Sub : return get_Sub_left(node); break;
953 case iro_Mul : return get_Mul_left(node); break;
954 case iro_Quot : return get_Quot_left(node); break;
955 case iro_DivMod: return get_DivMod_left(node); break;
956 case iro_Div : return get_Div_left(node); break;
957 case iro_Mod : return get_Mod_left(node); break;
958 case iro_And : return get_And_left(node); break;
959 case iro_Or : return get_Or_left(node); break;
960 case iro_Eor : return get_Eor_left(node); break;
961 case iro_Shl : return get_Shl_left(node); break;
962 case iro_Shr : return get_Shr_left(node); break;
963 case iro_Shrs : return get_Shrs_left(node); break;
964 case iro_Rot : return get_Rot_left(node); break;
965 case iro_Cmp : return get_Cmp_left(node); break;
966 default: return NULL;
971 set_binop_left (ir_node *node, ir_node *left) {
972 assert (node->op == op_Add ||
973 node->op == op_Sub ||
974 node->op == op_Mul ||
975 node->op == op_Quot ||
976 node->op == op_DivMod ||
977 node->op == op_Div ||
978 node->op == op_Mod ||
979 node->op == op_And ||
981 node->op == op_Eor ||
982 node->op == op_Shl ||
983 node->op == op_Shr ||
984 node->op == op_Shrs ||
985 node->op == op_Rot ||
986 node->op == op_Cmp );
988 switch (get_irn_opcode (node)) {
989 case iro_Add : set_Add_left(node, left); break;
990 case iro_Sub : set_Sub_left(node, left); break;
991 case iro_Mul : set_Mul_left(node, left); break;
992 case iro_Quot : set_Quot_left(node, left); break;
993 case iro_DivMod: set_DivMod_left(node, left); break;
994 case iro_Div : set_Div_left(node, left); break;
995 case iro_Mod : set_Mod_left(node, left); break;
996 case iro_And : set_And_left(node, left); break;
997 case iro_Or : set_Or_left(node, left); break;
998 case iro_Eor : set_Eor_left(node, left); break;
999 case iro_Shl : set_Shl_left(node, left); break;
1000 case iro_Shr : set_Shr_left(node, left); break;
1001 case iro_Shrs : set_Shrs_left(node, left); break;
1002 case iro_Rot : set_Rot_left(node, left); break;
1003 case iro_Cmp : set_Cmp_left(node, left); break;
1009 get_binop_right (ir_node *node) {
1010 assert (node->op == op_Add ||
1011 node->op == op_Sub ||
1012 node->op == op_Mul ||
1013 node->op == op_Quot ||
1014 node->op == op_DivMod ||
1015 node->op == op_Div ||
1016 node->op == op_Mod ||
1017 node->op == op_And ||
1018 node->op == op_Or ||
1019 node->op == op_Eor ||
1020 node->op == op_Shl ||
1021 node->op == op_Shr ||
1022 node->op == op_Shrs ||
1023 node->op == op_Rot ||
1024 node->op == op_Cmp );
1026 switch (get_irn_opcode (node)) {
1027 case iro_Add : return get_Add_right(node); break;
1028 case iro_Sub : return get_Sub_right(node); break;
1029 case iro_Mul : return get_Mul_right(node); break;
1030 case iro_Quot : return get_Quot_right(node); break;
1031 case iro_DivMod: return get_DivMod_right(node); break;
1032 case iro_Div : return get_Div_right(node); break;
1033 case iro_Mod : return get_Mod_right(node); break;
1034 case iro_And : return get_And_right(node); break;
1035 case iro_Or : return get_Or_right(node); break;
1036 case iro_Eor : return get_Eor_right(node); break;
1037 case iro_Shl : return get_Shl_right(node); break;
1038 case iro_Shr : return get_Shr_right(node); break;
1039 case iro_Shrs : return get_Shrs_right(node); break;
1040 case iro_Rot : return get_Rot_right(node); break;
1041 case iro_Cmp : return get_Cmp_right(node); break;
1042 default: return NULL;
1047 set_binop_right (ir_node *node, ir_node *right) {
1048 assert (node->op == op_Add ||
1049 node->op == op_Sub ||
1050 node->op == op_Mul ||
1051 node->op == op_Quot ||
1052 node->op == op_DivMod ||
1053 node->op == op_Div ||
1054 node->op == op_Mod ||
1055 node->op == op_And ||
1056 node->op == op_Or ||
1057 node->op == op_Eor ||
1058 node->op == op_Shl ||
1059 node->op == op_Shr ||
1060 node->op == op_Shrs ||
1061 node->op == op_Rot ||
1062 node->op == op_Cmp );
1064 switch (get_irn_opcode (node)) {
1065 case iro_Add : set_Add_right(node, right); break;
1066 case iro_Sub : set_Sub_right(node, right); break;
1067 case iro_Mul : set_Mul_right(node, right); break;
1068 case iro_Quot : set_Quot_right(node, right); break;
1069 case iro_DivMod: set_DivMod_right(node, right); break;
1070 case iro_Div : set_Div_right(node, right); break;
1071 case iro_Mod : set_Mod_right(node, right); break;
1072 case iro_And : set_And_right(node, right); break;
1073 case iro_Or : set_Or_right(node, right); break;
1074 case iro_Eor : set_Eor_right(node, right); break;
1075 case iro_Shl : set_Shl_right(node, right); break;
1076 case iro_Shr : set_Shr_right(node, right); break;
1077 case iro_Shrs : set_Shrs_right(node, right); break;
1078 case iro_Rot : set_Rot_right(node, right); break;
1079 case iro_Cmp : set_Cmp_right(node, right); break;
1085 get_Add_left (ir_node *node) {
1086 assert (node->op == op_Add);
1087 return get_irn_n(node, 0);
1091 set_Add_left (ir_node *node, ir_node *left) {
1092 assert (node->op == op_Add);
1093 set_irn_n(node, 0, left);
1097 get_Add_right (ir_node *node) {
1098 assert (node->op == op_Add);
1099 return get_irn_n(node, 1);
1103 set_Add_right (ir_node *node, ir_node *right) {
1104 assert (node->op == op_Add);
1105 set_irn_n(node, 1, right);
1109 get_Sub_left (ir_node *node) {
1110 assert (node->op == op_Sub);
1111 return get_irn_n(node, 0);
1115 set_Sub_left (ir_node *node, ir_node *left) {
1116 assert (node->op == op_Sub);
1117 set_irn_n(node, 0, left);
1121 get_Sub_right (ir_node *node) {
1122 assert (node->op == op_Sub);
1123 return get_irn_n(node, 1);
1127 set_Sub_right (ir_node *node, ir_node *right) {
1128 assert (node->op == op_Sub);
1129 set_irn_n(node, 1, right);
1134 get_Minus_op (ir_node *node) {
1135 assert (node->op == op_Minus);
1136 return get_irn_n(node, 0);
1140 set_Minus_op (ir_node *node, ir_node *op) {
1141 assert (node->op == op_Minus);
1142 set_irn_n(node, 0, op);
1147 get_Mul_left (ir_node *node) {
1148 assert (node->op == op_Mul);
1149 return get_irn_n(node, 0);
1153 set_Mul_left (ir_node *node, ir_node *left) {
1154 assert (node->op == op_Mul);
1155 set_irn_n(node, 0, left);
1159 get_Mul_right (ir_node *node) {
1160 assert (node->op == op_Mul);
1161 return get_irn_n(node, 1);
1165 set_Mul_right (ir_node *node, ir_node *right) {
1166 assert (node->op == op_Mul);
1167 set_irn_n(node, 1, right);
1171 get_Quot_left (ir_node *node) {
1172 assert (node->op == op_Quot);
1173 return get_irn_n(node, 1);
1177 set_Quot_left (ir_node *node, ir_node *left) {
1178 assert (node->op == op_Quot);
1179 set_irn_n(node, 1, left);
1183 get_Quot_right (ir_node *node) {
1184 assert (node->op == op_Quot);
1185 return get_irn_n(node, 2);
1189 set_Quot_right (ir_node *node, ir_node *right) {
1190 assert (node->op == op_Quot);
1191 set_irn_n(node, 2, right);
1195 get_Quot_mem (ir_node *node) {
1196 assert (node->op == op_Quot);
1197 return get_irn_n(node, 0);
1201 set_Quot_mem (ir_node *node, ir_node *mem) {
1202 assert (node->op == op_Quot);
1203 set_irn_n(node, 0, mem);
1207 get_DivMod_left (ir_node *node) {
1208 assert (node->op == op_DivMod);
1209 return get_irn_n(node, 1);
1213 set_DivMod_left (ir_node *node, ir_node *left) {
1214 assert (node->op == op_DivMod);
1215 set_irn_n(node, 1, left);
1219 get_DivMod_right (ir_node *node) {
1220 assert (node->op == op_DivMod);
1221 return get_irn_n(node, 2);
1225 set_DivMod_right (ir_node *node, ir_node *right) {
1226 assert (node->op == op_DivMod);
1227 set_irn_n(node, 2, right);
1231 get_DivMod_mem (ir_node *node) {
1232 assert (node->op == op_DivMod);
1233 return get_irn_n(node, 0);
1237 set_DivMod_mem (ir_node *node, ir_node *mem) {
1238 assert (node->op == op_DivMod);
1239 set_irn_n(node, 0, mem);
1243 get_Div_left (ir_node *node) {
1244 assert (node->op == op_Div);
1245 return get_irn_n(node, 1);
1249 set_Div_left (ir_node *node, ir_node *left) {
1250 assert (node->op == op_Div);
1251 set_irn_n(node, 1, left);
1255 get_Div_right (ir_node *node) {
1256 assert (node->op == op_Div);
1257 return get_irn_n(node, 2);
1261 set_Div_right (ir_node *node, ir_node *right) {
1262 assert (node->op == op_Div);
1263 set_irn_n(node, 2, right);
1267 get_Div_mem (ir_node *node) {
1268 assert (node->op == op_Div);
1269 return get_irn_n(node, 0);
1273 set_Div_mem (ir_node *node, ir_node *mem) {
1274 assert (node->op == op_Div);
1275 set_irn_n(node, 0, mem);
1279 get_Mod_left (ir_node *node) {
1280 assert (node->op == op_Mod);
1281 return get_irn_n(node, 1);
1285 set_Mod_left (ir_node *node, ir_node *left) {
1286 assert (node->op == op_Mod);
1287 set_irn_n(node, 1, left);
1291 get_Mod_right (ir_node *node) {
1292 assert (node->op == op_Mod);
1293 return get_irn_n(node, 2);
1297 set_Mod_right (ir_node *node, ir_node *right) {
1298 assert (node->op == op_Mod);
1299 set_irn_n(node, 2, right);
1303 get_Mod_mem (ir_node *node) {
1304 assert (node->op == op_Mod);
1305 return get_irn_n(node, 0);
1309 set_Mod_mem (ir_node *node, ir_node *mem) {
1310 assert (node->op == op_Mod);
1311 set_irn_n(node, 0, mem);
1315 get_Abs_op (ir_node *node) {
1316 assert (node->op == op_Abs);
1317 return get_irn_n(node, 0);
1321 set_Abs_op (ir_node *node, ir_node *op) {
1322 assert (node->op == op_Abs);
1323 set_irn_n(node, 0, op);
1327 get_And_left (ir_node *node) {
1328 assert (node->op == op_And);
1329 return get_irn_n(node, 0);
1333 set_And_left (ir_node *node, ir_node *left) {
1334 assert (node->op == op_And);
1335 set_irn_n(node, 0, left);
1339 get_And_right (ir_node *node) {
1340 assert (node->op == op_And);
1341 return get_irn_n(node, 1);
1345 set_And_right (ir_node *node, ir_node *right) {
1346 assert (node->op == op_And);
1347 set_irn_n(node, 1, right);
1351 get_Or_left (ir_node *node) {
1352 assert (node->op == op_Or);
1353 return get_irn_n(node, 0);
1357 set_Or_left (ir_node *node, ir_node *left) {
1358 assert (node->op == op_Or);
1359 set_irn_n(node, 0, left);
1363 get_Or_right (ir_node *node) {
1364 assert (node->op == op_Or);
1365 return get_irn_n(node, 1);
1369 set_Or_right (ir_node *node, ir_node *right) {
1370 assert (node->op == op_Or);
1371 set_irn_n(node, 1, right);
1375 get_Eor_left (ir_node *node) {
1376 assert (node->op == op_Eor);
1377 return get_irn_n(node, 0);
1381 set_Eor_left (ir_node *node, ir_node *left) {
1382 assert (node->op == op_Eor);
1383 set_irn_n(node, 0, left);
1387 get_Eor_right (ir_node *node) {
1388 assert (node->op == op_Eor);
1389 return get_irn_n(node, 1);
1393 set_Eor_right (ir_node *node, ir_node *right) {
1394 assert (node->op == op_Eor);
1395 set_irn_n(node, 1, right);
1400 get_Not_op (ir_node *node) {
1401 assert (node->op == op_Not);
1402 return get_irn_n(node, 0);
1406 set_Not_op (ir_node *node, ir_node *op) {
1407 assert (node->op == op_Not);
1408 set_irn_n(node, 0, op);
1413 get_Shl_left (ir_node *node) {
1414 assert (node->op == op_Shl);
1415 return get_irn_n(node, 0);
1419 set_Shl_left (ir_node *node, ir_node *left) {
1420 assert (node->op == op_Shl);
1421 set_irn_n(node, 0, left);
1425 get_Shl_right (ir_node *node) {
1426 assert (node->op == op_Shl);
1427 return get_irn_n(node, 1);
1431 set_Shl_right (ir_node *node, ir_node *right) {
1432 assert (node->op == op_Shl);
1433 set_irn_n(node, 1, right);
1437 get_Shr_left (ir_node *node) {
1438 assert (node->op == op_Shr);
1439 return get_irn_n(node, 0);
1443 set_Shr_left (ir_node *node, ir_node *left) {
1444 assert (node->op == op_Shr);
1445 set_irn_n(node, 0, left);
1449 get_Shr_right (ir_node *node) {
1450 assert (node->op == op_Shr);
1451 return get_irn_n(node, 1);
1455 set_Shr_right (ir_node *node, ir_node *right) {
1456 assert (node->op == op_Shr);
1457 set_irn_n(node, 1, right);
1461 get_Shrs_left (ir_node *node) {
1462 assert (node->op == op_Shrs);
1463 return get_irn_n(node, 0);
1467 set_Shrs_left (ir_node *node, ir_node *left) {
1468 assert (node->op == op_Shrs);
1469 set_irn_n(node, 0, left);
1473 get_Shrs_right (ir_node *node) {
1474 assert (node->op == op_Shrs);
1475 return get_irn_n(node, 1);
1479 set_Shrs_right (ir_node *node, ir_node *right) {
1480 assert (node->op == op_Shrs);
1481 set_irn_n(node, 1, right);
1485 get_Rot_left (ir_node *node) {
1486 assert (node->op == op_Rot);
1487 return get_irn_n(node, 0);
1491 set_Rot_left (ir_node *node, ir_node *left) {
1492 assert (node->op == op_Rot);
1493 set_irn_n(node, 0, left);
1497 get_Rot_right (ir_node *node) {
1498 assert (node->op == op_Rot);
1499 return get_irn_n(node, 1);
1503 set_Rot_right (ir_node *node, ir_node *right) {
1504 assert (node->op == op_Rot);
1505 set_irn_n(node, 1, right);
1509 get_Cmp_left (ir_node *node) {
1510 assert (node->op == op_Cmp);
1511 return get_irn_n(node, 0);
1515 set_Cmp_left (ir_node *node, ir_node *left) {
1516 assert (node->op == op_Cmp);
1517 set_irn_n(node, 0, left);
1521 get_Cmp_right (ir_node *node) {
1522 assert (node->op == op_Cmp);
1523 return get_irn_n(node, 1);
1527 set_Cmp_right (ir_node *node, ir_node *right) {
1528 assert (node->op == op_Cmp);
1529 set_irn_n(node, 1, right);
1533 get_Conv_op (ir_node *node) {
1534 assert (node->op == op_Conv);
1535 return get_irn_n(node, 0);
1539 set_Conv_op (ir_node *node, ir_node *op) {
1540 assert (node->op == op_Conv);
1541 set_irn_n(node, 0, op);
1545 get_Phi_preds_arr (ir_node *node) {
1546 assert (node->op == op_Phi);
1547 return (ir_node **)&(get_irn_in(node)[1]);
1551 get_Phi_n_preds (ir_node *node) {
1552 assert (node->op == op_Phi);
1553 return (get_irn_arity(node));
1557 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1558 assert (node->op == op_Phi);
1563 get_Phi_pred (ir_node *node, int pos) {
1564 assert (node->op == op_Phi);
1565 return get_irn_n(node, pos);
1569 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1570 assert (node->op == op_Phi);
1571 set_irn_n(node, pos, pred);
1575 get_Load_mem (ir_node *node) {
1576 assert (node->op == op_Load);
1577 return get_irn_n(node, 0);
1581 set_Load_mem (ir_node *node, ir_node *mem) {
1582 assert (node->op == op_Load);
1583 set_irn_n(node, 0, mem);
1587 get_Load_ptr (ir_node *node) {
1588 assert (node->op == op_Load);
1589 return get_irn_n(node, 1);
1593 set_Load_ptr (ir_node *node, ir_node *ptr) {
1594 assert (node->op == op_Load);
1595 set_irn_n(node, 1, ptr);
1600 get_Store_mem (ir_node *node) {
1601 assert (node->op == op_Store);
1602 return get_irn_n(node, 0);
1606 set_Store_mem (ir_node *node, ir_node *mem) {
1607 assert (node->op == op_Store);
1608 set_irn_n(node, 0, mem);
1612 get_Store_ptr (ir_node *node) {
1613 assert (node->op == op_Store);
1614 return get_irn_n(node, 1);
1618 set_Store_ptr (ir_node *node, ir_node *ptr) {
1619 assert (node->op == op_Store);
1620 set_irn_n(node, 1, ptr);
1624 get_Store_value (ir_node *node) {
1625 assert (node->op == op_Store);
1626 return get_irn_n(node, 2);
1630 set_Store_value (ir_node *node, ir_node *value) {
1631 assert (node->op == op_Store);
1632 set_irn_n(node, 2, value);
1636 get_Alloc_mem (ir_node *node) {
1637 assert (node->op == op_Alloc);
1638 return get_irn_n(node, 0);
1642 set_Alloc_mem (ir_node *node, ir_node *mem) {
1643 assert (node->op == op_Alloc);
1644 set_irn_n(node, 0, mem);
1648 get_Alloc_size (ir_node *node) {
1649 assert (node->op == op_Alloc);
1650 return get_irn_n(node, 1);
1654 set_Alloc_size (ir_node *node, ir_node *size) {
1655 assert (node->op == op_Alloc);
1656 set_irn_n(node, 1, size);
1660 get_Alloc_type (ir_node *node) {
1661 assert (node->op == op_Alloc);
1662 return node->attr.a.type = skip_tid(node->attr.a.type);
1666 set_Alloc_type (ir_node *node, type *type) {
1667 assert (node->op == op_Alloc);
1668 node->attr.a.type = type;
1672 get_Alloc_where (ir_node *node) {
1673 assert (node->op == op_Alloc);
1674 return node->attr.a.where;
1678 set_Alloc_where (ir_node *node, where_alloc where) {
1679 assert (node->op == op_Alloc);
1680 node->attr.a.where = where;
1685 get_Free_mem (ir_node *node) {
1686 assert (node->op == op_Free);
1687 return get_irn_n(node, 0);
1691 set_Free_mem (ir_node *node, ir_node *mem) {
1692 assert (node->op == op_Free);
1693 set_irn_n(node, 0, mem);
1697 get_Free_ptr (ir_node *node) {
1698 assert (node->op == op_Free);
1699 return get_irn_n(node, 1);
1703 set_Free_ptr (ir_node *node, ir_node *ptr) {
1704 assert (node->op == op_Free);
1705 set_irn_n(node, 1, ptr);
1709 get_Free_size (ir_node *node) {
1710 assert (node->op == op_Free);
1711 return get_irn_n(node, 2);
1715 set_Free_size (ir_node *node, ir_node *size) {
1716 assert (node->op == op_Free);
1717 set_irn_n(node, 2, size);
1721 get_Free_type (ir_node *node) {
1722 assert (node->op == op_Free);
1723 return node->attr.f = skip_tid(node->attr.f);
1727 set_Free_type (ir_node *node, type *type) {
1728 assert (node->op == op_Free);
1729 node->attr.f = type;
1733 get_Sync_preds_arr (ir_node *node) {
1734 assert (node->op == op_Sync);
1735 return (ir_node **)&(get_irn_in(node)[1]);
1739 get_Sync_n_preds (ir_node *node) {
1740 assert (node->op == op_Sync);
1741 return (get_irn_arity(node));
1746 set_Sync_n_preds (ir_node *node, int n_preds) {
1747 assert (node->op == op_Sync);
1752 get_Sync_pred (ir_node *node, int pos) {
1753 assert (node->op == op_Sync);
1754 return get_irn_n(node, pos);
1758 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1759 assert (node->op == op_Sync);
1760 set_irn_n(node, pos, pred);
1764 get_Proj_pred (ir_node *node) {
1765 assert (node->op == op_Proj);
1766 return get_irn_n(node, 0);
1770 set_Proj_pred (ir_node *node, ir_node *pred) {
1771 assert (node->op == op_Proj);
1772 set_irn_n(node, 0, pred);
1776 get_Proj_proj (ir_node *node) {
1777 assert (node->op == op_Proj);
1778 return node->attr.proj;
1782 set_Proj_proj (ir_node *node, long proj) {
1783 assert (node->op == op_Proj);
1784 node->attr.proj = proj;
1788 get_Tuple_preds_arr (ir_node *node) {
1789 assert (node->op == op_Tuple);
1790 return (ir_node **)&(get_irn_in(node)[1]);
1794 get_Tuple_n_preds (ir_node *node) {
1795 assert (node->op == op_Tuple);
1796 return (get_irn_arity(node));
1801 set_Tuple_n_preds (ir_node *node, int n_preds) {
1802 assert (node->op == op_Tuple);
1807 get_Tuple_pred (ir_node *node, int pos) {
1808 assert (node->op == op_Tuple);
1809 return get_irn_n(node, pos);
1813 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1814 assert (node->op == op_Tuple);
1815 set_irn_n(node, pos, pred);
1819 get_Id_pred (ir_node *node) {
1820 assert (node->op == op_Id);
1821 return get_irn_n(node, 0);
1825 set_Id_pred (ir_node *node, ir_node *pred) {
1826 assert (node->op == op_Id);
1827 set_irn_n(node, 0, pred);
1830 /******************************************************************/
1831 /* Auxiliary routines */
1832 /******************************************************************/
1835 skip_Proj (ir_node *node) {
1836 /* don't assert node !!! */
1837 if (node && (node->op == op_Proj)) {
1838 return get_Proj_pred(node);
1845 skip_Tuple (ir_node *node) {
1847 if (get_irn_op(node) == op_Proj) {
1848 pred = skip_nop(get_Proj_pred(node));
1849 if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */
1850 pred = skip_nop(skip_Tuple(pred));
1851 if (get_irn_op(pred) == op_Tuple)
1852 return get_Tuple_pred(pred, get_Proj_proj(node));
1858 skip_nop (ir_node *node) {
1859 /* don't assert node !!! */
1861 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1862 /* Don't use get_Id_pred: We get into an endless loop for
1863 self-referencing Ids. */
1864 assert (get_irn_arity (node) > 0);
1865 return node->in[0+1];
1872 skip_Id (ir_node *node) {
1873 return skip_nop(node);
1877 is_Bad (ir_node *node) {
1879 if ((node) && get_irn_opcode(node) == iro_Bad)
1885 is_no_Block (ir_node *node) {
1887 return (get_irn_opcode(node) != iro_Block);
1890 /* Returns true if the operation manipulates control flow. */
1892 is_cfop(ir_node *node) {
1893 return is_cfopcode(get_irn_op(node));
1896 /* Returns true if the operation can change the control flow because
1899 is_fragile_op(ir_node *node) {
1900 return ( (get_irn_opcode(node) == iro_Call)
1901 || (get_irn_opcode(node) == iro_Quot)
1902 || (get_irn_opcode(node) == iro_DivMod)
1903 || (get_irn_opcode(node) == iro_Div)
1904 || (get_irn_opcode(node) == iro_Mod)
1905 || (get_irn_opcode(node) == iro_Load)
1906 || (get_irn_opcode(node) == iro_Store)
1907 || (get_irn_opcode(node) == iro_Alloc)
1908 || (get_irn_opcode(node) == iro_Bad));
1912 /* Returns the memory operand of fragile operations. */
1913 ir_node *get_fragile_op_mem(ir_node *node) {
1914 assert(node && is_fragile_op(node));
1916 switch (get_irn_opcode (node)) {
1925 return get_irn_n(node, 0);