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);
87 res->kind = k_ir_node;
93 res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */
95 res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
96 memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
101 res->node_nr = get_irp_new_node_nr();
107 /* Copies all attributes stored in the old node to the new node.
108 Assumes both have the same opcode and sufficient size. */
110 copy_attrs (ir_node *old, ir_node *new) {
111 assert (get_irn_opcode(old) == get_irn_opcode(new));
112 memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old)));
115 /* IR-Nodes with attributes */
117 ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
120 ir_node *np = XP_GETARG (ir_node *, 0);
123 XPS ("<null ir_node>");
127 XPF1 ("%I", get_irn_opident(np));
129 switch (get_irn_opcode (np)) { /* node label */
131 XPF1 ("%I", get_irn_mode(np)->name);
133 XPF1 ("%v", get_irn_const_attr);
136 if (get_irn_modecode (np) == irm_b) {
138 XP (pnc_name_arr[get_irn_proj_attr(np)]);
139 } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) {
141 XP (pns_name_arr[get_irn_proj_attr(np)]);
143 XPF1 ("%I", get_irn_mode(np)->name);
145 XPF1 ("%d", get_irn_proj_attr(np));
149 XPF1 ("%I", get_irn_mode(np)->name);
151 XP (symconst_name_arr[get_irn_symconst_attr(np).num]);
152 XPF1 (" %#N", get_type_ident(get_SymConst_type(np)));
154 case iro_Start: /* don't dump mode of these */
163 XPF1 ("%I", get_irn_mode(np)->name);
169 /** getting some parameters from ir_nodes **/
171 /* returns the number of predecessors without the block predecessor. */
173 get_irn_arity (ir_node *node)
176 return (ARR_LEN((node)->in)-1);
179 /* Returns the array with ins. This array is shifted with respect to the
180 array accessed by get_irn_n: The block operand is at position 0 not -1.
181 (@@@ This should be changed.)
182 The order of the predecessors in this array is not guaranteed, except that
183 lists of operands as predecessors of Block or arguments of a Call are
186 get_irn_in (ir_node *node)
193 set_irn_in (ir_node *node, int arity, ir_node **in) {
195 if (arity != get_irn_arity(node)) {
196 ir_node *block = node->in[0];
197 node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, (arity+1));
200 memcpy (&node->in[1], in, sizeof (ir_node *) * arity);
203 /* to iterate through the predecessors without touching the array */
204 /* To iterate over the operands iterate from 0 to i < get_irn_arity(),
205 to iterate includind the Block predecessor iterate from i = -1 to
207 If it is a block, the entry -1 is NULL. */
209 get_irn_n (ir_node *node, int n)
212 assert (get_irn_arity (node) > n);
213 return skip_nop(node->in[n+1]);
217 set_irn_n (ir_node *node, int n, ir_node *in)
220 assert (get_irn_arity (node) > n);
225 get_irn_mode (ir_node *node)
232 get_irn_modecode (ir_node *node)
235 return node->mode->code;
240 get_irn_modeident (ir_node *node)
243 return node->mode->name;
247 get_irn_op (ir_node *node)
253 /* should be private to the library: */
255 set_irn_op (ir_node *node, ir_op *op)
262 get_irn_opcode (ir_node *node)
265 return node->op->code;
269 get_irn_opname (ir_node *node)
272 return id_to_str(node->op->name);
276 get_irn_opident (ir_node *node)
279 return node->op->name;
283 get_irn_visited (ir_node *node)
286 return node->visited;
290 set_irn_visited (ir_node *node, unsigned long visited)
293 node->visited = visited;
296 set_irn_link (ir_node *node, ir_node *link) {
302 get_irn_link (ir_node *node) {
308 /* Outputs a unique number for this node */
310 get_irn_node_nr(ir_node *node) {
312 return node->node_nr;
317 get_irn_const_attr (ir_node *node)
319 assert (node->op == op_Const);
320 return node->attr.con;
324 get_irn_proj_attr (ir_node *node)
326 assert (node->op == op_Proj);
327 return node->attr.proj;
331 get_irn_alloc_attr (ir_node *node)
333 assert (node->op == op_Alloc);
338 get_irn_free_attr (ir_node *node)
340 assert (node->op == op_Free);
341 return node->attr.f = skip_tid(node->attr.f);
345 get_irn_symconst_attr (ir_node *node)
347 assert (node->op == op_SymConst);
352 get_irn_call_attr (ir_node *node)
354 assert (node->op == op_Call);
355 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
359 get_irn_sel_attr (ir_node *node)
361 assert (node->op == op_Sel);
366 get_irn_phi_attr (ir_node *node)
368 assert (node->op == op_Phi);
369 return node->attr.phi0_pos;
373 get_irn_block_attr (ir_node *node)
375 assert (node->op == op_Block);
376 return node->attr.block;
379 /** manipulate fields of individual nodes **/
381 /* this works for all except Block */
383 get_nodes_Block (ir_node *node) {
384 assert (!(node->op == op_Block));
385 return get_irn_n(node, -1);
389 set_nodes_Block (ir_node *node, ir_node *block) {
390 assert (!(node->op == op_Block));
391 set_irn_n(node, -1, block);
394 /* Returns an array with the predecessors of the Block. Depending on
395 the implementation of the graph datastructure this can be a copy of
396 the internal representation of predecessors as well as the internal
397 array itself. Therefore writing to this array might obstruct the ir. */
399 get_Block_cfgpred_arr (ir_node *node)
401 assert ((node->op == op_Block));
402 return (ir_node **)&(get_irn_in(node)[1]);
407 get_Block_n_cfgpreds (ir_node *node) {
408 assert ((node->op == op_Block));
409 return (get_irn_arity(node));
414 set_Block_n_cfgpreds (ir_node *node, int n_preds) {
415 assert ((node->op == op_Block));
420 get_Block_cfgpred (ir_node *node, int pos) {
421 assert (node->op == op_Block);
422 return get_irn_n(node, pos);
426 set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
427 assert (node->op == op_Block);
428 set_irn_n(node, pos, pred);
432 get_Block_matured (ir_node *node) {
433 assert (node->op == op_Block);
434 return node->attr.block.matured;
438 set_Block_matured (ir_node *node, bool matured) {
439 assert (node->op == op_Block);
440 node->attr.block.matured = matured;
443 get_Block_block_visited (ir_node *node) {
444 assert (node->op == op_Block);
445 return node->attr.block.block_visited;
449 set_Block_block_visited (ir_node *node, unsigned long visit) {
450 assert (node->op == op_Block);
451 node->attr.block.block_visited = visit;
455 get_Block_graph_arr (ir_node *node, int pos) {
456 assert (node->op == op_Block);
457 return node->attr.block.graph_arr[pos+1];
461 set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
462 assert (node->op == op_Block);
463 node->attr.block.graph_arr[pos+1] = value;
467 add_End_keepalive (ir_node *end, ir_node *ka) {
468 assert (end->op == op_End);
469 ARR_APP1 (ir_node *, end->in, ka);
473 > Implementing the case construct (which is where the constant Proj node is
474 > important) involves far more than simply determining the constant values.
475 > We could argue that this is more properly a function of the translator from
476 > Firm to the target machine. That could be done if there was some way of
477 > projecting "default" out of the Cond node.
478 I know it's complicated.
479 Basically there are two proglems:
480 - determining the gaps between the projs
481 - determining the biggest case constant to konw the proj number for
483 I see several solutions:
484 1. Introduce a ProjDefault node. Solves both problems.
485 This means to extend all optimizations executed during construction.
486 2. Give the Cond node for switch two flavors:
487 a) there are no gaps in the projs (existing flavor)
488 b) gaps may exist, default proj is still the Proj with the largest
489 projection number. This covers also the gaps.
490 3. Fix the semantic of the Cond to that of 2b)
492 Solution 2 seems to be the best:
493 Computing the gaps in the Firm representation is not too hard, i.e.,
494 libfirm can implement a routine that transforms betweeen the two
495 flavours. This is also possible for 1) but 2) does not require to
496 change any existing optimization.
497 Further it should be far simpler to determine the biggest constant than
499 I don't want to choose 3) as 2a) seems to have advantages for
500 dataflow analysis and 3) does not allow to convert the representation to
504 get_Cond_selector (ir_node *node) {
505 assert (node->op == op_Cond);
506 return get_irn_n(node, 0);
510 set_Cond_selector (ir_node *node, ir_node *selector) {
511 assert (node->op == op_Cond);
512 set_irn_n(node, 0, selector);
516 get_Cond_kind (ir_node *node) {
517 assert (node->op == op_Cond);
518 return node->attr.c.kind;
522 set_Cond_kind (ir_node *node, cond_kind kind) {
523 assert (node->op == op_Cond);
524 node->attr.c.kind = kind;
528 get_Return_mem (ir_node *node) {
529 assert (node->op == op_Return);
530 return get_irn_n(node, 0);
534 set_Return_mem (ir_node *node, ir_node *mem) {
535 assert (node->op == op_Return);
536 set_irn_n(node, 0, mem);
540 get_Return_res_arr (ir_node *node)
542 assert ((node->op == op_Return));
543 if (get_Return_n_res(node) > 0)
544 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
550 get_Return_n_res (ir_node *node) {
551 assert (node->op == op_Return);
552 return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
557 set_Return_n_res (ir_node *node, int results) {
558 assert (node->op == op_Return);
563 get_Return_res (ir_node *node, int pos) {
564 assert (node->op == op_Return);
565 assert (get_Return_n_res(node) > pos);
566 return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
570 set_Return_res (ir_node *node, int pos, ir_node *res){
571 assert (node->op == op_Return);
572 set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
576 get_Raise_mem (ir_node *node) {
577 assert (node->op == op_Return);
578 return get_irn_n(node, 0);
582 set_Raise_mem (ir_node *node, ir_node *mem) {
583 assert (node->op == op_Raise);
584 set_irn_n(node, 0, mem);
588 get_Raise_exo_ptr (ir_node *node) {
589 assert (node->op == op_Raise);
590 return get_irn_n(node, 1);
594 set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
595 assert (node->op == op_Raise);
596 set_irn_n(node, 1, exo_ptr);
599 inline tarval *get_Const_tarval (ir_node *node) {
600 assert (node->op == op_Const);
601 return get_irn_const_attr(node);
605 set_Const_tarval (ir_node *node, tarval *con) {
606 assert (node->op == op_Const);
607 node->attr.con = con;
611 get_SymConst_kind (ir_node *node) {
612 assert (node->op == op_SymConst);
613 return node->attr.i.num;
617 set_SymConst_kind (ir_node *node, symconst_kind num) {
618 assert (node->op == op_SymConst);
619 node->attr.i.num = num;
623 get_SymConst_type (ir_node *node) {
624 assert ( (node->op == op_SymConst)
625 && ( get_SymConst_kind(node) == type_tag
626 || get_SymConst_kind(node) == size));
627 return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
631 set_SymConst_type (ir_node *node, type *type) {
632 assert ( (node->op == op_SymConst)
633 && ( get_SymConst_kind(node) == type_tag
634 || get_SymConst_kind(node) == size));
635 node->attr.i.tori.typ = type;
639 get_SymConst_ptrinfo (ir_node *node) {
640 assert ( (node->op == op_SymConst)
641 && (get_SymConst_kind(node) == linkage_ptr_info));
642 return node->attr.i.tori.ptrinfo;
646 set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
647 assert ( (node->op == op_SymConst)
648 && (get_SymConst_kind(node) == linkage_ptr_info));
649 node->attr.i.tori.ptrinfo = ptrinfo;
653 get_SymConst_type_or_id (ir_node *node) {
654 assert (node->op == op_SymConst);
655 return &(node->attr.i.tori);
659 set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
660 assert (node->op == op_SymConst);
661 memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
665 get_Sel_mem (ir_node *node) {
666 assert (node->op == op_Sel);
667 return get_irn_n(node, 0);
671 set_Sel_mem (ir_node *node, ir_node *mem) {
672 assert (node->op == op_Sel);
673 set_irn_n(node, 0, mem);
677 get_Sel_ptr (ir_node *node) {
678 assert (node->op == op_Sel);
679 return get_irn_n(node, 1);
683 set_Sel_ptr (ir_node *node, ir_node *ptr) {
684 assert (node->op == op_Sel);
685 set_irn_n(node, 1, ptr);
689 get_Sel_index_arr (ir_node *node)
691 assert ((node->op == op_Sel));
692 if (get_Sel_n_index(node) > 0)
693 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
699 get_Sel_n_index (ir_node *node) {
700 assert (node->op == op_Sel);
701 return (get_irn_arity(node) - SEL_INDEX_OFFSET);
706 set_Sel_n_index (ir_node *node, int n_index) {
707 assert (node->op == op_Sel);
712 get_Sel_index (ir_node *node, int pos) {
713 assert (node->op == op_Sel);
714 return get_irn_n(node, pos + SEL_INDEX_OFFSET);
718 set_Sel_index (ir_node *node, int pos, ir_node *index) {
719 assert (node->op == op_Sel);
720 set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
724 get_Sel_entity (ir_node *node) {
725 assert (node->op == op_Sel);
726 return node->attr.s.ent;
730 set_Sel_entity (ir_node *node, entity *ent) {
731 assert (node->op == op_Sel);
732 node->attr.s.ent = ent;
736 get_Sel_linkage_type (ir_node *node) {
737 assert (node->op == op_Sel);
738 return node->attr.s.ltyp;
742 set_Sel_linkage_type (ir_node *node, linkage_type lt) {
743 assert (node->op == op_Sel);
744 node->attr.s.ltyp = lt;
748 get_Call_mem (ir_node *node) {
749 assert (node->op == op_Call);
750 return get_irn_n(node, 0);
754 set_Call_mem (ir_node *node, ir_node *mem) {
755 assert (node->op == op_Call);
756 set_irn_n(node, 0, mem);
760 get_Call_ptr (ir_node *node) {
761 assert (node->op == op_Call);
762 return get_irn_n(node, 1);
766 set_Call_ptr (ir_node *node, ir_node *ptr) {
767 assert (node->op == op_Call);
768 set_irn_n(node, 1, ptr);
772 get_Call_param_arr (ir_node *node) {
773 assert (node->op == op_Call);
774 return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
778 get_Call_n_params (ir_node *node) {
779 assert (node->op == op_Call);
780 return (get_irn_arity(node) - CALL_PARAM_OFFSET);
784 get_Call_arity (ir_node *node) {
785 return get_Call_n_params(node);
789 set_Call_arity (ir_node *node, ir_node *arity) {
790 assert (node->op == op_Call);
795 get_Call_param (ir_node *node, int pos) {
796 assert (node->op == op_Call);
797 return get_irn_n(node, pos + CALL_PARAM_OFFSET);
801 set_Call_param (ir_node *node, int pos, ir_node *param) {
802 assert (node->op == op_Call);
803 set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
807 get_Call_type (ir_node *node) {
808 assert (node->op == op_Call);
809 return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
813 set_Call_type (ir_node *node, type *type) {
814 assert (node->op == op_Call);
815 assert (is_method_type(type));
816 node->attr.call.cld_tp = type;
819 /* For unary and binary arithmetic operations the access to the
820 operands can be factored out. Left is the first, right the
821 second arithmetic value as listed in tech report 0999-33.
822 unops are: Minus, Abs, Not, Conv
823 binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
824 Shr, Shrs, Rotate, Cmp */
827 is_unop (ir_node *node) {
828 return ( node->op == op_Minus ||
829 node->op == op_Abs ||
830 node->op == op_Not ||
831 node->op == op_Conv );
835 get_unop_op (ir_node *node) {
836 assert ( node->op == op_Minus ||
837 node->op == op_Abs ||
838 node->op == op_Not ||
839 node->op == op_Conv );
840 switch (get_irn_opcode (node)) {
841 case iro_Minus: return get_Minus_op(node); break;
842 case iro_Abs: return get_Abs_op(node); break;
843 case iro_Not: return get_Not_op(node); break;
844 case iro_Conv: return get_Conv_op(node); break;
845 default: return NULL;
850 set_unop_op (ir_node *node, ir_node *op) {
851 assert (node->op == op_Minus ||
852 node->op == op_Abs ||
853 node->op == op_Not ||
854 node->op == op_Conv );
855 switch (get_irn_opcode (node)) {
856 case iro_Minus: set_Minus_op(node, op); break;
857 case iro_Abs: set_Abs_op(node, op); break;
858 case iro_Not: set_Not_op(node, op); break;
859 case iro_Conv: set_Conv_op(node, op); break;
866 is_binop (ir_node *node) {
867 return (node->op == op_Add ||
868 node->op == op_Sub ||
869 node->op == op_Mul ||
870 node->op == op_Quot ||
871 node->op == op_DivMod ||
872 node->op == op_Div ||
873 node->op == op_Mod ||
874 node->op == op_And ||
876 node->op == op_Eor ||
877 node->op == op_Shl ||
878 node->op == op_Shr ||
879 node->op == op_Shrs ||
880 node->op == op_Rot ||
881 node->op == op_Cmp );
885 get_binop_left (ir_node *node) {
886 assert (node->op == op_Add ||
887 node->op == op_Sub ||
888 node->op == op_Mul ||
889 node->op == op_Quot ||
890 node->op == op_DivMod ||
891 node->op == op_Div ||
892 node->op == op_Mod ||
893 node->op == op_And ||
895 node->op == op_Eor ||
896 node->op == op_Shl ||
897 node->op == op_Shr ||
898 node->op == op_Shrs ||
899 node->op == op_Rot ||
900 node->op == op_Cmp );
902 switch (get_irn_opcode (node)) {
903 case iro_Add : return get_Add_left(node); break;
904 case iro_Sub : return get_Sub_left(node); break;
905 case iro_Mul : return get_Mul_left(node); break;
906 case iro_Quot : return get_Quot_left(node); break;
907 case iro_DivMod: return get_DivMod_left(node); break;
908 case iro_Div : return get_Div_left(node); break;
909 case iro_Mod : return get_Mod_left(node); break;
910 case iro_And : return get_And_left(node); break;
911 case iro_Or : return get_Or_left(node); break;
912 case iro_Eor : return get_Eor_left(node); break;
913 case iro_Shl : return get_Shl_left(node); break;
914 case iro_Shr : return get_Shr_left(node); break;
915 case iro_Shrs : return get_Shrs_left(node); break;
916 case iro_Rot : return get_Rot_left(node); break;
917 case iro_Cmp : return get_Cmp_left(node); break;
918 default: return NULL;
923 set_binop_left (ir_node *node, ir_node *left) {
924 assert (node->op == op_Add ||
925 node->op == op_Sub ||
926 node->op == op_Mul ||
927 node->op == op_Quot ||
928 node->op == op_DivMod ||
929 node->op == op_Div ||
930 node->op == op_Mod ||
931 node->op == op_And ||
933 node->op == op_Eor ||
934 node->op == op_Shl ||
935 node->op == op_Shr ||
936 node->op == op_Shrs ||
937 node->op == op_Rot ||
938 node->op == op_Cmp );
940 switch (get_irn_opcode (node)) {
941 case iro_Add : set_Add_left(node, left); break;
942 case iro_Sub : set_Sub_left(node, left); break;
943 case iro_Mul : set_Mul_left(node, left); break;
944 case iro_Quot : set_Quot_left(node, left); break;
945 case iro_DivMod: set_DivMod_left(node, left); break;
946 case iro_Div : set_Div_left(node, left); break;
947 case iro_Mod : set_Mod_left(node, left); break;
948 case iro_And : set_And_left(node, left); break;
949 case iro_Or : set_Or_left(node, left); break;
950 case iro_Eor : set_Eor_left(node, left); break;
951 case iro_Shl : set_Shl_left(node, left); break;
952 case iro_Shr : set_Shr_left(node, left); break;
953 case iro_Shrs : set_Shrs_left(node, left); break;
954 case iro_Rot : set_Rot_left(node, left); break;
955 case iro_Cmp : set_Cmp_left(node, left); break;
961 get_binop_right (ir_node *node) {
962 assert (node->op == op_Add ||
963 node->op == op_Sub ||
964 node->op == op_Mul ||
965 node->op == op_Quot ||
966 node->op == op_DivMod ||
967 node->op == op_Div ||
968 node->op == op_Mod ||
969 node->op == op_And ||
971 node->op == op_Eor ||
972 node->op == op_Shl ||
973 node->op == op_Shr ||
974 node->op == op_Shrs ||
975 node->op == op_Rot ||
976 node->op == op_Cmp );
978 switch (get_irn_opcode (node)) {
979 case iro_Add : return get_Add_right(node); break;
980 case iro_Sub : return get_Sub_right(node); break;
981 case iro_Mul : return get_Mul_right(node); break;
982 case iro_Quot : return get_Quot_right(node); break;
983 case iro_DivMod: return get_DivMod_right(node); break;
984 case iro_Div : return get_Div_right(node); break;
985 case iro_Mod : return get_Mod_right(node); break;
986 case iro_And : return get_And_right(node); break;
987 case iro_Or : return get_Or_right(node); break;
988 case iro_Eor : return get_Eor_right(node); break;
989 case iro_Shl : return get_Shl_right(node); break;
990 case iro_Shr : return get_Shr_right(node); break;
991 case iro_Shrs : return get_Shrs_right(node); break;
992 case iro_Rot : return get_Rot_right(node); break;
993 case iro_Cmp : return get_Cmp_right(node); break;
994 default: return NULL;
999 set_binop_right (ir_node *node, ir_node *right) {
1000 assert (node->op == op_Add ||
1001 node->op == op_Sub ||
1002 node->op == op_Mul ||
1003 node->op == op_Quot ||
1004 node->op == op_DivMod ||
1005 node->op == op_Div ||
1006 node->op == op_Mod ||
1007 node->op == op_And ||
1008 node->op == op_Or ||
1009 node->op == op_Eor ||
1010 node->op == op_Shl ||
1011 node->op == op_Shr ||
1012 node->op == op_Shrs ||
1013 node->op == op_Rot ||
1014 node->op == op_Cmp );
1016 switch (get_irn_opcode (node)) {
1017 case iro_Add : set_Add_right(node, right); break;
1018 case iro_Sub : set_Sub_right(node, right); break;
1019 case iro_Mul : set_Mul_right(node, right); break;
1020 case iro_Quot : set_Quot_right(node, right); break;
1021 case iro_DivMod: set_DivMod_right(node, right); break;
1022 case iro_Div : set_Div_right(node, right); break;
1023 case iro_Mod : set_Mod_right(node, right); break;
1024 case iro_And : set_And_right(node, right); break;
1025 case iro_Or : set_Or_right(node, right); break;
1026 case iro_Eor : set_Eor_right(node, right); break;
1027 case iro_Shl : set_Shl_right(node, right); break;
1028 case iro_Shr : set_Shr_right(node, right); break;
1029 case iro_Shrs : set_Shrs_right(node, right); break;
1030 case iro_Rot : set_Rot_right(node, right); break;
1031 case iro_Cmp : set_Cmp_right(node, right); break;
1037 get_Add_left (ir_node *node) {
1038 assert (node->op == op_Add);
1039 return get_irn_n(node, 0);
1043 set_Add_left (ir_node *node, ir_node *left) {
1044 assert (node->op == op_Add);
1045 set_irn_n(node, 0, left);
1049 get_Add_right (ir_node *node) {
1050 assert (node->op == op_Add);
1051 return get_irn_n(node, 1);
1055 set_Add_right (ir_node *node, ir_node *right) {
1056 assert (node->op == op_Add);
1057 set_irn_n(node, 1, right);
1061 get_Sub_left (ir_node *node) {
1062 assert (node->op == op_Sub);
1063 return get_irn_n(node, 0);
1067 set_Sub_left (ir_node *node, ir_node *left) {
1068 assert (node->op == op_Sub);
1069 set_irn_n(node, 0, left);
1073 get_Sub_right (ir_node *node) {
1074 assert (node->op == op_Sub);
1075 return get_irn_n(node, 1);
1079 set_Sub_right (ir_node *node, ir_node *right) {
1080 assert (node->op == op_Sub);
1081 set_irn_n(node, 1, right);
1086 get_Minus_op (ir_node *node) {
1087 assert (node->op == op_Minus);
1088 return get_irn_n(node, 0);
1092 set_Minus_op (ir_node *node, ir_node *op) {
1093 assert (node->op == op_Minus);
1094 set_irn_n(node, 0, op);
1099 get_Mul_left (ir_node *node) {
1100 assert (node->op == op_Mul);
1101 return get_irn_n(node, 0);
1105 set_Mul_left (ir_node *node, ir_node *left) {
1106 assert (node->op == op_Mul);
1107 set_irn_n(node, 0, left);
1111 get_Mul_right (ir_node *node) {
1112 assert (node->op == op_Mul);
1113 return get_irn_n(node, 1);
1117 set_Mul_right (ir_node *node, ir_node *right) {
1118 assert (node->op == op_Mul);
1119 set_irn_n(node, 1, right);
1123 get_Quot_left (ir_node *node) {
1124 assert (node->op == op_Quot);
1125 return get_irn_n(node, 1);
1129 set_Quot_left (ir_node *node, ir_node *left) {
1130 assert (node->op == op_Quot);
1131 set_irn_n(node, 1, left);
1135 get_Quot_right (ir_node *node) {
1136 assert (node->op == op_Quot);
1137 return get_irn_n(node, 2);
1141 set_Quot_right (ir_node *node, ir_node *right) {
1142 assert (node->op == op_Quot);
1143 set_irn_n(node, 2, right);
1147 get_Quot_mem (ir_node *node) {
1148 assert (node->op == op_Quot);
1149 return get_irn_n(node, 0);
1153 set_Quot_mem (ir_node *node, ir_node *mem) {
1154 assert (node->op == op_Quot);
1155 set_irn_n(node, 0, mem);
1159 get_DivMod_left (ir_node *node) {
1160 assert (node->op == op_DivMod);
1161 return get_irn_n(node, 1);
1165 set_DivMod_left (ir_node *node, ir_node *left) {
1166 assert (node->op == op_DivMod);
1167 set_irn_n(node, 1, left);
1171 get_DivMod_right (ir_node *node) {
1172 assert (node->op == op_DivMod);
1173 return get_irn_n(node, 2);
1177 set_DivMod_right (ir_node *node, ir_node *right) {
1178 assert (node->op == op_DivMod);
1179 set_irn_n(node, 2, right);
1183 get_DivMod_mem (ir_node *node) {
1184 assert (node->op == op_DivMod);
1185 return get_irn_n(node, 0);
1189 set_DivMod_mem (ir_node *node, ir_node *mem) {
1190 assert (node->op == op_DivMod);
1191 set_irn_n(node, 0, mem);
1195 get_Div_left (ir_node *node) {
1196 assert (node->op == op_Div);
1197 return get_irn_n(node, 1);
1201 set_Div_left (ir_node *node, ir_node *left) {
1202 assert (node->op == op_Div);
1203 set_irn_n(node, 1, left);
1207 get_Div_right (ir_node *node) {
1208 assert (node->op == op_Div);
1209 return get_irn_n(node, 2);
1213 set_Div_right (ir_node *node, ir_node *right) {
1214 assert (node->op == op_Div);
1215 set_irn_n(node, 2, right);
1219 get_Div_mem (ir_node *node) {
1220 assert (node->op == op_Div);
1221 return get_irn_n(node, 0);
1225 set_Div_mem (ir_node *node, ir_node *mem) {
1226 assert (node->op == op_Div);
1227 set_irn_n(node, 0, mem);
1231 get_Mod_left (ir_node *node) {
1232 assert (node->op == op_Mod);
1233 return get_irn_n(node, 1);
1237 set_Mod_left (ir_node *node, ir_node *left) {
1238 assert (node->op == op_Mod);
1239 set_irn_n(node, 1, left);
1243 get_Mod_right (ir_node *node) {
1244 assert (node->op == op_Mod);
1245 return get_irn_n(node, 2);
1249 set_Mod_right (ir_node *node, ir_node *right) {
1250 assert (node->op == op_Mod);
1251 set_irn_n(node, 2, right);
1255 get_Mod_mem (ir_node *node) {
1256 assert (node->op == op_Mod);
1257 return get_irn_n(node, 0);
1261 set_Mod_mem (ir_node *node, ir_node *mem) {
1262 assert (node->op == op_Mod);
1263 set_irn_n(node, 0, mem);
1267 get_Abs_op (ir_node *node) {
1268 assert (node->op == op_Abs);
1269 return get_irn_n(node, 0);
1273 set_Abs_op (ir_node *node, ir_node *op) {
1274 assert (node->op == op_Abs);
1275 set_irn_n(node, 0, op);
1279 get_And_left (ir_node *node) {
1280 assert (node->op == op_And);
1281 return get_irn_n(node, 0);
1285 set_And_left (ir_node *node, ir_node *left) {
1286 assert (node->op == op_And);
1287 set_irn_n(node, 0, left);
1291 get_And_right (ir_node *node) {
1292 assert (node->op == op_And);
1293 return get_irn_n(node, 1);
1297 set_And_right (ir_node *node, ir_node *right) {
1298 assert (node->op == op_And);
1299 set_irn_n(node, 1, right);
1303 get_Or_left (ir_node *node) {
1304 assert (node->op == op_Or);
1305 return get_irn_n(node, 0);
1309 set_Or_left (ir_node *node, ir_node *left) {
1310 assert (node->op == op_Or);
1311 set_irn_n(node, 0, left);
1315 get_Or_right (ir_node *node) {
1316 assert (node->op == op_Or);
1317 return get_irn_n(node, 1);
1321 set_Or_right (ir_node *node, ir_node *right) {
1322 assert (node->op == op_Or);
1323 set_irn_n(node, 1, right);
1327 get_Eor_left (ir_node *node) {
1328 assert (node->op == op_Eor);
1329 return get_irn_n(node, 0);
1333 set_Eor_left (ir_node *node, ir_node *left) {
1334 assert (node->op == op_Eor);
1335 set_irn_n(node, 0, left);
1339 get_Eor_right (ir_node *node) {
1340 assert (node->op == op_Eor);
1341 return get_irn_n(node, 1);
1345 set_Eor_right (ir_node *node, ir_node *right) {
1346 assert (node->op == op_Eor);
1347 set_irn_n(node, 1, right);
1352 get_Not_op (ir_node *node) {
1353 assert (node->op == op_Not);
1354 return get_irn_n(node, 0);
1358 set_Not_op (ir_node *node, ir_node *op) {
1359 assert (node->op == op_Not);
1360 set_irn_n(node, 0, op);
1365 get_Shl_left (ir_node *node) {
1366 assert (node->op == op_Shl);
1367 return get_irn_n(node, 0);
1371 set_Shl_left (ir_node *node, ir_node *left) {
1372 assert (node->op == op_Shl);
1373 set_irn_n(node, 0, left);
1377 get_Shl_right (ir_node *node) {
1378 assert (node->op == op_Shl);
1379 return get_irn_n(node, 1);
1383 set_Shl_right (ir_node *node, ir_node *right) {
1384 assert (node->op == op_Shl);
1385 set_irn_n(node, 1, right);
1389 get_Shr_left (ir_node *node) {
1390 assert (node->op == op_Shr);
1391 return get_irn_n(node, 0);
1395 set_Shr_left (ir_node *node, ir_node *left) {
1396 assert (node->op == op_Shr);
1397 set_irn_n(node, 0, left);
1401 get_Shr_right (ir_node *node) {
1402 assert (node->op == op_Shr);
1403 return get_irn_n(node, 1);
1407 set_Shr_right (ir_node *node, ir_node *right) {
1408 assert (node->op == op_Shr);
1409 set_irn_n(node, 1, right);
1413 get_Shrs_left (ir_node *node) {
1414 assert (node->op == op_Shrs);
1415 return get_irn_n(node, 0);
1419 set_Shrs_left (ir_node *node, ir_node *left) {
1420 assert (node->op == op_Shrs);
1421 set_irn_n(node, 0, left);
1425 get_Shrs_right (ir_node *node) {
1426 assert (node->op == op_Shrs);
1427 return get_irn_n(node, 1);
1431 set_Shrs_right (ir_node *node, ir_node *right) {
1432 assert (node->op == op_Shrs);
1433 set_irn_n(node, 1, right);
1437 get_Rot_left (ir_node *node) {
1438 assert (node->op == op_Rot);
1439 return get_irn_n(node, 0);
1443 set_Rot_left (ir_node *node, ir_node *left) {
1444 assert (node->op == op_Rot);
1445 set_irn_n(node, 0, left);
1449 get_Rot_right (ir_node *node) {
1450 assert (node->op == op_Rot);
1451 return get_irn_n(node, 1);
1455 set_Rot_right (ir_node *node, ir_node *right) {
1456 assert (node->op == op_Rot);
1457 set_irn_n(node, 1, right);
1461 get_Cmp_left (ir_node *node) {
1462 assert (node->op == op_Cmp);
1463 return get_irn_n(node, 0);
1467 set_Cmp_left (ir_node *node, ir_node *left) {
1468 assert (node->op == op_Cmp);
1469 set_irn_n(node, 0, left);
1473 get_Cmp_right (ir_node *node) {
1474 assert (node->op == op_Cmp);
1475 return get_irn_n(node, 1);
1479 set_Cmp_right (ir_node *node, ir_node *right) {
1480 assert (node->op == op_Cmp);
1481 set_irn_n(node, 1, right);
1485 get_Conv_op (ir_node *node) {
1486 assert (node->op == op_Conv);
1487 return get_irn_n(node, 0);
1491 set_Conv_op (ir_node *node, ir_node *op) {
1492 assert (node->op == op_Conv);
1493 set_irn_n(node, 0, op);
1497 get_Phi_preds_arr (ir_node *node) {
1498 assert (node->op == op_Phi);
1499 return (ir_node **)&(get_irn_in(node)[1]);
1503 get_Phi_n_preds (ir_node *node) {
1504 assert (node->op == op_Phi);
1505 return (get_irn_arity(node));
1509 inline void set_Phi_n_preds (ir_node *node, int n_preds) {
1510 assert (node->op == op_Phi);
1515 get_Phi_pred (ir_node *node, int pos) {
1516 assert (node->op == op_Phi);
1517 return get_irn_n(node, pos);
1521 set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
1522 assert (node->op == op_Phi);
1523 set_irn_n(node, pos, pred);
1527 get_Load_mem (ir_node *node) {
1528 assert (node->op == op_Load);
1529 return get_irn_n(node, 0);
1533 set_Load_mem (ir_node *node, ir_node *mem) {
1534 assert (node->op == op_Load);
1535 set_irn_n(node, 0, mem);
1539 get_Load_ptr (ir_node *node) {
1540 assert (node->op == op_Load);
1541 return get_irn_n(node, 1);
1545 set_Load_ptr (ir_node *node, ir_node *ptr) {
1546 assert (node->op == op_Load);
1547 set_irn_n(node, 1, ptr);
1552 get_Store_mem (ir_node *node) {
1553 assert (node->op == op_Store);
1554 return get_irn_n(node, 0);
1558 set_Store_mem (ir_node *node, ir_node *mem) {
1559 assert (node->op == op_Store);
1560 set_irn_n(node, 0, mem);
1564 get_Store_ptr (ir_node *node) {
1565 assert (node->op == op_Store);
1566 return get_irn_n(node, 1);
1570 set_Store_ptr (ir_node *node, ir_node *ptr) {
1571 assert (node->op == op_Store);
1572 set_irn_n(node, 1, ptr);
1576 get_Store_value (ir_node *node) {
1577 assert (node->op == op_Store);
1578 return get_irn_n(node, 2);
1582 set_Store_value (ir_node *node, ir_node *value) {
1583 assert (node->op == op_Store);
1584 set_irn_n(node, 2, value);
1588 get_Alloc_mem (ir_node *node) {
1589 assert (node->op == op_Alloc);
1590 return get_irn_n(node, 0);
1594 set_Alloc_mem (ir_node *node, ir_node *mem) {
1595 assert (node->op == op_Alloc);
1596 set_irn_n(node, 0, mem);
1600 get_Alloc_size (ir_node *node) {
1601 assert (node->op == op_Alloc);
1602 return get_irn_n(node, 1);
1606 set_Alloc_size (ir_node *node, ir_node *size) {
1607 assert (node->op == op_Alloc);
1608 set_irn_n(node, 1, size);
1612 get_Alloc_type (ir_node *node) {
1613 assert (node->op == op_Alloc);
1614 return node->attr.a.type = skip_tid(node->attr.a.type);
1618 set_Alloc_type (ir_node *node, type *type) {
1619 assert (node->op == op_Alloc);
1620 node->attr.a.type = type;
1624 get_Alloc_where (ir_node *node) {
1625 assert (node->op == op_Alloc);
1626 return node->attr.a.where;
1630 set_Alloc_where (ir_node *node, where_alloc where) {
1631 assert (node->op == op_Alloc);
1632 node->attr.a.where = where;
1637 get_Free_mem (ir_node *node) {
1638 assert (node->op == op_Free);
1639 return get_irn_n(node, 0);
1643 set_Free_mem (ir_node *node, ir_node *mem) {
1644 assert (node->op == op_Free);
1645 set_irn_n(node, 0, mem);
1649 get_Free_ptr (ir_node *node) {
1650 assert (node->op == op_Free);
1651 return get_irn_n(node, 1);
1655 set_Free_ptr (ir_node *node, ir_node *ptr) {
1656 assert (node->op == op_Free);
1657 set_irn_n(node, 1, ptr);
1661 get_Free_size (ir_node *node) {
1662 assert (node->op == op_Free);
1663 return get_irn_n(node, 2);
1667 set_Free_size (ir_node *node, ir_node *size) {
1668 assert (node->op == op_Free);
1669 set_irn_n(node, 2, size);
1673 get_Free_type (ir_node *node) {
1674 assert (node->op == op_Free);
1675 return node->attr.f = skip_tid(node->attr.f);
1679 set_Free_type (ir_node *node, type *type) {
1680 assert (node->op == op_Free);
1681 node->attr.f = type;
1685 get_Sync_preds_arr (ir_node *node) {
1686 assert (node->op == op_Sync);
1687 return (ir_node **)&(get_irn_in(node)[1]);
1691 get_Sync_n_preds (ir_node *node) {
1692 assert (node->op == op_Sync);
1693 return (get_irn_arity(node));
1698 set_Sync_n_preds (ir_node *node, int n_preds) {
1699 assert (node->op == op_Sync);
1704 get_Sync_pred (ir_node *node, int pos) {
1705 assert (node->op == op_Sync);
1706 return get_irn_n(node, pos);
1710 set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
1711 assert (node->op == op_Sync);
1712 set_irn_n(node, pos, pred);
1716 get_Proj_pred (ir_node *node) {
1717 assert (node->op == op_Proj);
1718 return get_irn_n(node, 0);
1722 set_Proj_pred (ir_node *node, ir_node *pred) {
1723 assert (node->op == op_Proj);
1724 set_irn_n(node, 0, pred);
1728 get_Proj_proj (ir_node *node) {
1729 assert (node->op == op_Proj);
1730 return node->attr.proj;
1734 set_Proj_proj (ir_node *node, long proj) {
1735 assert (node->op == op_Proj);
1736 node->attr.proj = proj;
1740 get_Tuple_preds_arr (ir_node *node) {
1741 assert (node->op == op_Tuple);
1742 return (ir_node **)&(get_irn_in(node)[1]);
1746 get_Tuple_n_preds (ir_node *node) {
1747 assert (node->op == op_Tuple);
1748 return (get_irn_arity(node));
1753 set_Tuple_n_preds (ir_node *node, int n_preds) {
1754 assert (node->op == op_Tuple);
1759 get_Tuple_pred (ir_node *node, int pos) {
1760 assert (node->op == op_Tuple);
1761 return get_irn_n(node, pos);
1765 set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
1766 assert (node->op == op_Tuple);
1767 set_irn_n(node, pos, pred);
1771 get_Id_pred (ir_node *node) {
1772 assert (node->op == op_Id);
1773 return get_irn_n(node, 0);
1777 set_Id_pred (ir_node *node, ir_node *pred) {
1778 assert (node->op == op_Id);
1779 set_irn_n(node, 0, pred);
1782 /******************************************************************/
1783 /* Auxiliary routines */
1784 /******************************************************************/
1787 skip_Proj (ir_node *node) {
1788 /* don't assert node !!! */
1789 if (node && (node->op == op_Proj)) {
1790 return get_Proj_pred(node);
1797 skip_Tuple (ir_node *node) {
1798 if ((node->op == op_Proj) && (get_irn_op(get_Proj_pred(node)) == op_Tuple))
1799 return get_Tuple_pred(get_Proj_pred(node), get_Proj_proj(node));
1805 skip_nop (ir_node *node) {
1806 /* don't assert node !!! */
1808 if (node && (node->op == op_Id) && (node != get_Id_pred(node))) {
1809 /* Don't use get_Id_pred: We get into an endless loop for
1810 self-referencing Ids. */
1811 assert (get_irn_arity (node) > 0);
1812 return node->in[0+1];
1819 is_Bad (ir_node *node) {
1821 if ((node) && get_irn_opcode(node) == iro_Bad)
1827 is_no_Block (ir_node *node) {
1829 return (get_irn_opcode(node) != iro_Block);
1832 /* Returns true if the operation manipulates control flow. */
1834 is_cfop(ir_node *node) {
1835 return ( (get_irn_opcode(node) == iro_Start)
1836 || (get_irn_opcode(node) == iro_Jmp)
1837 || (get_irn_opcode(node) == iro_Cond)
1838 || (get_irn_opcode(node) == iro_Return)
1839 || (get_irn_opcode(node) == iro_Raise)
1840 || (get_irn_opcode(node) == iro_Bad));
1843 /* Returns true if the operation can change the control flow because
1846 is_fragile_op(ir_node *node) {
1847 return ( (get_irn_opcode(node) == iro_Call)
1848 || (get_irn_opcode(node) == iro_Quot)
1849 || (get_irn_opcode(node) == iro_DivMod)
1850 || (get_irn_opcode(node) == iro_Div)
1851 || (get_irn_opcode(node) == iro_Mod)
1852 || (get_irn_opcode(node) == iro_Load)
1853 || (get_irn_opcode(node) == iro_Store)
1854 || (get_irn_opcode(node) == iro_Alloc)
1855 || (get_irn_opcode(node) == iro_Bad));
1859 /* Returns the memory operand of fragile operations. */
1860 ir_node *get_fragile_op_mem(ir_node *node) {
1861 assert(node && is_fragile_op(node));
1863 switch (get_irn_opcode (node)) {
1872 return get_irn_n(node, 0);